文章介绍了如何使用动态规划方法解决最小路径累加和问题，通过空间压缩技巧减少存储需求。同时，展示了计算组成特定金额的硬币组合数目的算法，探讨了从左往右尝试模型和记忆化搜索在不同情况下的应用，并提出了避免重复计算的优化策略。
题目一（返回二维数组最小距离累加和）
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;
//dp[i][j]表明从0，0到i，j的最短距离
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];
//dp第0行的值填入
for (int j = 1; j < col; j++) {
dp[j] = dp[j - 1] + m[0][j];
}
//dp第一行及后续行更新滚动填入
for (int i = 1; i < row; i++) {
//dp[0]代表dp上一行0位置的值，通过这一行0位置的值加上一行0位置的值
dp[0] += m[i][0];
for (int j = 1; j < col; j++) {
//dp[j-1]左侧的值，dp[j]代表上侧的值
dp[j] = Math.min(dp[j - 1], dp[j]) + m[i][j];
}
}
//返回最后一个格子
return dp[col - 1];
}
空间压缩技巧，进一步省空间的方案，计算脑海中二维dp数组的实际物理结构没有那么大。
题目二（返回组成aim的方法数）
从左往右尝试模型：
public static int coinWays(int[] arr, int aim) {
return process(arr, 0, aim);
}
// arr[index....] 从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 {
//选index和不选index
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;
//0-N，aim是0-aim
int[][] dp = new int[N + 1][aim + 1];
/*
if (index == arr.length) { // 没钱了！
return rest == 0 ? 1 : 0;
}
*/
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];
}
题目三
从左往右尝试模型：
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) {
//由for循环省去rest<0的basecase
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;
}
改dp：
public static int dp(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 += process(arr, index + 1, rest - (zhang * arr[index]));
// }
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];
}
如果没有枚举行为记忆化搜索和严格表结构【从表中简单位置推导出复杂位置的解】复杂度一样的好，如果有枚举行为的话，需要搞出
表结构后再继续优化。
如上图所示，假设当前i位置的面值i为3元，当前在第十四列，发现它依赖于（15，14），（15，11）（15，8）（15，5）（15，2）这些位置之和才能得到那个对号的值，那么怎么优化呢？我看星号这个位置，是b+c+d+e，那么推对号则是a+星号的值（发现优化点）推严格表结构是为了建立空间感，发现优化枚举行为可以通过邻近位置推导。
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[1,2]）第二个为张数数组（zhang[4,2]）。
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;
}
这种情况对号再根据星号来算的话会多算一个d出来
对号则就等于星号加a单减一个d
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];
}
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]];
}
//看看是否算重复，rest如果减掉极限的张数加了一还是大于等于0，则存在重复的需要减掉
if (rest - coins[index] * (zhangs[index] + 1) >= 0) {
dp[index][rest] -= dp[index + 1][rest - coins[index] * (zhangs[index] + 1)];
}
}
}
return dp[0][aim];
}
题目五
public static double livePosibility1(int row, int col, int k, int N, int M) {
//生存的点数除以4的k次方就是它存活的概率
return (double) process(row, col, k, N, M) / Math.pow(4, k);
}
// 目前在row，col位置，还有rest步要走，走完了如果还在棋盘中就获得1个生存点，
// 返回总的生存点数（总的情况数为4的k次方）
public static long process(int row, int col, int rest, int N, int M) {
//如果越界了则不在生存点，那么返回0
if (row < 0 || row == N || col < 0 || col == M) {
return 0;
}
// 还在棋盘中！（未发生越界），正好步数为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;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
