九章算法第九课，动态规划

动态规划的四步：定义状态，设计状态转移方程，初始化边界，确定答案。

109. 数字三角形
这个形状和树的结构相似，可以利用分治的思路求解。但是会超时，时间复杂度O(n^2)。

class Solution {
public:
    int minimumTotal(vector<vector<int>> &triangle) {
        int n=triangle.size();
        return dfshelper(triangle,0,0,n);
    }
    int dfshelper(vector<vector<int>> &triangle,int x,int y,int n) {
        if (x==n) return 0;
        
        return triangle[x][y]+min(dfshelper(triangle,x+1,y,n),dfshelper(triangle,x+1,y+1,n));
    }
};

 分析结构发现，这个三角形和树不同的地方在于每个节点左上和右上均有联通节点，因此计算过程中可能存在重复访问。如果能记录下已经算过的节点的最小路径和，就不用再重复计算了。时间复杂度降低为O(n*n)。

class Solution {
public:
    int minimumTotal(vector<vector<int>> &triangle) {
        int n=triangle.size();
        int m=triangle[n-1].size();
        vector<vector<int>> f(n,vector<int>(m,INT_MAX));
        return dfshelper(triangle,0,0,n,f);
    }
    int dfshelper(vector<vector<int>> &triangle,int x,int y,int n,vector<vector<int>> &f) {
        if (x==n) return 0;
        if (f[x][y]!=INT_MAX) return f[x][y];
        else f[x][y]=triangle[x][y]+min(dfshelper(triangle,x+1,y,n,f),dfshelper(triangle,x+1,y+1,n,f));
        
        return f[x][y];
    }
};

写成for循环的形式，就是动态规划。 

class Solution {
public:
    int minimumTotal(vector<vector<int>> &triangle) {
        int n=triangle.size();
        
        for (int i=n-2;i>=0;i--) {
            for (int j=0;j<triangle[i].size();j++)
                triangle[i][j]+=min(triangle[i+1][j],triangle[i+1][j+1]);
        }
        
        return triangle[0][0];
    }
};

124. 最长连续序列
这个题是典型的不能使用动态规划的代表。使用的数据是一个集合而不是有序的序列(即没有方向性)。这个题为了使时间复杂度降到O(n),必须使用哈希表。且当每次访问了这个元素之后，在哈希表内删除(精髓中的精髓，保证每个元素最多访问一次)。

class Solution {
public:
    int longestConsecutive(vector<int> &num) {
        if (num.size()<=1) return num.size();
        
        unordered_set<int> hash(num.begin(),num.end());
        int res=1;
        for (int i=0;i<num.size();i++) {
            if (hash.find(num[i])!=hash.end()) {
                hash.erase(num[i]);