【bzoj1049】【HAOI2006】【数字序列】【dp+暴力】

Description

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

Input

第一行包含一个数n，接下来n个整数按顺序描述每一项的键值。

Output

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

Sample Input

4
5 2 3 5

Sample Output

1
4

HINT

【数据范围】

90%的数据n<=6000。

100%的数据n<=35000。

保证所有数列是随机的。

题解：首先有一个直观的思路。就是把原数列的每个数都减去他们的位置构成一个新数列。即b[i]=a[i]-i;

首先第一问比较简单。我们考虑补集转换，我们求最多有多少点可以不修改。然后就对新数列求一个最长不下降子序列就好了。然后答案就是n-最长不下降子序列的长度。

对于第二问。设g[i]表示把1-i的这段区间变成上升序列的最小代价。实际上就是把b数列变成不下降序列的最小代价。

首先我们可以证明对于i-j的一段区间并且满足f[i]+1=f[j],并且b[i]<=b[j];我们把它变成不下降的最小代价一定是从中间取一个点t,我们把i+1---t全都变成b[i],t+1---j-1全都变成b[j];然后我们枚举t就好了。

                         即              g[i]=min(g[j]+cost[i][j])(f[i]+1=f[j],b[i]<=b[j]);

每次计算代价的时候预处理两个前缀和数组就能做到O(n^3)了。。因为数据随机。所以合法的j应该很少，这样就可以过了。。

另外，听说正解是二分图。。。

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
#define mid (l+r)/2
#define inf 210000000
#define INF 2100000000000000000
const int N=36000;
int n,a[N],top=0,s[N],f[N],cnt,point[N],next[N],to[N],l,r,u;
long long g[N],x[N],y[N];
void add(int x,int y){next[++cnt]=point[x];point[x]=cnt;to[cnt]=y;}
int abs(int x){return x<0?-x:x;}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;++i) scanf("%d",&a[i]),a[i]-=i;
    a[++n]=inf;s[0]=-inf;
    for(int i=1;i<=n;++i)
    {
        if(a[i]>=s[top]) s[++top]=a[i],f[i]=top;
        else
        {
            l=1;r=top;
            while(l<=r){if(a[i]>=s[mid]) l=mid+1;else r=mid-1;}
            s[l]=a[i];f[i]=l;
        }
    }
    printf("%d\n",n-top);
    for(int i=n;~i;--i){g[i]=INF;add(f[i],i);}
    a[0]=-inf;g[0]=0;
    for(int i=1;i<=n;++i)
      for(int j=point[f[i]-1];j;j=next[j])
      {
        u=to[j];
        if(u>i) break;if(a[u]>a[i]) continue;
        x[u-1]=y[u-1]=0;
        for(int k=u;k<=i;++k){x[k]=x[k-1]+abs(a[u]-a[k]);y[k]=y[k-1]+abs(a[i]-a[k]);}
        for(int k=u;k<i;++k) g[i]=min(g[i],g[u]+x[k]-x[u]+y[i]-y[k]);
      }
    printf("%lld\n",g[n]);
}