分治算法：将问题划分成一些独立的子问题，递归地求解各子问题，然后合并子问题的解（子问题独立适合该方法）
贪心算法：求局部最优，以得到全局最优（不一定是正确的，需要证明）
动态规划：通过一些状态来描述一些子问题，然后通过状态之间的转移来求解（子问题重叠适合该方法）
动态实质=分治算法+解决子问题数据冗余
动态规划性质
最优子结构性质：当一个问题的最优解中包含了子问题的最优解时，则称该问题具有最优子结构特性
无后效性：下一时刻的状态只与当前状态有关，而和当前状态之前的状态无关，当前状态是对以往决策的总结
重叠子问题：在用递归算法自顶向下解此问题时，每次产生的子问题并不总是新的子问题，有些子问题被反复计算
动态规划求解过程
状态和状态转移方程（类似数学归纳法中的递推公式）
参考链接：https://blog.csdn.net/sunhuaqiang1/article/details/52103965
http://www.cnblogs.com/batys/p/3322553.html
http://www.hawstein.com/posts/dp-novice-to-advanced.html
https://blog.csdn.net/yake827/article/details/52119469
1.最大连续子序列和
给定K个整数的序列{ N1, N2, ..., NK }，其任意连续子序列可表示为{ Ni, Ni+1, ..., Nj }，其中 1 <= i <= j <= K。最大连续子序列是所有连续子序中元素和最大的一个， 例如给定序列{ -2, 11, -4, 13, -5, -2 }，其最大连续子序列为{ 11, -4, 13 }，最大和为20。
分析：最大连续子序列和只可能是以位置0～n-1中某个位置结尾。当遍历到第i个元素时，判断在它前面的连续子序列和是否大于0，如果大于0，则以位置i结尾的最大连续子序列和为元素i和前门的连续子序列和相加；否则，则以位置i结尾的最大连续子序列和为元素i。
状态转移方程： sum[i]=max{sum[i-1]+a[i],a[i]};
int FindGreatestSumOfSubArray(vector<int> array) {
if(array.size()==0)
return 0;
int MaxSum=array[0]; //这里一定要初始化为第一个数，而不能是0，因为可能出现全部负数的情况
int CurrentSum=array[0];
for(int i=1;i<array.size();i++)
{
CurrentSum+=array[i]; //向后累加
if(CurrentSum>MaxSum) //如果当前子列和更大，则更新
MaxSum=CurrentSum;
if(CurrentSum<0) //如果当前子列和为负，则不可能使后面的部分和增大，所以抛弃之
CurrentSum=0;
}
return MaxSum;
}2.最长公共子序列(不连续)(LCS)
对于母串X=<x1,x2,⋯,xm>, Y=<y1,y2,⋯,yn>，求LCS与最长公共子串。
分析：假设Z=<z1,z2,⋯,zk>是X与Y的LCS， 我们观察到
如果Xm=Yn，则Zk=Xm=Yn，有Zk−1是Xm−1与Yn−1的LCS；
如果Xm≠Yn，则Zk是Xm与Yn−1的LCS，或者是Xm−1与Yn的LCS。
状态转移方程：
#include <iostream>
#include <vector>
#include <String>
#include <math.h>
using namespace std;
int Lcs(string s1,string s2){
int n = s1.length();
int m = s2.length();
// vector<vector<int> > res(n+1);
// for(int i = 0;i <= n;i++){
// res[i].resize(m+1);
// }
//初始化
int res[n+1][m+1];
for(int i = 0;i <= n;i++) //行
for(int j = 0; j <= m;j++)//列
res[i][j]=0;
//这里不用取等号，因为后面是用+1的，而不是-1
for(int i = 0;i < n;i++){
for(int j = 0; j < m;j++){
if(s1[i] == s2[j]){
res[i+1][j+1] = res[i][j] + 1;
}
else{
res[i+1][j+1] = max(res[i][j+1],res[i+1][j]);
}
}
}
for(int i = 0;i <= n;i++){
for(int j = 0;j <= m;j++){
cout<<res[i][j]<<" ";
}
cout<<endl;
}
cout<<endl;
return res[n][m];
}
int main(int argc, char *argv[])
{
string s1,s2;
getline(cin,s1);
getline(cin,s2);
int max=Lcs(s1,s2);
cout<<"MaxLength:"<<max<<endl;
return 0;
}时间复杂度为O（m*n），空间复杂度O（m*n）
参考链接：https://blog.csdn.net/tingyun_say/article/details/52373566
https://blog.csdn.net/u012102306/article/details/53184446
https://blog.csdn.net/hrn1216/article/details/51534607
3.最长公共子串(连续)(LCS)
与上题目类似，只不过这里是上面的特殊情况，因此只需要修改最后一个条件即可。
状态转移方程如下：
//最长公共子串（子序列特殊情况）
int Lcs2(string s1,string s2){
int n = s1.length();
int m = s2.length();
int result=0;
//初始化
int res[n+1][m+1];
for(int i = 0;i <= n;i++) //行
for(int j = 0; j <= m;j++)//列
res[i][j]=0;
//这里不用取等号，因为后面是用+1的，而不是-1
for(int i = 0;i < n;i++){
for(int j = 0; j < m;j++){
if(s1[i] == s2[j]){
res[i+1][j+1] = res[i][j] + 1;
result = max(res[i+1][j+1],result);
}
else{
res[i+1][j+1] = 0;
}
}
}
for(int i = 0;i <= n;i++){
for(int j = 0;j <= m;j++){
cout<<res[i][j]<<" ";
}
cout<<endl;
}
cout<<endl;
return result;
}4.最长递增子序列
给定一个长度为N的数组，找出一个最长的单调自增子序列（不一定连续，但是顺序不能乱）。例如：给定一个长度为6的数组A{5， 6， 7， 1， 2， 8}，则其最长的单调递增子序列为{5，6，7，8}，长度为4.
法一：最长公共子序列法
这个问题可以转换为最长公共子序列问题。如例子中的数组A{5，6， 7， 1， 2， 8}，则我们排序该数组得到数组A‘{1， 2， 5， 6， 7， 8}，然后找出数组A和A’的最长公共子序列即可。
法二：动态规划法（时间复杂度O（n*n））
设长度为N的数组为{a0，a1, a2, ...an-1)，则假定以aj结尾的数组序列的最长递增子序列长度为L(j)，则L(j)={ max(L(i))+1, i<j且a[i]<a[j] }。也就是说，我们需要遍历在j之前的所有位置i(从0到j-1)，找出满足条件a[i]<a[j]的L(i)，求出max(L(i))+1即为L(j)的值。最后，我们遍历所有的L(j)（从0到N-1），找出最大值即为最大递增子序列。时间复杂度为O(N^2)。
例如给定的数组为{5，6，7，1，2，8}，则L(0)=1, L(1)=2, L(2)=3, L(3)=1, L(4)=2, L(5)=4。所以该数组最长递增子序列长度为4，序列为{5，6，7，8}
法三：O（NlogN）算法
具体可以参考：https://blog.csdn.net/u013178472/article/details/54926531