几道动态规划算法题

1.题目描述

在数组中找到连续的子数组（至少包含一个数字），这个数组的总和最大。

例如，给定数组[-2,1，-3,4，-1,2,1，-5,4]，
连续的子数组[ 4，-1,2,1]具有最大的和= 6。

class Solution {
public:
    int maxSubArray(int A[], int n) {
    int sum = A[0], maxSum = A[0];
    for (int i = 1; i < n;i++)
    {
        if (sum < 0)
            sum = 0;//先判断之前的sum能否被这次利用（小于0则抛弃）
        sum += A[i];
        maxSum = max(maxSum, sum);
    }
    return maxSum;
    }
};

2.爬梯子
题目描述

You are climbing a stair case. It takes n steps to reach to the top.

Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?

递归法：（时间限制不够用）

class Solution {
public:
    int climbStairs(int n) {
        int count=0;
        if(n==0) 
            count=0;
        if(n==1||n==2) 
           count=n;

        if(n>2){
            count=climbStairs(n-1)+climbStairs(n-2);
        }
        return count;
    }
};

非递归法

class Solution {
public:
    int climbStairs(int n) {
        int count=0;
        if(n==0) 
            count=0;
        if(n==1||n==2) 
           count=n;

        int a=1;
        int b=2;
        for(int i=3;i<=n;i++){
            count=a+b;
            a=b;
            b=count;
        }
        return count;

    }
};

3.机器人路径问题
题目描述

机器人位于一个m x n 网格的左上角（在下图中标记为“开始”）。

机器人只能随时向下或向右移动。机器人正在尝试到达网格的右下角（在下图中标记为“完成”）。

有多少可能的独特路径？
上面是一个3 x 7网格。有多少可能的独特路径？
注意： m和n最多为100。

class Solution {
public:
    int uniquePaths(int m, int n) {
        int c=0;
        int A[m][n];
        if(m>100||n>100)
            return 0;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                A[i][j]=0;
                if(i==0||j==0){
                    A[i][j]=1;
                    continue;
                }
                A[i][j]=A[i-1][j]+A[i][j-1];

            }

        }
        return A[m-1][n-1];
      }
};

4.格雷码
题目描述

格雷码是一个二进制数字系统，其中两个连续值仅在一个位上不同。

给定一个代表代码总位数的非负整数n，打印格雷码序列。灰色代码序列必须以0开头。

例如，给定n = 2，返回[0,1,3,2]。其灰色代码序列是：

00 - 0
01 - 1
11 - 3
10 - 2
注意：
对于给定的n，格雷码序列不是唯一定义的。

例如，[0,2,3,1]也是根据上述定义的有效格雷码序列。

class Solution {
public:
    vector<int> grayCode(int n) {
        vector<int> result(pow(2,n));
        for (int i=1;i<=n;++i)
        {
            int size = 1<<i;
            int flag = 1<<(i-1);
            int index = 0;
            for (int j=size-1;2*j>=size;--j)
            {
                result[j] = result[index++]|flag;  //左部插入1
            }
        }
        return result;


    }
};

当n=1时，为[0,1]
当n=2时，为[00,01,11,10]
当n=3时，为[000,001,011,010,110,111,101,100]
由此可以看出新的序列其实是在前面序列基础上插入新的值
其中前半部分的数值不变，后半部分的数值为上个序列中每个元素第n个位变1，逆向插入

通俗的解法二：

    vector<int>v;
        if(n==0){
            v.push_back(0);
            return v;
        }
        v = grayCode(n-1);
        int len = (int)v.size();
        for(int i = 0 ;i < len;i++){
            v.push_back(v[len-i-1]+pow(2,n-1));
        }
        return v;