【bzoj1049】[HAOI2006]数字序列

1049: [HAOI2006]数字序列

Time Limit: 10 Sec  Memory Limit: 162 MB
Submit: 1842  Solved: 797
[Submit][Status][Discuss]

Description

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

Input

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

Output

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

Sample Input

4
5 2 3 5

Sample Output

1
4

HINT

Source

[Submit][Status][Discuss]

神。。神题。。。。
首先第一问就很显然，设b[i] = a[i] - i，答案就为b数组的n - LIS
然后第二问就很难（看了ydc的sol才懂）
考虑LIS的f数组的转移，每个最优转移用边给连起来
因为a的单调递增意味着b的单调不降，所以可以考虑设g[i]为答案
则g[i] = min{g[j],w(j,i)} (1 <= j < i)
w(j,i)为使[j,i]区间合法的最小代价
然后有一个结论：w(j,i)的最优方案，一定是存在一个k，使得[j,k]为b[j]，[k + 1,i]为b[i]
证明详见ydc的sol

代码：#include<cstdio>
#include<vector>
#include<queue>
#include<ctime>
#include<algorithm>
#include<cstdlib>
#include<stack>
#include<cstring>
#include<cmath>
using namespace std;

typedef long long LL;

const LL INF = 10000000000000000LL;
const int maxn = 100010;

vector<int> p[maxn];
int n;
LL a[maxn],b[maxn],f[maxn],g[maxn],sum[maxn];
int lc[maxn * 4],rc[maxn * 4],rt[maxn];
LL data[maxn],ha[maxn],N;
LL maxx[maxn];

inline LL getint()
{
LL ret = 0,f = 1;
char c = getchar();
while (c < '0' || c > '9')
{
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
ret = ret * 10 + c - '0',c = getchar();
return ret * f;
}

inline LL w(int j,int i)
{
LL now = 0,ret;
for (int t = j + 1; t < i; t++)
now += abs(ha[b[t]] - ha[b[i]]);
ret = now;
for (int t = j + 1; t < i; t++)
now += abs(ha[b[t]] - ha[b[j]]) - abs(ha[b[t]] - ha[b[i]]) , ret = min(now,ret);
return ret;
}

int main()
{
n = getint();
for (int i = 1; i <= n; i++) a[i] = getint();
for (int i = 1; i <= n; i++) data[i] = b[i] = a[i] - i;
sort(data + 1,data + n + 1);
for (int i = 1; i <= n; i++)
if (i == 1 || data[i - 1] != data[i])
ha[++N] = data[i];
ha[0] = ha[1];
for (int i = 1; i <= n; i++)
b[i] = lower_bound(ha + 1,ha + N + 1,b[i]) - ha;
LL ans = 0;
for (int i = 1; i <= n; i++)
{
for (int j = b[i]; j; j -= j & -j) f[i] = max(f[i],maxx[j] + 1);
for (int j = b[i]; j <= N; j += j & -j) maxx[j] = max(maxx[j],f[i]);
ans = max(f[i],ans);
}
printf("%d\n",n - ans);
p[0].push_back(0);
for (int i = 1; i <= n; i++)
{
g[i] = INF;
p[f[i]].push_back(i);
for (int k = 0; k < p[f[i] - 1].size(); k++)
{
int j = p[f[i] - 1][k];
if (b[j] > b[i]) continue;
g[i] = min(g[i],g[j] + w(j,i));
}
}
LL Ans = INF;
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + ha[b[i]];
for (int i = 0; i <= n; i++)
{
if (f[i] != ans) continue;
Ans = min(g[i] + ha[b[i]] * (n - i) - (sum
- sum[i]),Ans);
}
printf("%lld\n",Ans);
return 0;
}