最长递增子序列问题（你真的会了吗）

转x33g5p2x  于2022-07-04 转载在 其他  
字(4.1k)|赞(0)|评价(0)|浏览(299)

一.最长递增子序列问题I

二.最长递增子序列问题II

三. 最长递增子序列问题III

一.最长递增子序列问题I

1.对应牛客网链接
最长上升子序列(一)_牛客题霸_牛客网 (nowcoder.com)

2.题目描述：

3.解题思路

1.首先我们分析题意：最长递增子序列拆：要递增的，还是序列，不一定连续 ，要长度最长的。

2.子序列和子数组问题我们一般考虑必须以某个位置结尾如何如何，在本题中我们可以这样考虑必须以i位置结尾的情况下最长递增子序列的最大长度是多少我们每个位置都这么干那么答案一定就在其中

下面以[5,7,1,9,4,6,2,8,3]为例：

第一个元素 5： 递增长度只能为1， 接下来第二个7，比5大，长度为2

第三个元素 1：前面没有比它大的，只能为1 ， 第四个元素9，前面有5，7，故长度为3到这里你发现，9比7大，7往前构成的长度是2，那9就可以接在7的后面，变成长度加一的新序列。

我相信老铁应该懂了

4.对应代码：

  1. class Solution {
  2.   public:
  3.     /**
  4.      * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
  5.      *
  6.      * 给定数组的最长严格上升子序列的长度。
  7.      * @param arr int整型vector 给定的数组
  8.      * @return int整型
  9.      */
  10.     int LIS(vector<int>& arr) {
  11.         if (arr.empty())
  12.             return 0;
  13.         // write code here
  14.         int N = arr.size();
  15.         vector<int>dp(N, 1);//每个位置最长递增子序列的长度至少为1自己本身就是
  16.         //dp的含义是必须以i位置结尾的情况下最长递增子序列的最大长度
  17.         int maxLen = 1;
  18.         for (int i = 1; i < N; i++) {
  19.             for (int j = 0; j < i; j++) {
  20.                 if (arr[i] > arr[j]) {
  21.                     dp[i] = max(dp[i], dp[j] + 1); //长度加1
  22.                 }
  23.             }
  24.             maxLen = max(maxLen, dp[i]);//更新最大长度
  25.         }
  26.         return maxLen;
  27.     }
  29. };

二.最长递增子序列问题II

1.对应牛客网链接：
最长上升子序列(二)_牛客题霸_牛客网 (nowcoder.com)

2.题目描述：

3.解题思路：

1.在这里我们引入end数组，end[i]的值为最目前为止长度为i+1的最小结尾

2.每次去end数组里面去找大于等于arr[i]最左的位置

我们看同样是长度为2的子序列，[2,3]就比[2,5]好。因为[2,3]后面如果有4的话，组成[2,3,4]长度就是3了，但是[2,5]因为不满足条件，就没法组队了。

我们组成子序列的时候，不仅要让这个序列尽可能的长，而且要让子序列中的上升的时候尽可能的缓慢，[2,3]就比[2,5]上升的缓慢，这样就有机会能拼接出更长的上升子序列。我们用一个数组来保存当前的最长上升子序列，这个数组是严格递增的。
因为是严格递增的，数组中最后一个值nums[max]就是最大值，如果下次再碰到一个数字n，它比num[max]还要大，那么很明显，这个子序列的长度就要+1，并且将数组n添加到数组的末尾。

[2,3,7,8,11,13,18]是目前为止最长的上升子序列，之后如果又碰到了19，或者101，因为他们都大于数组中的最大值18，所以直接将其添加到数组末尾就可以了，同时子序列的长度要+1。19和101的例子很好理解，但如果下次碰到的数字是6或者12呢？因为要让子序列上升的尽可能缓慢，那么让[2,5,7...]变成[2,5,6...]更合适，因为后者上升的更缓慢。同样,将[...8,11,13,18]变成[...8,11,12,18]也是上升的更缓慢一点。
也就是，已知上升子序列[i,i_1,i_2,....,i_n]，现在我们在继续遍历的过程中碰到了一个值i_k，这个值是小于i_n的，所以上升子序列的长度还是不变。但是我们需要找到一个位置，将i_k替换掉某个旧的值。

对应动图：

4.对应代码：

  1. class Solution {
  2.   public:
  3.     /**
  4.      * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
  5.      *
  6.      * 该数组最长严格上升子序列的长度
  7.      * @param a int整型vector 给定的数组
  8.      * @return int整型
  9.      */
  10.     int LIS(vector<int>& arr) {
  11.         // write code here
  12.         if (arr.empty()) {
  13.             return 0;
  14.         }
  15.         int N = arr.size();
  16.         vector<int>end(N);
  17.         //end[i]的含义是目前为止长度为i+1的最小结尾
  18.         end[0] = arr[0];
  19.         int L = 0;
  20.         int maxLen = 1;
  21.         int right = 0; //用于控制end数组的范围
  22.         int R = right;
  23.         for (int i = 1; i < N; i++) {
  24.             L = 0;
  25.             R = right;
  26.             while (L <= R) {//用于查找大于等于arr[i]最左边的位置
  27.                 int mid = (L + R) >> 1;
  28.                 if (arr[i] > end[mid]) {
  29.                     L = mid + 1;
  30.                 } else {
  31.                     R = mid - 1;
  32.                 }
  33.             }
  34.             right = max(right, L); //更新右边界
  35.             maxLen = max(maxLen, L + 1);
  36.             end[L] = arr[i];
  38.         }
  39.         return maxLen;
  40.     }
  41. };

