动态规划_基础_最长公共子序列_多种方法

D: 魔法少女资格面试

题目描述

众所周知，魔法少女是一个低危高薪职业。随着近年来报考魔法少女的孩子们越来越多，魔法少女行业已经出现饱和现象！
为了缓和魔法少女界的就业压力，魔法少女考核员丁丁妹决定增加魔法少女资质考核的难度。
然而，即使如此，通过资质考核的魔法少女们数量仍然过多，因此，丁丁妹决心增加一轮面试，从而淘汰掉更多的预备魔法少女。
具体而言，她打算对所有面试者询问这样一个问题：
给两个长度为

的全排列，它们的最长公共子序列长度是多少？
不幸的是，由于丁丁妹没有好好上过学，她自己也不知道答案是多少，因此她使用魔法找到了你，希望你来帮她解决这个问题。

输入描述

每个测试点仅有一组数据。
第一行是一个正整数

，表示全排列长度。
第二行有

个整数，保证是一个

的全排列。
第三行有

个整数，保证是一个

的全排列。
其中，保证

≤

1000

。

输出描述

输出一行一个整数，表示两数组的最长公共子序列长度。

样例输入

5
1 3 2 4 5
5 2 3 1 4

样例输出

Hint

如果你愿意思考

≤

1000000

时的解法，那么丁丁妹会很高兴地录取你。

题解思路

这道题思路比较明显的，关系式就是：

也可以从后往前写成

L（i，j）=L（i+1，j+1）取等

L（i，j）=max（L（i，j+1），L（i+1，j））不等

但是这个式子我用递归直接写，就给TE了，如下为代码：

 #include <iostream>

 #include <cstdio>

 #include <cstring>

 #include <algorithm>

 #include <numeric>

 using namespace std;

 typedef long long ll;

 const int M=1e3+;

 int n;

 int a[M],b[M];

 int ans=;

 int dfs(int x,int y) {

     int t=;

     if(y>n||x>n) {

         return t;

     } else if(a[x]==b[y]) {

         t=+dfs(x+,y+);

     } else {

         int t1=dfs(x,y+);

         int t2=dfs(x+,y);

         t=max(t1,t2);

     }

     ans=max(ans,t);

     return t;

 }

 /*

 6

 5 3 1 4 2 6

 1 5 3 2 4 6

 */

 int main() {

     scanf("%d",&n);

     for(int i=; i<=n; i++)scanf("%d",&a[i]);

     for(int i=; i<=n; i++)scanf("%d",&b[i]);

     dfs(,);

     printf("%d\n",ans);

     return ;

 }

改了一下，写成动态规划，将原本dfs（i，j）改写成dp【i】【j】存起来

i ，j，表示当前序列 — a，b，分别在哪个位置，dp【i】【j】表示在这一状态下，a1-- ai 与 b1-- bj，存在最大公共子序列的长度

 #include <iostream>

 #include <cstdio>

 #include <cstring>

 #include <algorithm>

 #include <numeric>

 using namespace std;

 typedef long long ll;

 const int M=1e3+;

 int n;

 int a[M],b[M];

 int ans=;

 int dp[M][M];

 /*

 int dfs1(int x,int y) {

     int t=0;

     if(y>n||x>n) {

         return t;

     } else if(a[x]==b[y]) {

         t=1+dfs(x+1,y+1);

     } else {

         int t1=dfs(x,y+1);

         int t2=dfs(x+1,y);

         t=max(t1,t2);

     }

     ans=max(ans,t);

     return t;

 }

 int dfs(int x,int y) {

     int t=0;

     if(y<1||x<1) {

         return t;

     } else if(a[x]==b[y]) {

         t=1+dfs(x-1,y-1);

     } else {

         int t1=dfs(x,y-1);

         int t2=dfs(x-1,y);

         t=max(t1,t2);

     }

     ans=max(ans,t);

     return t;

 }*/

 /*

 6

 5 3 1 4 2 6

 1 5 3 2 4 6

 */

 void f() {

     int i,j;

     memset(dp,,sizeof(dp));

     for( i=; i<=n; i++) {

         for( j=; j<=n; j++) {

             if(a[i]==b[j]) {

                 dp[i][j]=dp[i-][j-]+;

             } else {

                 dp[i][j]=max(dp[i-][j],dp[i][j-]);

             }

         }

     }

     printf("%d\n",dp[n][n]);

 }

 int main() {

     scanf("%d",&n);

     for(int i=; i<=n; i++)scanf("%d",&a[i]);

     for(int i=; i<=n; i++)scanf("%d",&b[i]);

     f();

 //    int n1=n;

     //dfs(n1,n1);

     //printf("%d\n",ans);

     return ;

 }

（AC代码）

巴特西

动态规划_基础_最长公共子序列_多种方法_递归/dp