UVA 1204 Fun Game(状压dp)

此题真心有难度，之前刷紫书dp题时就卡在这题，重新拿起总算基本想通，但是关于每个串都与下个串有重叠的解决办法没有看懂，最后去看了下LRJ的代码，原来根本不必额外特判什么的。只需要规定一个串为首串，在最后的时候把dp[(1<<n)-1][x]中的x与规定那个串减下重叠长度就行，至于绕好几圈的那个问题就更加简单了，因为如果他绕了好几圈，那么在去除那些被包含的串的时候，就会把所有的串除了那个绕几圈的串给删除，最后只剩下那个绕几圈的串，那么在做预处理2个串（自己和自己）最大叠起来长度的时候，就已经找到这个串的最短长度了，最短长度等于串长度减去重叠的就是了，这个和kmp里的一道题的思想类似。

然后其他的做法书上都说了，对于一个状态加一个串是正过来贴还是反过来贴去更新下个状态。

然后我还犯了一个很隐蔽的错误，找了很久。。具体就是，在去除那些被包含的串的时候，如果2个串是相同或者是颠倒相同的时候，我会把2个串都删了。。这个LRJ代码里是按照长度排序后只跟后面的一一比较。而我是全部都比较，所以会出现这个问题，解决的话规定一个方向就行了，如果是2个串长度一样，且重叠起点是开头，那么i>j才删除，反之不删除。

其实现在想想，此题的难度就在于圈的时候怎么处理，以及预处理写起来比较烦。

AC代码：

#pragma comment(linker, "/STACK:102400000,102400000")
#include<cstdio>
#include<ctype.h>
#include<algorithm>
#include<iostream>
#include<cstring>
#include<vector>
#include<cstdlib>
#include<stack>
#include<queue>
#include<set>
#include<map>
#include<cmath>
#include<ctime>
#include<string.h>
#include<string>
#include<sstream>
#include<bitset>
using namespace std;
#define ll long long
#define ull unsigned long long
#define eps 1e-8
#define NMAX 201000
#define MOD 1000000007
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define PI acos(-1)
template<class T>
inline void scan_d(T &ret)
{
    char c;
    int flag = 0;
    ret=0;
    while(((c=getchar())<'0'||c>'9')&&c!='-');
    if(c == '-')
    {
        flag = 1;
        c = getchar();
    }
    while(c>='0'&&c<='9') ret=ret*10+(c-'0'),c=getchar();
    if(flag) ret = -ret;
}
int comp[17][2][17][2],len[17];
char s[17][2][105];
bool can[17];
int dp[(1<<16)+10][17][2],n;

int find_overlap(char *a, char *b, int len1, int len2)
{
    int p;
    if(len1 > len2) p = len1-len2+1;
    else p = 1;
    for(int i = p; i < len1; i++)
    {
        if(strncmp(a+i,b,len1-i) == 0)
            return len1-i;
    }
    return 0;
}

void init()
{
    char tmp[17][2][105];
    int tlen[17];
    for(int i = 0; i < n; i++)
    {
        scanf("%s",tmp[i][0]);
        int m = strlen(tmp[i][0]);
        strcpy(tmp[i][1],tmp[i][0]);
        reverse(tmp[i][1],tmp[i][1]+m);
//        reverse_copy(tmp[i][0],tmp[i][0]+m,tmp[i][1]);
//        cout<<tmp[i][1]<<endl;
        tlen[i] = m;
    }
    memset(can,0,sizeof(can));
    for(int i = 0; i < n; i++)//remove strings
    {
        for(int j = 0; j < n; j++) if(j != i)
        {
            if(tlen[j] < tlen[i]) continue;
            bool ok = 0;
            for(int k = 0; k <= tlen[j] - tlen[i]; k++)
            {
                if(strncmp(tmp[i][0],tmp[j][0]+k,tlen[i]) == 0)
                {
                    ok = 1;
                    if(k == 0 && tlen[i] == tlen[j] && i > j) ok = 0;
                    break;
                }
                if(strncmp(tmp[i][0],tmp[j][1]+k,tlen[i]) == 0)
                {
                    ok = 1;
                    if(k == 0 && tlen[i] == tlen[j] && i > j) ok = 0;
                    break;
                }
            }
            if(ok)
            {
                can[i] = 1;
                break;
            }
        }
    }
    int nct = 0;
    for(int i = 0; i < n; i++) if(!can[i])
    {
        memcpy(s[nct],tmp[i],sizeof(tmp[i]));
        len[nct++] = tlen[i];
    }
    n = nct;
    for(int i = 0; i < n; i++)
        for(int x = 0; x < 2; x++)
            for(int j = 0; j < n; j++)
                for(int y = 0; y < 2; y++)
                    comp[i][x][j][y] = find_overlap(s[i][x],s[j][y],len[i],len[j]);
}

int main()
{
#ifdef GLQ
    freopen("input.txt","r",stdin);
//    freopen("o3.txt","w",stdout);
#endif
    while(~scanf("%d",&n) && n)
    {
        init();
        memset(dp,-1,sizeof(dp));
        dp[1][0][0] = len[0];
        for(int s = 1; s < (1<<n); s++)
            for(int i = 0; i < n; i++)
                for(int j = 0; j < 2; j++) if(dp[s][i][j] != -1)
                    for(int k = 0; k < n; k++) if(!((1<<k)&s))
                    {
                        int &d = dp[s|(1<<k)][k][0],&d2 = dp[s|(1<<k)][k][1];
                        if(d == -1 || d > dp[s][i][j]+len[k]-comp[i][j][k][0])
                            d = dp[s][i][j]+len[k]-comp[i][j][k][0];
                        if(d2 == -1 || d2 > dp[s][i][j]+len[k]-comp[i][j][k][1])
                            d2 = dp[s][i][j]+len[k]-comp[i][j][k][1];
                    }
        int ans = -1;
        for(int i = 0; i < n; i++)
            for(int j = 0; j < 2; j++) if(dp[(1<<n)-1][i][j] > 0)
            {
                if(ans == -1 || ans > dp[(1<<n)-1][i][j]-comp[i][j][0][0])
                    ans = dp[(1<<n)-1][i][j]-comp[i][j][0][0];
            }
        if(ans < 2) ans = 2;
        printf("%d\n",ans);
    }
    return 0;
}