牛客之牛牛的背包问题

最新推荐文章于 2022-09-24 11:18:30 发布

Java学习之旅

最新推荐文章于 2022-09-24 11:18:30 发布

阅读量362

点赞数

分类专栏：算法文章标签：算法背包问题牛客 java 回溯算法

本文链接：https://blog.csdn.net/m0_37954722/article/details/100625871

版权

算法专栏收录该内容

17 篇文章 0 订阅

订阅专栏

本文介绍了牛牛在牛客网上遇到的一道结合背包问题和回溯算法的题目。当零食总体积不超过背包容量时，需要找出所有可能的零食组合。题目类似于子集问题，但不需要去重。作者分享了如何利用回溯算法解决此问题，并提到当零食总重量小于等于背包容量时，问题转化为全排列，答案为2^n（注意牛客网中浮点数与整数的判断差异）。

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

今天在牛客上发现了一道比较有趣的背包问题，乍一看以为是动态规划问题，其实仔细看是回溯算法问题，下面是题目。

题目描述

牛牛准备参加学校组织的春游, 出发前牛牛准备往背包里装入一些零食, 牛牛的背包容量为w。

牛牛家里一共有n袋零食, 第i袋零食体积为v[i]。

牛牛想知道在总体积不超过背包容量的情况下,他一共有多少种零食放法(总体积为0也算一种放法)。

输入描述:
输入包括两行
第一行为两个正整数n和w(1 <= n <= 30, 1 <= w <= 2 * 10^9),表示零食的数量和背包的容量。
第二行n个正整数v[i](0 <= v[i] <= 10^9),表示每袋零食的体积。
输出描述:
输出一个正整数, 表示牛牛一共有多少种零食放法。
示例1

输入
3 10
1 2 4
输出
8
说明
三种零食总体积小于10,于是每种零食有放入和不放入两种情况，一共有2*2*2 = 8种情况。

这道题有点像LeetCode的子集问题，详情可以看我的另外一篇博客LeetCode之子集问题，这里不需要去重，然后我就开开心心的打了一大段代码，第一次提交的通过率只有80%。然后仔细想了一下，如果n种零食的总重量小于等于背包重量的话，直接输出Math.pow(2,n)即可，注意需要转成int类型，因为牛客判定8 != 8.0。

import java.util.Scanner;
import java.util.List;

public class Main{
    public static long count = 0;
    
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        
        int n = sc.nextInt();
        Long w = sc.nextLong();
        
        int[] v = new int[n];
        Long sum = 0L;
        for(int i = 0;i < n;i++){
            v[i] = sc.nextInt();
            sum += v[i];
        }
        //没有这个提交通过率只有80% 因为会超时。
        if(sum <= w){
            System.out.println((int)Math.pow(2,n));
            return;
        }
        
        quicksort(v,0,n - 1);
        
        backtrack(v,0,0L,w);
        System.out.println(count);
    }
    
    public static void quicksort(int[] nums,int left,int right){
        if(left >= right || nums == null)
            return;
        int key = nums[left];
        int l = left,r = right;
        while(l < r){
            while(l < r && nums[r] >= key)
                r--;
            while(l < r && nums[l] <= key)
                l++;
            if(l < r)
                nums[l] = nums[l] + nums[r] - (nums[r] = nums[l]);
        }
        nums[left] = nums[l];
        nums[l] = key;
        quicksort(nums,l + 1,right);
    }
    
    public static void backtrack(int[] v,int start,Long cur,Long w){
        if(cur > w)
            return;
        count++;
        for(int i = start;i < v.length;i++){
            backtrack(v,i + 1,cur + v[i],w);
        }
    }
}

其实就是回溯算法+一点优化而已，这里的优化就是有一种情况：如果n种零食的总重量小于等于背包重量。这种情况就是全排列问题即Math.pow(2,n)。