多维DP UVA 11552 Fewest Flop

题目传送门

 /*
     题意：将子符串分成k组，每组的字符顺序任意，问改变后的字符串最少有多少块
     三维DP：可以知道，每一组的最少块是确定的，问题就在于组与组之间可能会合并块，总块数会-1。
         dp[i][j]表示第i组以第j个字符结尾的最少块数，状态转移方程：dp[i][j] = min (dp[i][j], dp[i-1][l] + chunk - 1);
         意思就是枚举上一组的所有字符，当出现在i组并且不是放到末尾，那么能-1
 */
 /************************************************
 * Author        :Running_Time
 * Created Time  :2015-8-7 11:08:46
 * File Name     :UVA_11552.cpp
  ************************************************/

 #include <cstdio>
 #include <algorithm>
 #include <iostream>
 #include <sstream>
 #include <cstring>
 #include <cmath>
 #include <string>
 #include <vector>
 #include <queue>
 #include <deque>
 #include <stack>
 #include <list>
 #include <map>
 #include <set>
 #include <bitset>
 #include <cstdlib>
 #include <ctime>
 using namespace std;

 #define lson l, mid, rt << 1
 #define rson mid + 1, r, rt << 1 | 1
 typedef long long ll;
 const int MAXN = 1e3 + ;
 const int INF = 0x3f3f3f3f;
 const int MOD = 1e9 + ;
 char str[MAXN];
 int dp[MAXN][MAXN];
 bool vis[];

 int main(void)    {     //UVA 11552 Fewest Flop
     int T;  scanf ("%d", &T);
     while (T--) {
         int k;  scanf ("%d%s", &k, str + );
         int len = strlen (str + );
         memset (dp, INF, sizeof (dp));
         for (int i=; i<=len/k; ++i)    {
             memset (vis, false, sizeof (vis));
             for (int j=(i-)*k+; j<=i*k; ++j)  {
                 vis[str[j]] = true;
             }
             int chunk = ;
             for (int j='a'; j<='z'; ++j)    {
                 if (vis[j])    chunk++;
             }
             if (i == ) {
                 for (int j=; j<=k; ++j)    {
                     dp[i][j] = chunk;
                 }
                 continue;
             }
             for (int j=; j<=k; ++j)    {
                 int last = (i - ) * k + j;
                 for (int l=; l<=k; ++l)    {
                     int pre = (i - ) * k + l;
                     if (vis[str[pre]] && (chunk ==  || str[pre] != str[last]))  {
                         dp[i][j] = min (dp[i][j], dp[i-][l] + chunk - );
                     }
                     else    dp[i][j] = min (dp[i][j], dp[i-][l] + chunk);
                 }
             }
         }

         int ans = INF;
         for (int i=; i<=k; ++i)    {
             ans = min (ans, dp[len/k][i]);
         }
         printf ("%d\n", ans);
     }

     return ;
 }