CodeForces 49 E.Common ancestor（dp）

Description

给出两个字符串$a$和$b$，有$n$种变换$c_i\rightarrow a_ib_i$表示可以把一个$c_i$字符变成连续的两个字符$a_ib_i$，问是否存在一个字符串$c$使得$c$可以经过若干次操作变成$a$和$b$，如果存在则求$c$的最短长度，如果不存在输出$-1$

Input

首先输入两个字符串$a$和$b$，之后输入一整数$n$表示变换个数，最后输入$n$个变换，所有字符均为小写字母

$(1\le |a|,|b|\le 50,0\le n\le 50)$

Output

如果存在满足条件的字符串$c$则输出$c$的最短长度，否则输出$-1$

Sample Input

ababa
aba
2
c->ba
c->cc

Sample Output

2

Solution

以$fa[i][j][c]$表示$a$字符串的第$i$个字符到第$j$个字符这段区间是否可以由字符$c$经过若干次操作形成，枚举$c$字符是否可以经过某个操作变成$c_1c_2$，进而有转移$fa[i][j][c]|=fa[i][k][c_1]\&\&fa[k+1][j][c_2],i\le k<j$，在转移的过程中记录$va[i][c]$表示使得$fa[i][j][c]=1$的右端点$j$的集合，同理可以求出$fb[i][j][c]$和$vb[i][c]$，时间复杂度$O(50^3\cdot 26)$

以$dp[i][j]$表示$a$字符串前$i$个字符和$b$字符串前$j$个字符可以被同一字符串表示出来的该字符串最短长度，则通过枚举下一个字符$c$以及枚举$va[i+1][c]$中元素$ii$和$vb[j+1][c]$中元素$jj$得到转移$dp[ii][jj]=min(dp[ii][jj],dp[i][j]+1)$，$dp[|a|][|b|]$即为答案，转移的时间复杂度$O(50^4\cdot 26)$

Code

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<ctime>
using namespace std;
typedef long long ll;
typedef pair<int,int>P;
const int INF=0x3f3f3f3f;
int la,lb,n,fa[55][55][27],fb[55][55][27],dp[55][55];
vector<int>va[55][27],vb[55][27];
vector<P>v[27];
char a[55],b[55],s[11];
int main()
{
    scanf("%s%s",a+1,b+1);
    la=strlen(a+1),lb=strlen(b+1);
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%s",s);
        v[s[0]-'a'].push_back(P(s[3]-'a',s[4]-'a')); 
    }
    for(int i=la;i>=1;i--)
    {
        fa[i][i][a[i]-'a']=1;
        va[i][a[i]-'a'].push_back(i);
        for(int j=i+1;j<=la;j++)
            for(int c=0;c<26;c++)
            {
                int flag=0;
                for(int l=0;l<v[c].size();l++)
                {
                    P temp=v[c][l];
                    int u=temp.first,v=temp.second;
                    for(int k=i;k<j;k++)
                        if(fa[i][k][u]&&fa[k+1][j][v])
                        {
                            fa[i][j][c]=1;
                            flag=1;
                            break;
                        }
                    if(flag)break;
                }
                if(flag)va[i][c].push_back(j);
            }
    }
    for(int i=lb;i>=1;i--)
    {
        fb[i][i][b[i]-'a']=1;
        vb[i][b[i]-'a'].push_back(i);
        for(int j=i+1;j<=lb;j++)
            for(int c=0;c<26;c++)
            {
                int flag=0;
                for(int l=0;l<v[c].size();l++)
                {
                    P temp=v[c][l];
                    int u=temp.first,v=temp.second;
                    for(int k=i;k<j;k++)
                        if(fb[i][k][u]&&fb[k+1][j][v])
                        {
                            fb[i][j][c]=1;
                            flag=1;
                            break;
                        }
                    if(flag)break;
                }
                if(flag)vb[i][c].push_back(j);
            }
    }
    memset(dp,-1,sizeof(dp));
    for(int c=0;c<26;c++)
        for(int i=0;i<va[1][c].size();i++)
            for(int j=0;j<vb[1][c].size();j++)
                dp[va[1][c][i]][vb[1][c][j]]=1;
    for(int i=1;i<la;i++)
        for(int j=1;j<lb;j++)
            if(~dp[i][j])
                for(int c=0;c<26;c++)
                    for(int x=0;x<va[i+1][c].size();x++)
                        for(int y=0;y<vb[j+1][c].size();y++)
                        {
                            int ii=va[i+1][c][x],jj=vb[j+1][c][y];
                            if(dp[ii][jj]==-1||dp[i][j]+1<dp[ii][jj])dp[ii][jj]=dp[i][j]+1;
                        }
    printf("%d\n",dp[la][lb]);
    return 0;
}