动态规划

动态规划和贪心算法相似，都是用来求解最优解的，但是区别也很大，适合动态规划求解的问题，也满足最优子结构性质，却不一定满足贪心的选择的性质，贪心算法是局部最优解，其实在动态规划中，贪心算法被替换成无后效性。

动态规划的基本思想

动态规划的基本思想源自递归，是一种问题转化策略，基于递归的问题转化策略有限多。

例如：有一个由正整数组成的三角形，第一行只有一个数，除了最下行外，每个数的左下方和右下方都有一个正整数。从第一行数开始，每次可以沿左下或右下往下走，把沿途经过的数全部加起来，如何走，能使这个和达到最大？

首先想到找出这个大三角形可以分出几块子结构，接着再把子结构分成子结构，通过递归可以完成这一步；每个子结构中都存在第一行+max(左下，右下) ；最后求得最大值。

#include<iostream>
#include<stdio.h>
using namespace std ;
int a[100][100] ;
int solve(int i , int j)    {
    if(i == 4)
        return a[i][j] ;
    else
        return (a[i][j] + max(solve(i+1,j) , solve(i+1,j+1))) ;
}

int main()  {

    for(int i = 0 ; i < 5 ; i++)
        for(int j = 0 ; j <= i ; j++)
            cin >> a[i][j] ;
    cout << solve(0,0) << endl;
    return 0 ;
}

这样做正确，但是肯定很耗时，因为有了很多的重复计算 。

当然也可以使用递推的方法：

从最后一层开始算，每一行都会得到下一行中两个数中最大值与其相加的和；则第一行就是最大值；

#include<iostream>
#include<stdio.h>
using namespace std ;
int main()  {
    int a[100][100] ;
    for(int i = 0 ; i < 5 ; i++)
        for(int j =  0 ; j <= i ; j++)
            cin >> a[i][j] ;
    for(int ii = 3 ; ii >= 0 ; ii-- )
        for(int jj = 0 ; jj <= ii ; jj++)
            a[ii][jj] += ( a[ii+1][jj] > a[ii+1][jj+1] ? a[ii+1][jj] : a[ii+1][jj+1] );
    cout << a[0][0] << endl ;
    return 0 ;
}

第三种方法就是记忆化搜索（动态规划）

主要在第一种方法的基础之上，加上了访问标记，防止了重复的计算：

#include<iostream>
#include<stdio.h>
using namespace std ;


int a[100][100] ;
int dp[100][100] = {0} ;


int solve(int i , int j)    {
    if(i == 4)
        return a[i][j];
    if(dp[i][j]>0)
        return dp[i][j] ;
    else    {
         dp[i][j] =  a[i][j] + max(solve(i+1 , j) , solve(i+1 , j+1) ) ;
         return dp[i][j] ;
    }
}


int main()  {
    for(int i = 0 ; i < 5 ; i++)
        for(int j = 0 ; j <= i ; j++)
        cin >> a[i][j] ;
    cout << solve(0,0) << endl;
    return 0 ;
}

这就是动态规划的基本思想：建立子问题的描述，建立状态间的转移关系，使用递推或记忆化搜索来实现