CSU 1620 A Cure for the Common Code （HASH+区间DP）



题意：给定一个字符串，重复的子串可以用简写的方法表示。求最短可以表示成多长。

大白书上有原题，应该在动态规划一章。

HASH预处理出每个区间的串的信息（一定要记住每个字符的信息不能是0！！！！），dp[i][j]记录四个信息，一个是区间内最小循环串的长度，一个是该区间的最小长度，一个是循环次数，还有一个信息是这个这个区间的循环串是什么。

然后就是区间合并了，先看两个相邻区间的循环串是不是一样的。一样的直接合并，不一样的循环次数回一，但是串的长度可以直接赋值为两者之和，并且串的信息要重新截取更新一次。

#include <algorithm>
#include <iostream>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
using namespace std;
#define MAXN 510
#define ULL unsigned long long

char s[MAXN];
ULL w[MAXN], w2[MAXN], HASH[MAXN], HASH2[MAXN];

struct Node
{
    int l, k, c;
    ULL str, str2;
}dp[MAXN][MAXN];

int getLen(int k) {
    int ret = 0;
    while(k) k /= 10, ret++;
    return ret;
}

Node& Merge(int i, int k, int j) {
    Node ret;
    ULL a = dp[i][k].str * HASH[k + 1];
    ULL b = dp[k + 1][j].str * HASH[i];
    if(a == b) {
        ret.k = dp[i][k].k + dp[k + 1][j].k;
        ret.c = dp[i][k].c;
        ret.l = ret.c + getLen(ret.k);
        if(ret.c > 1) ret.l += 2;
        ret.str = dp[i][k].str;
    } else {
        ret.k = 1;
        ret.l = ret.c = dp[i][k].l + dp[k + 1][j].l;
        ret.str = w[j] - w[i - 1];
    }
    return ret;
}

int main() {

    HASH[1] = 131;
    for(int i = 2; i < MAXN; i++)
        HASH[i] = HASH[i - 1] * 131;

    int cas = 0;

    while(scanf("%s", s + 1) && s[1] != '0') {

        printf("Case %d: ", ++cas);
        int len = strlen(s + 1);

        w[0] = 0;
        for(int i = 1; i <= len; i++)
            w[i] = HASH[i] * (s[i] - 'a' + 1) + w[i - 1];

        for(int i = 1; i <= len; i++)
            for(int j = i; j <= len; j++) {
                dp[i][j].l = dp[i][j].c = (j - i + 1);
                dp[i][j].k = 1;
                dp[i][j].str = w[j] - w[i - 1];
        }

        for(int i = 1; i <= len; i++) {
            for(int l = 1; l <= len / 2; l++) {
                int k = 1;
                ULL st = w[l + i - 1] - w[i - 1];
                while((k + 1) * l + i - 1 <= len &&
                      st * HASH[l] == (w[(k + 1) * l + i - 1] - w[k * l + i - 1])) {
                    st = (w[(k + 1) * l + i - 1] - w[k * l + i - 1]);
                    k++;
                }
                int sl = l + getLen(k);
                if(l > 1) sl += 2;
                if(sl < dp[i][k * l + i - 1].l) {
                    dp[i][k * l + i - 1].l = sl;
                    dp[i][k * l + i - 1].k = k;
                    dp[i][k * l + i - 1].c = l;
                    dp[i][k * l + i - 1].str = w[l + i - 1] - w[i - 1];
                }

            }
        }

        for(int l = 1; l <= len; l++)
            for(int i = 1; i + l <= len; i++)
                for(int k = i; k < i + l; k++) {
                    Node tmp = Merge(i, k, i + l);
                    if(tmp.l < dp[i][i + l].l || tmp.l == dp[i][i + l].l && tmp.k > dp[i][i + l].k)
                        dp[i][i + l] = tmp;
                }
        printf("%d\n", dp[1][len].l);
    }
    return 0;
}