1. (和)最大子序列(连续)
这是一道非常经典的动态规划的题目，用到的思路我们在别的动态规划题目中也很常用，以后我们称为”局部最优和全局最优解法“。基本思路是这样的，在每一步，我们维护两个变量，一个是全局最优，就是到当前元素为止最优的解，一个是局部最优，就是必须包含当前元素的最优的解。接下来说说动态规划的递推式（这是动态规划最重要的步骤，递归式出来了，基本上代码框架也就出来了）。假设我们已知第i步的global[i]（全局最优）和local[i]（局部最优），那么第i+1步的表达式是：local[i+1]=Math.max(A[i], local[i]+A[i])，就是局部最优是一定要包含当前元素，所以不然就是上一步的局部最优local[i]+当前元素A[i]（因为local[i]一定包含第i个元素，所以不违反条件），但是如果local[i]是负的，那么加上他就不如不需要的，所以不然就是直接用A[i]；
局部最优和全局最优解法
- 首先local[i]表示以a[i]为结尾的子序列的最大的和，则global = max{local[0], … , local[n-1]} 。 global即为答案。而local[i + 1]只有两个选择，要不就是和之前的数字连在一起组成一个序列，或者自己a[i+1]独立组成一个序列，哪个大选哪个,local[i+1] = max{ a[i+1], local[i] + a[i+1] }.
#include<vector>
#include<algorithm>
#include<cstdio>
#include <unordered_map>
#include <cmath>
#include <string>
#include <set>
using namespace std;
class Solution {
private:
int max(int a, int b)
{
return a>b? a:b;
}
public:
int maxSubArray(vector<int>& nums) {
int size = (int)nums.size();
int local = nums[0];
int global = local;
for (int i = 1; i < size; i++)
{
local = max(local + nums[i], nums[i]);
global = max(local, global);
}
return global;
}
};
分治法
易知，对于一数字序列，其最大连续子序列和对应的子序列可能出现在三个地方。或是整个出现在输入数据的前半部（左），或是整个出现在输入数据的后半部（右），或是跨越输入数据的中部从而占据左右两半部分。前两种情况可以通过递归求解，第三种情况可以通过求出前半部分的最大和（包含前半部分的最后一个元素）以及后半部分的最大和（包含后半部分的第一个元素）而得到，然后将这两个和加在一起即可。
#include<vector>
#include<algorithm>
#include<cstdio>
#include <unordered_map>
#include <cmath>
#include <string>
#include <set>
using namespace std;
class Solution {
private:
int max(int a, int b)
{
return a>b? a:b;
}
int maxSubSum(vector<int>& nums, int l, int r)
{
if (l == r) return nums[l];
int mid = (l + r)/2;
int wholeLeft = maxSubSum(nums, l, mid);
int wholeRight = maxSubSum(nums, mid+1, r);
int partleft = nums[mid];
int sum = partleft;
for (int i = mid-1; i>= l; i--)
{
sum += nums[i];
partleft = max(partleft, sum);
}
int partright = nums[mid+1];
int sum2 = partright;
for (int i = mid + 2; i <= r; i++)
{
sum2 += nums[i];
partright = max(partright, sum2);
}
return max(max(wholeRight, wholeLeft), partright + partleft);
}
public:
int maxSubArray(vector<int>& nums) {
int size = (int)nums.size();
return maxSubSum(nums, 0, size-1);
}
};
2. 最长递增子序列(不连续) LIS
一个简单的思路，O(n^2)。编程之美里的一个思路可以加速到O(nlgn)
一个整型数组，求其中最长递增子序列的长度。
简单的想法：从前到后遍历数组，对于每一个元素，从该元素开始往前判断是不是大于前面的元素，如果大于，则根据是否大于当前位置的最长子序列长度，相应的更新当前这个子序列的长度。
public class CopyOfTest1 {
public static void main(String ss[]) {
System.out.println(get(new int[] { 1, -1, 2, -3, 4, -5, 6, -7 }));
}
public static int get(int[] data) {
int[] len = new int[data.length];// 记录最长信息
for (int i = 0; i < len.length; i++) {
len[i] = 1;
}
for (int i = 0; i < data.length; i++) {
for (int j = i - 1; j >= 0; j--) {
if (data[i] > data[j] && len[i] < len[j] + 1) {
len[i] = len[j] + 1;
}
}
}
int max = -1;
for (int i = 0; i < len.length; i++) {
if (max < len[i]) {
max = len[i];
}
}
return max;
}
}
