最长单调子序列例题

最新推荐文章于 2024-02-29 20:37:09 发布
最新推荐文章于 2024-02-29 20:37:09 发布
阅读量410 收藏 1
点赞数
分类专栏： 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41410799/article/details/89211549
版权

1. HDU 1025  Constructing Roads In JGShining's Kingdom

Problem Description

JGShining's kingdom consists of 2n(n is no more than 500,000) small cities which are located in two parallel lines.

Half of these cities are rich in resource (we call them rich cities) while the others are short of resource (we call them poor cities). Each poor city is short of exactly one kind of resource and also each rich city is rich in exactly one kind of resource. You may assume no two poor cities are short of one same kind of resource and no two rich cities are rich in one same kind of resource.

With the development of industry, poor cities wanna import resource from rich ones. The roads existed are so small that they're unable to ensure the heavy trucks, so new roads should be built. The poor cities strongly BS each other, so are the rich ones. Poor cities don't wanna build a road with other poor ones, and rich ones also can't abide sharing an end of road with other rich ones. Because of economic benefit, any rich city will be willing to export resource to any poor one.

Rich citis marked from 1 to n are located in Line I and poor ones marked from 1 to n are located in Line II.

The location of Rich City 1 is on the left of all other cities, Rich City 2 is on the left of all other cities excluding Rich City 1, Rich City 3 is on the right of Rich City 1 and Rich City 2 but on the left of all other cities ... And so as the poor ones.

But as you know, two crossed roads may cause a lot of traffic accident so JGShining has established a law to forbid constructing crossed roads.

For example, the roads in Figure I are forbidden.
 



In order to build as many roads as possible, the young and handsome king of the kingdom - JGShining needs your help, please help him. ^_^

 

 

Input

Each test case will begin with a line containing an integer n(1 ≤ n ≤ 500,000). Then n lines follow. Each line contains two integers p and r which represents that Poor City p needs to import resources from Rich City r. Process to the end of file.

 

 

Output

For each test case, output the result in the form of sample.
You should tell JGShining what's the maximal number of road(s) can be built.

 

 

Sample Input

 

2

1 2

2 1

3

1 2

2 3

3 1

Sample Output

Case 1: My king, at most 1 road can be built.

Case 2: My king, at most 2 roads can be built.

代码如下：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
const int maxn=5*1e5+5;
int n;
int a[maxn];
int dp[maxn];
int cnt;
int main()
{
    int Case=0;
    while(scanf("%d",&n)!=EOF)
    {
        Case++;
        cnt=0;
        for (int i=0;i<n;i++)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            a[x]=y;
        }
        for (int i=1;i<=n;i++)
        {
            int loc=lower_bound(dp,dp+cnt,a[i])-dp;
            if(loc==cnt) dp[cnt++]=a[i];
            else dp[loc]=a[i];
        }
        if(cnt==1)
            printf("Case %d:\nMy king, at most %d road can be built.\n\n",Case,cnt);
        else
            printf("Case %d:\nMy king, at most %d roads can be built.\n\n",Case,cnt);
    }
    return 0;
}

2. POJ 3903 Stock Exchange

题目链接：

http://poj.org/problem?id=3903

代码如下：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
const int maxn=1e5+5;
int n;
int cnt;
int a[maxn];
int dp[maxn];
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        cnt=0;
        for (int i=1;i<=n;i++) scanf("%d",&a[i]);
        for (int i=1;i<=n;i++)
        {
            int loc=lower_bound(dp,dp+cnt,a[i])-dp;
            if(loc==cnt) dp[cnt++]=a[i];
            else dp[loc]=a[i];
        }
        printf("%d\n",cnt);
    }
    return 0;
}

3. POJ - 1065 Wooden Sticks

题目链接：

https://vjudge.net/problem/POJ-1065

思路：

先排序，然后找最长单调子序列。

