算法设计与分析 第四次编程作业 14387. 【原4387】Longest Increasing Sequence

最新推荐文章于 2024-05-23 11:51:48 发布
最新推荐文章于 2024-05-23 11:51:48 发布
阅读量225 收藏
点赞数
分类专栏： 算法设计与分析 文章标签： 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhiyuan5986/article/details/124238778
版权

题目描述

author: sakiko 原OJ链接：https://acm.sjtu.edu.cn/OnlineJudge-old/problem/4387

Description

给定一个长度为 n n n的整数序列，求出它的最长上升子序列。
子序列不一定要在原序列中连续，但相对顺序要一致，如 [ 1 , 2 ] [1, 2] [1,2]是 [ 1 , 3 , 2 ] [1, 3, 2] [1,3,2]的一个子序列，而 [ 2 , 3 ] [2, 3] [2,3]不是。

Input Format

第一行是一个整数 n n n,表示序列的长度。
接下来一行 n n n个整数，表示该序列。

Output Format

请输出两行答案。
第一行一个整数表示最长上升子序列的长度。
第二行请输出字典序最小的最长上升子序列。

Sample Input 1

4
1 2 3 4

Sample Output 1

4
1 2 3 4

Sample Input 2

6
4 5 6 1 2 3

Sample Output 2

3
1 2 3

Data Range

对于 30 % 30\% 30%的数据， n ≤ 100 n \le 100 n≤100。
对于 100 % 100\% 100%的数据， n ≤ 10000 n \le 10000 n≤10000，序列元素 ≤ 10000 \le 10000 ≤10000。

解决方案

#include <iostream>
#include <vector>
//这一版是可以过的
//参考了https://leetcode-cn.com/problems/longest-increasing-subsequence/solution/dong-tai-gui-hua-er-fen-cha-zhao-tan-xin-suan-fa-p/
using namespace std;
const int MAXN = 10001;

int main()
{
    int n;
    cin>>n;
    vector<int> arr(n);
    for(int i=0;i<n;i++)
        cin>>arr[i];
    vector<int> dp(n,1);//dp[i]=k 表示以arr[i]结尾的最长递增子序列长度
    vector<int> tail(n+1,0);  //tail[k]=i  表示长度为k的递增子序列的末尾最小数为i
    tail[1]=arr[0];
    int _max=1;
    int index=0;
    for(int i=1;i<n;i++)
    {
        int val=arr[i];
        int l=1;
        int r=_max;
        while(l<=r)  //二分查找第一个比val大的数
        {
            int mid=(l+r)>>1;
            if(tail[mid]<val)
                l=mid+1;
            else
                r=mid-1;
        }
        //tail[l]是第一个比val大的数
        tail[l]=val;
        dp[i]=l;//以i结尾的数 最长的递增子序列长度为l
        if(l>=_max)  //后来的arr[]总是字典序更小字典序更小
        {
            _max=l;
            index=i;
        }
    }
    vector<int> ans(_max);
    cout << _max << endl;
    for(int i=index;i>=0;i--)
    {
        if(dp[i]==_max)
        {
            ans[--_max]=arr[i];
          
        }
        
    }
    for(int i=0;i<ans.size();i++)
        cout<<ans[i]<<" ";
    
}

总结

本题其实是leetcode上面的原题https://leetcode-cn.com/problems/longest-increasing-subsequence/
实际实现过程中，参考了大佬的解法https://leetcode-cn.com/problems/longest-increasing-subsequence/solution/dong-tai-gui-hua-er-fen-cha-zhao-tan-xin-suan-fa-p/
在参考了这个解法后我写了贪心+二分的代码来实现本题

#include <iostream>
#include <vector>
//这一版是可以过的
//参考了https://leetcode-cn.com/problems/longest-increasing-subsequence/solution/dong-tai-gui-hua-er-fen-cha-zhao-tan-xin-suan-fa-p/
using namespace std;
const int MAXN = 10001;

