Love Calculator LightOJ - 1013(线性递推 dp)

题目连接

题意

1. 给我们两个字符串 a、b ， 问我们两个问题：
   1. 输出 最短的字符串 s 的长度是多少，要求 a、b 都最为子序列出现在 s 中。
   2. 在最短长度的基础上，s 字符串有多少种方案数。

思路

1. 对于第一问最短长度模拟一下就可以得出：n + m - LIS (a,b), 其中 n = strlen (a), m = strlen (b) , LIS (a, b) 是 a、b 的最短公共子序列。
2. 对于第二问求方案数：自己做的时候没有思路，但是盲猜了一下状态转移方程为：dp [x][i][j]，觉得可以进行递推状态转移， 然后就从不可做，变为可做了😂 。
3. dp [x][i][j] 表示当前 s 字符串长度为 x，且包含了 a 字符串的前 i 位，b 字符串的前 j 位时，s 字符串的方案数。
4. 当我们在长度为 x 字符的基础上新添加一个字符能产生的状态转移为：

代码

#include <bits/stdc++.h>
using namespace std;
#define db  double
#define ll  long long
#define sc  scanf
#define pr  printf
#define fi  first
#define se  second
#define pb  push_back
#define m_p make_pair
#define Pir pair<int, int>
#define inf 0x3f3f3f3f
#define INF 0x3f3f3f3f3f3f3f3f
/*==========ACMer===========*/
const int N = 35;
int f[N][N];
ll dp[100][N][N];
char a[N], b[N];


int main()
{
    int T, cas = 1; sc("%d", &T);
    while (T --)
    {
        sc("%s %s", a + 1, b + 1);
        int n = strlen(a + 1);
        int m = strlen(b + 1);

        memset(f, 0, sizeof f);

        for (int i = 1; i <= n; i ++)
            for (int j = 1; j <= m; j ++)
            {
                if (a[i] == b[j])
                    f[i][j] = f[i - 1][j - 1] + 1;
                else
                    f[i][j] = max(f[i - 1][j], f[i][j - 1]);
            }

        memset(dp, 0, sizeof dp);
        dp[0][0][0] = 1;
        int len = n + m - f[n][m];

        for (int i = 0; i < len; i ++)
        {
            for (int j = 0; j <= n; j ++)
            {
                for (int k = 0; k <= m; k ++)
                {
                    if (dp[i][j][k])
                    {
                        if (a[j + 1] == b[k + 1])
                            dp[i + 1][j + 1][k + 1] += dp[i][j][k];
                        else
                        {
                            dp[i + 1][j + 1][k] += dp[i][j][k];
                            dp[i + 1][j][k + 1] += dp[i][j][k];
                        }
                    }
                }
            }
        }

        pr("Case %d: %d %lld\n", cas ++, len, dp[len][n][m]);
    }



    return 0;
}