bzoj1049[HAOI2006]数字序列

1049: [HAOI2006]数字序列

Time Limit: 10 Sec  Memory Limit: 162 MB
Submit: 1813  Solved: 789
[Submit][Status][Discuss]

Description

　　现在我们有一个长度为n的整数序列A。但是它太不好看了，于是我们希望把它变成一个单调严格上升的序列。
但是不希望改变过多的数，也不希望改变的幅度太大。

Input

　　第一行包含一个数n，接下来n个整数按顺序描述每一项的键值。n<=35000,保证所有数列是随机的

Output

　　第一行一个整数表示最少需要改变多少个数。 第二行一个整数，表示在改变的数最少的情况下，每个数改变
的绝对值之和的最小值。

Sample Input

4
5 2 3 5

Sample Output

1
4

 

被细节恶心到啦。
第一问可以补集转换，减下标然后求最长不下降子序列，用总序列长度-lis长度水过，关键是这个第二问呐。。
有个并不显然的显然结论：
若j<i&&f[j]+1==f[i]&&a[j]<=a[i](保证j可以转移到i)
那么把这段区间中的数值改成a[j]或者a[i]一定是最优的，跑个dp决策

这里有证明
http://pan.baidu.com/share/link?uk=2651016602&shareid=1490516411

#include<bits/stdc++.h>
#define ll long long
#define N 35005
using namespace std;
int n,mx,a[N],b[N],f[N],hd[N],nxt[N];ll g[N],s1[N],s2[N];
int find(int x){
    int l=1,r=mx,mid,ans=0;
    while(l<=r){
        if(b[mid=(l+r)>>1]<=x)l=(ans=mid)+1;
        else r=mid-1;
    }return ans;
}
void dp(){
    memset(b,0x3f,sizeof(b));
    b[0]=-1<<30;
    for(int i=1;i<=n;i++){
        int p=find(a[i]);
        mx=max(mx,f[i]=p+1);
        b[p+1]=min(b[p+1],a[i]);
    }
}
void add(int x,int y){nxt[y]=hd[x];hd[x]=y;}
void solve(){
    //memset(g,0x3f,sizeof(g));g[0]=0;
    for(int i=1;i<=n;i++)g[i]=1ll<<60;
    memset(hd,-1,sizeof(hd));
    for(int i=n;i>=0;i--)add(f[i],i);
    for(int i=1;i<=n;i++){
        for(int j=hd[f[i]-1];~j&&j<i;j=nxt[j]){
            if(a[j]>a[i])continue;
            for(int k=j;k<=i;k++)
            s1[k]=abs(a[k]-a[j]),s2[k]=abs(a[k]-a[i]);
            for(int k=j+1;k<=i;k++)
            s1[k]+=s1[k-1],s2[k]+=s2[k-1];
            for(int k=j;k<i;k++)
            g[i]=min(g[i],g[j]+s1[k]-s1[j]+s2[i]-s2[k]);
        }
    }
}
int main(){
    scanf("%d",&n);a[0]=-1<<30;
    for(int i=1;i<=n;i++)
    scanf("%d",&a[i]),a[i]-=i;
    a[++n]=1<<30;
    dp();solve();
    printf("%d\n%lld\n",n-mx,g[n]);
    return 0;
}