Java使用动态规划算法思想解决01背包问题

Java使用动态规划算法思想解决背包问题

背包问题是一种组合优化的NP完全问题。问题可以描述为:给定一组物品,每种物品都有自己的重量和价格,在限定的总重量内,我们如何选择,才能使得物品的总价格最高

动态规划算法

动态规划算法的思想

动态规划算法处理的对象是多阶段复杂决策问题,动态规划算法和分治算法类似,其基本思想也是将待求解问题分解成若干个子问题(阶段),然后分别求解各个子问题(阶段),最后将子问题的解组合起来得到原问题的解,但是与分治算法不同的是,子问题往往不是相互独立的,而是相互联系又相互区别的

动态规划算法问题求解的目标是获取导致问题最优解的最优决策序列(最优策略)。对于一个决策序列,可以用一个数值函数(目标函数)衡量这个决策的优劣。

最优性原理

动态规划算法的最优性原理:一个最优决策序列具有这样的性质,不论初始状态和第一步决策如何,对前面的决策所形成的状态而言,其余的决策必须按照前一次决策所产生的新状态构成一个最优决策序列。

最优性原理体现为问题的最优子结构特性,对于一个问题,如果能从较小规模的子问题的最优解求得较大规模同类子问题的最优解,最终得到给定问题的最优解,也就是问题的最优解中所包含的子问题的最优解,这种性质被称为最优子结构性质。最优子结构特性使得在从较小问题的解构造较大问题的解时,只需考虑子问题的最优解,然后以自底向上的方式递归地从子问题的最优解逐步构造出整个问题的最优解,它保证了原问题的最优解可以通过求解子问题的最优解来获得,最优子结构的特性是动态规划算法求解问题的必要条件。

动态规划算法的三大特点

  • 如果求解的问题满足最优性原理,则说明用动态规划算法有可能解决该问题,在分析问题的最优子结构时,所使用的方法具有普遍性。要注意一个问题可以有多种方式刻画它的最优子结构,有些表示方法的求解速度更快(空间占用少,问题的维度低)。
  • 递归定义最优解决方案。动态规划的每一步决策都依赖于子问题的解,动态规划算法求解最优化问题的步骤为:找出最优解的结构,具体来说就是看这个问题是否满足最优子结构特性;其次递归定义一个最优解的值,即构造原问题和子问题之间的递归方程,原问题的最优解可以通过子问题的最优解获得。
  • 以自底向上的方式计算出最优解的值(最优解的目标函数的值)。对子问题的分解是基于原问题的分解的基础之上进行的,而且这些子问题的分解过程是相互独立的。在对原问题分解的过程中,会出现大量的共享重叠子问题,为了避免对大量重叠子问题的重复计算,一般动态规划算法从自底向上开始计算,对每一个问题只解一次,并且保存求解子问题的最优值,当再需要求解这个子问题的时候,可以用常数时间查看一下结果,而不是再递归的去求解每一个问题的解,因此提高了动态规划算法的效率。

动态规划算法中的0/1背包问题

0/1背包问题的规则是不允许该物品进行拆分,即只有把物品放入和不放入两个基本状态,要使用动态规划算法求解决如何放物品才可以是背包中的物品的总价值达到最高。

示例

有一个载重为10的背包,现有4类物品,每类物品的重量分别为(w0,w1,w2,w3)=(2,3,4,7),它们的价值分别为(p0,p1,p2,p3)=(1,3,5,9)。试问如何装载能够使背包容纳物品的价值最大。

