[Noip模拟题]PermRLE

Description
文本压缩的算法有很多种，这里给出一种叫做PermRLE的压缩算法。定义一个整数$k$， PermRLE算法依赖于一种压缩顺序。所谓的压缩顺序就是一种1~$k$的排列。例如当$k=4$的时候，其中一种排列方式是{1,2,4,3},对于字符串”abdb”，按照这种排列方式进行排列之后就变成了”abbd”。对于一段长度为$Len$的文本，其中$k$能整除$Len$，那么PermRLE算法就是把整个文本分成$Len/k$段，然后每一段按照一种1~$k$的排列方式进行重新排列，重新排列完之后，就把这$Len/k$段进行合并。对于合并之后得到一个新字符串，PermRLE算法就是把字符串中连续相同的字符合并成一个字符，例如aabccaabb合并后就变成了abcab。给出一段长度$Len(1≤Len≤50000)$的文本以及一个整数$k(1≤k≤16)$其中$k$能整除$Len$，你的任务就是找出一种1~$k$的排列，使得PermRLE算法压缩之后的文本的长度最小。当然，为了降低难度，你只需输出文本压缩之后最小的长度，而不需要输出这种排列。

Input
输入第一行有一个整数$k(1≤k≤16)$，意义如上所述。
接下来一行有一个字符串，保证字符串的长度能被k整除，且字符串里仅含有小写字母。
$1≤k≤16$，$1≤Len≤50000$

Output
输出一行，仅包含文本压缩之后的最小长度。

Sample Input
4
abcabcabcabc

Sample Output
7

HINT
$k$的排列是1 4 3 2，然后原字符串变成aacbbbacccba，压缩之后变成acbacba，长度为7，可以证明，这是最小答案

思路
对于一个字符串，它总是能够分成$Len/k$段。记两个数组$inside_{i,j}$和$between_{i,j}$，前者表示在$Len/k$个块中每个块的第$i$个和第$j$个字符总共有多少个相同的，后者表示每个块的第$i$个字符和下一个块的第$j$个字符总共有多少个相同的。如样例：

abcabcabcabc

分成块就是：

abca
bcab
cabc

那么$inside_{1,4}=3$，$inside_{1,3}=0$，$between_{4,3}=2$。
对于$k$的一个排列，显然只需要关心那些数出现过，那些没有，设$f_{S,i,j}$表示在前$x$个数中（不关心$x$的值），使用过的数是$S$的二进制状态，第一个数字为$i$，最后一个数字为$j$所能压缩的最大长度。 那么状态转移方程为：

$$f_{S,j,k}=f_{S-(1<<k-1),j,x}+inside_{k,x}(j,k,x\in{S},j!=k)$$ 最后考虑块与块之间的压缩，对于每个$f_{(1<<n)-1,i,j}$，都加上$between_{i,j}$，最终$n-\max(f_{(1<<n)-1,i,j})$就是压缩后答案的最小值。

代码

#include <cstdio>
#include <cstring>
#include <algorithm>

const int maxn=16;
const int maxlen=60000;

int f[1<<maxn][maxn+1][maxn+1],ans;
int n,len,inside[maxn+1][maxn+1],between[maxn+1][maxn+1];
char s[maxlen+10];

int main()
{
    scanf("%d%s",&n,s+1);
    len=strlen(s+1);
    for(int i=0; i<len/n; i++)
    {
        for(int j=1; j<=n; j++)
        {
            for(int k=1; k<=n; k++)
            {
                if(j!=k)
                {
                    inside[j][k]+=s[i*n+j]==s[i*n+k];
                }
            }
        }
    }
    for(int i=0; i<len/n-1; i++)
    {
        for(int j=1; j<=n; j++)
        {
            for(int k=1; k<=n; k++)
            {
                between[j][k]+=s[i*n+j]==s[(i+1)*n+k];
            }
        }
    }
    for(int i=0; i<1<<n; i++)
    {
        for(int j=1; j<=n; j++)
        {
            if(i&(1<<(j-1)))
            {
                for(int k=1; k<=n; k++)
                {
                    if((j!=k)&&(i&(1<<(k-1))))
                    {
                        for(int l=1; l<=n; l++)
                        {
                            if(i&(1<<(l-1)))
                            {
                                if(k!=l)
                                {
                                    f[i][j][k]=std::max(f[i][j][k],f[i^(1<<(k-1))][j][l]+inside[k][l]);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    for(int i=1; i<=n; i++)
    {
        for(int j=1; j<=n; j++)
        {
            ans=std::max(ans,f[(1<<n)-1][i][j]+between[i][j]);
        }
    }
    printf("%d\n",len-ans);
    return 0;
}