7

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];
    }
};