Codeforces Round #338 (Div. 2) C. Running Track（DP）

最新推荐文章于 2024-07-15 17:55:50 发布

原创最新推荐文章于 2024-07-15 17:55:50 发布 · 521 阅读

1 ·

CC 4.0 BY-SA版权

动态规划专栏收录该内容

54 篇文章

订阅专栏

本文介绍了一种使用一个字符串的子串及其旋转形式来构建另一个字符串的方法。通过动态规划等技术找到最优解，即最少次数的子串使用来完成构建。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题意：

给你两个字符串a和b，让你用a中的子串来构造b（a中的子串可以旋转），让你输出构成方案。

思路：

做了好久好久，最终还是借鉴了大神的思路过的。此题实现的方法有很多，字典树、KMP、DP都可以做，据说直接暴力也是能过的…
首先根据字符串a正序逆序跑一遍和b的公共子串，分别存到dp1和dp2中。dp1[i][j] （dp2[i][j]）表示能从当前位置往前匹配长度为dp1[i][j]的字符串。
状态转移方程式：

if(a[i]==b[j])
dp1[i][j]=dp[i-1][j-1]+1

数组dp用来维护构成b需要的a的子串的数量，数组step用来记录字符串回跳的位置。

#include<string.h>
#include<stdio.h>
#include<stdlib.h>
#include<algorithm>
using namespace std;
#define ll __int64     
const int maxn = 1000001;
const int INF=1<<30;
const double EPS = 1e-5;
const double PI = acos(-1.0);
char a[2200],b[2200],c[2200];
int dp1[2200][2200],dp2[2200][2200];//记录公共最长子串
int dp[2200];//用来记录能用多少a的子串组成b
int path[2200];
int ans[2200][4];
int main()
{
    int t,n,m,i,j;
    scanf("%s%s",a+1,b+1);
    int lena=strlen(a+1);
    int lenb=strlen(b+1);
    for(i=1;i<=lenb;++i)
        dp[i]=INF;
    memset(dp1,0,sizeof(dp1));
    memset(dp2,0,sizeof(dp2));
    for(i=1,j=lena;i<=lena;++i,--j)
    {
        c[i]=a[j];
    }
    for(i=1;i<=lena;++i)
    {
        for(j=1;j<=lenb;++j)
        {
            if(a[i]==b[j]) dp1[i][j]=dp1[i-1][j-1]+1;
            if(c[i]==b[j]) dp2[i][j]=dp2[i-1][j-1]+1;
        }
    }
    for(i=1;i<=lenb;++i)
    {
        for(j=1;j<=lena;++j)
        {
            if(dp1[j][i]&&dp[i]>dp[i-dp1[j][i]]+1)
            {
                dp[i]=dp[i-dp1[j][i]]+1;
                path[i]=i-dp1[j][i];
            }

            if(dp2[j][i]&&dp[i]>dp[i-dp2[j][i]]+1)
            {
                dp[i]=dp[i-dp2[j][i]]+1;
                path[i]=i-dp2[j][i];
            }
        }
    }
    int p = lenb;
    int num = dp[lenb];
    if(num==INF)
    {
        puts("-1");
    }
    else
    {
        while(num--)
        {
            for(i=1;i<=lena;++i)
            {
                if(dp1[i][p]+path[p]==p)
                {
                    ans[num][0]=i-dp1[i][p]+1;
                    ans[num][5]=i;
                    p=path[p];
                    break;
                }
                if(dp2[i][p]+path[p]==p)
                {
                    ans[num][0]=lena-i+dp2[i][p];
                    ans[num][6]=lena-i+1;
                    p=path[p];
                    break;
                }
            }
        }
        printf("%d\n",dp[lenb]);
        for(i=0;i<dp[lenb];++i)
            printf("%d %d\n",ans[i][0],max(ans[i][6],ans[i][5]));
    }
    return 0;
}