leetcode-20-Dynamic Programming

303. Range Sum Query - Immutable

解题思路：

Note里说sumRange会被调用很多次。。所以简直强烈暗示要做cache啊。。。所以刚开始，虽然用每次都去遍历数组求和的方式可以

AC，但是真的耗时太长了。因此，考虑不存储数组nums，而是在array[i+1]处存前i项的和。这样的话，求i和j之间的和，只需要用

array[j+1]-array[i]即可以求得了。这样是直接访问数组，会快很多。

class NumArray {
public:
    NumArray(vector<int> nums) {
        // default is 0
        array = new int[nums.length() + 1];
        for (int i = 0; i < nums.length(); i++) {
            array[i + 1] = array[i] + nums[i];
        }
    }

    int sumRange(int i, int j) {
        return array[j + 1] - array[i];
    }
private:
    // Notice
    int[] array;
};

---

70. Climbing Stairs

解题思路：

类似汉诺塔问题。。

int climbStairs(int n) {
        if (n <= 2)
            return n;
        // from n-1 to n
        int oneBefore = 2;
        int twoBefore = 1;
        int sum = 0;
        for (int i = 2; i < n; i++) {
            sum = oneBefore + twoBefore;
            twoBefore = oneBefore;
            oneBefore = sum;
        }
        return sum;
    }

---

198. House Robber

解题思路：

由题目可知，不能抢劫相邻的两家，所以可以考虑单数线和双数线。

int Max(int a, int b) {
        return a > b ? a : b;
    }
    int rob(vector<int>& nums) {
        int even = 0;
        int odd = 0;
        for(int i = 0; i < nums.size(); i++) {
            if (i % 2 == 0)
            // if odd is bigger, nums[i-1] is chosen and nums[i] isn't chosen
            // otherwise, nums[i] is chosen.
                even = Max(even + nums[i], odd);
            else
                odd = Max(even, odd + nums[i]);
        }
        // return max of two lines
        return Max(even, odd);
    }

---

300. Longest Increasing Subsequence

解题思路：

arr[i]存的是以nums[i]结尾的最长递增子序列的长度，所以计算时：

arr[i] = max(arr[j]+1)　其中, nums[j] < nums[i], j = 0...i-1

写的时候，注意max在内层循环结束后要更新。。。最终只要得到arr[]中的最大值就是结果。

int lengthOfLIS(vector<int>& nums) {
        if (nums.size() <= 1)
            return nums.size();
        int arr[nums.size()];
        arr[0] = 1;
        int i, j;
        int max = 1;
        for (i = 0; i < nums.size(); i++) {
            for (j = 0; j < i; j++) {
                if (nums[j] < nums[i]) {
                    if (arr[j] + 1 > max)
                        max = arr[j] + 1;
                }
            }
            arr[i] = max;
            max = 1;
        }
        int result = arr[0];
        for (i = 1; i < nums.size(); i++)
          if (arr[i] > result)
              result =arr[i];
        return result;
    }

---

72. Edit Distance

解题思路：

听老师讲完编辑距离那块，做这个就很容易了。思路是用一个数组edit[i][j]存储word1[1..i]变到word2[1..j]的编辑距离。数组的递推公式为：

解释：前两行是空串到非空串的情况；第三行是i,j > 0时，前两种是增加一个字母，最后一种是替换或不替换（word1[i]与word[j]相同，所以

此处要保持编辑距离）

实际写的时候，注意字符串的下标从0开始，所以diff(i-1, j-1)

int Min(int a, int b, int c) {
        if (a <= b && a <= c)
            return a;
        if (b <= a && b <= c)
            return b;
        if (c <= a && c <= b)
            return c;
    }
    int minDistance(string word1, string word2) {
        int len1 = word1.length();
        int len2 = word2.length();
        if (len1 == 0)
            return len2;
        if (len2 == 0)
            return len1;
        int edit[len1+1][len2+1];
        for (int i = 0; i <= len1; i++)
            edit[i][0] = i;
        for (int i = 0; i <= len2; i++)
            edit[0][i] = i;
        int diff;
        int i, j;
        for (i = 1; i <= len1; i++) {
            for (j = 1; j <= len2; j++) {
                if (word1[i-1] == word2[j-1])
                    diff = 0;
                else
                    diff = 1;
                edit[i][j] = Min(edit[i-1][j]+1, edit[i][j-1]+1, diff+edit[i-1][j-1]);
            }
        }
        return edit[len1][len2];
    }

---