Arrays.fill(dp, Integer.MAX_VALUE)

最新推荐文章于 2024-04-11 22:52:16 发布
原创 最新推荐文章于 2024-04-11 22:52:16 发布 · 501 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #java

本文解释了如何在Java中使用Arrays.fill()函数将数组dp的所有元素设置为整型最大值Integer.MAX_VALUE，此操作常见于算法和动态规划的初始化过程，便于后续比较和更新。

Java中的Arrays.fill()函数来将数组dp中的所有元素都填充为Integer.MAX_VALUE，即整型变量能表示的最大值。

Arrays.fill()函数用于将指定的值赋给数组中的每个元素，其语法如下：

public static void fill(int[] array, int value)

其中，array表示要填充的数组，value表示要赋给数组元素的值。

在这段代码中，Arrays.fill(dp, Integer.MAX_VALUE)将数组dp中的每个元素都赋为Integer.MAX_VALUE，即整型变量能表示的最大值。

这通常用于算法或动态规划问题中，将数组初始化为一个较大的数值，以便在后续的计算中进行比较和更新操作。

华为机试 | 笔记
weixin_44779122的博客
04-05 4056
1、勾股数元组 1. 判断质数 boolean数组默认true → 0和1不是 → 从i=2开始，对i的倍数从i倍开始，置为false public static boolean isPrimer(int n) { boolean[] countPrime = new boolean[n+1]; Arrays.fill(countPrime, true);//1. 先默认都是质数 countPrime[0] = false; countPrime[1] = false;//2. 0-1不是质数 //
Integer.MAX_VALUE的含义
m0_51697147的博客
03-18 832
Integer.MAX_VALUE表示int数据类型的最大取值数：2 147 483 647 Integer.MIN_VALUE表示int数据类型的最小取值数：-2 147 483 648
Java数组填充：Arrays.fill()方法
2301_80261854的博客
03-25 2534
线性表(Linear List)”:由同类型数据元素构成有序序列的线性结构➢表中元素个数称为线性表的长度➢线性表没有元素时，称为空表➢表起始位置称表头，表结束位置称表尾。
java的Arrays.fills（）函数详解
qq_40181114的博客
10-14 622
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 java的Arrays.fills()函数有 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑
※322 零钱兑换(java)(背包问题)
weixin_43306331的博客
03-08 492
给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。 示例 1: 输入: coins = [1, 2, 5], amount = 11 输出: 3 解释: 11 = 5 + 5 + 1 示例 2: 输入: coins = [2], amount = 3 输出: -1 说明: 你可...
Java 中的 Arrays.fill()详细解释
weixin_45428910的博客
01-18 720
Java 中的 Arrays.fill()详细解释
public class Solution { public int coinChange(int[] coins, int amount) { int max = amount + 1; int[] dp = new int[amount + 1]; Arrays.fill(dp, max); dp[0] = 0; for (int i = 1; i <= amount; i++) { for (int j = 0; j < coins.length; j++) { if (coins[j] <= i) { dp[i] = Math.min(dp[i], dp[i - coins[j]] + 1); } } } return dp[amount] > amount ? -1 : dp[amount]; } } 这个代码存在什么问题
09-10
Arrays.fill(dp, max); dp[0] = 0; for (int coin : coins) { for (int i = coin; i ; i++) { dp[i] = Math.min(dp[i], dp[i - coin] + 1); } } return dp[amount] > amount ? -1 : dp[amount]; } } ``` ...
int[] memo; int coinChange(int[] coins, int amount) { memo = new int[amount + 1]; // 备忘录初始化为⼀个不会被取到的特殊值，代表还未被计算 Arrays.fill(memo, -666);return dp(coins, amount); } int dp(int[] coins, int amount) { if (amount == 0) return 0; if (amount < 0) return -1; // 查备忘录，防⽌重复计算 if (memo[amount] != -666) return memo[amount]; int res = Integer.MAX_VALUE; for (int coin : coins) { // 计算⼦问题的结果 int subProblem = dp(coins, amount - coin); // ⼦问题⽆解则跳过 if (subProblem == -1) continue; // 在⼦问题中选择最优解，然后加⼀ res = Math.min(res, subProblem + 1); } // 把计算结果存⼊备忘录 memo[amount] = (res == Integer.MAX_VALUE) ? -1 : res; return memo[amount]; }
05-25
2. 调用dp函数，传入coins数组和amount金额。 3. 如果amount为0，直接返回0； 4. 如果amount小于0，说明当前组合不可行，返回-1； 5. 查备忘录，如果memo[amount]不等于特殊值，说明已经计算过，直接返回memo[amount...
private void initialize() { for (int i = 1; i <= n; i++) { dp[i] = Long.MAX_VALUE; } dp[1] = 0; }
04-15
Arrays.fill(dp, Long.MAX_VALUE); dp[0] = 0; // 初始状态 for (int i = 1; i ; i++) { for (int j : previousStates) { if (dp[j] != Long.MAX_VALUE) { dp[i] = Math.min(dp[i], dp[j] + cost(j, i)); } } ...
import java.util.ArrayList; import java.util.Arrays; import java.util.List; public class MilkTeaShopLocation { // 输入参数（可根据实际场景调整） private static final int n = 8; // 区域数量（0~7） private static final int[] p = {50, 80, 120, 60, 150, 90, 70, 110}; // 各区域人流量 private static final int L = 1; // 有效覆盖范围（距离≤1的区域） private static final int C = 2000; // 单店开设成本（元） private static final int R = 20; // 单位人流量收益（元/人） private static final int k = 2; // 计划开设奶茶店数量 // 前缀和数组（预处理人流量总和） private static int[] prefixSum; // DP数组：dp[i][j] = 前i个区域开j家店，第j家在i-1号区域的最大利润 private static int[][] dp; // 回溯数组：记录dp[i][j]的最优前驱m（用于查找选址方案） private static int[][] prev; /** * 预处理前缀和数组 */ private static void initPrefixSum() { prefixSum = new int[n + 1]; for (int i = 0; i < n; i++) { prefixSum[i + 1] = prefixSum[i] + p[i]; } } /** * 动态规划计算最大利润 * @return 最大利润（若为-∞表示无可行方案） */ private static int calculateMaxProfit() { // 初始化DP数组和回溯数组 dp = new int[n + 1][k + 1]; prev = new int[n + 1][k + 1]; for (int i = 0; i <= n; i++) { Arrays.fill(dp[i], Integer.MIN_VALUE / 2); // 避免溢出 Arrays.fill(prev[i], -1); } // 1. 初始状态：j=1（开1家店） for (int i = 1; i <= n; i++) { int shopLoc = i - 1; // 奶茶店开设在第i-1号区域 int left = Math.max(0, shopLoc - L); int right = Math.min(n - 1, shopLoc + L); int totalPeople = prefixSum[right + 1] - prefixSum[left]; int profit = totalPeople * R - C; if (profit > 0) { // 利润为负时不开店（可选：允许负利润则直接赋值） dp[i][1] = profit; } } // 2. 状态转移：j≥2（开j家店） for (int j = 2; j <= k; j++) { for (int i = j; i <= n; i++) { // 前i个区域开j家，i至少为j（每个店占1个区域） int currentShopLoc = i - 1; // 当前第j家店的位置 // 遍历前驱m：前m个区域开j-1家，m的范围是[j-1, currentShopLoc - L - 1]（两店距离> L） int maxPrevM = currentShopLoc - L - 1; if (maxPrevM < j - 1) continue; // 前m个区域至少能开j-1家店（m≥j-1） for (int m = j - 1; m <= maxPrevM; m++) { if (dp[m][j - 1] == Integer.MIN_VALUE / 2) continue; // 前驱状态不可行 // 计算当前店的覆盖范围（左边界=前一家店的位置+1，避免分流） int left = Math.max(m, currentShopLoc - L); // m是前m个区域的最后一个，对应位置m-1，左边界≥m int right = Math.min(n - 1, currentShopLoc + L); int totalPeople = prefixSum[right + 1] - prefixSum[left]; int currentProfit = totalPeople * R - C; int totalProfit = dp[m][j - 1] + currentProfit; // 更新DP值和回溯记录 if (totalProfit > dp[i][j]) { dp[i][j] = totalProfit; prev[i][j] = m; } } } } // 3. 提取最大利润（前i个区域开k家店的所有可能） int maxProfit = Integer.MIN_VALUE / 2; for (int i = k; i <= n; i++) { maxProfit = Math.max(maxProfit, dp[i][k]); } return maxProfit; } /** * 回溯查找最优选址方案（奶茶店所在区域编号） * @return 最优选址列表（按开设顺序排列） */ private static List<Integer> findOptimalLocations() { List<Integer> locations = new ArrayList<>(); int maxProfit = Integer.MIN_VALUE / 2; int lastI = -1; // 找到最后一家店的位置对应的i for (int i = k; i <= n; i++) { if (dp[i][k] > maxProfit) { maxProfit = dp[i][k]; lastI = i; } } if (lastI == -1) return locations; // 无可行方案 // 回溯查找所有店的位置 int j = k; int i = lastI; while (j > 0 && i != -1) { locations.add(i - 1); // 店的位置是i-1（前i个区域的最后一个区域） i = prev[i][j]; j--; } // 反转列表，按区域编号升序排列 java.util.Collections.reverse(locations); return locations; } /** * 暴力枚举所有方案（验证动态规划结果正确性） */ private static void verifyByBruteForce() { System.out.println("\n=== 暴力枚举验证（所有" + k + "家店组合）==="); List<List<Integer>> allCombinations = new ArrayList<>(); generateCombinations(0, new ArrayList<>(), k, allCombinations); int maxBruteProfit = Integer.MIN_VALUE; List<Integer> bestBruteLocation = new ArrayList<>(); for (List<Integer> locs : allCombinations) { int profit = calculateProfit(locs); if (profit > maxBruteProfit) { maxBruteProfit = profit; bestBruteLocation = locs; } System.out.printf("选址方案：%s → 利润：%d元%n", locs, profit); } System.out.printf("暴力枚举最优方案：%s → 最大利润：%d元%n", bestBruteLocation, maxBruteProfit); } /** * 生成所有k个区域的组合（递归） */ private static void generateCombinations(int start, List<Integer> current, int k, List<List<Integer>> result) { if (current.size() == k) { result.add(new ArrayList<>(current)); return; } for (int i = start; i < n; i++) { current.add(i); generateCombinations(i + 1, current, k, result); current.remove(current.size() - 1); } } /** * 计算指定选址方案的利润（暴力枚举用） */ private static int calculateProfit(List<Integer> locations) { if (locations.size() != k) return Integer.MIN_VALUE / 2; // 标记每个区域的归属（最近的奶茶店）和人流量分配 int[] belong = new int[n]; // -1=未分配，0~k-1=归属第i家店 int[] peoplePerShop = new int[k]; Arrays.fill(belong, -1); for (int area = 0; area < n; area++) { int minDist = Integer.MAX_VALUE; int bestShop = -1; // 找最近的奶茶店 for (int s = 0; s < locations.size(); s++) { int dist = Math.abs(area - locations.get(s)); if (dist < minDist) { minDist = dist; bestShop = s; } } // 仅在覆盖范围内才分配 if (minDist <= L) { peoplePerShop[bestShop] += p[area]; } } // 计算总利润 int totalRevenue = 0; for (int people : peoplePerShop) { totalRevenue += people * R; } int totalCost = k * C; return totalRevenue - totalCost; } /** * 打印输入参数和DP数组（调试用） */ private static void printParamsAndDP() { System.out.println("=== 输入参数 ==="); System.out.printf("区域数量：%d个（编号0~%d）%n", n, n-1); System.out.printf("各区域人流量：%s%n", Arrays.toString(p)); System.out.printf("覆盖范围L：%d（距离≤%d的区域）%n", L, L); System.out.printf("单店开设成本C：%d元%n", C); System.out.printf("单位人流量收益R：%d元/人%n", R); System.out.printf("计划开店数量k：%d家%n", k); System.out.printf("前缀和数组：%s%n", Arrays.toString(prefixSum)); System.out.println("\n=== DP数组（dp[i][j]：前i个区域开j家店的最大利润）==="); for (int j = 0; j <= k; j++) { for (int i = 0; i <= n; i++) { if (dp[i][j] == Integer.MIN_VALUE / 2) { System.out.printf("%6s", "∞"); } else { System.out.printf("%6d", dp[i][j]); } } System.out.println(); } } public static void main(String[] args) { System.out.println("=== 奶茶店选址优化（动态规划实现）==="); // 初始化前缀和 initPrefixSum(); // 动态规划计算最大利润 int maxProfit = calculateMaxProfit(); // 查找最优选址方案 List<Integer> optimalLocations = findOptimalLocations(); // 打印参数和DP数组 printParamsAndDP(); // 输出最优结果 System.out.println("\n=== 动态规划最优结果 ==="); if (maxProfit <= 0 || optimalLocations.isEmpty()) { System.out.println("❌ 无可行选址方案（利润≤0或无法满足开店数量）"); } else { System.out.printf("✅ 最大利润：%d元%n", maxProfit); System.out.printf("✅ 最优选址：%s（区域编号）%n", optimalLocations); } // 暴力枚举验证 verifyByBruteForce(); } }详细解析这段算法
最新发布
11-28
这里如果利润为负，则`dp[i][1]`保持`Integer.MIN_VALUE/2`（即不可行）。但这样可能导致即使开一家店利润为负，但不开店的情况不被考虑（而动态规划要求必须开j家店）。所以，如果要求必须开满j家店，那么即使某家...
算法日常训练12.5
weixin_57695844的博客
12-05 537
首先有个很大的进步，看见困难题我没选择做逃兵跑路，这点起码是进步了，虽然算法能力还是那么拉，但是起码敢不自量力地分析一下。。。还能看题解理解下。 这里的dp可以发现是维护一个滑动窗口中的最小值，第一次见，详细分析见 力扣大佬题解 总之就是需要优化每次找最小值的时间，我选择使用优先队列，感觉好理解一点，看了很久，这题有点超出我水平了，溜了，有缘回来再看。 经典的搜索题，写了好几遍了
112、☆完全背包-LeetCode-322.零钱兑换
新手村玩家的博客
05-08 220
class Solution { public int coinChange(int[] coins, int amount) { //上一道是凑出来组合数，这一道不仅要凑出来，还要找到数量最小的！ //倒着来，从大的硬笔开始，出现凑出来的情况就返回？此时成了01背包 int[] dp = new int[amount + 1]; //不再是找组合数，数组值是放入的硬币值！ for(int i = 0;i < c.
代码随想录算法训练营day50 || 57. 爬楼梯，322. 零钱兑换，279.完全平方数
旭
02-14 439
思路：延续零钱兑换II 的做法，统计某个数值可以被找零，是求的组合，所以本题的递推公式也是包含累加的思想，但是由于统计的是硬币数量，因此在每判断一种硬币后，是将j-coins[i[的位置的值加1得到dp[j]位置的值。区别dp[j] += dp[j-coins[i]]和dp[j] = dp[j-coins[i]]+1；递推公式与找零的递推公式保持一致，使用的是减去一个当前可用物品后加一。思路：递推公式dp[j]+=dp[j-nums[i]]的练习 ，这里爬楼梯的来源从2变成了m，所以求和m个位置即可。
动态规划——子序列问题——连续？不连续？
getinobacar的博客
03-03 6738
动态规划——子序列问题——连续？不连续？ 子序列问题是动态规划的一个常考题型，本篇文章主要介绍 子序列（连续）和子序列（不连续）两个问题。连续和不连续指的是子序列是否是连续的，还是说中间是可以有间隔的子序列。 一：子序列（不连续） 300. 最长递增子序列 分析：从题意我们可以读出该题想求的是不连续的递增子序列。 解法：动态规划 第一步：dp[i]的定义 dp[i]表示i之前包括i的最长上升子序列的长度。 第二步：状态转移方程 位置 i 的最长升序子序列等于 j 从 0..
动态规划--＞最长递增子序列
qq_45774645的博客
04-23 1377
什么是动态规划？ 通过组合子问题的解来求解原问题的，动态规划对于每一个子子问题只求解一次，将其解保存在一个表格里面，从而无需每次求解一个子子问题时都重新计算，避免了不必要的计算工作，简单的说，动态规划的特征就是，当前状态的转移依赖于与前一个状态。 详细理解动态规划，点击这里，我觉得这位博主讲的很清楚。 下面将力扣中两道动态规划题列举出来，做一下比较。 最长递增子序列 给你一个整数数组nums，找到其中最长严格递增子序列的长度。 子序列是由数组派生而来的序列，删除（或不删除）数组中的...
Array.fill()用法
weixin_43613968的博客
03-07 5909
自我学习
蓝桥杯备考随手记: 动态规划
DaPiCaoMin的博客
04-11 1408
在动态规划中，每个子问题只需要求解一次，并将其结果保存起来，以便于下次需要时直接使用，避免重复计算。这种将问题分解成多个子问题并保存子问题的求解结果的方法，可以有效地提高求解问题的效率。
牛客刷题——找零最少
a_small_Bird233的博客
03-24 594
题目：给定数组arr，arr中所有的值都为正整数且不重复。每个值代表一种面值的货币，每种面值的货币可以使用任意张，再给定一个aim，代表要找的钱数，求组成aim的最少货币数。 eg：输入：[5,2,3],20 ，输出：4 动归是硬伤啊，还是不会做。 思路应该是对的，针对已有的面值，对前面的每个状态 j 进行计算，但是动归方程到底啥时候用一维啥时候用二维啊.... 首先将所有的元素初始化为 Integer.MAX_VALUE-1，然后将 dp[0] 置为0，因为当找零为0时，所需要的数量为0，...
经典动态规划：背包问题-（LC322）
一只程序小洋的博客
07-30 251
题目： 给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。 计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回-1 。 你可以认为每种硬币的数量是无限的。 题解： 我们采用自下而上的方式进行思考。仍定义 F(i) 为组成金额 i 所需最少的硬币数量，假设在计算 F(i) 之前，我们已经计算出 F(0)−F(i−1) 的答案。 c_j代表的是第 j 枚硬币的面值，即我们枚举最后一枚硬币面额是 c_j，那么...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值