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

Problem Description

Lee has a string of n pearls. In the beginning, all the pearls have no color. He plans to color the pearls to make it more fascinating. He drew his ideal pattern of the string on a paper and asks for your help. 

In each operation, he selects some continuous pearls and all these pearls will be painted to their target colors. When he paints a string which has k different target colors, Lee will cost k² points. 

Now, Lee wants to cost as few as possible to get his ideal string. You should tell him the minimal cost.

 

Input

There are multiple test cases. Please process till EOF.

For each test case, the first line contains an integer n(1 ≤ n ≤ 5×10⁴), indicating the number of pearls. The second line contains a₁,a₂,...,a_n (1 ≤ a_i ≤ 10⁹) indicating the target color of each pearl.

 

Output

For each test case, output the minimal cost in a line.

 

Sample Input

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

 

Sample Output

2
7

 

Source

2014 ACM/ICPC Asia Regional Xi'an Online

题意：有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;
}

版权声明：本文博主原创文章，博客，未经同意不得转载。