seq(2018.10.24)

一道$dp$题。。。
期望$40$分解法
预处理：离散化，然后让连续一段值相同的元素合并为一个元素。
正式$DP$：
显然有个最差策略为每个元素处都切一次，则切的次数为元素的个数$-1$
相对地来说就是假设全部元素之间就已经切开，要尽量多地合并元素
$DP$的第一维用来确认当前是合并了值为多少的两个数值段，DP的第二维来记住最后一次合并是合并了哪个位置的两个线段
即$DP[i][j]=$对于值为$1$到$i+1$的数值段，最后一次合并为合并$a[j]$和$a[j+1]$这两个元素，最多能合并的总次数
而相对应的转移方程就是：
$DP[i][j] =max( DP[i-1][j']+1) (合并 a[j'] , a[j'+1] 不会与合并a[j],a[j+1]冲突)$
冲突是指合并$ a[i],a[i+1] $的同时也合并$a[j],a[j+1]$ 会导致无法拼接成单调不降的序列，其充要条件是$i+1=j$且值为$a[i+1]$的数值段在原序列中出现了不止$1$次,

空间和时间复杂度都是$O(n^2)$,期望得分$40$分

期望$100$分解法
优化：
$1.$滚动数组优化空间为$O(n)$
$2.$因为对于每个$i=x$，转移的时候只用考虑最大值和次大值，如果最大值和当前状态冲突，则用次大值更新

空间和时间复杂度都是$O(n)$,期望得分$100$分

#include<cstdio>
#include<algorithm>
#include<map>
using namespace std;
int n,a[100001],cnt,b[100001],tot,pre[100001],nxt[100001],h[100001],deg[100001];
pair<int,int>dp[2],DP[2];
map<int,int>mp;
void add(int x,int y){pre[++cnt]=y;nxt[cnt]=h[x];h[x]=cnt;deg[x]++;}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d",&a[i]),b[i]=a[i];
    sort(b+1,b+n+1);
    for(int i=1;i<=n;i++)if(!mp[b[i]])mp[b[i]]=++tot;
    for(int i=1;i<=n;i++)a[i]=mp[a[i]];tot=0;
    for(int i=1;i<=n;i++)if(a[i]!=a[i+1])a[++tot]=a[i];
    for(int i=1;i<=tot;i++)add(a[i],i);
    for(int i=h[1];i;i=nxt[i])
        if(a[pre[i]+1]==2)
        {
            dp[1]=max(dp[1],make_pair(1,pre[i]));
            if(dp[1]>DP[1])swap(dp[1],DP[1]);
        }
    for(int i=2;i<cnt;i++)
    {
        dp[i&1]=dp[(i&1)^1];DP[i&1]=DP[(i&1)^1];
        for(int j=h[i];j;j=nxt[j])
            if(a[pre[j]+1]==a[pre[j]]+1)
            {
                if(DP[(i&1)^1].second+1!=pre[j]||deg[i]==1)dp[i&1]=max(dp[i&1],make_pair(DP[(i&1)^1].first+1,pre[j]));
                else dp[i&1]=max(dp[i&1],make_pair(dp[(i&1)^1].first+1,pre[j]));
                if(dp[i&1]>DP[i&1])swap(dp[i&1],DP[i&1]);
            }
    }
    printf("%d\n",tot-1-DP[(cnt-1)&1].first);
}

猜你喜欢