牛牛选物

时间限制：C/C++ 5秒，其他语言10秒
空间限制：C/C++ 262144K，其他语言524288K
64bit IO Format: %lld

题目描述

现在有n个物品，每个物品有一个体积v[i]和重量g[i],选择其中总体积恰好为V的若干个物品，想使这若干个物品的总重量最大，求最大总重量为多少。（如果不存在合法方案，返回-1）

示例1

输入

复制 [1,2,3],[2,3,4],3

[1,2,3],[2,3,4],3

返回值

复制 5

5

说明

可以选择前两个物品，总体积为1+2=3恰好等于V，总重量为2+3=5，为符合题意选法中的最大重量 

示例2

输入

复制 [1,3],[100,300],2

[1,3],[100,300],2

返回值

复制 -1

-1

说明

只有一个体积为1的和一个体积为3的物品，无法选出总体积为2的若干物品，所以返回-1 

备注:

对于100%的数据，1≤n≤20,1≤v[i]≤1e8,1≤g[i]≤1e8,1≤V≤1e9对于100\%的数据，1\leq n\leq 20,1\leq v[i]\leq 1e8,1\leq g[i]\leq 1e8,1\leq V\leq 1e9对于100%的数据，1≤n≤20,1≤v[i]≤1e8,1≤g[i]≤1e8,1≤V≤1e9

给定三个参数，第一个参数为数组v，第二个参数为数组g，第三个参数为体积V，求最大总重量为多少。

(所给字符串与返回字符串都不带引号)

 

一开始没仔细审题，忽略了V可能很大，物品数量很小，必须要体积和恰好为V。尝试动态规划，又尝试记忆化搜索的没做出来，要么超时要么超内存，抓住题目数据的特征，总的不超过20个数据，可以用二进制来保存状态，只需要计算每个状态哪一些被选中，总体积是不是V就可以。

 

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 返回总体积为V若干物品的最大总重量，如果g存在选择若干物品总体积为V的情况，返回-1
     * @param v int整型vector 
     * @param g int整型vector 
     * @param V int整型 
     * @return int整型
     */
    int Maximumweight(vector<int>& v, vector<int>& g, int V) {
        int ans = -1;
        int n = v.size();
        for(int i = 1;i < 1 << n;i++)
        {
            int vv = 0,gg = 0;
            for(int j = 0;j < n;j++)
            {
                if((1 << j) & i)
                {
                    vv += v[j];
                    gg += g[j];
                    if(vv > V)
                    {
                       break;
                    }
                }
            }
            if(vv == V) ans = max(ans, gg);
        }
        return ans;
    }
};

可以用二分枚举优化

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 返回总体积为V若干物品的最大总重量，如果g存在选择若干物品总体积为V的情况，返回-1
     * @param v int整型vector 
     * @param g int整型vector 
     * @param V int整型 
     * @return int整型
     */
    int Maximumweight(vector<int>& v, vector<int>& g, int V) {
        int ans = -1;
        int n = v.size();
        std::map<int,int> mp1;
        std::map<int,int> mp2;
        int n1 = n / 2;
        int n2 = n - n1;
        for(int i = 0;i < (1 << n1);i++)
        {
            int vv = 0,gg = 0;
            int d = i,j = 0;
            while(d)
            {
                if(d % 2)
                {
                    vv += v[j];
                    gg += g[j];
                    if(vv > V)
                    {
                       break;
                    }
                }
                j ++;
                d /= 2;
            }
            if(vv <= V && mp1[vv] < gg) mp1[vv] = gg;
        }
        for(int i = 0;i < (1 << n2);i++)
        {
            int vv = 0,gg = 0;
            int d = i,j = n1;
            while(d)
            {
                if(d % 2)
                {
                    vv += v[j];
                    gg += g[j];
                    if(vv > V)
                    {
                       break;
                    }
                }
                j ++;
                d /= 2;
            }
            
            if(vv <= V && mp2[vv] < gg) mp2[vv] = gg;
        }
        for(auto& pa : mp1)
        {
            if(mp2.find(V - pa.first) == mp2.end()) continue;
            ans = max(ans, pa.second + mp2[V - pa.first]);
        }
        ans = max(ans, mp2[V]);
        ans = max(ans, mp1[V]);
        return ans <= 0 ? -1 : ans;
    }
};

 用unordered_map应该可以更快。