字符合并 题解

由于分数非负，所以对于能够合并的区间要尽量去合并

一个区间合并后的最终长度范围为$1\sim k-1$

设$asd[i][j][t]$表示初始串中$[i,j]$合并成状态$t$时的最大分数。

初始值：

$asd[i][i][no{w}_{state}]=0$

$asd[i][i][othe{r}_{state}]=-inf$

按照区间长度从小到大来枚举$[i,j]$，枚举$k,t_1,t_2$表示$[i,j]$由$[i,k-1]$，$[k,j]$转移而来，$[i,k-1]$，$[k,j]$

合并后的状态分别为$t_1$，$t_2$。

由此可得$dp$转移式子就：

$asd[i][j][merge(t_1,t_2)]=max(asd[i][k-1][t_1]+asd[k][j][t_2])$

最终答案就是$max(asd[1][n][al{l}_{state}])$

预计得分$80pts$

考虑优化。

$FIRST$：

对于一个长度为$len$的区间，它合并后的最终长度是一个定值，即$(len-1)\%(k-1)+1$。所以$t$这个状态枚举量可以得到优化。

$SECOND$：

对于一个区间内的合并，会出现子区间的合并先后顺序不同但本质相同的情况。考虑怎么优化 ：对于当前区间$[i,j]$假设它由$[i,k-1]$，$[k,j]$转移而来，那么我们要求$k$是满足$[k,j]$区间合并后长度为$1$的数，这样的话就唯一确认了合并序列。

状态转移方程：

$asd[i][j][(t<<1)+0/1]=max(asd[i][k-1][t]+asd[k][j][0/1])$

特殊地，如果$[i,j]$可以恰好合并成一个字符，则有$asd[i][j][c[t]]=max(asd[i][j][t]+w[t])$，其中$c[t]$，$w[t]$表示合并状态$t$后产生的新字符和分数。

额外的，判断最优值时，先用一个新变量$g[0/1]$存最优值，而不是直接更新$asd$数组，以防止转移顺序影响计算。

#include<bits/stdc++.h>
using namespace std;
#define f1(a,b,c) for(int c=a;c<=b;c++)
#define f2(a,b,c) for(int c=a;c>=b;c--)
#define f3(a,b,c) for(int c=a;c;c=b)
#define so1(a,n) sort(a+1,a+n+1,mycmp);
#define so2(a,n) sort(a+1,a+n+1);
#define ll long long
#define itn int
#define ubt int 
#define mp make_pair
#define pii pair<int,int>
#define pll pair<ll,ll>
const int twx=300+100;
const ll inf=0x3f3f3f3f3f3f3f3f;
ll read()
{
    ll sum=0;
    ll flag=1;
    char c=getchar();
    while(c<'0'||c>'9')
    {
        if(c=='-')
        {
            flag=-1;
        }
        c=getchar();
    }
    while(c>='0'&&c<='9')
    {
        sum=((sum*10)+c-'0');
        c=getchar();
    }
    return sum*flag;
}
int n,k;
int a[twx];
int c[twx];
int w[twx];
ll asd[twx][twx][1<<8];//asd[i][j][t]表示将初始串中[i,j]合并成t状态所得的最大值
ll g[twx];
ll ans=-inf;
void cmax(ll &x,const ll &y)
{
    if(x<y)
    {
        x=y;
    }
    return ; 
}
void init()
{
	n=read();
    k=read();
    f1(1,n,i)
    {
        a[i]=read();
    }
    f1(0,(1<<k)-1,i)
    {
        c[i]=read();
        w[i]=read();
    }
}
void work()
{
    f1(1,n,i)
    {
        f1(0,(1<<k)-1,j)
        {
            asd[i][i][j]=-inf;
        }
        asd[i][i][a[i]]=0;
    }
    f1(2,n,len)
    {
        for(int i=1,j=i+len-1;j<=n;i++,j++)
        {
            f1(0,(1<<k)-1,t)
            {
                asd[i][j][t]=-inf;
            }
            int l=(len-1)%(k-1);
            if(!l)
            {
                l=k-1;
            }
            for(int s=j;s>i;s-=k-1)
            {
                f1(0,(1<<l)-1,t)
                {
                    cmax(asd[i][j][t<<1],asd[i][s-1][t]+asd[s][j][0]);
                    cmax(asd[i][j][t<<1|1],asd[i][s-1][t]+asd[s][j][1]);
                }
            }
            if(l==k-1)
            {
                g[0]=g[1]=-inf;
                f1(0,(1<<k)-1,t)
                {
                    cmax(g[c[t]],asd[i][j][t]+w[t]);
                }
                asd[i][j][0]=g[0];
                asd[i][j][1]=g[1];
            }
        }
    }
    f1(0,(1<<k)-1,t)
    {
        cmax(ans,asd[1][n][t]);
    }
}
void print()
{
    printf("%lld\n",ans);
}
int main()
{
    init();
    work();
    print();
	return 0;
}