算法数据结构（十九）----暴力递归改动态规划（四）

最新推荐文章于 2024-05-25 19:38:43 发布
最新推荐文章于 2024-05-25 19:38:43 发布
阅读量280 收藏 1
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011624267/article/details/119581370
版权
本文通过四个不同的题目展示了如何使用动态规划和递归解决数组与路径求和、货币组合计数以及醉汉概率计算的问题。方法包括空间压缩优化、递归求解以及动态规划表格填充。每个问题都提供了两种解法，强调了算法效率和空间复杂性的平衡。
摘要由CSDN通过智能技术生成

题目一

给定一个二维数组matrix，一个人必须从左上角出发，最后到达右下角

沿途只可以向下或者向右走，沿途的数字都累加就是距离累加和

返回最小距离累加和

//方法一 
public static int minPathSum1(int[][] m) {
		if (m == null || m.length == 0 || m[0] == null || m[0].length == 0) {
			return 0;
		}
		int row = m.length;
		int col = m[0].length;
		int[][] dp = new int[row][col];
		dp[0][0] = m[0][0];
		for (int i = 1; i < row; i++) {
			dp[i][0] = dp[i - 1][0] + m[i][0];
		}
		for (int j = 1; j < col; j++) {
			dp[0][j] = dp[0][j - 1] + m[0][j];
		}
		for (int i = 1; i < row; i++) {
			for (int j = 1; j < col; j++) {
				dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + m[i][j];
			}
		}
		return dp[row - 1][col - 1];
	}

//方法二 空间压缩
public static int minPathSum2(int[][] m) {
		if (m == null || m.length == 0 || m[0] == null || m[0].length == 0) {
			return 0;
		}
		int row = m.length;
		int col = m[0].length;
		int[] dp = new int[col];
		dp[0] = m[0][0];
		for (int j = 1; j < col; j++) {
			dp[j] = dp[j - 1] + m[0][j];
		}
		for (int i = 1; i < row; i++) {
			dp[0] += m[i][0];
			for (int j = 1; j < col; j++) {
				dp[j] = Math.min(dp[j - 1], dp[j]) + m[i][j];
			}
		}
		return dp[col - 1];
	}

题目二

 arr是货币数组，其中的值都是正数。再给定一个正数aim。

每个值都认为是一张货币，

即便是值相同的货币也认为每一张都是不同的，

返回组成aim的方法数

例如：arr = {1,1,1}，aim = 2

第0个和第1个能组成2，第1个和第2个能组成2，第0个和第2个能组成2

一共就3种方法，所以返回3

//暴力递归
public static int coinWays(int[] arr, int aim) {
		return process(arr, 0, aim);
	}

	// arr[index....] 组成正好rest这么多的钱，有几种方法
	public static int process(int[] arr, int index, int rest) {
		if (rest < 0) {
			return 0;
		}
		if (index == arr.length) { // 没钱了！
			return rest == 0 ? 1 : 0;
		} else {
			return process(arr, index + 1, rest) + process(arr, index + 1, rest - arr[index]);
		}
	}



//动态规划
public static int dp(int[] arr, int aim) {
		if (aim == 0) {
			return 1;
		}
		int N = arr.length;
		int[][] dp = new int[N + 1][aim + 1];
		dp[N][0] = 1;
		for (int index = N - 1; index >= 0; index--) {
			for (int rest = 0; rest <= aim; rest++) {
				dp[index][rest] = dp[index + 1][rest] + (rest - arr[index] >= 0 ? dp[index + 1][rest - arr[index]] : 0);
			}
		}
		return dp[0][aim];
	}

题目三

 arr是面值数组，其中的值都是正数且没有重复。再给定一个正数aim。

每个值都认为是一种面值，且认为张数是无限的。

返回组成aim的方法数

例如：arr = {1,2}，aim = 4

方法如下：1+1+1+1、1+1+2、2+2

一共就3种方法，所以返回3

