子序列问题
- 最长公共子序列：
- 最长上升子序列（要输出序列，和最大长度）
- 1.dp
- 2.贪心+二分
- 导弹拦截 （最长上升/下降子序列长度）
最长公共子序列：
class Solution {
public:
//dfs(i,j)代表s串i前字符和t串j前个字符，的公共子序列长度
//假设最长公共子序列是lcs，则当s[i]==t[j]时，那么公共子序列长度因该是+1
//不同时，如果s[i]在lcs中则dfs(i,j-1), 否则t[j]在lcs中则dfs(i-1,j)
//也有可能s[i]和t[j]都不在lcs中，那么就是dfs(i-1,j-1)
//但是显然这个能构造出来的最长公共子序列是小于上面两个的
// int dfs(string& s,string& t,int i,int j)
// {
// if(i<0||j<0)return 0;
// if(s[i]==t[j])
// return dfs(s,t,i-1,j-1)+1;
// else
// return max(dfs(s,t,i-1,j),dfs(s,t,i,j-1));
// }
// int longestCommonSubsequence(string s, string t) {
// return dfs(s,t,s.size()-1,t.size()-1);
// }
// };这样朴素的暴搜，显然会超时，并且可以很直观的发现，这里进行了很多重复的操作
//用二维数组记录之前的结果，dfs+记忆化
int cache[1005][1005];
int dfs(string& s, string& t, int i, int j)
{
if (i < 0 || j < 0)return 0;
int& ans = cache[i][j];
if (ans != 0)return ans;//不为0说明已经确定过这个值了，不必dfs
if (s[i] == t[j])
return ans = dfs(s, t, i - 1, j - 1) + 1;
else
return ans = max(dfs(s, t, i - 1, j), dfs(s, t, i, j - 1));
//return dfs(s,t,i,j);
}
int longestCommonSubsequence(string s, string t) {
return dfs(s, t, s.size() - 1, t.size() - 1);
}
};
最长上升子序列（要输出序列，和最大长度）
两种解法：
1.dp
#include<bits/stdc++.h>
using namespace std;
/*
* 最长不下降子序列
* 1.状态描述
* dp[i]：是以i为结尾的最长不下降子序列的长度
* 2.状态转移方程
* if(a[i]>=a[j]) dp[i]=max(dp[i],dp[j]+1);
* j是i之前的元素
*/
int n, a[201], dp[201], pre[201];
void reverse_print(int index)
{
if (index == -1)return;
reverse_print(pre[index]);
cout << a[index] << " ";
}
/*
14
13 7 9 16 38 24 37 18 44 19 21 22 63 15
*/
int main()
{
memset(pre, -1, sizeof(pre));
cin >> n;
for (int i = 0; i < n; i++)
{
cin >> a[i];
dp[i] = 1;//初始化
}
int maxx = 1;//最大长度至少都是1
int maxIndex = 0;
for (int i = 1; i < n; i++)
{
for (int j = 0; j < i; j++)
{
/*if (a[i] >= a[j])//如果只是求解序列长度，这样即可，但是要去找到这个序列，那还需要去记录其前驱
dp[i] = max(dp[i], dp[j] + 1);
maxx = max(maxx, dp[i]);*/
if (a[i] >= a[j])
{
if (dp[j] + 1 > dp[i])//说明以j为前驱时，会得到更长的序列，此时更新pre[i]
{
dp[i] = dp[j] + 1;
pre[i] = j;
}
}
if (dp[i] > maxx)
{
maxx = dp[i];
maxIndex = i;
}
}
}
std::cout << "max=" << maxx << endl;
reverse_print(maxIndex);
return 0;
}
2.贪心+二分
/*解法一：贪心+二分 */
class Solution {
public:
int low_bound(vector<int>& arr, int key)//去找一个最小的大于key的
{
int left = 0, right = arr.size();
while (left < right)
{
int mid = (left + right) / 2;
if (arr[mid] < key)
left = mid + 1;
else if (arr[mid] > key)//当mid大于key时，不是让right=mid-1;因为有可能此时的mid就是最小的大于key的
right = mid;
}
return right;
}
int lengthOfLIS(vector<int>& nums) {
vector<int> ret;//ret[i]表示长度为i+1的子序列的最小值
/*
我尽可能让这个子序列的末尾元素小，这样后面更多的元素才可能加入
*/
ret.push_back(nums[0]);//一个必然升序
for (int i = 1, k = 1; i < nums.size(); i++)//k是此时ret中有多少个元素，作为下标使用k-1
{
if (nums[i] > ret[k - 1])//大于ret的结尾，ret的结尾是ret中的最大的，直接加入
{
ret.push_back(nums[i]);
k++;
}
else if (nums[i] < ret[k - 1])//遇到小于，则往前去找一个最小的并且大于的num[i]的ret
{
int pos = low_bound(ret, nums[i]);//这里使用二分，提高效率
//cout << "pos=" << pos << endl;
//if (ret[pos] == nums[i])continue;
ret[pos] = nums[i];
}
}
return ret.size();
}
};
导弹拦截 （最长上升/下降子序列长度）
/*
* 某国为了防御敌国的导弹袭击，发展出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的导弹来袭。由于该系统还在试用阶段，所以只有一套系统，因此有可能不能拦截所有的导弹。
输入导弹依次飞来的高度（雷达给出的高度数据是不大于30000的正整数，导弹数不超过1000），计算这套系统最多能拦截多少导弹，如果要拦截所有导弹最少要配备多少套这种导弹拦截系统。
389 207 155 300 299 170 158 65
6
2
其实就是去求这个序列的最长上升子序列的长度，和最长下降子序列的长度
*/
#include<bits/stdc++.h>
using namespace std;
int n = 1, a[1001], dp_up[1001], dp_down[1001];
int main()
{
while (cin >> a[n])
{
dp_up[n] = dp_down[n] = 1;
n++;
}
n--;
int max_down = 1, max_up = 1;
for (int i = 2; i <= n; i++)
{
for (int j = 1; j < i; j++)
{
if (a[i] > a[j])dp_up[i] = max(dp_up[i], dp_up[j] + 1);
if (a[i] <= a[j])dp_down[i] = max(dp_down[i], dp_down[j] + 1);
}
max_down = max(max_down, dp_down[i]);
max_up = max(max_up, dp_up[i]);
}
cout << max_down << endl << max_up << endl;
return 0;
}
