【算法——动态规划&算法题】

DP（动态规划，dynamic programming）.

将一个问题拆成几个子问题，分别求解这些子问题，即可推断出大问题的解。

概念：

1. 无后效性。（严格定义：如果给定某一阶段的状态，则在这一阶段以后过程的发展不受这阶段以前各段状态的影响。）
2. 最优子结构。大问题的最优解可以由小问题的最优解推出，这个性质叫做“最优子结构性质”。

3. 能将大问题拆成几个小问题，且满足无后效性、最优子结构性质。

1.简单

1.1爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意：给定 n 是一个正整数。

示例 1：

输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。
1.  1 阶 + 1 阶
2.  2 阶

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/climbing-stairs

第 i 阶可以由以下两种方法得到：

在第 (i-1) 阶后向上爬一阶。

在第 (i-2) 阶后向上爬两阶。

所以到达第 i 阶的方法总数就是到第 (i-1) 阶和第 (i-2) 阶的方法数之和。

令 dp[i] 表示能到达第 i 阶的方法总数：

dp[i]=dp[i-1]+dp[i-2]
dp[i]=dp[i−1]+dp[i−2]

作者：LeetCode
链接：https://leetcode-cn.com/problems/climbing-stairs/solution/pa-lou-ti-by-leetcode/

int climbStairs(int n) {
    if(n == 1)
        return 1;
    int dp[n + 1];
    dp[1] = 1;
    dp[2] = 2;
    for(int i = 3; i <= n; i++){
        dp[i] = dp[i - 1] + dp[i - 2];
    }
    return dp[n];
}

1.2打家劫舍

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。

输入: [1,2,3,1]
输出: 4
解释: 偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
     偷窃到的最高金额 = 1 + 3 = 4 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/house-robber

https://leetcode-cn.com/problems/house-robber/solution/da-jia-jie-she-by-leetcode/

int rob(vector<int>& nums) {
    if(nums.size() == 1)
        return nums[0];
    nums.insert(nums.begin(), 0);
    int dp[nums.size() + 1];
    dp[1] = nums[1];
    dp[2] = max(nums[1], nums[2]);
    for(int i = 3; i <= nums.size(); i++){
        dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
    }
    return dp[nums.size()];
}

1.3区域和检索

给定一个整数数组  nums，求出数组从索引 i 到 j  (i ≤ j) 范围内元素的总和，包含 i,  j 两点。

给定 nums = [-2, 0, 3, -5, 2, -1]，求和函数为 sumRange()

sumRange(0, 2) -> 1

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/range-sum-query-immutable
先通过动态规划把各位和保存到内存

class NumArray {
public:
    int dp[];

    NumArray(vector<int>& nums) {
        if(!nums.empty()){
            dp = new int[nums.size()];
            dp[0] = nums[0];
            for(int i = 1; i < nums.size(); i++){
                dp[i] = dp[i - 1] + nums[i];
            }
        }
    }

    int sumRange(int i, int j) {
        if(i == 0){
            return dp[j];
        } else{
            return dp[j] - dp[i - 1];
        }
    }
};

2.中等

2.1不同路径

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

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。

问总共有多少条不同的路径？

输入: m = 7, n = 3
输出: 28

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/unique-paths

典型的动态规划题目，仅第一行或第一列路径数只能是1，定义F(i，j) 为某点应有的路径数，则F(i，j) = F(i - 1, j) + F(i, j - 1)。

int uniquePaths(int m, int n) {
    int dp[n][m];
    if(n == 1 || m == 1)
        return 1;
    dp[0][0] = 0;
    for(int i = 1; i < m; i++){
        dp[0][i] = 1;
    }
    for(int i = 1; i < n; i++){
        dp[i][0] = 1;
    }
    for(int i = 1; i < n; i++){
        for(int j = 1; j < m; j++){
            dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
        }
    }
    return dp[n - 1][m - 1];
}

2.2最长上升子序列

给定一个无序的整数数组，找到其中最长上升子序列的长度。

输入: [10,9,2,5,3,7,101,18]
输出: 4 
解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-increasing-subsequence
动态规划法，dp[i]代表以i为尾，最长上升子序列长度，最小为1。状态转移方程为 

dp[i] = max(dp[i], dp[j] + 1); 其中，0 <= j < i, 且 nums[i] > nums[j]

int lengthOfLIS(vector<int>& nums) {
    if(nums.empty())
        return 0;
    int dp[nums.size()];

    for (int i = 0; i < nums.size(); ++i) {
        dp[i] = 1;
        for (int j = 0; j < i; ++j) {
            if(nums[i] > nums[j]){
                dp[i] = max(dp[i], dp[j] + 1);
            }
        }
    }

    int maxVal = dp[0];
    for(int i = 1; i < nums.size(); i++){
        maxVal = max(maxVal, dp[i]);
    }
    return maxVal;
}