//暴力递归
public static int coinsWay(int[] arr, int aim) {
		if (arr == null || arr.length == 0 || aim < 0) {
			return 0;
		}
		return process(arr, 0, aim);
	}

	// arr[index....] 所有的面值，每一个面值都可以任意选择张数，组成正好rest这么多钱，方法数多少？
	public static int process(int[] arr, int index, int rest) {
		if (index == arr.length) { // 没钱了
			return rest == 0 ? 1 : 0;
		}
		int ways = 0;
		for (int zhang = 0; zhang * arr[index] <= rest; zhang++) {
			ways += process(arr, index + 1, rest - (zhang * arr[index]));
		}
		return ways;
	}


//动态规划
public static int dp1(int[] arr, int aim) {
		if (arr == null || arr.length == 0 || aim < 0) {
			return 0;
		}
		int N = arr.length;
		int[][] dp = new int[N + 1][aim + 1];
		dp[N][0] = 1;
		for (int index = N - 1; index >= 0; index--) {
			for (int rest = 0; rest <= aim; rest++) {
				int ways = 0;
				for (int zhang = 0; zhang * arr[index] <= rest; zhang++) {
					ways += dp[index + 1][rest - (zhang * arr[index])];
				}
				dp[index][rest] = ways;
			}
		}
		return dp[0][aim];
	}


//动态规划2 根据具体表结构 找规律消除枚举过程
public static int dp2(int[] arr, int aim) {
		if (arr == null || arr.length == 0 || aim < 0) {
			return 0;
		}
		int N = arr.length;
		int[][] dp = new int[N + 1][aim + 1];
		dp[N][0] = 1;
		for (int index = N - 1; index >= 0; index--) {
			for (int rest = 0; rest <= aim; rest++) {
				dp[index][rest] = dp[index + 1][rest];
				if (rest - arr[index] >= 0) {
					dp[index][rest] += dp[index][rest - arr[index]];
				}
			}
		}
		return dp[0][aim];
	}

题目四

 arr是货币数组，其中的值都是正数。再给定一个正数aim。

每个值都认为是一张货币，

认为值相同的货币没有任何不同，

返回组成aim的方法数

例如：arr = {1,2,1,1,2,1,2}，aim = 4

方法：1+1+1+1、1+1+2、2+2

一共就3种方法，所以返回3

public static class Info {
		public int[] coins;
		public int[] zhangs;

		public Info(int[] c, int[] z) {
			coins = c;
			zhangs = z;
		}
	}

	public static Info getInfo(int[] arr) {
		HashMap<Integer, Integer> counts = new HashMap<>();
		for (int value : arr) {
			if (!counts.containsKey(value)) {
				counts.put(value, 1);
			} else {
				counts.put(value, counts.get(value) + 1);
			}
		}
		int N = counts.size();
		int[] coins = new int[N];
		int[] zhangs = new int[N];
		int index = 0;
		for (Entry<Integer, Integer> entry : counts.entrySet()) {
			coins[index] = entry.getKey();
			zhangs[index++] = entry.getValue();
		}
		return new Info(coins, zhangs);
	}

	public static int coinsWay(int[] arr, int aim) {
		if (arr == null || arr.length == 0 || aim < 0) {
			return 0;
		}
		Info info = getInfo(arr);
		return process(info.coins, info.zhangs, 0, aim);
	}

	// coins 面值数组，正数且去重
	// zhangs 每种面值对应的张数
	public static int process(int[] coins, int[] zhangs, int index, int rest) {
		if (index == coins.length) {
			return rest == 0 ? 1 : 0;
		}
		int ways = 0;
		for (int zhang = 0; zhang * coins[index] <= rest && zhang <= zhangs[index]; zhang++) {
			ways += process(coins, zhangs, index + 1, rest - (zhang * coins[index]));
		}
		return ways;
	}

 

