HDU 5009 （dp+双向链表优化）

点击打开链接

西安网络预赛题。

连续选区间填充，完全覆盖。

dp[i] 完全覆盖的最优解。

连续一起的同种颜色缩并。

优化：

1. 至多每个单独选，价值最高为N

2.不能连续选择超过sqrt(N)+1个不同的颜色

3.第i种颜色来的时候，它之前本身的颜色不再考虑。

PS：此题本来打算离散化数据，但是用map就不用了（直接判重）。对于有序的数据，离散化还要再映射

优化可以这样理解：不用处理重复出现的颜色，因为从右边i点开始往左里面已经包含了这个颜色。

题意：有n个珠子需要你染上特定的颜色，初始的时候是没有染色的，每次染的代价是不同颜色的平方。
思路：借鉴一段题解：双向链表优化dp。dp[i]表示涂完前i个所化的最小代价，
显然有dp[i]=min{dp[j]+num(j+1,i)^2},其中1<=j<i,num(j+1,i)表示区间[j+1,i]的颜色个数。
这样复杂度为O（n^2）显然超时。那么需要优化一下，比如第二组测试数据3 4 2 4 4 2 4 3 2 2，假设dp[1]...dp[8]已更新完毕，现在要更新dp[9]，可以看到a
[9]为2，按照原始的dp[i]=min{dp[j]+num(j+1,i)^2}，
i=9，枚举j=8，dp[9]=min{dp[9],dp[8]+1^2};j=7,dp[9]=min{dp[9],dp[7]+2^2};现在貌似没什么变化。。。
j=6，这里就神奇了，如果dp[9]=min{dp[9],dp[6]+3^2}，那么这个就太弱了，因
为此时2 4 3是连着涂的，但是2之前是3 4 2 4 4，这些如果跟着一起涂，那么仍然是3^2的代价，但前面的数字变少了，显然这种更优。
于是乎dp[9]=min{dp[9],dp[0]+3^2}，可以看到6直接跳到了0，为什么这么跳？
因为这之前都是些234啊，重复了没必要保存。所以在dp时，我们只需要维护好前后关系即可。
比如当前dp第i位，那么即a[i]加进来，所以之前如果有a[i]值的必须删掉，具体双向链表维护。因此可以看到任意时刻，每种颜色只会保存一次，复杂度就降下来了。
但仍然可以给出坑爹的数据，比如1 2 3 4 ... n那么这个dp的话，复杂度仍为O（n^2），于是继续优化。我们知道如果一个一个涂，那么需要花费n。所以最优
方案不能大于n，也就是不能连着sqrt(n)个不同的颜色一起涂，否则代价大于n了，这里进行剪枝。复杂度降为O（nsqrt（n））,还是可以接受的。

去重的方法 sort(a,a+n)  cnt=unique(a,a+n)-a;
使用并查集代替双向链表

#include <iostream>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <map>
#define MAXN (50000+5)
using namespace std;
int a[MAXN],b[MAXN],pre[MAXN],nxt[MAXN];
int dp[MAXN];
int main()
{
    int N,M;pre[0]=-1;map<int,int> color;
    while(~scanf("%d",&N)){
        for(int i=1;i<=N;i++)
            scanf("%d",a+i),pre[i]=i-1,nxt[i]=i+1;
        M=1;b[1]=a[1];
        for(int i=2;i<=N;i++)
            if(a[i]!=a[i-1])
                b[++M]=a[i];
        dp[0]=0;color.clear();
        for(int i=1;i<=M;i++){
            if(color[b[i]]==0) color[b[i]]=i;//map判重
            else{
                int k=color[b[i]];
                nxt[pre[k]]=nxt[k];
                pre[nxt[k]]=pre[k];
                color[b[i]]=i;
            }
            dp[i]=i;
            for(int j=i-1,k=1;j!=-1;j=pre[j],k++){
                if(k>(int)sqrt(M)+1) break;
                int tmp=dp[j]+k*k;
                if(tmp>M)break;
                dp[i]=min(dp[i],tmp);
            }
        }
        printf("%d\n",dp[M]);
    }
}

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
using namespace std;
const int MAXN = 50010;
int a[MAXN];
int F[MAXN];
int find(int x){
	if(F[x] == -1)return x;
	return F[x] = find(F[x]);
}
void bing(int x,int y){
	int t1 = find(x), t2 = find(y);
	if(t1 != t2)F[t2] = t1;
}
int b[MAXN];
int last[MAXN];
int dp[MAXN];

int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    int n;
	while(scanf("%d",&n) == 1){
		int cnt = 0;
		for(int i = 1;i <= n;i++){
			scanf("%d",&a[i]);
			b[cnt++] = a[i];
		}
		sort(b,b+cnt);
		cnt = unique(b,b+cnt) - b;
		map<int,int>mp;
		for(int i = 0;i < cnt;i++){
			mp[b[i]] = i;
			last[i] = -1;
		}
		for(int i = 1;i <= n;i++)a[i] = mp[a[i]];
		dp[0] = 0;
		F[0] = -1;
		for(int i = 1;i <= n;i++){
			F[i] = -1;
			if(last[a[i]] != -1){
				bing(last[a[i]]-1,last[a[i]]);
			}
			last[a[i]] = i;
			dp[i] = i;
			int num = 0;
			for(int j = i;j > 0;j = find(j-1)){
				num++;
				if(num*num >= dp[i])break;
				int nxt = find(j-1);
				dp[i] = min(dp[i],dp[nxt]+num*num);
			}
		}
		printf("%d\n",dp[n]);
	}
    return 0;
}