代码如下：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
const int maxn=5*1e3+5;
int t;
int n;
int cnt;
struct node
{
    int x,y;
};
node dp[maxn];
node a[maxn];
int vis[maxn];
int no[maxn];
int cur;
int compare (node a,node b)
{
    if(a.x!=b.x) return a.x<b.x;
    return a.y<b.y;
}
int main()
{
    scanf("%d",&t);
    while(t--)
    {
        memset (vis,0,sizeof(vis));
        scanf("%d",&n);
        for (int i=1;i<=n;i++)
        {
            scanf("%d%d",&a[i].x,&a[i].y);
        }
        int ans=0;
        sort(a+1,a+n+1,compare);
        int num=n;
        while(num)
        {
            ans++;
            cur=0;
            cnt=0;
            for (int i=1;i<=n;i++)
            {
                if(vis[i]) continue;
                if(cur<=a[i].y)
                {
                    cnt++;
                    vis[i]=1;
                    cur=a[i].y;
                }
            }
            num-=cnt;
        }
        printf("%d\n",ans);
    }
    return 0;
}

4.POJ 1631 Bridging signals

题目链接：

http://poj.org/problem?id=1631

代码如下：

//include <bits/stdc++.h>
#include <set>
#include <map>
#include <cmath>
#include <queue>
#include <stack>
#include <time.h>
#include <vector>
#include <string>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <functional>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const ll MOD = 1000000007;
const int maxn = 4*1e4+5;
const int INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3f3f;
template <class T>
inline bool scan_d(T &ret) {
	char c; int sgn;
	if (c = getchar(), c == EOF) return 0;
	while (c != '-' && (c<'0' || c>'9')) c = getchar();
	sgn = (c == '-') ? -1 : 1;
	ret = (c == '-') ? 0 : (c - '0');
	while (c = getchar(), c >= '0'&&c <= '9') ret = ret * 10 + (c - '0');
	ret *= sgn;
	return 1;
}
int t,n;
int a[maxn];
int L[maxn];
int main()
{
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        for (int i=0;i<n;i++)
        {
            scanf("%d",&a[i]);
        }
        int num=0;
        for (int i=0;i<n;i++)
        {
            int loc=lower_bound(L,L+num,a[i])-L;
            if(loc==num)
            {
                L[num++]=a[i];
            }
            L[loc]=a[i];
        }
        printf("%d\n",num);
    }
	return 0;
}

5. POJ 1952 BUY LOW, BUY LOWER

题目链接：

http://poj.org/problem?id=1952

此题在求最长递减子序列的同时还需要求出方案数。

我们可以通过建立一个cnt数组表示以其为子序列结尾的数目， 这样只要满足dp[j]+1==dp[i]&&a[j]>a[i]就可以为cnt[i]加上cnt[j],

但是如果序列中有相同的数字的话，则在遍历序列的时候将前面相同的数字的cnt 置为0，这样就不会出现重复加的情况了。

代码如下：

//include <bits/stdc++.h>
#include <set>
#include <map>
#include <cmath>
#include <queue>
#include <stack>
#include <time.h>
#include <vector>
#include <string>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <functional>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const ll MOD = 1000000007;
const int maxn = 5*1e3+5;
const int INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3f3f;
template <class T>
inline bool scan_d(T &ret) {
	char c; int sgn;
	if (c = getchar(), c == EOF) return 0;
	while (c != '-' && (c<'0' || c>'9')) c = getchar();
	sgn = (c == '-') ? -1 : 1;
	ret = (c == '-') ? 0 : (c - '0');
	while (c = getchar(), c >= '0'&&c <= '9') ret = ret * 10 + (c - '0');
	ret *= sgn;
	return 1;
}
int n;
int a[maxn];
int L[maxn];
int dp[maxn];
int cnt[maxn];
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for (int i=0;i<n;i++)
        {
            scanf("%d",&a[i]);
        }
        memset (cnt,0,sizeof(cnt));
        int num=0;
        int ans=1;
        for (int i=0;i<n;i++) dp[i]=1;
        for (int i=0;i<n;i++)
        {
            for (int j=i+1;j<n;j++)
            {
                if(a[i]>a[j])
                {
                    dp[j]=max(dp[j],dp[i]+1);
                }
                ans=max(dp[j],ans);
            }
        }
        for (int i=0;i<n;i++)
        {
            for (int j=0;j<i;j++)
            {
                if(a[j]==a[i])
                {
                    cnt[j]=0;
                }
            }
            if(dp[i]==1)
            {
                cnt[i]=1;
            }
            else
            {
                for (int j=0;j<i;j++)
                {
                    if(a[i]<a[j]&&dp[j]+1==dp[i])
                    {
                        cnt[i]+=cnt[j];
                    }
                }
            }
        }
        for (int i=0;i<n;i++)
        {
            if(ans==dp[i])
            {
                num+=cnt[i];
            }
        }
        printf("%d %d\n",ans,num);
    }
	return 0;
}

