动态规划

leetcode64
题目描述：

给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。

说明：每次只能向下或者向右移动一步。

示例:

输入:
[
[1,3,1],
[1,5,1],
[4,2,1]
]
输出: 7
解释: 因为路径 1→3→1→1→1 的总和最小。

答案：
①定义dp[i][j]为(i,j)处的最小路径和。
定义一个m行n列的二维数组，由于数组从索引0值开始，故m行n列处的最小路径和为dp[m-1][n-1]。
②初始值为第一行和第一列的dp值。
③有两个坐标可以走到m,n处，取路径和较小的一个。
等价关系为dp[i][j] = min(dp[i-1][j],dp[i][j-1]) + arr[i][j]。

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {

        int hang = grid.size(); //二维数组的行数
        int lie = grid[0].size(); //二维数组的列数

        //dp[i][j]为(i,j)处的最小路径和
        int dp[hang][lie];

        //初始值
        dp[0][0] = grid[0][0];

        //数组第一行
        for(int i = 1;i < lie;++i)
        {
            dp[0][i] = dp[0][i - 1] + grid[0][i]; 
        }
        //数组第一列
        for(int i = 1;i < hang;++i)
        {
            dp[i][0] = dp[i-1][0] + grid[i][0]; 
        }

        //求dp[hang - 1][lie -1]
        for(int i = 1;i < hang;++i)
        {
            for(int j = 1;j < lie;++j)
            {
                dp[i][j] = min(dp[i-1][j],dp[i][j-1]) + grid[i][j]; //时序关系
            }
        }

        return dp[hang-1][lie-1];
    }
};

//优化思路：原地dp，时间复杂度O(1)
//优化思路：一维dp，dp只储存一行的最大值，从上到下，从左到右依次更新直至右下角
leetcode72
题目描述：
给你两个单词 word1 和 word2，请你计算出将 word1 转换成 word2 所使用的最少操作数 。

你可以对一个单词进行如下三种操作：

插入一个字符
删除一个字符
替换一个字符

示例 1：

输入：word1 = “horse”, word2 = “ros”
输出：3
解释：
horse -> rorse (将 ‘h’ 替换为 ‘r’)
rorse -> rose (删除 ‘r’)
rose -> ros (删除 ‘e’)
示例 2：

输入：word1 = “intention”, word2 = “execution”
输出：5
解释：
intention -> inention (删除 ‘t’)
inention -> enention (将 ‘i’ 替换为 ‘e’)
enention -> exention (将 ‘n’ 替换为 ‘x’)
exention -> exection (将 ‘n’ 替换为 ‘c’)
exection -> execution (插入 ‘u’)

class Solution {
public:
    int minDistance(string word1, string word2) {

        int size1 = word1.length();
        int size2 = word2.length();

        //定义dp[i][j]为 word1长度为i word2长度为j时 的最少操作数
        //int[][] dp = new int[size1+1][size2+1];
        int dp[size1+1][size2+1];
        
        dp[0][0] = 0;
        //当word1长度为0时 只进行插入操作
        //注意加等号
        for(int i = 1;i <= size2;++i)
        {
            dp[0][i] = dp[0][i-1] + 1;
        }
        //当word2长度为0时 只进行删除操作
        for(int i = 1;i <= size1;++i)
        {
            dp[i][0] = dp[i-1][0] + 1;
        }

        //计算dp[size1][size2]
        //注意加等号，注意dp的ij与word索引ij不是完全对应的关系
        for(int i = 1;i <= size1;++i)
        {
            for(int j = 1;j <= size2;++j)
            {
                if(word1[i-1] == word2[j-1]) dp[i][j] = dp[i-1][j-1]; //长度为i,j时，索引为i-1,j-1
                else dp[i][j] = min(min(dp[i][j-1],dp[i-1][j]),dp[i-1][j-1]) + 1;
                //dp[i][j-1] + 1插入字符
                //dp[i-1][j] + 1删除字符
                //dp[i-1][j-1] + 1替换字符
            }
        }

        return dp[size1][size2];
    }

};

leetcode 面试题42. 连续子数组的最大和
题目描述：

输入一个整型数组，数组里有正数也有负数。数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。

要求时间复杂度为O(n)。

重点：dp[i]定义为以nums[i]为结尾时的子数组和最大值
注意：int maxVal = nums[0]; //初始值这样定义，可以解决数组只有一个值的情况

示例1:

输入: nums = [-2,1,-3,4,-1,2,1,-5,4]
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

class Solution {
public:
    int maxSubArray(vector<int>& nums) {

        if(nums.empty()) return -1;

        int size = nums.size();

        //设动态规划列表dp ，dp[i]代表以元素nums[i] 为结尾的连续子数组最大和。

        int dp[size];
        int maxVal = nums[0]; //初始值考虑到数组只有一个值的情况

        dp[0] = nums[0];

        for(int i = 1;i < size;++i)
        {
            dp[i] = max(dp[i-1] + nums[i],nums[i]);
        }

        for(int i = 1;i < size;++i)
        {
            if(dp[i] > maxVal) maxVal = dp[i];
        }
        return maxVal;
    }
};
/*
//如果一定有正有负 一次遍历即可
class Solution {
    public int maxSubArray(int[] nums) {
        int temp = 0;
        int max = Integer.MIN_VALUE;
        for(int i = 0;i < nums.length;i++){
            temp = temp+nums[i];
            max = max>temp?max:temp;
            if(temp < 0){
                temp = 0;
            }
        }
        return max;
    }
}*/

题目描述
假设把某股票的价格按照时间先后顺序存储在数组中，请问买卖该股票一次可能获得的最大利润是多少？

示例 1:

输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。
示例 2:

输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

思路：
动态规划：定义dp[i] 为前i日的最大利润，则dp[i] = max(dp[i-1],prices[i] - minCost)
优化：dp[i]数组可由一个变量maxProfit 直接代替。

一次遍历：时间复杂度O（n）

class Solution {
public:
    int maxProfit(vector<int>& prices) {

        if(prices.size() < 2) return 0;
       
        /*int maxIndex = 0; //获得最高价值的买入日
        int maxValue = 0; //获得的最高价值

        //移动指针i，若当天比历史股票价格低，更新maxIndex，否则更新获得的最大利润
        for(int i = 1;i < prices.size();++i)
        {
            if(prices[i] > prices[maxIndex])
            {               
                maxValue = max(prices[i] - prices[maxIndex],maxValue);
            }
            else maxIndex = i; 
        }
        
        return maxValue;*/

        int minCost = prices[0]; //买入最低值
        int maxProfit = 0; //最大利润

        //移动指针i，记录最低买入值和最大利润值
        for(int i = 1;i < prices.size();++i)
        {
            minCost = min(prices[i],minCost);
            maxProfit = max(prices[i] - minCost,maxProfit);
        }        
        return maxProfit;   
    }

    //动态规划：定义dp[i] 为前i日的最大利润，则dp[i] = max(dp[i-1],prices[i] - minCost)
};