动态规划初步_leetcode刷题总结

动态规划,我之前也是不了解的,嘻嘻嘻

只是后面发现在相关搜索题目中,如果只需要求解的树木或者相关数值问题时候,往往使用动态规划会比深度遍历搜索高效很多。jio得还可以好吧

因为考虑到大家对于动态规划不是很熟悉,我们先来一个简单的小练习来上手下动态规划。

对于爬楼梯的问题,相信大家都比较熟悉吧,一次可以走一步,也可以走两步,请问走到第100步,有多少种走法?

  • 首先,这个问题,很容易想到 f(100) = (f99) + f(98) 吧,ok,然后如果有回溯的基础的话,去用递归求解应该是一种很容易的求解方法好吧,

public int f(int level){
    if(level==1)
        return 1;
    if(level==2)
        return 2;
    else:
        return f(level-1)+f(level-2);

}
  • 但是呢,动态规划是一种更加高效的方法好吧,代码是这样的:
public int f(int length){
    int[] result = new int[length+1];
    result[1] = 1;
    result[2] = 2;
    for(int i=3;i<length+1;i++){
        result[i] = result[i-1]+result[i-2];
    }
    return result[length];
}

简单的来对比以下,这两个有啥区别呢?其实递归的解法的话,求return f(level-1)+f(level-2);的过程中,可以认为f(level-2)和f(level-1)的计算过程有着很多一样的计算过程,就是说同样的计算步骤计算重复了两遍,造成的一个问题是,使得浪费了时间复杂度,emmmmm,所以我们通过使用动态规划的办法,可以减少这种不必要的运算~

ps: 有些书中提到,其实在递归求解中加入一个int[]的全局变量,在遍历之前先判断之前有没有运算过,也可以到达这种效果,称之为备忘录式的递归,但是个人觉得,没有必要吧,直接使用动态规划就可以了嘛~

好,是不是觉得有点味道,好,我们来撕撕几道题目。

  • 1、跳跃游戏 https://leetcode-cn.com/problems/jump-game/

    给定一个非负整数数组,你最初位于数组的第一个位置。
    数组中的每个元素代表你在该位置可以跳跃的最大长度。
    判断你是否能够到达最后一个位置。
    示例 1:
    输入: [2,3,1,1,4]
    输出: true
    解释: 从位置 0 到 1 跳 1 步, 然后跳 3 步到达最后一个位置。
    示例 2:
    输入: [3,2,1,0,4]
    输出: false
    解释: 无论怎样,你总会到达索引为 3 的位置。但该位置的最大跳跃长度是 0 , 所以你永远不可能到达最后一个位置。

这个题目,我们可以用一个数组int[] dp来记录每一步当前能够到的最远的距离,最后再判断int[nums.length-1]是不是>=nums.length-1即可~代码:

	public boolean canJump(int[] nums) {
        int[] dp = new int[nums.length];
        dp[0] = nums[0];
        for (int i = 1; i <nums.length; i++) {
            if (dp[i-1]<i)
                return false;
            else
                dp[i] = Math.max(dp[i-1],nums[i]+i);
        }
        return dp[nums.length-1]>=nums.length-1;
    }

但是分析上面的代码,不难发现,其实我们是可以优化,因为最后其实只是用到了最后一个

	public boolean canJump(int[] nums) {
        int max_length = nums[0];

        for (int i = 1; i <nums.length; i++) {
            if (max_length<i)
                return false;
            else
                max_length = Math.max(max_length,nums[i]+i);
                if (max_length>=nums.length-1)
                    return true;
        }
        return max_length>=nums.length-1;
    }

这种就只用了一个空间来记录最大长度,jio得还可以~

  • 2、跳跃游戏 II https://leetcode-cn.com/problems/jump-game-ii/

    给定一个非负整数数组,你最初位于数组的第一个位置。
    数组中的每个元素代表你在该位置可以跳跃的最大长度。
    你的目标是使用最少的跳跃次数到达数组的最后一个位置。
    示例:
    输入: [2,3,1,1,4]
    输出: 2
    解释: 跳到最后一个位置的最小跳跃数是 2。
    从下标为 0 跳到下标为 1 的位置,跳 1 步,然后跳 3 步到达数组的最后一个位置。
    嗯,其实这道题如果用贪心会更加的好,但是为了dp而dp一把,呜~

	public int jump2(int[] nums) {
        //假设到达位置i所需要的步数
		int[] dp = new int[nums.length];
        dp[0]= 0;
        int cur_max_length = 0;
        int next_max_length = nums[0];
        for (int i = 1; i <nums.length; i++) {
            if (i<=cur_max_length){
                dp[i] = dp[i-1];
                next_max_length = Math.max(next_max_length,nums[i]+i);
            }else {
                if (next_max_length>=i){
                    cur_max_length = next_max_length;
                    dp[i]=dp[i-1]+1;
                    next_max_length = Math.max(next_max_length,nums[i]+i);
                }else {
                    return -1;
                }
            }
        }
        return dp[nums.length-1];
    }

嗯,这道题,如果用贪心的话,可以这样:

	public int jump(int[] nums) {
        int length = nums.length;
        int cur_max_length = 0;
        int next_max_length =  nums[0];
        int res =0;
        for (int i = 1; i < length; i++) {
            if (i>cur_max_length){
                res++;
                cur_max_length = next_max_length;
            }
            next_max_length = Math.max(next_max_length,nums[i]+i);
        }
        return res;
    }
  • 4、不同路径 https://leetcode-cn.com/problems/unique-paths/

    一个机器人位于一个 m x n 网格的左上角 (起始点在下图中标记为“Start” )。
    机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角(在下图中标记为“Finish”)。
    问总共有多少条不同的路径?
    例如,上图是一个7 x 3 的网格。有多少可能的路径?
    说明:m 和 n 的值均不超过 100。
    示例 1:
    输入: m = 3, n = 2
    输出: 3
    解释:
    从左上角开始,总共有 3 条路径可以到达右下角。

    1. 向右 -> 向右 -> 向下
    2. 向右 -> 向下 -> 向右
    3. 向下 -> 向右 -> 向右
      示例 2:
      输入: m = 7, n = 3
      输出: 28