6. HDU 2881 Jack's struggle

题目链接：

http://acm.hdu.edu.cn/showproblem.php?pid=2881

将两点能否在规定的时间到达进行dp。

代码如下：

//include <bits/stdc++.h>
#include <set>
#include <map>
#include <cmath>
#include <queue>
#include <stack>
#include <time.h>
#include <vector>
#include <string>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <functional>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const ll MOD = 1000000007;
const int maxn = 1e4+5;
const int INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3f3f;
template <class T>
inline bool scan_d(T &ret) {
	char c; int sgn;
	if (c = getchar(), c == EOF) return 0;
	while (c != '-' && (c<'0' || c>'9')) c = getchar();
	sgn = (c == '-') ? -1 : 1;
	ret = (c == '-') ? 0 : (c - '0');
	while (c = getchar(), c >= '0'&&c <= '9') ret = ret * 10 + (c - '0');
	ret *= sgn;
	return 1;
}
int n,m;
struct node
{
    int x,y,t;
};
int compare (node a,node b)
{
    return a.t<b.t;
}
bool judge (node a,node b)
{
    int dis=abs(a.x-b.x)+abs(a.y-b.y);
    if(abs(a.t-b.t)<dis) return false;
    return true;
}
node a[maxn];
int dp[maxn];
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(n==0&&m==0) break;
        for (int i=0;i<m;i++)
        {
            scanf("%d%d%d",&a[i].t,&a[i].x,&a[i].y);
        }
        int ans=0;
        sort(a,a+m,compare);
        memset (dp,0,sizeof(dp));
        for (int i=0;i<m;i++)
        {
            dp[i]=1;
            for (int j=0;j<i;j++)
            {
                if(judge(a[i],a[j]))
                {
                    dp[i]=max(dp[i],dp[j]+1);
                }
            }
            ans=max(ans,dp[i]);
        }
        printf("%d\n",ans);
    }
	return 0;
}

7.  POJ Crossed Matchings

题目链接：

http://poj.org/problem?id=1692

题解参考：

https://www.cnblogs.com/zjutlitao/p/3572187.html

代码如下：