三. 最长递增子序列问题III

1.对应letecode链接：
最长上升子序列(三)_牛客题霸_牛客网 (nowcoder.com)

2.题目描述：

3.解题思路

1.本题只是上题的一个升级版我们只需要定义一个变量记录 一下最长递增子序列的结尾位置在哪里即可，然后再依次遍历

4.对应代码：

  1. class Solution {
  2.   public:
  3.     /**
  4.      * retrun the longest increasing subsequence
  5.      * @param arr int整型vector the array
  6.      * @return int整型vector
  7.      */
  8.     vector<int> LIS(vector<int>& arr) {
  9.         // write code here
  10.         if (arr.empty()) {
  11.             return {};
  12.         }
  13.         int N = arr.size();
  14.         vector<int>dp(N, 1);
  15.         vector<int>end(N);
  16.         int maxLen = 1;
  17.         int maxIndex = 0;
  18.         end[0] = arr[0];
  19.         int right = 0;
  20.         int L = 0;
  21.         int R = right;
  22.         for (int i = 1; i < N; i++) {
  23.             L = 0;
  24.             R = right;
  25.             while (L <= R) {
  26.                 int mid = (L + R) >> 1;
  27.                 if (arr[i] > end[mid]) {
  28.                     L = mid + 1;
  29.                 } else {
  30.                     R = mid - 1;
  31.                 }
  32.             }
  33.             right = max(right, L);
  34.             maxLen = max(maxLen, L + 1);
  35.             end[L] = arr[i];
  36.             dp[i] = L + 1;
  37.             if (dp[i] >= maxLen) {//由于要求子典序最小
  38.                 maxIndex = i;
  39.                 maxLen = dp[i];
  40.             }
  41.         }
  42.         vector<int>ans(maxLen);//获取最长的递增子序列
  43.         for (int i = maxIndex; i >= 0; i--) {
  44.             if (dp[i] == maxLen) {
  45.                 ans[--maxLen] = arr[i];
  46.             }
  47.         }
  48.         return ans;
  49.     }
  50. };

思考题：如果要获取所有递增子序列了？

  1. #include<iostream>
  2. #include<vector>
  3. using namespace std;
  4. vector<int> process(vector<int>& arr,vector<int>&dp ,int maxLen, int index) {//获取所有最长递增子序列
  5. 	vector<int>ans(maxLen);
  6. 	for (int i = index; i >= 0; i--) {
  7. 		if (dp[i] == maxLen) {
  8. 			ans[--maxLen] = arr[i];
  9. 		}
  10. 	}
  11. 	cout << "进来" << endl;
  12. 	return ans;
  14. }
  15. int main() {
  16. 	int N;
  17. 	cin >> N;
  18. 	vector<int>arr(N);
  19. 	for (int i = 0; i < N; i++) {
  20. 		cin >> arr[i];
  21. 	}
  22. 	vector<int>dp(N, 1);
  23. 	vector<int>end(N);
  24. 	int maxLen = 1;
  25. 	int maxIndex = 0;
  26. 	end[0] = arr[0];
  27. 	int right = 0;
  28. 	int L = 0;
  29. 	int R = right;
  30. 	for (int i = 1; i < N; i++) {
  31. 		L = 0;
  32. 		R = right;
  33. 		while (L <= R) {
  34. 			int mid = (L + R) >> 1;
  35. 			if (arr[i] > end[mid]) {
  36. 				L = mid + 1;
  37. 			}
  38. 			else {
  39. 				R = mid - 1;
  40. 			}
  41. 		}
  42. 		right = max(right, L);
  43. 		maxLen = max(maxLen, L + 1);
  44. 		end[L] = arr[i];
  45. 		dp[i] = L + 1;
  46. 		if (dp[i] >= maxLen) {
  47. 			maxIndex = i;
  48. 			maxLen = dp[i];
  49. 		}
  50. 	}
  51. 	
  52. 	vector<vector<int>>ans;
  53. 	for (int i = 0; i < N; i++) {
  54. 		if (dp[i] == maxLen) {
  55. 			ans.push_back(process(arr, dp, maxLen, i));
  56. 		}
  57. 	}
  58. 	for (int i = 0; i < ans.size(); i++) {
  59. 		for (int j = 0; j < ans[0].size(); j++) {
  60. 			cout << ans[i][j] << " ";
  61. 		}
  62. 		cout << endl;
  63. 	}
  65. 	return 0;
  66. }

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/qq_56999918/article/details/125582884

内容来源于网络，如有侵权，请联系作者删除！

leetcode算法

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com