01背包之折半搜索优化

先贴题

由于涉及小数，故源数据先乘100再加以利用。所以正常操作是开一个3百万的数组进行dp，事实证明这会超时。

投巧的小操作

观察到这道题的数据点，合格的发票数量不多。所以枚举的话不会超时。

时间复杂度为：1+2+4+...+2^(n-1) = 2^n-1; 也就是 O(2^n) 的算法。明显投机取巧了orz

        vector<int> maxmoney;
        maxmoney.push_back(0);
        for (int i = 0; i < count; i++)
        {
            int maxmoney_size = maxmoney.size();
            for (int j = 0; j < maxmoney_size; j++)
            {
                int tmp = maxmoney[j] + Value[i];
                if (tmp <= sum)
                {
                    maxmoney.push_back(tmp);
                }
            }
        }
        int res = 0;
        for (auto i : maxmoney) res = max(res, i);
        printf("%0.2lf\n", res / 100.0);

折半搜索

我们可以将所有发票分成两部分，对这两部分分别进行搜索，然后使用vector来储存搜索过程中产生的可能的组合。最后再将两部分进行合并，得出最终的答案。

最终的时间复杂度为 O(2^(n/2+1) + n/2 * log(n/2)) ，前者为分别搜索的时间复杂度，后者为合并的时间复杂度。
好像也没优化多少hhh，不过 n = 40 还是可以从容应对的。
合并时，我们可以先将一部分进行排序使其有序，然后遍历另一部分，每次进行二分搜索查找可行的答案然后取较大值。

        vector<int> a, b;
        int ans = 0;
        dfs(0, (count - 1) / 2, 0, a);   //搜索第一部分
        dfs((count - 1) / 2 + 1, count - 1, 0, b);  //搜索第二部分
        sort(a.begin(), a.end());    //将第一部分排序，使其有序
        for (int i = 0; i < b.size(); i++)
        {
           // ans += upper_bound(a.begin(), a.end(), sum - b[i]) - a.begin();
           // //每次寻找花费比剩下的钱还要少的方案数，注意这里要使用upper_bound
           ////若使用lower_bound，则出现等于的情况时，方案数会有错误
            ans = max(ans, a[upper_bound(a.begin(), a.end(), sum - b[i]) - a.begin() - 1] + b[i]);
        }
        printf("%0.2lf\n", ans / 100.0);

引申思考

二维情况下，比如求满足总重量不超过 M 的条件时可累计的最大价值V，该如何处理？

完整代码

#include<iostream>
#include<vector>
#include<algorithm>
#include<cstring>
using namespace std;
#pragma warning(disable:4996)
#define int long long

char TypeA = 'A', TypeB = 'B', TypeC = 'C';
int n, m, sum, price;
double d_sum, d_price;
char type;
int Value[35];
//int dp[3000005];
void dfs(int start,int end, int total, vector<int>& R)
{
    if (total > sum) return;
    if (start > end)
    {
        R.push_back(total);
        return;
    }
    dfs(start + 1, end, total + Value[start], R);
    dfs(start + 1, end, total, R);
}
signed main() {
    while (1) {
        scanf("%lf%d", &d_sum, &n);
        if (n == 0) break;
        sum = (int)(d_sum * 100 + 0.5);
        int count = 0;
        memset(Value, 0, sizeof(Value));
      /*  memset(dp, 0, sizeof(dp));*/
        for (int i = 1; i <= n; i++) {
            bool flag = true;
            int sum_A = 0, sum_B = 0, sum_C = 0;
            int temp = 0;
            scanf("%d", &m);
            for (int j = 1; j <= m; j++) {
                scanf(" %c:%lf", &type, &d_price);    //空格     字符字符字符字符！！！
                price = (int)(d_price * 100 + 0.5);
                if (type == TypeA) {
                    sum_A += price;
                    temp += price;
                }
                else if (type == TypeB) {
                    sum_B += price;
                    temp += price;
                }
                else if (type == TypeC) {
                    sum_C += price;
                    temp += price;
                }
                else {
                    flag = false;
                }
            }
            if (flag && temp <= 100000 && sum_A <= 60000 && sum_B <= 60000 && sum_C <= 60000) {
                Value[count++] = temp;
            }
        }
        vector<int> a, b;
        int ans = 0;
        dfs(0, (count - 1) / 2, 0, a);   //搜索第一部分
        dfs((count - 1) / 2 + 1, count - 1, 0, b);  //搜索第二部分
        sort(a.begin(), a.end());    //将第一部分排序，使其有序
        for (int i = 0; i < b.size(); i++)
        {
           // ans += upper_bound(a.begin(), a.end(), sum - b[i]) - a.begin();
           // //每次寻找花费比剩下的钱还要少的方案数，注意这里要使用upper_bound
           ////若使用lower_bound，则出现等于的情况时，方案数会有错误
            ans = max(ans, a[upper_bound(a.begin(), a.end(), sum - b[i]) - a.begin() - 1] + b[i]);
        }
        printf("%0.2lf\n", ans / 100.0);
        //for (int i = 0; i < count; i++) {
        //    for (int j = sum; j >= Value[i]; j--)
        //        dp[j] = max(dp[j], dp[j - Value[i]] + Value[i]);
        //}
        //double x;
        //x = (dp[sum]) / 100.0; // 除 100。00   保留两位小数
        //printf("%0.2lf\n", x);
    }
    return 0;
}