【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[n] - sum[i]),Ans);
	}
	printf("%lld\n",Ans);
	return 0;
}