package com.xuda.test
 import java.util.Arrays;
 import java.util.Scanner;
 //m表示的是背包的容量,a表示有多少种类的物品,数组w用与存放每类物品的重量,数组val用于存放每类物品的价值
 public class my {
     public static void main(String[] args) {
         Scanner scanner = new Scanner(System.in);
         System.out.print("请输入背包的容量:");
         int m = scanner.nextInt();
         Scanner inScanner = new Scanner(System.in);
         System.out.print("请输入物品的个数:");
         int a = inScanner.nextInt();
         int[] w = new int[a + 1];
         System.out.print("请输入物品的重量:" + " ");
         for (int i = 1; i <= a; i++) {
             w[i] = inScanner.nextInt();
         }
         int[] val = new int[a+ 1];
         System.out.print("请输入物品的价值:" + " ");
         for (int i = 1; i <= a; i++) {
             val[i] = inScanner.nextInt();
         }
         int n = val.length;
         int[][] path = new int[n +1][m+1 ];
         //创建二维数组
         //v[i][j]:表示在前i个物品中能够装入容量为j的背包中的最大价值
         int[][] v = new int[n +1][m + 1];
         //初始化第一行和第一列
         for (int i = 0; i < v.length; i++) {//v.length:获取二维数组的行数
             v[i][0] = 0;//将第一列设置为0
         }
         for (int i = 0; i < v[0].length; i++) {//v[0].length:获取二维数组的列数
             v[0][i] = 0;//将第一行设置为0
         }
         for (int i = 1; i < v.length; i++) {//int i = 1 不处理第一行
             for (int j = 1; j < v[0].length; j++) {//int j = 1 不处理第一列
                 if (w[i - 1] > j) {
                     v[i][j] = v[i - 1][j];
                 } else {
                     if (v[i - 1][j] < (val[i - 1] + v[i - 1][j - w[i - 1]])) {
                         v[i][j] = val[i - 1] + v[i - 1][j - w[i - 1]];
                         //把当前情况记录到path
                         path[i][j] = 1;
                     } else {
                         v[i][j] = v[i - 1][j];
                     }
                 }
             }
         }
         //输出二维数组:
         for (int[] ints : v) {
             System.out.println(Arrays.toString(ints));
         }
         //输出最后我们是放入的那些商品
         int i = path.length - 1;//行的最大下标
         int j = path[0].length - 1;//列的最大下标
         while (i > 0 && j > 0) {//从path的最后开始找
             if (path[i][j] == 1) {
                 System.out.printf("第%d个商品放入背包\n", i-1);
                 j -= w[i - 1];
             }
             i--;
         }
     }
 }

输入一个背包容量为10,里面有4类物品,物品的重量分别为2,3,4,7,物品的价值分别为1,3,5,9

结果

动态规划算法的优点

