DP基础（LIS和LCS）

最新推荐文章于 2024-04-07 23:50:03 发布
最新推荐文章于 2024-04-07 23:50:03 发布
阅读量367 收藏 1
点赞数
分类专栏： 模板 文章标签： DP基础 LIS LCS 最大上升子序列 最长公共子序列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43870697/article/details/97413565
版权

目录

 

LIS（最大上升子序列）

思路

模板

LCS（最长公共子序列）

思路

模板

例题

A:POJ-1836 Alignment

B:POJ-2533 Longest Ordered Subsequence

C:HDU-1159 Common Subsequence

D:POJ-2250 Compromise

E:POJ-2264 Advanced Fruits

F:HDU-1160 FatMouse's Speed

LIS（最大上升子序列）

思路

状态设计：dp[i]代表以a[i]结尾的LIS的长度
状态转移：dp[i]=max(dp[i], dp[j]+1) (1<=j< i, a[j]< a[i])
边界处理：dp[i]=1 (1<=i<=n)
时间复杂度：O(N^2)

模板

#include<iostream>
#include<string>
#include<cstring>
#include<algorithm>
#define MAXN 1000
using namespace std;
typedef long long ll;
int ans[MAXN+5];
int dp[MAXN+5];
int main()
{
	int n,re=1;
	cin>>n;
	for(int i=1;i<=n;++i){
		cin>>ans[i];
	}
	for(int i=1;i<=n;++i){
		dp[i]=1;
		for(int j=1;j<=i-1;++j){
			if(ans[j]<ans[i]) dp[i]=max(dp[i],dp[j]+1);
		}
		re=max(re,dp[i]);
	}
	cout<<re<<endl;
 }

LCS（最长公共子序列）

思路（转自LCS）

dp[i][j]表示字符串x的前i个字符构成的子串和字符串y的前j个字符构成的子串的最长公共子序列的长度

状态转移方程

i=0 or j=0说明有一个字符串的长度为0，因此最长公共组序列长度为0。当字符串x的第i个字符和字符串y的第j个字符相等时，dp[i][j]就等于dp[i-1][j-1]+1，如果不等dp[i][j]=max(dp[i][j-1],dp[i-1][j])

模板

int dp[1000][1000]
int Lcs(string x,string y)
{
	for(int i=0;i<=x.length();i++)
	  for(int j=0;j<=y.length();j++)
	    if(i==0||j==0)
	      dp[i][j]=0;
	    else if(x[i-1]==y[j-1])
	      dp[i][j]=dp[i-1][j-1]+1;
	    else
	      dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
	return dp[x.length()][y.length()];
}

例题

A:POJ-1836 Alignment:LIS变形题，看懂题意应该就能写出来，看不懂的可以看Alignment题解，AC代码：

#include <cstring>
#include <iostream>
#include <cstdio>
#include <fstream>
#include <algorithm>
using namespace std;
const int maxn=1e4+7;
const int INF=0x3f3f3f3f;
double hige[maxn];
double size1[maxn],dp[maxn],dp1[maxn];
int main()
{
    int n;
    while(cin>>n){
        for(int i=1;i<=n;i++){
            cin>>hige[i];
        }
        for(int i=1;i<=n;i++){
			dp[i]=1;
		}
        for(int i=1;i<=n;i++){
           for(int j=1;j<i;j++){
               if(hige[j]<hige[i])
                  dp[i]=max(dp[i],dp[j]+1);
           }
        }
        for(int i=1;i<=n;i++){
			dp1[i]=1;
		}
		for(int i=n;i>=1;i--){
           for(int j=i+1;j<=n;j++){
               if(hige[j]<hige[i])
                  dp1[i]=max(dp1[i],dp1[j]+1);
           }
        }
        int ans=0;
        for(int i=1;i<=n;i++)
            for(int j=i+1;j<=n;j++)
               if(dp[i]+dp1[j]>ans)
                   ans=dp[i]+dp1[j];
        cout<<n-ans<<endl;
    }
    return 0;
}

B:POJ-2533 Longest Ordered Subsequence:本题考查LIS的O(nlogn)算法，具体解析可看(最长上升子序列(LIS)长度的O(nlogn)算法),AC代码：

#include <cstring>
#include <iostream>
#include <cstdio>
#include <fstream>
#include <algorithm>
using namespace std;
const int maxn=1e3+7;
const int INF=0x3f3f3f3f;
int a[maxn],s[maxn],tmp;
int main()
{
    int n;
    while(cin>>n){
        for(int i=1;i<=n;i++)
            cin>>a[i];
        int tot=1;
        s[tot]=a[1];
        for(int i=2;i<=n;i++){
            if(a[i]>s[tot])
                s[++tot]=a[i];
            else{
                tmp=lower_bound(s+1,s+tot+1,a[i])-s;
                s[tmp]=a[i];
            }
        }
        cout<<tot<<endl;
    }
    return 0;
}

