leetcode c++ 动态规划

#include <iostream>
#include <vector>
#include <algorithm>


using namespace std;

class Solution
{
public:
    /***************************************************
    *  函数功能：爬楼梯
    *  参数说明
    *       输入参数：3
    *       输出参数：3
    *  复杂性分析：时间复杂度：O(n)，空间复杂度：O(1)
    *  题目来源  ：https://leetcode.com/problems/climbing-stairs/description/
    *  日期：2018-07-07-21.47
    ***************************************************/
    int climbStairs(int n)
    {
        if(n<0) return 0;
        vector<int> dp(n+3,0);
        dp[1]=1;
        dp[2]=2;
        for(int i=3;i<=n;i++)
        {
            dp[i]=dp[i-1]+dp[i-2];
        }
        return dp[n];
    }

    /***************************************************
    *  函数功能：House Robber
    *  参数说明
    *       输入参数：[2,7,9,3,1]
    *       输出参数：12
    *  复杂性分析：时间复杂度：O(n)，空间复杂度：O()
    *  题目来源  ： https://leetcode.com/problems/house-robber/description/
    *  日期：2018-07-07-21.50
    ***************************************************/
    int rob(vector<int>& nums)
    {
        if(nums.size()<1) return 0;
        if(nums.size()<2) return nums[0];

        vector<int> dp(nums.size(),0);
        dp[0]=nums[0];
        dp[1]=max(dp[0],nums[1]);
        for(int i=2;i<nums.size();i++)
        {
            dp[i]=max(dp[i-1],dp[i-2]+nums[i]);
        }
        return dp[nums.size()-1];
    }

    /***************************************************
    *  函数功能：Maximum Subarray
    *  参数说明
    *       输入参数：[-2,1,-3,4,-1,2,1,-5,4]
    *       输出参数：6
    *  复杂性分析：时间复杂度：O()，空间复杂度：O()
    *  题目来源  ： https://leetcode.com/problems/maximum-subarray/description/
    *  日期：2018-07-07-21.59
    ***************************************************/
    int maxSubArray(vector<int>& nums)
    {
        if(nums.size()<1) return 0;
        if(nums.size()<2) return nums[0];
        vector<int> dp(nums.size(),-1);
        dp[0]=nums[0];
        int maxN=dp[0];
        for(int i=1;i<nums.size();i++)
        {
            dp[i]=max(dp[i-1]+nums[i],nums[i]);
            if(maxN<dp[i])
            {
                maxN=dp[i];
            }
        }
        return maxN;
    }

    /***************************************************
    *  函数功能：Coin Change
    *  参数说明
    *       输入参数：coins = [1, 2, 5], amount = 11
    *       输出参数：3  Explanation: 11 = 5 + 5 + 1
    *  复杂性分析：时间复杂度：O(n)，空间复杂度：O()
    *  题目来源  ： https://leetcode.com/problems/coin-change/description/
    *  日期：2018-07-07-22.14
    ***************************************************/
    int coinChange(vector<int>& coins,int amount)
    {
        if(amount<1 || coins.size()<1) return -1;
        vector<int> dp(amount+1,-1);
        sort(coins.begin(),coins.end());
        dp[0]=0;
        for(int i=1;i<=amount;i++)
        {
            for(int j=0;j<coins.size();j++)
            {
                if(i-coins[j]>=0 && dp[i-coins[j]]!=-1)
                {
                    if(dp[i]==-1 || dp[i] > (dp[i-coins[j]]+1))
                    {
                       dp[i]=dp[i-coins[j]]+1;
                    }
                }
            }
        }
        return dp[amount];
    }

