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;  
    }  
}  

3. 最长公共子序列(不连续) 和 最长公共子串(连续)

链接

4. 字符串编辑距离

链接