514
class Solution {
public:/*
* @param n: non-negative integer, n posts
* @param k: non-negative integer, k colors
* @return: an integer, the total number of ways
*/
int numWays(int n, int k) {
if(k==1)
{
if(n>2)
return 0;
else
return 1;
}
int dp[99];
dp[1]=k;
dp[2]=k*k;
for(int i=3;i<=n;i++)
{
dp[i]=(k-1)*dp[i-1]+(k-1)*dp[i-2];
}
return dp[n];
}
};
397
class Solution {
public:
/*
* @param A: An array of Integer
* @return: an integer
*/
int longestIncreasingContinuousSubsequence(vector<int> &A) {
int beg,end,now;
beg=0,end=0;
int ans[99999];
int tmp=0;
int n=A.size();
if(n==0)
return 0;
memset(ans,0,sizeof(ans));
for(int i=1;i<n;i++)
{
now=i;
if(A[now]>A[now-1])
{
end=now-1;
ans[tmp++]=end-beg;
beg=now;
}
}
end=n-1;
ans[tmp++]=end-beg;
beg=0;
for(int i=1;i<n;i++)
{
now=i;
if(A[now]<A[now-1])
{
end=now-1;
ans[tmp++]=end-beg;
beg=now;
}
}
end=n-1;
ans[tmp++]=end-beg;
int maxx=0;
for(int i=0;i<tmp;i++)
{
maxx=max(maxx,ans[i]);
}
return maxx+1;
}
};
115
class Solution {
public:
/*
* @param obstacleGrid: A list of lists of integers
* @return: An integer
*/
int uniquePathsWithObstacles(vector<vector<int>> &obstacleGrid) {
int dp[105][105];
memset(dp,0,sizeof(dp));
int n=obstacleGrid[0].size();
int m=obstacleGrid.size();
dp[m][n]=1;
for(int i=m;i>=1;i--)
{
for(int j=n;j>=1;j--)
{
if(obstacleGrid[i-1][j-1]==1)
continue;
if(i+1<=m&&obstacleGrid[i][j-1]!=1)
dp[i][j]+=dp[i+1][j];
if(j+1<=n&&obstacleGrid[i-1][j]!=1)
dp[i][j]+=dp[i][j+1];
}
}
return dp[1][1];
}
};
114
class Solution {
public:
/*
* @param m: positive integer (1 <= m <= 100)
* @param n: positive integer (1 <= n <= 100)
* @return: An integer
*/
int uniquePaths(int m, int n) {
// write your code here
int dp[105][105];
memset(dp,0,sizeof(dp));
dp[m][n]=1;
for(int i=m;i>=1;i--)
{
for(int j=n;j>=1;j--)
{
if(i+1<=m)
dp[i][j]+=dp[i+1][j];
if(j+1<=n)
dp[i][j]+=dp[i][j+1];
}
}
return dp[1][1];
}
};
111
class Solution {
public:
/**
* @param n: An integer
* @return: An integer
*/
int climbStairs(int n) {
int dp[105];
dp[1]=1;
dp[2]=2;
for(int i=3;i<=n;i++)
{
dp[i]=dp[i-1]+dp[i-2];
}
return dp[n];
}
};
110
class Solution {
public:
/*
* @param grid: a list of lists of integers
* @return: An integer, minimizes the sum of all numbers along its path
*/
int minPathSum(vector<vector<int>> &grid) {
int dp[1005][1005];
int m=grid.size();
int n=grid[0].size();
dp[m][n]=grid[m-1][n-1];
for(int i=0;i<m;i++)
{
for(int j=0;j<n;j++)
{
dp[i+1][j+1]=grid[i][j];
}
}
for(int i=m;i>=1;i--)
{
for(int j=n;j>=1;j--)
{
if(i+1>m)
{
if(j+1<=n)
{
dp[i][j]+=dp[i][j+1];
}
}
else
{
if(j+1<=n)
{
dp[i][j]+=min(dp[i+1][j],dp[i][j+1]);
}
else
{
dp[i][j]+=dp[i+1][j];
}
}
}
}
return dp[1][1];
}
};
109
class Solution {
public:
/*
* @param triangle: a list of lists of integers
* @return: An integer, minimum path sum
*/
int minimumTotal(vector<vector<int>> &triangle) {
// write your code here
int dp[1005][1005];
int m=triangle.size();
int n=triangle[0].size();
for(int i=m-1;i>=0;i--)
{
for(int j=i;j>=0;j--)
{
dp[i][j]=triangle[i][j];
if(i==m-1)
continue;
dp[i][j]+=min(dp[i+1][j],dp[i+1][j+1]);
}
}
return dp[0][0];
}
};