    /***************************************************
    *  函数功能：Triangle
    *  参数说明
    *       输入参数：
                         [2],
                        [3,4],
                       [6,5,7],
                      [4,1,8,3]
    *       输出参数：11
    *  复杂性分析：时间复杂度：O()，空间复杂度：O()
    *  题目来源  ： https://leetcode.com/problems/triangle/description/
    *  日期：2018-07-09-19.53
    ***************************************************/
    int minimunTotal(vector<vector<int> >& triangle)
    {
        if(triangle.size()<1) return 0;
        vector<vector<int> > dp;
        for(int i=0;i<triangle.size();i++)
        {
            dp.push_back(vector<int>());
            for(int j=0;j<triangle[i].size();j++)
            {
                dp[i].push_back(-1);
            }
        }
        for(int i=0;i<triangle.size();i++)
        {
            dp[triangle.size()-1][i]=triangle[triangle.size()-1][i];
        }
        for(int i=triangle.size()-2;i>=0;i--)
        {
            for(int j=0;j<triangle[i].size();j++)
            {
                dp[i][j]=min(dp[i+1][j],dp[i+1][j+1])+triangle[i][j];
            }
        }


        return dp[0][0];
    }

    /***************************************************
    *  函数功能：Longest Increasing Subsequence
    *  参数说明
    *       输入参数：[10,9,2,5,3,7,101,18]
    *       输出参数：4
    *  复杂性分析：时间复杂度：O(n)，空间复杂度：O()
    *  题目来源  ： https://leetcode.com/problems/longest-increasing-subsequence/description/
    *  日期：2018-07-09-20.52
    ***************************************************/
    int lengthOfLIS(vector<int>& nums)
    {
        if(nums.size()<2) return nums.size();
        vector<int> node;
        node.push_back(nums[0]);
        for(int i=1;i<nums.size();i++)
        {
            if(node.back()<nums[i])
            {
                node.push_back(nums[i]);
            }else
            {
                for(int j=0;j<node.size();j++)
                {
                    if(node[j]>=nums[i])
                    {
                        node[j]=nums[i];
                        break;
                    }
                }
            }
        }

        return node.size();
    }

    /***************************************************
    *  函数功能：Minimum Path Sum
    *  参数说明
    *       输入参数：
                  [1,3,1],
                  [1,5,1],
                  [4,2,1]
    *       输出参数：7
    *  复杂性分析：时间复杂度：O(n^2)，空间复杂度：O()
    *  题目来源  ：https://leetcode.com/problems/minimum-path-sum/description/
    *  日期：2018-07-09-20.55
    ***************************************************/
    int minPathSum(vector<vector<int> >& grid)
    {
        if(grid.size()<1) return 0;
        vector<vector<int> > dp;
        for(int i=0;i<grid.size();i++)
        {
            dp.push_back(vector<int>());
            for(int j=0;j<grid[i].size();j++)
            {
                dp[i].push_back(0);
            }
        }
        dp[0][0]=grid[0][0];
        for(int i=1;i<grid.size();i++)
        {
            dp[i][0]=grid[i][0]+dp[i-1][0];
        }
        for(int i=1;i<grid[0].size();i++)
        {
            dp[0][i]=grid[0][i]+dp[0][i-1];
        }
        for(int i=1;i<grid.size();i++)
        {
            for(int j=1;j<grid[i].size();j++)
            {
                dp[i][j]=min(dp[i][j-1],dp[i-1][j])+grid[i][j];
            }
        }
        int x=grid.size()-1;
        int y=grid[x].size()-1;
        return dp[x][y];
    }