这个题目,嗯,我们可以用一个二维的dp数组来求解,上代码:

	public int uniquePaths(int m, int n) {
        //创建一个m*n的数组矩阵来存储
        int [][] result = new int[m+1][n+1];

        for (int i = 1; i < m+1; i++) {
            result[i][1]=1;
        }

        for (int i = 1; i < n+1; i++) {
            result[1][i]=1;
        }

        for (int i = 2; i <m+1 ; i++) {
            for (int j = 1; j <n+1; j++) {
                result[i][j] = result[i-1][j]+result[i][j-1];
            }
        }
        return result[m][n];
    }
  • 5、 不同路径 II https://leetcode-cn.com/problems/unique-paths-ii/
    现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径?
    网格中的障碍物和空位置分别用 1 和 0 来表示。
    说明:m 和 n 的值均不超过 100。
    示例 1:
    输入:
    [
    [0,0,0],
    [0,1,0],
    [0,0,0]
    ]
    输出: 2
    解释:
    3x3 网格的正中间有一个障碍物。
    从左上角到右下角一共有 2 条不同的路径:
  1. 向右 -> 向右 -> 向下 -> 向下
  2. 向下 -> 向下 -> 向右 -> 向右
	public int uniquePathsWithObstacles(int[][] obstacleGrid) {
      int height = obstacleGrid.length;
        int width =obstacleGrid[0].length;
        int[][] result = new int[height+1][width+1];
        boolean flag = true;
        for (int i = 1; i < height+1; i++) {
            if (obstacleGrid[i-1][0]==1){
                flag=false;
            }
            result[i][1]=flag?1:0;
        }

        flag = true;
        for (int i = 1; i < width+1; i++) {
            if (obstacleGrid[0][i-1]==1){
                flag=false;
            }
            result[1][i]=flag?1:0;
        }

        for (int i = 2; i < height+1; i++) {
            for (int j = 2; j < width+1; j++) {
                if (obstacleGrid[i-1][j-1]==1){
                    result[i][j]=0;
                }else {
                    result[i][j]=result[i-1][j]+result[i][j-1];
                }
            }
        }

        return result[height][width];  
    }

基本上差不多的~

  • 6、 编辑距离 https://leetcode-cn.com/problems/edit-distance/

    给定两个单词 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’)

这道题比之前的题目会绕一点,就是得想到用二维数组dp[length1][length2]来表示

	public int minDistance(String word1, String word2) {
        int length1 = word1.length();
        int length2 = word2.length();
        int[][] result = new int[length1+1][length2+1];
        result[0][0] = 0;
        for (int i = 1; i <length1+1;i++) {
            result[i][0] = result[i-1][0]+1;
        }
        for (int i = 1; i <length2+1; i++) {
            result[0][i] = result[0][i-1]+1;
        }

        for (int i = 1; i < length1+1 ; i++) {
            for (int j = 1; j < length2+1; j++) {
                int distance1 = result[i-1][j-1]+(word1.charAt(i-1)==word2.charAt(j-1)?0:1);
                int distance2 = result[i-1][j]+1;
                int distance3 = result[i][j-1]+1;
                result[i][j] = Math.min(Math.min(distance1,distance2),distance3);
            }
        }
        return result[length1][length2];
    }
  • 7、交错字符串 https://leetcode-cn.com/problems/interleaving-string/

    给定三个字符串 s1, s2, s3, 验证 s3 是否是由 s1 和 s2 交错组成的。

    示例 1:

    输入: s1 = “aabcc”, s2 = “dbbca”, s3 = “aadbbcbcac”
    输出: true
    示例 2:

    输入: s1 = “aabcc”, s2 = “dbbca”, s3 = “aadbbbaccc”
    输出: false

这里我们也可以利用一个二维的dp[s1.length][s2.length]来进行记录:

	public boolean isInterleave(String s1, String s2, String s3) {
        int length1 = s1.length();
        int length2 = s2.length();
        int length3 = s3.length();
        if (length1+length2!=length3)
            return false;
        boolean[][] dp = new boolean[length1+1][length2+1];
        dp[0][0] = true;
        for (int i = 1; i <=length1; i++) {
            dp[i][0] = dp[i-1][0]&&(s1.charAt(i-1)==s3.charAt(i-1));
        }


        for (int i = 1; i <=length2; i++) {
            dp[0][i] = dp[0][i-1]&&(s2.charAt(i-1)==s3.charAt(i-1));
        }

        for (int i = 1; i <=length1; i++) {
            for (int j = 1; j <= length2; j++) {
                boolean down = dp[i][j-1]&&(s2.charAt(j-1)==s3.charAt(i+j-1));
                boolean right = dp[i-1][j]&& (s1.charAt(i-1)==s3.charAt(i+j-1));
                dp[i][j] = down || right;
            }
        }
        return dp[length1][length2];
    }

这种方法也有点像是走迷宫一样,是不是越说越神似勒!~哈哈哈哈,还好玩不

其实,动态规划的内容还有些,但是我要回家了,找时间再补补吧~

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值