若要解一个给定问题,我们需要解其不同部分(即子问题),再合并子问题的解以得出原问题的解。 通常许多子问题非常相似,为此动态规划法试图仅仅解决每个子问题一次,从而减少计算量: 一旦某个给定子问题的解已经算出,则将其记忆化存储,以便下次需要同一个子问题解之时直接查表。 这种做法在重复子问题的数目关于输入的规模呈指数增长时特别有用。

  • 2
    点赞
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 贪心算法动态规划都可以用来解决背包问题。贪心算法是一种贪心思想,每次选择当前最优的解决方案,不考虑未来的影响。而动态规划则是将问题分解成子问题,通过求解子问题的最优解来得到原问题的最优解。 在Java中,可以使用贪心算法实现背包问题,具体实现方法如下: 1. 将物品按照单位重量的价值从大到小排序。 2. 依次将物品放入背包中,直到背包装满或者物品已经全部放入。 3. 如果物品不能完全放入背包中,则将物品按照单位重量的价值从大到小的顺序,依次将物品的一部分放入背包中,直到背包装满。 动态规划实现背包问题的方法如下: 1. 定义状态:设f(i,j)表示前i个物品放入容量为j的背包中所能获得的最大价值。 2. 状态转移方程:f(i,j) = max{f(i-1,j), f(i-1,j-w[i])+v[i]},其中w[i]表示第i个物品的重量,v[i]表示第i个物品的价值。 3. 初始化:f(,j) = ,f(i,) = 。 4. 最终结果:f(n,C),其中n表示物品的数量,C表示背包的容量。 以上是贪心算法动态规划实现背包问题的方法,具体实现可以参考相关的Java代码。 ### 回答2: 背包问题是计算机科学中的经典问题,贪心算法动态规划算法都可以用来解决该问题。其中,贪心算法是一种直观而简单的算法,可以用来获取快速的近似值。在本篇文章中,我们将讨论如何使用贪心算法实现背包问题的动态规划,并且使用Java语言来实现。 问题描述 背包问题是指给定一个背包和一些物品,每个物品具有重量和价值。现在需要从物品中选择一些填满背包并且总价值最大。该问题可以表示为以下的数学模型: $$ \begin{aligned} \text{max} & \sum_{i=1}^{n} v_i *x_i \\ \text{s.t.} & \sum_{i=1}^{n} w_i*x_i \leq W,\\ & x_i\in \{0,1\} \end{aligned} $$ 其中,$v_i$表示物品$i$的价值,$w_i$表示物品$i$的重量,$x_i$表示是否取该物品,$W$表示背包容量。 贪心算法思路 在使用贪心算法解决背包问题时,我们需要按照物品的单位价值(即价值除以重量)降序排列,然后选择单位价值最高的物品放入背包。如果该物品不能全部放入背包,那么我们就将它分成若干部分,选择剩余空间最大的那部分,直到背包被填满。 代码实现 以下是使用Java语言实现贪心算法的代码: ``` public static int greedy(int[] v, int[] w, int W) { int n = v.length; double[] ratio = new double[n]; for (int i = 0; i < n; i++) { ratio[i] = (double)v[i] / w[i]; } // 根据单位价值降序排列 int[] index = IntStream.range(0, n).boxed().sorted((i, j) -> Double.compare(ratio[j], ratio[i])).mapToInt(ele -> ele).toArray(); int value = 0; double remain = W; for (int i = 0; i < n && remain > 0; i++) { int idx = index[i]; if (w[idx] <= remain) { remain -= w[idx]; value += v[idx]; } else { value += v[idx] * remain / w[idx]; remain = 0; } } return value; } ``` 该方法首先计算每个物品的单位价值,然后按照降序排列。接着我们迭代每个物品,将尽可能多的物品放入背包中。如果剩余空间不足以容纳一个物品,那么就部分填充该物品。 结果分析 贪心算法虽然看起来很简单,但是这种方法并不总是能够产生最佳解。但是根据实验,贪心算法能够产生非常接近最佳解的结果。以下是使用两个不同的例子来验证我们实现的方法 问题1 给定一组物品:重量为$w=\{2,3,4,5\}$,价值为$v=\{3,4,5,6\}$。背包容量为W=8。在该问题中,贪心算法最优价值为14,而最优答案为13。 问题2 给定一组物品:重量为$w=\{31,10,20,19,4,3,6\}$,价值为$v=\{70,20,39,37,7,5,10\}$。背包容量为W=50。在该问题中,贪心算法最优价值为150,而最优答案为150。 结论 在本文中,我们介绍了如何使用贪心算法解决背包问题,并使用Java语言来实现。虽然该方法并不能总是得到最优解,但是在某些场景中,贪心算法可以产生接近最优解的结果。 ### 回答3: 背包问题是一种经典的优化问题,其中有一个物品集合和一个称重限制。我们需要从中选出一些物品放入背包中,以使得背包中的物品总价值最大,同时不超过重量限制。 对于背包问题,可以采用贪心算法动态规划算法来求解。在这里,我们将介绍如何使用贪心算法来实现背包问题的动态规划解法。 首先,我们可以计算每个物品的单位价值,即每个物品的价值除以其重量。接下来,我们将按照单位价值从大到小的顺序对物品进行排序。然后,我们依次将每个物品放入背包中,直到达到重量限制或将所有物品都放入背包为止。 在这个过程中,我们将记录已放入背包中的物品总价值,以及剩余的重量。如果将一个物品放入背包后,剩余的重量已经不能放入下一个物品,那么我们就不再继续放物品。这个过程中,我们不断更新背包的总价值,直到没有新的物品可以放入为止。 以下是Java实现贪心算法的代码: ``` public class KnapsackProblem { public static void main(String[] args) { int[] values = {60, 100, 120}; int[] weights = {10, 20, 30}; int maxWeight = 50; int result = getMaxValue(values, weights, maxWeight); System.out.println("The maximum value is " + result); } public static int getMaxValue(int[] values, int[] weights, int maxWeight) { int n = values.length; double[] unitValues = new double[n]; for (int i = 0; i < n; i++) { unitValues[i] = (double) values[i] / weights[i]; } for (int i = 0; i < n; i++) { for (int j = i + 1; j < n; j++) { if (unitValues[i] < unitValues[j]) { swap(unitValues, i, j); swap(values, i, j); swap(weights, i, j); } } } int totalWeight = maxWeight; int maxValue = 0; for (int i = 0; i < n; i++) { if (weights[i] > totalWeight) { break; } maxValue += values[i]; totalWeight -= weights[i]; } if (totalWeight > 0 && i < n) { maxValue += unitValues[i] * totalWeight; } return maxValue; } public static void swap(double[] arr, int i, int j) { double tmp = arr[i]; arr[i] = arr[j]; arr[j] = tmp; } public static void swap(int[] arr, int i, int j) { int tmp = arr[i]; arr[i] = arr[j]; arr[j] = tmp; } } ``` 这个代码首先计算每个物品的单位价值,然后将它们按照从大到小的顺序排序。对于每个物品,如果将其放入背包后,剩余的重量已经不能放入下一个物品,那么就不再继续放入物品。最终,它将返回背包中的物品总价值。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值