    /***************************************************
    *  函数功能：Dungeon Game
    *  参数说明
    *       输入参数：
                    [-2 -3 3]
                    [-5 -10 1]
                    [10 30 -5]
    *       输出参数：7
    *  复杂性分析：时间复杂度：O(n^2)，空间复杂度：O()
    *  题目来源  ：https://leetcode.com/problems/dungeon-game/description/
    *  日期：2018-07-09-21.20
    ***************************************************/
    int calculateMinimumHP(vector<vector<int> >& dungeon)
    {
        if(dungeon.size()<1) return 1;
        vector<vector<int> > dp;
        for(int i=0;i<dungeon.size();i++)
        {
            dp.push_back(vector<int>());
            for(int j=0;j<dungeon[i].size();j++)
            {
                dp[i].push_back(0);
            }
        }
        int x=dungeon.size()-1;
        int y=dungeon[x].size()-1;
        dp[x][y]=max(1,1-dungeon[x][y]);
        for(int i=x-1;i>=0;i--) // row
        {
             dp[i][y]=max(1,dp[i+1][y]-dungeon[i][y]);
        }
        for(int i=y-1;i>=0;i--) //column
        {
             dp[x][i]=max(1,dp[x][i+1]-dungeon[x][i]);
        }
        for(int i=x-1;i>=0;i--)
        {
            for(int j=y-1;j>=0;j--)
            {
                int k=min(dp[i][j+1],dp[i+1][j]);
                dp[i][j]=max(1,k-dungeon[i][j]);
            }
        }
//        for(int i=0;i<=x;i++)
//        {
//            for(int j=0;j<=y;j++)
//            {
//                cout<<dp[i][j]<<" ";
//            }
//            cout<<endl;
//        }
//        cout<<"-------------"<<endl;
        return dp[0][0];
    }
};


int main()
{
    vector<vector<int> > grid;
    int a[][3]={{-2,-3,3},{-5,-10,1},{10,30,-5}};
    for(int i=0;i<3;i++)
    {
        grid.push_back(vector<int>());
        for(int j=0;j<3;j++)
        {
            grid[i].push_back(a[i][j]);
        }
    }
    Solution ss;
    cout<<ss.calculateMinimumHP(grid)<<endl;
    return 0;
}

/*
int main()
{
    vector<vector<int> > grid;
    int a[][3]={{1,3,1},{1,5,1},{4,2,1}};
    for(int i=0;i<3;i++)
    {
        grid.push_back(vector<int>());
        for(int j=0;j<3;j++)
        {
            grid[i].push_back(a[i][j]);
        }
    }
    Solution ss;
    cout<<ss.minPathSum(grid)<<endl;
    return 0;
}
*/


/*
int main()
{
    int a[]={4,10,4,3,8,9};
    int len=sizeof(a)/sizeof(*a);
    vector<int> nums;
    for(int i=0;i<len;i++)
    {
        nums.push_back(a[i]);
    }
    Solution ss;
    cout<<ss.lengthOfLIS(nums)<<endl;
    return 0;
}
*/

/*
int main()
{
    Solution ss;
    vector<int> T;
    vector<vector<int> > triangle;
    T.push_back(2);
    triangle.push_back(T);
    T.clear();
    T.push_back(3);
    T.push_back(4);
    triangle.push_back(T);
    T.clear();
    T.push_back(6);
    T.push_back(5);
    T.push_back(7);
    triangle.push_back(T);
    T.clear();
    T.push_back(4);
    T.push_back(1);
    T.push_back(8);
    T.push_back(3);
    triangle.push_back(T);
    T.clear();

    cout<<ss.minimunTotal(triangle)<<endl;

    return 0;
}
*/


/*
int main()
{
    Solution ss;
    vector<int> coins;
    int a[]={1,2,5};
    int len=sizeof(a)/sizeof(*a);
    for(int i=0;i<len;i++)
    {
        coins.push_back(a[i]);
    }
    int amount=11;
    cout<<ss.coinChange(coins,amount)<<endl;

    return 0;
}
*/


/*
int main()
{
    Solution ss;
    int A[]={-2,1,-3,4,-1,2,1,-5,4};
    int len=sizeof(A)/sizeof(*A);
    vector<int> nums;
    for(int i=0;i<len;i++)
    {
        nums.push_back(A[i]);
    }
    cout<<ss.maxSubArray(nums)<<endl;

    return 0;
}
*/


/*
int main()
{
    Solution ss;
    int A[]={2,7,9,3,1};
    int len=sizeof(A)/sizeof(*A);
    vector<int> nums;
    for(int i=0;i<len;i++)
    {
        nums.push_back(A[i]);
    }
    cout<<ss.rob(nums)<<endl;
    cout<<ss.climbStairs(3)<<endl;


    return 0;
}
*/