HDU - 5009 Paint Pearls(dp+优化双向链表)

3
1 3 3
10
3 4 2 4 4 2 4 3 2 2

2
7

题意：有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））,还是能够接受的。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <map>
using namespace std;
const int maxn = 50010;
const int inf = 0x3f3f3f3f;

int a[maxn], pre[maxn], nxt[maxn], dp[maxn];
map<int, int> mp;

int main() {
    int n;
    while (scanf("%d", &n) != EOF) {
        for (int i = 1; i <= n; i++) {
            scanf("%d", &a[i]);
            pre[i] = i - 1;
            nxt[i] = i + 1;
        }

        mp.clear();
        memset(dp, inf, sizeof(dp));
        dp[0] = 0, pre[0] = -1;
        for (int i = 1; i <= n; i++) {
            if (!mp.count(a[i])) mp[a[i]] = i;
            else {
                int id = mp[a[i]];
                nxt[pre[id]] = nxt[id];
                pre[nxt[id]] = pre[id];
                mp[a[i]] = i;
            }

            int cnt = 0;
            for (int j = pre[i]; j != -1; j = pre[j]) {
                cnt++;
                dp[i] = min(dp[i], dp[j] + cnt * cnt);
                if (cnt * cnt > i)
                    break;
            }
        }

        printf("%d\n", dp[n]);
    }
    return 0;
}