C:HDU-1159 Common Subsequence:LCS最长公共子序列裸体，AC代码：

#include <cstring>
#include <iostream>
#include <cstdio>
#include <fstream>
#include <algorithm>
using namespace std;
const int maxn=1e3+7;
const int INF=0x3f3f3f3f;
char str1[maxn],str2[maxn];
int dp[maxn][maxn];
int main()
{
    while(cin>>str1>>str2){
        int n=strlen(str1),m=strlen(str2);
        memset(dp,0,sizeof(dp));
        for(int i=0;i<=n;i++)
        for(int j=0;j<=m;j++){
            if(i==0||j==0)
                dp[i][j]=0;
            else if(str1[i-1]==str2[j-1])
                dp[i][j]=dp[i-1][j-1]+1;
            else
                dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
        }
        cout<<dp[n][m]<<endl;
    }
    return 0;
}

D:POJ-2250 Compromise：LCS的记录路径问题的模板题。看下代码应该就能明白：

#include <cstring>
#include <iostream>
#include <cstdio>
#include <fstream>
#include <algorithm>
using namespace std;
const int maxn=1e2+7;
const int INF=0x3f3f3f3f;
char str1[maxn][50],str2[maxn][50];
int dp[maxn][maxn];
void dfs(int i, int j)
{
    if (i == 0 || j == 0)
        return;
    if (strcmp(str1[i-1],str2[j-1])==0){
        dfs(i - 1, j - 1);
        cout <<str1[i-1]<< " ";
    }
    else
    {
        if (dp[i - 1][j] > dp[i][j - 1])
            dfs(i - 1, j);
        else
            dfs(i, j - 1);
    }
}
int main()
{
    char s[50];
    while(cin>>s){
        int n=0,m=0;
        while(strcmp(s,"#")!=0){
             strcpy(str1[n++],s);
             cin>>s;
        }
        cin>>s;
        while(strcmp(s,"#")!=0){
             strcpy(str2[m++],s);
             cin>>s;
        }
        memset(dp,0,sizeof(dp));
        for(int i=0;i<=n;i++)
        for(int j=0;j<=m;j++){
            if(i==0||j==0)
                dp[i][j]=0;
            else if(strcmp(str1[i-1],str2[j-1])==0){
                dp[i][j]=dp[i-1][j-1]+1;
            }
            else
                dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
        }
        dfs(n,m);
        cout<<endl;
    }
    return 0;
}

E:POJ-2264 Advanced Fruits:LCS记录路径 + 最短公共父序列。和上一题的区别是要把各自独特含有的输出出来，还是直接上代码，代码挺好理解的：

#include <cstring>
#include <iostream>
#include <cstdio>
#include <fstream>
#include <algorithm>
using namespace std;
const int maxn=1e2+7;
const int INF=0x3f3f3f3f;
char str1[maxn],str2[maxn];
int dp[maxn][maxn],ans[maxn][maxn];
void dfs(int i, int j)
{
    if(i==0&&j==0)//注意是且，因为要把各自独有的都输出完
        return ;
    if(ans[i][j]==0){
        dfs(i-1,j-1);
        cout <<str1[i-1];
    }
    else if (ans[i][j]==1){
        dfs(i-1, j);
        cout<<str1[i-1];
    }
    else{
        dfs(i,j-1);
        cout<<str2[j-1];
    }
}
int main()
{
    while(cin>>str1>>str2){
        int n=strlen(str1),m=strlen(str2);
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=n;i++)  //本题出现ans数组而上题不用的原因就在这和下面的四行的初始化，因为要输出各自独有的内容。
            ans[i][0]=1;
        for(int i=1;i<=m;i++)
            ans[0][i]=-1;
        for(int i=0;i<=n;i++)
        for(int j=0;j<=m;j++){
            if(i==0||j==0)
                dp[i][j]=0;
            else if(str1[i-1]==str2[j-1]){
                dp[i][j]=dp[i-1][j-1]+1;
                ans[i][j]=0;
            }
            else if(dp[i-1][j] >= dp[i][j-1]){
                dp[i][j] = dp[i-1][j];
                ans[i][j]=1;
            }
            else{
                dp[i][j] = dp[i][j-1];
                ans[i][j]=-1;
            }
        }
        dfs(n,m);
        cout<<endl;
    }
    return 0;
}

F:HDU-1160 FatMouse's Speed:LIS+结构体，因为排序的条件是两种，可构建结构体，对其中一个条件进行排序，因为要排序，而结果要输出原本的位置，所以结构体还要储存位置，剩下的就和LIS一样了，不过需要输出路径，所以这里的c[i] = j;意思就是当前这个最优解i是由上一个最优解j递推出来的。所以可以用这种方法求的最优路径。AC代码：