int main()
{
    int n;
    cin>>n;
    vector<int> arr(n);
    for(int i=0;i<n;i++)
        cin>>arr[i];
    vector<int> dp(n,1);//dp[i]=k 表示以arr[i]结尾的最长递增子序列长度
    vector<int> tail(n+1,0);  //tail[k]=i  表示长度为k的递增子序列的末尾最小数为i
    tail[1]=arr[0];
    int _max=1;
    int index=0;
    for(int i=1;i<n;i++)
    {
        int val=arr[i];
        int l=1;
        int r=_max;
        while(l<=r)  //二分查找第一个比val大的数
        {
            int mid=(l+r)>>1;
            if(tail[mid]<val)
                l=mid+1;
            else
                r=mid-1;
        }
        //tail[l]是第一个比val大的数
        tail[l]=val;
        dp[i]=l;//以i结尾的数 最长的递增子序列长度为l
        if(l>=_max)  //后来的arr[]总是字典序更小字典序更小
        {
            _max=l;
            index=i;
        }
    }
    vector<int> ans(_max);
    cout << _max << endl;
    for(int i=index;i>=0;i--)
    {
        if(dp[i]==_max)
        {
            ans[--_max]=arr[i];
          
        }
        
    }
    for(int i=0;i<ans.size();i++)
        cout<<ans[i]<<" ";
    
}

之前我有写过一版动态规划的代码，但是只能过十个样例，一个简略的思路是： L I S [ i ] LIS[i] LIS[i]表示前 i i i个点能够得到的最长子序列长度，对于数组中每个元素 a [ i ] a[i] a[i], 对于 k = 1 : n − 1 k=1:n-1 k=1:n−1,遍历 a [ k ] a[k] a[k], 在过程中，如果发现一个更小的数，即 a [ i ] > a [ k ] a[i]>a[k] a[i]>a[k],且 L I S [ i ] < L I S [ k ] + 1 LIS[i] < LIS[k]+1 LIS[i]<LIS[k]+1, 那么直接把 L I S [ i ] LIS[i] LIS[i]置为 L I S [ k ] + 1 LIS[k]+1 LIS[k]+1，且 p r e [ a [ i ] ] = a [ k ] pre[a[i]]=a[k] pre[a[i]]=a[k]。另一种情况，如果 a [ i ] > a [ k ] a[i]>a[k] a[i]>a[k]且 L I S [ i ] = L I S [ k ] + 1 LIS[i] = LIS[k]+1 LIS[i]=LIS[k]+1，比较 a [ k ] a[k] a[k]和 a [ i ] a[i] a[i]目前的最小字典序的大小 j j j，如果 a [ k ] a[k] a[k]的字典序比 j j j小，则更新j和 p r e [ a [ k ] ] pre[a[k]] pre[a[k]]。代码如下：

#include <iostream>
#include <stack>
// #include <cassert>
using namespace std;
const int MAXN = 10001;
int pre[MAXN];
//按字典序很好实现，只需要在选择最长串时同时考虑最后一位的数字大小即可。

//修改自v5
int main()
{
    int n;
    cin >> n;
    int *a = new int[n+1];
    // int *prev = new int[n+1];
    int *LIS = new int[n+1];
    for (int i=1;i<=n;++i) cin >> a[i];
    for (int i=0;i<=n;++i) {LIS[i] = 0;pre[i] = -1;}
    int maxi=1,j,tail = a[1];//maxi,tail用作标记所有路径中字典序最小的那一条路径，j用作每一个a[i]的字典序最小值
    LIS[1] = 1;
    bool flag = false;
    for (int i=2;i<=n;++i) {
        flag = false;
        j = n+1;
        for (int k=1;k<i;++k) {
            if (a[i] > a[k] && LIS[i] == LIS[k]+1) {
                if (a[k] < j) {//比上一个字典序小
                    pre[a[i]] = a[k];
                    j = a[k];
                }
                flag = true;
            } 
            if (a[i] > a[k] && LIS[i] < LIS[k]+1) {
                LIS[i] = LIS[k]+1;
                pre[a[i]] = a[k];
                flag = true;
                j = a[k];
                if (LIS[i] == maxi && tail > a[i] || LIS[i] > maxi) {
                    maxi = LIS[i];
                    tail = a[i];
                }
            }

        }
        if (!flag) {//若没能有一个前向
            LIS[i] = 1;
            if (maxi == 1 && tail > a[i]) tail = a[i];
        }
        
    }
    // stack<int> s;
    // cout << maxi<< endl;
    // for (int i=0;i<maxi;++i) {
    //     s.push(tail);
    //     tail = prev[tail];
    // }
    // for (int i=0;i<maxi;++i) {
    //     cout << s.top() << ' ';
    //     s.pop();
    // }
    cout << maxi << endl;
    int *output = new int[maxi+1];
    for (int i=maxi;i>0;i--)
    {
        output[i]=tail;
        tail=pre[tail];
    }
    for (int i=1;i<=maxi;i++)
    {
        cout << output[i] << ' ';
    }
    // cout << endl;
    // for (int i=1;i<=n;++i) cout << pre[i] << ' ';
    return 0; 
}

