【背包问题】有依赖的背包问题

HeyBlog

于 2021-08-23 17:22:57 发布

阅读量514

点赞数

分类专栏：数据结构与算法背包问题文章标签：算法数据结构

原文链接：https://cloud.tencent.com/developer/article/1788763

版权

数据结构与算法同时被 2 个专栏收录

9 篇文章 3 订阅

订阅专栏

背包问题

9 篇文章 0 订阅

订阅专栏

这篇博客探讨了一种特殊的背包问题，其中物品之间存在依赖关系，形成一棵树状结构。如果选择某个物品，就必须选择其依赖的所有父节点。作者通过一个实例展示了如何使用动态规划解决此类问题，输出能够最大化价值的物品组合。输入和输出格式清晰，代码实现详细解释了算法思路，包括深度优先搜索和动态规划矩阵更新的过程。

摘要由CSDN通过智能技术生成

一、问题

这种背包问题的物品间存在某种“依赖”的关系。也就是说，物品 $i$ 依赖于物品 $j$ ，表示若选物品 $i$ ，则必须选物品 $j$ 。
我们直接用一个题目来解释这个问题，题目如下。

题目：有 $N$ 个物品和一个容量是 $V$ 的背包。物品之间具有依赖关系，且依赖关系组成一棵树的形状。如果选择一个物品，则必须选择它的父节点。如下图所示：
在这里插入图片描述
如果选择物品5，则必须选择物品1和2。这是因为2是5的父节点，1是2的父节点。

每件物品的编号是 $i$ ，体积是 $v_i$ ，价值是 $w_i$ ，依赖的父节点编号是 $p_i$ 。物品的下标范围是 $1 \dots N$ 。

求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。输出最大价值。

输入格式：
第一行有两个整数 $N$ ， $V$ ，用空格隔开，分别表示物品个数和背包容量。

接下来有 $N$ 行数据，每行数据表示一个物品。
第 $i$ 行有三个整数 $v_i,w_i,p_i$ ，用空格隔开，分别表示物品的体积、价值和依赖的物品编号。
如果 $p_i=−1$ ，表示根节点。数据保证所有物品构成一棵树。

输出格式：
输出一个整数，表示最大价值。

数据范围：
$1 \leq N, V \leq 100$
$1≤v_i,w_i≤100$
父节点编号范围：

内部结点： $1≤p_i≤N$
根节点 $p_i=−1$

输入样例：

5 7
2 3 -1
2 2 1
3 5 1
4 7 2
3 6 2

输出样例：

11

class DependPack {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();//物品的个数
        int C = sc.nextInt();//背包容量
        int[] V = new int[N];//物品的体积
        int[] W = new int[N];//物品的价值
        int[] P = new int[N];//所依赖物品的编号
        for (int i = 0; i < N; i++) {
            V[i] = sc.nextInt();//第i个物品的体积
            W[i] = sc.nextInt();//第i个物品的价值
            P[i] = sc.nextInt();//第i个物品所依赖的物品编号
        }
        int ans = dependPack(N, C, V, W, P);
        System.out.println(ans);
    }

    private static int dependPack(int N, int C, int[] V, int[] W, int[] P) {
        // dp[i][j]：选择以 i 为子树的物品，在容量不超过 j 时所获得的最大价值
        int[][] dp = new int[N][C + 1];

        // 建立一个数组，每个下标存放对应 “以该下标为父节点” 的所有子节点（root 节点的编号为 1）
        // 该数组下标为 0 的存放的是 root 节点，下标为 1 存放的是以 root 节点为父节点的结点 ...
        List<Integer>[] tree = new List[N + 1]; 
        Arrays.setAll(tree, e -> new ArrayList<Integer>());
        int root = -1;
        for (int i = 0; i < N; i++) {
            if (P[i] == -1) {
                root = i;  
            } else {
                tree[P[i]].add(i); 
            }
        }

        // dfs 求解
        dfs(N, C, V, W, dp, root, tree);

        // 最终答案是以 root 为子树（代表了 root 本身也是可以被选或不选）、容量不超过 C 的最大价值
        return dp[root][C];
    }

    private static void dfs(int N, int C, int[] V, int[] W, int[][] dp, int root, List<Integer>[] tree) {
        int vi = V[root];
        int wi = W[root];
        for (int i = vi; i <= C; i++) {
            dp[root][i] = wi;
        }
        List<Integer> child = tree[root + 1]; // root 的编号为 1
        int size = child.size();
        for (int i = 0; i < size; i++) {
            int node = child.get(i);
            dfs(N, C, V, W, dp, node, tree);
            for (int j = C; j >= vi; j--) {
                for (int k = 0; k <= j - vi; k++) {
                    dp[root][j] = Math.max(dp[root][j], dp[root][j - k] + dp[node][k]);
                }
            }
        }
    } 
}