#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;
}
*/
#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;
}
*/