//include <bits/stdc++.h>
#include <set>
#include <map>
#include <cmath>
#include <queue>
#include <stack>
#include <time.h>
#include <vector>
#include <string>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <functional>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const ll MOD = 1000000007;
const int maxn = 1e2+5;
const int INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3f3f;
template <class T>
inline bool scan_d(T &ret) {
	char c; int sgn;
	if (c = getchar(), c == EOF) return 0;
	while (c != '-' && (c<'0' || c>'9')) c = getchar();
	sgn = (c == '-') ? -1 : 1;
	ret = (c == '-') ? 0 : (c - '0');
	while (c = getchar(), c >= '0'&&c <= '9') ret = ret * 10 + (c - '0');
	ret *= sgn;
	return 1;
}
int m;
int n1,n2;
int a[maxn],b[maxn];
int dp[maxn][maxn];
int main()
{
    scanf("%d",&m);
    while(m--)
    {
        scanf("%d%d",&n1,&n2);
        for (int i=1;i<=n1;i++)
        {
            scanf("%d",&a[i]);
        }
        for (int i=1;i<=n2;i++)
        {
            scanf("%d",&b[i]);
        }
        int ans=0;
        memset (dp,0,sizeof(dp));
        for (int i=1;i<=n1;i++)
        {
            for (int j=1;j<=n2;j++)
            {
                dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
                if(a[i]==b[j]) continue;
                for (int k=1;k<i;k++)
                {
                    for (int l=1;l<j;l++)
                    {
                        if(a[k]==b[j]&&b[l]==a[i])
                        {
                            dp[i][j]=max(dp[i][j],dp[k-1][l-1]+2);
                        }
                    }
                }
                ans=max(ans,dp[i][j]);
            }
        }
        printf("%d\n",ans);
    }
	return 0;
}

 

