GMOJ P1241【PermRLE】

最新推荐文章于 2022-08-04 21:23:25 发布

sbxnmp

最新推荐文章于 2022-08-04 21:23:25 发布

阅读量98

点赞数 1

分类专栏：题解

本文链接：https://blog.csdn.net/qq_40167327/article/details/103432259

版权

题解专栏收录该内容

20 篇文章 0 订阅

订阅专栏

本文介绍了一种使用状态压缩动态规划（状压DP）的方法来解决特定字符串重组问题，目标是最小化重组后的字符串长度。通过巧妙的算法设计，文章详细解释了如何在给定条件下将字符串分割、重组并消除重复字符，最终达到最优解。

摘要由CSDN通过智能技术生成

Description

给你一个长度为 $n$ 的字符串，和一个正整数 $m$ ，其中 $m$ 能整除 $n$ ，现有一算法就是把整个字符串分成 $\dfrac{n}{m}$ 段，然后每一段按照一个相同的 $1$ ~ $m$ 的排列方式进行重新排列，然后把这 $\dfrac{n}{m}$ 段合并，算法把字符串中连续相同的字符合并成一个字符，得到一个新字符串。

请你求出新的字符串可能的最短长度。

$\leq m \leq 16,1 \leq n \leq 5 \leq 10^4$ 。

时间限制为 4s ，空间限制为 65536 KB 。

Solution

发现 $m$ 很小，考虑使用 状压 DP 来解题。

设 $f [S] [i] [j]$ 表示当前已经选的数的状态为 $S$ ，排列中的第一个数是 $i$ ，当前已经选择的最后一个数是 $j$ 的情况下的新字符串可能的最小长度。

但是我们发现这样会空超。

考虑删掉一维，于是我们得到了下面的定义：

设 $f [S] [i]$ 表示当前已经选的数的状态为 $S$ ，当前已经选择的最后一个数是 i 的情况下的新字符串可能的最小长度。

然后枚举 排列中的第一个数 即可。

这样就不会空超了。

然后我们设 $s u m [i] [j]$ 表示如果在排列中， $i$ 在 $j$ 的后面一个位置，那么所新产生的长度为 $s u m [i] [j]$ 。

这个是可以用 $O (n m)$ 的时间复杂度预处理出来的。

并且设 $s a m e (x, y)$ 表示当排列中的第 $m$ 个数为 $x$ ，排列中的第一个数为 $y$ 时能够消掉的长度为 $s a m e (x, y)$ 。

这个是可以用 $O(\dfrac{n}{m})$ 的时间复杂度求出来的，然后就可以利用它们来转移了。

转移方程如下：

$f[S|2^j][j]=\begin{cases} \min\{f[S][i]+sum[i][j]\}\quad\quad\quad\quad\quad\quad\quad\quad\; (S|2^j) \not= 2^m-1 \\ \min\{f[S][i]+sum[i][j]+same(j,he)\} \quad\quad (S|2^j) \not= 2^m-1 \end{cases}$

。

其中 $h e$ 表示的是排列中的第一个数。

时间复杂度

$O(2^mm^2+nm)$

，记得注意位运算的优先级！
然后这道题目就做完啦。

Code

#include <cstdio>
#include <cstring>
int f[ 65537 ][ 17 ] , sum[ 17 ][ 17 ] ;
char st[ 1000001 ] ;
int ans = 2147483647 , n = 0 , m = 0 ;
int min( int x , int y )
{
    return x < y ? x : y ;
}
int same( int x , int y )
{
    int da = 0 ;
    for(int i = 1 ; i <= n / m - 1 ; i ++ )
    {
        char tx = st[ ( i - 1 ) * m + x ] ;
        char ty = st[ i * m + y ] ;
        if( tx == ty )
        {
            da ++ ;
        }
    }
    return da ;
}
void work( int he )
{
    memset( f , 127 / 3 , sizeof( f ) ) ;
    f[ 1 << ( he - 1 ) ][ he ] = n / m ;
    int ma = ( 1 << m ) - 1 ;
    for(int S = 1 ; S <= ma ; S ++ )
    {
        if( ( S & ( 1 << ( he - 1 ) ) ) == 0 )
        {
            continue ;
        }
        for(int i = 1 ; i <= m ; i ++ )
        {
            if( ( S & ( 1 << ( i - 1 ) ) ) == 0 )
            {
                continue ;
            }
            for(int j = 1 ; j <= m ; j ++ )
            {
                if( ( S & ( 1 << ( j - 1 ) ) ) != 0 )
                {
                    continue ;
                }
                if( ( S | ( 1 << ( j - 1 ) ) ) != ma )
                {
                    f[ S | ( 1 << ( j - 1 ) ) ][ j ] = min( f[ S | ( 1 << ( j - 1 ) ) ][ j ] , f[ S ][ i ] + sum[ i ][ j ] ) ;
                }
                else
                {
                    f[ S | ( 1 << ( j - 1 ) ) ][ j ] = min( f[ S | ( 1 << ( j - 1 ) ) ][ j ] , f[ S ][ i ] + sum[ i ][ j ] - same( j , he ) ) ;
                }
            }
        }
    }
    for(int i = 1 ; i <= m ; i ++ )
    {
        if( he == i )
        {
            continue ;
        }
        ans = min( ans , f[ ma ][ i ] ) ;
    }
}
int main()
{
    scanf("%d" , &m ) ;
    scanf("%s" , st + 1 ) ;
    n = strlen( st + 1 ) ;
    for(int i = 1 ; i <= m ; i ++ )
    {
        for(int j = 1 ; j <= m ; j ++ )
        {
            if( i == j )
            {
                continue ;
            }
            for(int k = 1 ; k <= n / m ; k ++ )
            {
                if( st[ ( k - 1 ) * m + i ] != st[ ( k - 1 ) * m + j ] )
                {
                    sum[ i ][ j ] ++ ;
                }
            }
        }
    }
    for(int i = 1 ; i <= m ; i ++ )
    {
        work( i ) ;
    }
    printf("%d" , ans ) ;
    return 0 ;
}