uva10453动态规划+递归回溯

最新推荐文章于 2024-04-24 23:16:35 发布

hesorchen

最新推荐文章于 2024-04-24 23:16:35 发布

阅读量163

点赞数

CC 4.0 BY-SA版权

分类专栏： # 区间DP

本文链接：https://blog.youkuaiyun.com/hesorchen/article/details/115980009

区间DP 专栏收录该内容

5 篇文章

订阅专栏

本文介绍了一种算法，解决如何在给定字符串中添加最少字符使其成为回文串，同时记录了状态转移过程。通过动态规划实现，代码展示了如何构造dp数组和处理边界情况，最终输出最小添加字符数及构建回文串的一种方案。

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

题目

给一个字符串，可以在任意位置增加任意字符，求最小增加多少个字符使字符串变成回文串，并输出一种方案。

求最小代价的题已经写过了，这题只需要状态转移的时候记录路径。（实际上好抽象，想不明白，不过瞎调调出来了… …

代码

#include <bits/stdc++.h>
using namespace std;

struct node
{
    int L, R;
    char V;
} opt[1010][1010];
char s[1010];

string v1[1010];
string v2[1010];
int dp[1010][1010];

void dfs(int l, int r)
{
    if (l == r)
        return;
    if (opt[l][r].L == l)
    {
        if (opt[l][r].V)
            v1[l] += opt[l][r].V;
    }
    else if (opt[l][r].R == r)
    {
        if (opt[l][r].V)
            v2[r] += opt[l][r].V;
    }
    dfs(opt[l][r].L, opt[l][r].R);
}
void solve()
{
    memset(dp, 0x3f3f3f3f, sizeof dp);
    int n = strlen(s + 1);
    for (int i = 1; i <= n; i++)
        v1[i].clear(), v2[i].clear();

    for (int i = 1; i <= n; i++)
        for (int j = i; j <= n; j++)
            opt[i][j].L = opt[i][j].R = opt[i][j].V = 0;
    for (int i = 1; i <= n; i++)
        dp[i][i] = 0;
    for (int i = 1; i < n; i++)
    {
        if (s[i] == s[i + 1])
        {
            opt[i][i + 1].L = i;
            opt[i][i + 1].R = i;
            dp[i][i + 1] = 0;
        }
        else
        {
            opt[i][i + 1].L = i;
            opt[i][i + 1].R = i;
            opt[i][i + 1].V = s[i + 1];
            dp[i][i + 1] = 1;
        }
    }

    for (int len = 3; len <= n; len++)
    {
        for (int l = 1; l <= n; l++)
        {
            int r = l + len - 1;
            if (s[l] == s[r])
            {
                dp[l][r] = dp[l + 1][r - 1];
                opt[l][r].L = l + 1;
                opt[l][r].R = r - 1;
            }
            else
            {
                if (dp[l + 1][r] + 1 < dp[l][r])
                {
                    dp[l][r] = dp[l + 1][r] + 1;
                    opt[l][r].L = l + 1;
                    opt[l][r].R = r;
                    opt[l][r].V = s[l];
                }
                if (dp[l][r - 1] + 1 < dp[l][r])
                {
                    dp[l][r] = dp[l][r - 1] + 1;
                    opt[l][r].L = l;
                    opt[l][r].R = r - 1;
                    opt[l][r].V = s[r];
                }
            }
        }
    }
    cout << dp[1][n] << ' ';
    dfs(1, n);
    for (int i = 1; i <= n; i++)
    {
        cout << v1[i];
        cout << s[i];
        reverse(v2[i].begin(), v2[i].end());
        cout << v2[i];
    }
    cout << endl;
}
int main()
{
    while (cin >> s + 1)
        solve();
    return 0;
}