#include <cstring>
#include <iostream>
#include <cstdio>
#include <fstream>
#include <algorithm>
using namespace std;
const int maxn1=1e3+7;
const int INF=0x3f3f3f3f;
int dp[maxn1],c[maxn1];
struct mouse{
    int s,e;
    int index;
}p[maxn1];
bool cmp(mouse x,mouse y){
    return x.s<y.s;
}
void pri(int k){
    if(k==0)
        return ;
    pri(c[k]);
    cout<<p[k].index<<endl;
}
int main()
{
    memset(c,0,sizeof(c));
    int n=1;
    while(scanf("%d%d",&p[n].s,&p[n].e)!=EOF){
       p[n].index=n;
       ++n;
    }
    sort(p+1,p+n+1,cmp);
    for(int i=0;i<=n;i++)
        dp[i]=1;
    for(int i=1;i<=n;i++)
        for(int j=1;j<i;j++)
            if(p[j].e>p[i].e&&p[i].s!=p[j].s&&(dp[j]+1>dp[i])){
               dp[i]=dp[j]+1;
               c[i]=j;
        }
    int maxn=0,maxm=0;
    for (int i=1;i<=n;i++)
		if (maxn<dp[i]){
			maxn=dp[i];
			maxm=i;
		}
	cout<<maxn<<endl;
	pri(maxm);
    return 0;
}

 