//动态规划1
public static int dp1(int[] arr, int aim) {
		if (arr == null || arr.length == 0 || aim < 0) {
			return 0;
		}
		Info info = getInfo(arr);
		int[] coins = info.coins;
		int[] zhangs = info.zhangs;
		int N = coins.length;
		int[][] dp = new int[N + 1][aim + 1];
		dp[N][0] = 1;
		for (int index = N - 1; index >= 0; index--) {
			for (int rest = 0; rest <= aim; rest++) {
				int ways = 0;
				for (int zhang = 0; zhang * coins[index] <= rest && zhang <= zhangs[index]; zhang++) {
					ways += dp[index + 1][rest - (zhang * coins[index])];
				}
				dp[index][rest] = ways;
			}
		}
		return dp[0][aim];
	}


//动态规划2  根据具体表结构  找规律 去除枚举过程
public static int dp2(int[] arr, int aim) {
		if (arr == null || arr.length == 0 || aim < 0) {
			return 0;
		}
		Info info = getInfo(arr);
		int[] coins = info.coins;
		int[] zhangs = info.zhangs;
		int N = coins.length;
		int[][] dp = new int[N + 1][aim + 1];
		dp[N][0] = 1;
		for (int index = N - 1; index >= 0; index--) {
			for (int rest = 0; rest <= aim; rest++) {
				dp[index][rest] = dp[index + 1][rest];
				if (rest - coins[index] >= 0) {
					dp[index][rest] += dp[index][rest - coins[index]];
				}
				if (rest - coins[index] * (zhangs[index] + 1) >= 0) {
					dp[index][rest] -= dp[index + 1][rest - coins[index] * (zhangs[index] + 1)];
				}
			}
		}
		return dp[0][aim];
	}

题目五

 给定5个参数，N，M，row，col，k

表示在N*M的区域上，醉汉Bob初始在(row,col)位置

Bob一共要迈出k步，且每步都会等概率向上下左右四个方向走一个单位

任何时候Bob只要离开N*M的区域，就直接死亡

返回k步之后，Bob还在N*M的区域的概率

//暴力递归
public static double livePosibility1(int row, int col, int k, int N, int M) {
		return (double) process(row, col, k, N, M) / Math.pow(4, k);
	}

	// 目前在row，col位置，还有rest步要走，走完了如果还在棋盘中就获得1个生存点，返回总的生存点数
	public static long process(int row, int col, int rest, int N, int M) {
		if (row < 0 || row == N || col < 0 || col == M) {
			return 0;
		}
		// 还在棋盘中！
		if (rest == 0) {
			return 1;
		}
		// 还在棋盘中！还有步数要走
		long up = process(row - 1, col, rest - 1, N, M);
		long down = process(row + 1, col, rest - 1, N, M);
		long left = process(row, col - 1, rest - 1, N, M);
		long right = process(row, col + 1, rest - 1, N, M);
		return up + down + left + right;
	}

//动态规划
public static double livePosibility2(int row, int col, int k, int N, int M) {
		long[][][] dp = new long[N][M][k + 1];
		for (int i = 0; i < N; i++) {
			for (int j = 0; j < M; j++) {
				dp[i][j][0] = 1;
			}
		}
		for (int rest = 1; rest <= k; rest++) {
			for (int r = 0; r < N; r++) {
				for (int c = 0; c < M; c++) {
					dp[r][c][rest] = pick(dp, N, M, r - 1, c, rest - 1);
					dp[r][c][rest] += pick(dp, N, M, r + 1, c, rest - 1);
					dp[r][c][rest] += pick(dp, N, M, r, c - 1, rest - 1);
					dp[r][c][rest] += pick(dp, N, M, r, c + 1, rest - 1);
				}
			}
		}
		return (double) dp[row][col][k] / Math.pow(4, k);
	}

	public static long pick(long[][][] dp, int N, int M, int r, int c, int rest) {
		if (r < 0 || r == N || c < 0 || c == M) {
			return 0;
		}
		return dp[r][c][rest];
	}