萧瑟1
关注
专栏目录
专题：最长单调子序列（LIS）问题
eliyou的博客
04-27 1064
专题：最长单调子序列（LIS）问题 （4.27 记录） LIS问题是DP当中的一个很经典的问题。 LIS问题的核心在于状态的保护和转移。 一.LIS的长度 解法1：一般DP 时间复杂度O(n2) 很显然，对于某一个点i，1-i的最长单调子序列是唯一的，而以i结尾的最长单调子序列也是唯一的。这样就有两种思路： A dp[i]表示1-i中出现的最长单调子序列的长度； B dp[i]表示以i结尾的最长单调子序列的长度。 这两种思路唯一的区别在于dp是否要转移，或者更直观的来说，区别在于dp[n]是否就是最长单调子
最长单调子序列求解
jin的专栏
06-30 2936
本文给出了如下题目的参考解答，虽然方法并不是最优，但详细的分析具有很好的参考价值！题目：已知一个序列，由随机数构成，求其最长单调子序列。要求： 单调分严格和不严格两种情况，并分别求解并输出一个最长单调子序列和所有符合要求的子序列。
最长单调子序列（DP）
weixin_33953384的博客
04-19 96
问题描述：给定某一组无序的数，求其中最长的单调序列的长度（该单调序列不一定是连续的），如在 5 6 1 2 4 7 5 中最长上升增序列是1 2 4 7 或者1 2 4 5。 该题可以用动态规划的方法解决，时间复杂度为O（n^2）： 设A[t]表示序列中的第t个数，F[t]表示从1到t这一段中以t结尾的最长上升子序列的长度。 动态规划方程：F[t]=max{1,F[j]+...
最长单调子序列问题（LIS，dp入门）
蒲公英殇的博客
12-24 682
dp的一种很简单的题型。 小编便以两道题来介绍一下。
最长单调子序列
weixin_53488675的博客
05-11 288
题目描述 给出一个序列a1,a2,a3,a4,a5,a6,a7…an，求它的一个子序列（设为s1,s2,…sn），使得这个子序列满足这样的性质：s1<s2<s3<…<sn并且这个子序列的长度最长。输出这个最长子序列的长度，要求时间复杂度为O(n2)。 输入 每组输入包括两行，第一行为序列长度n，第二行为序列。 输出 输出最长递增子序列的长度。 样例输入 Copy 7 1 7 3 5 9 4 8 样例输出 Copy 4 import java.util.Scanner; public
poj 1887Testing the CATCHER（最长下降子序列）
tanhaiyuan
08-20 661
令我很无语，这道题…… Testing the CATCHER Time Limit: 1000MS   Memory Limit: 30000K Total Submissions: 10919   Accepted: 3951
最长单调子序列.cpp
11-10
最长单调子序列.cpp
算法相关－最长单调子序列
12-12
最长单调子序列问题是一个经典的计算机科学中的算法问题，主要涉及数据结构和算法设计。在这个问题中，目标是找到一个给定序列中长度最长的单调递增或递减的子序列。这里的“单调”指的是子序列中的元素要么总是递增...
c语言求最长单调子序列,设计一个O(n2)时间算法,找出由n个数组成的序列的最长单调递增子序列...
weixin_34990053的博客
05-24 2140
满意答案dfjordan232017.10.23采纳率：55%等级：10已帮助：466人算法导论15.4-5 请给出一个O(n^2)时间的算法，使之能找出一个n个数的序列中最长的单调递增子序列。这个题目是在动态规划部分，此处显然是要用到动态规划。我们知道可以使用动态规划思想的问题的的两个重要的特征是具有最优子结构和重叠子问题。下面就来分析一下这个问题：对于一个n个元素的序列nums，设其...
最长单调子序列（动态规划）
weixin_44350170的博客
07-29 477
最长上升子序列（Longest Increasing Subsequence），简称LIS，也有些情况求的是最长非降序子序列，二者区别就是序列中是否可以有相等的数。 例如： 对于序列(1, 7, 3, 5, 9, 4, 8)，我们就会得到一些上升的子序列，如(1, 7, 9), (3, 4, 8), (1, 3, 5, 8)等等，而这些子序列中最长的（如子序列(1, 3, 5, 8) ），它的长...
题目17：单调递增最长子序列
杨林峰的笔记
08-28 317
题目链接：http://acm.nyist.net/JudgeOnline/problem.php?pid=17 描述 求一个字符串的最长递增子序列的长度 如：dabdbf最长递增子序列就是abdf，长度为4 输入 第一行一个整数n,表示有n个字符串要处理 随后的n行，每行有一个字符串，该字符串的长度不会超过10000 输出 输出字符串的最长递增子序列的长度 样例输入 3 aa
poj 怪盗基德的滑翔翼
weixin_33991727的博客
06-09 647
2019独角兽企业重金招聘Python工程师标准>>> ...
HDU1160-FatMouse's Speed【最长单调子序列】
独钓门前月
02-28 257
FatMouse believes that the fatter a mouse is, the faster it runs. To disprove this, you want to take the data on a collection of mice and put as large a subset of this data as possible into a sequence...
最长单调子序列问题(Longest increasing subsequence)
zgottingen的专栏
03-25 2200
给定一个长度为n的数组a[0...n-1]。 （1）如果存在0 （2）如果存在0 = a[i2] >= ... >= a[ik]，则称a[i1],a[i2]...a[ik]是数组a的一个长度为k的单调下降子序列 （3）如果存在0 （4）如果存在0 a[i2] > ... > a[ik]，则称a[i1],a[i2]...a[ik]是数组a的一个长度为k的严格单调下降子序列 最长单调子
【动态规划】最长单调子序列
Coco416的博客
11-14 1435
详细讲解如何设计一个O(n2)的算法实现查询最长单调子序列
经典DP-最长单调子序列
最新发布
qq_73886051的博客
02-29 380
最长递增子序列的个数 知识点 Arrays.fill(count, 1); 是 Java 中的一个方法调用，用于将数组 的所有元素设置为指定的值，即 。这个方法来自于 类，是一个静态工具类，提供了很多用于操作数组（例如排序、搜索、填充等）的静态方法。在这个特定的情境下， 被用来初始化 数组。由于我们正在计算最长递增子序列的个数，每个元素至少可以作为一个长度为 1 的递增子序列的结束元素。因此， 数组的每一个位置都被设置为 ，意味着每个元素开始时都被视为一个独立的递增子序列。
动态规划解析：最长单调子序列与多阶段决策问题
"本文主要探讨了线性动态规划（DP）的应用，特别是在解决最长单调子序列（LIS）问题上的实例。动态规划是一种用于解决多阶段决策过程最优化问题的有效方法，通过构建决策序列来找到最优解。文章还介绍了如何通过辅助...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值