这份代码最大的问题就是， p r e pre pre数组用的是元素来存，这里应该用下标，否则有反例 3 , 4 , 5 , 1 , 4 3,4,5,1,4 3,4,5,1,4。还有就是 L I S LIS LIS的值相等时，应该让 a [ k ] < = a [ p r e [ i ] ] a[k] <= a[pre[i]] a[k]<=a[pre[i]]和 a [ t a i l ] > = a [ i ] a[tail] >= a[i] a[tail]>=a[i]这两处要取等。感谢助教学姐指出错误。

#include <iostream>
#include <stack>
// #include <cassert>
using namespace std;
// const int MAXN = 10001;
// int pre[MAXN];
//按字典序很好实现，只需要在选择最长串时同时考虑最后一位的数字大小即可。

//修改自v6
int main()
{
    int n;
    cin >> n;
    int *a = new int[n+1];
    // int *prev = new int[n+1];
    int *LIS = new int[n+1];
    int *pre = new int[n+1];
    for (int i=1;i<=n;++i) cin >> a[i];
    for (int i=0;i<=n;++i) {LIS[i] = 0;pre[i] = n+1;}
    int maxi=1,j,tail = 1;//maxi,tail用作标记所有路径中字典序最小的那一条路径，j用作每一个a[i]的字典序最小值
    LIS[1] = 1;
    bool flag = false;
    for (int i=2;i<=n;++i) {
        flag = false;
        // j = pre[a[i]];
        for (int k=1;k<i;++k) {
            if (a[i] > a[k] && LIS[i] == LIS[k]+1) {
                if (a[k] <= a[pre[i]]) {//比上一个字典序小，=不能漏
                    pre[i] = k;
                    // pre[a[i]] = a[k];
                }
                flag = true;
            } 
            if (a[i] > a[k] && LIS[i] < LIS[k]+1) {
                LIS[i] = LIS[k]+1;
                pre[i] = k;
                flag = true;
                // j = a[k];
                if (LIS[i] == maxi && a[tail] >= a[i] || LIS[i] > maxi) {
                    maxi = LIS[i];
                    tail = i;
                }
            }

        }
        if (!flag) {//若没能有一个前向
            LIS[i] = 1;
            if (maxi == 1 && a[tail] > a[i]) tail = i;
        }
        
    }
    // stack<int> s;
    // cout << maxi<< endl;
    // for (int i=0;i<maxi;++i) {
    //     s.push(tail);
    //     tail = prev[tail];
    // }
    // for (int i=0;i<maxi;++i) {
    //     cout << s.top() << ' ';
    //     s.pop();
    // }
    cout << maxi << endl;
    int *output = new int[maxi+1];
    for (int i=maxi;i>0;i--)
    {
        output[i]=a[tail];
        tail=pre[tail];
    }
    for (int i=1;i<=maxi;i++)
    {
        cout << output[i] << ' ';
    }
    // cout << endl;
    // for (int i=1;i<=n;++i) cout << pre[i] << ' ';
    return 0; 
}

声明

本人对代码保有版权，但是题目来自校内OJ平台，本人没有题目的版权。如有侵权，请联系本人删除。