严太白
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
左神算法与数据结构全新力作课程-网盘链接提取码下载 .txt
02-13
这是一次有深度的数据结构与算法课程，跟着大神选算法不吃亏，从暴力递归到动态规划，再到算法精通不会太遥远！ 视频大小：5G
算法学习动态规划-3
sinat_36759535的博客
12-07 525
文章目录前言一、最小路径累加和二、Bob求生概率三、不同货币组成目标面值四、货币不限张数组成目标面值五、货币限定张数组成目标面值总结 前言 进入大厂起码得学到动态规划，下面继续开始算法的学习，算法是一种需要长期练习，增强灵感～～～ 一、最小路径累加和 题目： * 给定一个二维数组matrix，一个人必须从左上角出发，最后到达右下角 * 沿途只可以向下或者向右走，沿途的数字都累加就是距离累加和 * 返回最小距离累加和 分析： 还是从尝试入手，从（0，0）出发到达右下角的目标 递归函数的含义定义为：从
NC9 字母收集
weixin_55859275的博客
11-16 738
描述 有一个n*mn∗m的矩形方阵，每个格子上面写了一个小写字母。 小红站在矩形的左上角，她每次可以向右或者向下走，走到某个格子上就可以收集这个格子的字母。 小红非常喜欢 "love" 这四个字母。她拿到一个 l 字母可以得 4 分，拿到一个 o 字母可以得 3 分，拿到一个 v 字母可以得 2 分，拿到一个 e 字母可以得 1 分。 她想知道，在最优的选择一条路径的情况下，她最多能获取多少分？ 输入描述： 1≤n,m≤500 接下来的nn行 每行一个长度为mm的、仅有小写字母构成的字符串...
在N * M的区域上，李四初始在(row,col)位置，他一共要迈出k步，且每步都会等概率向上下左右四个方向走一个单位，期间李四只要离开N*M的区域，直接死亡，走k步之后，李四还在N * M区域的概率
nandao158的博客
07-12 272
问题描述：给出5个参数，N，M，row，col，k，表示在N * M的区域上，李四初始在(row,col)位置，他一共要迈出k步，且每步都会等概率向上下左右四个方向走一个单位，任何时候李四只要离开N*M的区域，就直接死亡，走了k步之后，李四还在N * M区域的概率，即李四活着的概率。 解决方案：暴力递归和动态规划的解决方案 1、暴力递归： 1.1、图示分析： 6*6的格子，在（3，3）位置，向四个方向移动5次，不越界的概率 1.2、核心代码： public class NanDaoLiS.
算法28：最小路径和（力扣64题）
街头小瘪三的专栏
01-02 645
动态规划之样本模型
12.算法习题之暴力递归与动态规划
sam475259540的博客
03-09 819
算法习题之暴力递归与动态规划
多米诺骨牌算法leetcode-Algorithm:数据结构算法
07-01
哈希表、技巧、数据结构组合使用 重点题 哈希表、数组、排序 哈希表 哈希表、双向链表 重点题 哈希表、双向映射 重点题 哈希表、双向映射 Map/数组、计数 哈希表 树的遍历 题目 关键字 先序遍历、递归 递归 递归 ...
基础算法与数据结构汇总，包括排序、链表、二叉树、图、暴力递归、贪心算法等相关内容.zip
04-25
贪心算法 一般来说，贪婪算法有五个组成部分: 一个候选集：从中创建一个解决方案 一个选择函数：用于选择要添加到解决方案中的最佳候选项 一个可行性函数：用于确定候选项是否可以为解决方案做出贡献 一个目标函数...
算法参考资料Introduction-to-algorithms-3rd-edition
04-15
四、动态规划和贪心算法 - 动态规划原理：一种通过将问题分解为重叠的子问题并保存这些子问题的解，以避免重复计算来解决问题的方法。 - 贪心算法：在每一步选择中都采取在当前状态下最好或最优（即最有利）的选择，...
算法数据结构学习视频教程，算法和数据结构的基础概念、进阶技巧以及特定算法的应用和实现
03-26
第1节 算法和数据结构路线、注意点与常见问题.mp4 第2节 认识复杂度、对数器、二分法.mp4 ...第22节 暴力递归到动态规划（四）.mp4 第23节 暴力递归到动态规划（五）.mp4 第24节 暴力递归到动态规划（六）.mp4 共48节课
动态规划-货币问题
Slowstep_的博客
09-17 923
有重复子过程的递归可以尝试将其改写为动态规划，这样会使得解决问题的时间复杂度大大减小，动态规划的状态转移方程其实就是递归的尝试过程，dp表的初始化就是递归的出口，dp表的填表顺序取决于尝试策略，在填表时，若确定dp表的一个位置需要使用for循环，应该尝试分析递归过程和位置依赖，以确定是否可以做进一步的优化。
动态规划：路径最小累加和（经典）
明朗晨光的专栏
10-20 341
动态规划使用空间压缩技巧解决经典问题——路径最小累加和
Leetcode 题解 - 搜索
Melo
01-22 1545
BFS 广度优先搜索一层一层地进行遍历，每层遍历都以上一层遍历的结果作为起点，遍历一个距离能访问到的所有节点。需要注意的是，遍历过的节点不能再次被遍历。 第一层： 0 -> {6,2,1,5} 第二层： 6 -> {4} 2 -> {} 1 -> {} 5 -> {3} 第三层： 4 -> {} 3 -> {} 每一层遍历的节点都与根节点距离...
Bob还在棋盘中的概率
最新发布
qinghehe198508的博客
05-25 177
题目描述：给定5个参数，N，M，row，col，K，表示在N*M的区域上，醉汉Bob初始在（row,col）位置，Bob一共要迈出K步，且每步都会等概率向上下左右的4个方向之一走一个单位，任何时候Bob只要离开N * M区域，就直接死亡，返回K步之后，Bob还在N * M区域中的概率。way：初始在某点的概率=在某点可以生存下来的路线数/在某点可以走的总路线数(4的K次方）（K步）。
暴力递归改动态规划(空间压缩)
xiaolu567的博客
06-04 208
给定一个二维数组matrix，一个人必须从左上角出发，最后到达右下角 沿途只可以向下或者向右走，沿途的数字都累加就是距离累加和 返回最小距离累加和二维dp方法 在方法1中dp[i][j]依赖左边和上边位置,因此我们可以使用一维dp表滚动更新 dp[i]位置依赖dp[i-1]和未更新的dp[i] 二、货币问题1 arr是货币数组，其中的值都是正数。再给定一个正数aim。 每个值都认为是一张货币， 即便是值相同的货币也认为每一张都是不同的， 返回组成aim的方法数 例如：arr = {1,1,1}，aim =
算法：货币数组组成面值的方法数-同值无差别(张数限定)
OceanStar的博客
06-15 214
（1）定义一个方法，有硬币arr[]，我们从0个硬币开始做尝试，要求返回刚好组成rest的方法数，即： 假设当前有 N = arr.length因此，有这么几种情况（1）先看下目标是什么，如果rest
返回arr数组中组成aim的方法数2
m0_51760968的博客
09-17 107
返回arr数组中组成aim的方法数
返回arr数组中组成aim的方法数1
m0_51760968的博客
09-17 130
返回arr数组中组成aim的方法数
内卷大厂系列《货币问题四连击》
Mark-Zoe的博客
04-06 156
大厂高频算法面试题：《货币问题系列》，通过货币问题四连击，您将学到如何从暴力递归改动态规划，而不是一上来就硬憋dp，一切从尝试入手，从暴力递归开始，通过暴力递归填dp格子，进一步看有没有优化空间，需不需要斜率优化。
左神算法与数据结构深度解析课程-网盘资源下载
"左神算法与数据结构全新力作课程，由知名专家讲解，旨在深入探讨数据结构和算法，包括暴力递归、动态规划等主题，适合想要提升算法能力的学习者。课程视频总大小为5G，可在指定网盘链接下载。" 在IT领域，数据结构...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值