Shmilky
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LIS & LCS（动态规划)
01-20
他想要知道序列A的LIS和序列AB的LCS的长度。 注意，LIS为严格递增的，即a1<a2<…<ak(ai<=1,000,000,000)。 Input 第一行两个数n，m（1<=n<=5,000,1<=m<=5,000） 第二行n个数，表示序列A 第...
DP模板1
08-08
同样采用DP，状态`dp[i][j]`表示序列1的前`i`个字符和序列2的前`j`个字符的最长公共子序列长度。 4. **区间DP**：处理与区间有关的问题，如区间覆盖、区间最值等。描述中的区间统计即属于此类。 5. **数位DP**：...
LIS和LCSdp分析
m0_51641706的博客
04-01 249
文章目录LISLCSLCS状态划分图解（***) 下面写的东西理解之后都要背住。 LIS 最长上升子序列模型 一个序列最长的严格单调递增的子序列的最大长度是多少？ 注：子序列不是连续子序列，可以跳着选数。（这一点和后面的分析强相关） 比如12345，135也是它的子序列。 开始分析： 对于dp方程为什么是这样，很大部分原因是子序列不是连续的，也就是说，以第i个数字结尾的子序列，第i个数字可以不选（当然符合条件的话也是要选的）。因此要全部遍历一遍才可以确定最大值是多少（可以用二分优化复杂度，以后再说） 这一
线性结构上的dp——LIS,LCS,LCIS
weixin_53459056的博客
05-07 310
一些之前的概念区别： （1）字符子串：指的是字符串中连续的n个字符，如abcdefg中，ab，cde，fg等都属于它的字串。 （2）字符子序列：指的是字符串中不一定连续但先后顺序一致的n个字符，即可以去掉字符串中的部分字符，但不可改变其前后顺序。如abcdefg中，acdg，bdf属于它的子序列，而bac，dbfg则不是，因为它们与字符串的字符顺序不一致。 (3) 公共子序列：如果序列C既是序列A的子序列，同时也是序列B的子序列，则称它为序列A和序列B的公共子序列。如对序列...
线性DP之 LIS_LCS_LCIS
qq_42852687的博客
08-05 154
线性DP之 LIS_LCS_LCIS引言一、LIS问题（最长上升子序列）1，朴素做法2，贪心做法（更优）二、LCS问题（最长公共子序列）三、LCIS问题（最长公共上升子序列）1，朴素代码（生硬套模板）2，前缀和思路优化 引言 一、LIS问题（最长上升子序列） LIS(Longest−Increasing−Subsequence)\mathcal{LIS(Longest- Increasing -Subsequence)}LIS(Longest−Increasing−Subsequence) 1，朴素做
DP，三，LIS和LCS
sunnyorrainy的博客
04-26 183
一，O(n^2) LCS：HDU1159 最长公共子序列模板，求两个字符串的最长公共子序列 #include<iostream> #include<cstdio> #include<cstring> #include<cmath> using namespace std; char a[10005],b[10005]; int dp[1005...
LIS、LCS算法模型
席万里的博客
03-26 279
最长公共子序列
LIS 和 LCS
最新发布
青柠
04-07 970
最长公共子序列 LCS（Longest Common Subsequence）是指两个序列中最长的相同子串。两个序列 {3, 2, 1, 4, 5} 和 {1, 2, 3, 4, 5} 的最长子串为 {3, 4, 5}，其 LCS 为 3。
【DP】LIS&LCS
weixin_43891518的博客
05-02 105
问题描述 （注：LIS为最长上升子序列，LCS为最长公共子序列） 东东有两个序列A和B。 他想要知道序列A的LIS和序列AB的LCS的长度。 注意，LIS为严格递增的，即a1<a2<…<ak(ai<=1,000,000,000)。 Input 第一行两个数n，m（1<=n<=5,000,1<=m<=5,000） 第二行n个数，表示序列A 第三行m个数...
LIS和LCS LCIS
dingcao9109的博客
04-29 149
首先介绍一下LIS和LCS的DP解法O(N^2) LCS：两个有序序列a和b，求他们公共子序列的最大长度 我们定义一个数组DP[i][j],表示的是a的前i项和b的前j项的最大公共子序列的长度，那么由于是用迭代法，所以计算DP[i][j]前，DP[i-1][j]和DP[i][j-1]就都已经计算出来了，不难理解就可以得出状态转移方程： DP[i][j] = DP[i-1][j-1...
DP基础题型总结(01背包和LIS以及LCS)
mumei的博客
07-25 264
今天做了学长拉的LIS和LCS以及背包问题的专题，因此就在这做个总结。 首先讲一下关于背包问题， 背包中最关键的无非就是01背包，以及完全背包，而且这两个代码也都很好写，也很好理解（就循环遍历的顺序变了），除此之外还有多重背包，二维费用的背包，以及混合背包，但万变不离其宗，都是由01背包演变而来，而且大都可以变成01背包的形式。 关于背包问题的讲解，大家可以去网上搜一下dd大佬的背包九讲，这...
最长递增子序列LCS的实现C源码
04-03
对于LCS问题，我们可以创建一个二维数组`dp`，其中`dp[i][j]`表示序列`nums[0...i-1]`和`nums[j+1...n-1]`中的LIS长度。初始化`dp`为1，表示每个单独的元素本身就是递增子序列，然后通过比较所有可能的前缀和后缀...
leetcode表现最好的时间段-DP-Interviews:DP-面试
06-30
LIS 问题。 找到序列的 LIS 和deletions = arr.length - LIS.length （非常类似于双调序列） 选择最后一个操作的所有可能间隔中的所有可能削减 在这里解释—— （类似于爆破气球） 卡达内斯 解释 - 买入和卖出 1 只...
动态规划总结与题目分类
05-17
一、简单基础dp 1、递推： 2、背包 3、LIS 4、LCS 二、区间dp 四、数位dp 五、概率(期望) dp 六、状态压缩dp 七、数据结构优化的dp 1、二进制优化 2、单调队列优化 3、斜率优化 4、四边形不等式优化
最小生成树基础与习题
weixin_43870697的博客
07-23 2755
目录 图的几个基础概念 Kruskal算法 算法思想 模板 Prim算法 算法思想 模板 例题 A.POJ-1251 Jungle Roads B.POJ-1287 Networking C:POJ-2031 Building a Space Station D:ZOJ-1586 QS Network E:POJ-2349 Arctic...
最短路基础与习题
weixin_43870697的博客
07-23 955
目录 前言 Floyd算法 Dijkstra算法 详解 模板 Spfa算法 详解 模板 例题 A.POJ-2387 Til the Cows Come Home B.POJ-2253 Frogger C.POJ-1797 Heavy Transportation D：POJ-3268 Silver Cow Party E:POJ-1860 Currency Exc...
二分图匹配基础与例题
weixin_43870697的博客
07-25 666
目录 判断是否二分图 匈牙利算法 原理 模板 KM算法 原理 模板 例题 A:HDU-1045 Fire Net B:HDU-2444 The Accomodation of Students C:HDU-1083 Courses D:HDU-1281 棋盘游戏 E:HDU-2819 Swap F:HDU-2389 Rain on your Parade G:HDU-...
并查集基础与习题
weixin_43870697的博客
08-12 528
目录 并查集 例题： A:POJ-2236 Wireless Network B:POJ-1611 The Suspects C:HDU-1213 How Many Tables D:HDU-3038 How Many Answers Are Wrong E:POJ-1182 食物链 F:POJ-1456 Supermarket G:POJ-1733 Parity game H...
清华大学DP讲义：动态规划基础与优化
讲义还提到了一些具体的问题，如LIS和LCS（最长公共子序列）问题，它们都是经典的动态规划问题。LIS问题通过单调数组和二分查找可以达到O(n log n)的时间复杂度；而LCS问题，状态定义为两个字符串的对应位置，可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值