POJ 2817 WordStack (状态DP)

一些二进制的基本知识：

判断j是否属于集合i：i&(1<< j)
在集合i中去除j：i-(1<< j)或者i&(!(1<< j)) i^(1<< j)
在集合i中加入点j：i|(1<< j);

先预处理len[i][j]表示第i个字符串与第j个字符串组合能匹配的最大字符数
用一个二进制数表示字符串的选取情况，1表示选取字符串，0表示不选；因此每个字符串有0和1两种状态，那么n个字符串就有2^n种选取方式（状态），如n=3, 枚举所有状态：000，001，010，011，100，101，110，111，分别表示一个也不选，选第1个，选第2个，第3个……第7个。
dp[i][j]代表当选取的字符串为i状态，且最后一个选取的字符串是第j个字符串时的最优值
状态转移：枚举某个状态时，枚举一个已选的字符串（即当前状态二进制位为1的位），再枚举一个未选的字符串（当前状态二进制位为0的位），通过这两个字符串的拼接来更新拼接之后新的状态，因为加进了一个没在状态中的字符串，所以状态变成了 i|(1<< k) 假设i是当前枚举的状态，k是二进制位为0的位

所以状态转移就为:

dp[i|(1<< k)][k]=max(dp[i|(1<< k)][k],dp[i][j]+len[j][k]);

如果大家仔细观察一下代码中的关键转移部分，会发现：当我们要去更新dp[i|(1<< k)][k]状态时，dp[i][j]肯定已经是求好了的，在这道题目里dp[i][j]就是dp[i|(1<< k)][k]的子结构，每次都尝试着用dp[i|(1<< k)][k]的子结构去更新它。

#include<iostream>
#include<string>
#include<algorithm>

const int MaxState = 1 << 10;
const int Max = 12;
int dp[MaxState][Max];
int len[Max][Max];
std::string word[Max];
int n;

int main() {
    while (std::cin >> n, n) {
        memset(len, 0, sizeof(len));
        memset(dp, 0, sizeof(dp));

        for (int i = 0; i < n; ++i) {
            std::cin>>word[i];
        }

        for (int i = 0; i < n; ++i)
        {
            for (int j = 0; j < n; ++j)
            {
                if (i != j) {
                    int maxDiff = -1;

                    for (int k = 0; k < word[j].length(); ++k) {
                        int diff = 0;
                        for (int m = 0, n = k; m < word[i].length() && n < word[j].length(); ++m, ++n) {
                            if (word[i][m] == word[j][n]) {
                                diff++;
                            }
                        }
                        maxDiff = std::max(maxDiff, diff);
                    }

                    len[i][j]=len[j][i] = std::max(len[i][j], maxDiff);
                }
            }

        }

        for (int i = 0; i < (1 << n); ++i) {
            for (int j = 0; j < n; ++j) {
                if (i&(1 << j)) {
                    for (int k = 0; k < n; ++k) {
                        if (!(i&(1 << k))) {
                            dp[i|1<<k][k] = std::max(dp[i|1<<k][k], dp[i][j] + len[j][k]);
                        }
                    }
                }
            }
        }
        int count = 0;
        for (int i = 0; i < n; ++i) {
            count = std::max(count, dp[(1 << n) - 1][i]);
        }
        std::cout << count << std::endl;
    }
    return 0;
}

---

参考：http://www.cnblogs.com/ACMan/archive/2012/08/08/2628853.html