zhiyuan5986
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
实验九lcs算法.doc
04-28
最长公共子序列（Longest Common Subsequence LCS）是从给定的两个序列X和Y中取出尽可能多的一部分字符，按照它们在原序列排列的先后次序排列得到。
最长公共子序列Longest Monotonically Increasing Sequence Algorithm
01-18
LMS Longest Monotonically Increasing Sequence Algorithm
最长递增子序列（longest increasing subsequence）
lddladada的专栏
10-20 335
问题 给定一个长度为N的数组，找出一个最长的单调自增子序列（不一定连续，但是顺序不能乱）。例如：给定一个长度为6的数组A{5， 6， 7， 1， 2， 8}，则其最长的单调递增子序列为{5，6，7，8}，长度为4. int LIS(int nums[], int n, int result[]){//暴力法，时间O(n^2) int* lis = new int[n]; int*
leetcode 300. Longest Increasing Subsequence
Genius_J的博客
02-02 93
一、题意 给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。 子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。 二、解法 解法： 贪心+二分查找 dp[i]dp[i]dp[i]代表长度为i的最长上升子序列的末尾元素的最小值， nums[j]>dp[i]：dp[++i]=nums[j]dp[++i]=nums[j]dp[++i]=nums[j] else：找到i，使得dp[i−1]
Lexicographic Order （字符串的字典序
Minelois的博客
12-19 684
添加链接描述 #include<bits/stdc++.h> using namespace std; typedef long long ll; double esp=1e-2; const int N=110; ll mod=998244353; int mp[N][N]; int dist[N][N],vis[N][N]; int n,m,stx,sty; int dx[]={0,0,1,-1}; int dy[]={1,-1,0,0}; typedef pair<int,int&g
动态规划 ---- 最长不下降子序列（Longest Increasing Sequence, LIS）
Lucky小黄人的博客
02-01 183
分析： 完整 代码： 1 // 最长不下降子序列 2 #include <stdio.h> 3 #include <algorithm> 4 using namespace std; 5 6 const int N = 100; 7 int A[N], dp[N]; 8 9 int main() 10 { 11 freopen...
算法设计与分析第七次作业
xiaoshang3636的博客
10-28 156
leetcode 322.Coin Change 题目描述如下： You are given coins of different denominations and a total amount of money amount. Write a function to compute the fewest number of coins that you need to make up tha...
longest-common-string.rar_LONGEST COMMON STRI_longest_longest co
09-21
这是动态规划中，求最长公共子序列（Longest common string）的源代码。自己编写执行。程序简单，有注释。
前端大厂最新面试题-longestCommonSequence.docx
06-06
前端工程师面试
C#，最长公共扩展（LCE，Longest Common Extention）的算法与源代码
03-24
C#，最长公共扩展（LCE，Longest Common Extention）的算法与源代码 考虑一个字符串s，并为每对（L，R）计算从L和R开始的s的最长子字符串。 在LCE中，在每个查询中，我们必须回答从索引L和R开始的最长公共前缀的长度...
算法设计与分析 第四次编程作业 14385. 【原4385】Edit Distance
zhiyuan5986的博客
04-17 215
题目描述 author: sakiko 原OJ链接：https://acm.sjtu.edu.cn/OnlineJudge-old/problem/4385 Description 给定两个字符串，需要你求出他们的编辑距离。 这里我们假设添加或删除一个字符的代价为xxx,修改一个字符的代价为yyy，并有y<2xy<2xy<2x。 Input Format 第一行两个整数xxx和yyy分别表示插入删除字符和修改字符的代价。 接下来两行，是我们需要求出编辑距离的两个字符串。 Output Fo
算法设计与分析第八次作业
xiaoshang3636的博客
11-03 254
10.Regular Expression Matching 题目描述如下： Given an input string (s) and a pattern §, implement regular expression matching with support for ‘.’ and ‘’. ‘.’ Matches any single character. '’ Matches zero ...
week11-必做题 1-4
beautiful_pain的博客
05-06 241
这里写目录标题11-111-2InputOutputSample InputSample Output代码11-311-4InputOutputSample Input-1Sample Output-1Sample Input-2Sample Output-2Sample Input-3Sample Output-3解题思路以及关键代码全部代码 11-1 #include<iostream...
蓝桥杯算法心得——矿石样本分析（贪心+两数之和）
晴天学长
05-19 476
链表的时间复杂度要知道查找（o（1））（o（n））一般都用ArrayList，除非是修改。
【算法】二分算法——x的平方根
2302_79031646的博客
05-17 886
用二分边界算法来求解——x的平方根，从暴力求解到二分的优化细说
【算法】【二叉树，DFS，哈希集合，分类讨论】力扣1110. 删点成林
未来就在脚下。
05-20 769
本题通过DFS遍历二叉树，结合分类讨论的方法，逐步删除指定节点并生成新的森林。该算法有效地处理了节点删除后树结构的调整问题，并通过哈希集合优化删除判断的时间复杂度，最终实现了高效的解决方案。
力扣62 不同路径 Java版本
m0_47066863的博客
05-20 272
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。从左上角开始，总共有 3 条路径可以到达右下角。题目数据保证答案小于等于 2 * 109。输入：m = 3, n = 7。输入：m = 3, n = 2。输入：m = 7, n = 3。输入：m = 3, n = 3。问总共有多少条不同的路径？
每周一算法：Prim算法求最小生成树
最新发布
少儿编程乔老师
05-23 707
在一个无向图中求边权和最小的生成树，即无向连通图的最小生成树（Minimum Spanning Tree，MST）。本文介绍使用Prim算法求最小生成树。
算法算法设计与分析动态规划的课程设计比较好的选题
06-12
4. 矩阵连乘问题（Matrix Chain Multiplication） 5. Floyd 算法解决最短路径问题（Floyd Algorithm for Shortest Path Problem） 6. 最小生成树问题（Minimum Spanning Tree Problem） 7. 聚类问题（Clustering ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值