tyvj/joyoi 1340 送礼物

论搜索顺序的优越性。

从小到大搜索，T到怀疑人生。

从大到小搜索，轻松AC。

 

双向搜索。

是这样的。我们首先排序一下，然后翻转。(当然也可以写cmp)

然后我们搜前半部分，把结果记录在某一数组中。

然后把结果排序(去重)，再搜另一部分。

接下来有两种想法：

1.同样方式处理另一部分，然后双指针扫描。

2.第二次每次搜到终点，二分更新ans。

  还可以加上剪枝：如果当前的和加上后面所有再加上第一部分最大值都达不到ans，剪枝。

还可以用set，但是CE了...不知道为什么。

细节顺序还可以更优，但是我不想再去烦那台可怜的评测机了.....

进步已经很明显了。

下面上代码。(最优版)

#include <cstdio>
#include <algorithm>
const int N = 50;
typedef long long LL;

int n, mid, t = -1;
LL a[N], b[1 << 23], W, ans, large, sum[N];

void DFS1(int k, LL S) {
    if(S > W) {
        return;
    }
    if(S == W) {
        printf("%lld", W);
        exit(0);
    }
    if(k == mid + 1) {
        b[++t] = S;
        large = std::max(S, large);
        return;
    }
    DFS1(k + 1, S);
    DFS1(k + 1, S + a[k]);
    return;
}

void DFS2(int k, LL S) {
    if(S > W) {
        return;
    }
    if(S == W) {
        printf("%lld", W);
        exit(0);
    }
    if(large + sum[k] + S <= ans) { /// 就是这里
        return;
    }
    if(k == n + 1) {
        int temp = std::upper_bound(b, b + t + 1, W - S) - b;
        ans = std::max(ans, S + b[temp - 1]);
        return;
    }
    DFS2(k + 1, S + a[k]); /// 这个顺序对应上面那个剪枝。
    DFS2(k + 1, S);
    return;
}

int main() {
    scanf("%lld%d", &W, &n);
    for(int i = 1; i <= n; i++) {
        scanf("%lld", &a[i]);
    }
    std::sort(a + 1, a + n + 1);
    std::reverse(a + 1, a + n + 1);
    mid = (n + 1) >> 1;
    for(int i = n; i >= mid; i--) {
        sum[i] = sum[i + 1] + a[i];
    }
    DFS1(1, 0);
    std::sort(b, b + t + 1);
    t = std::unique(b, b + t + 1) - b - 1; /// 注意reverse和unique的用法
    DFS2(mid + 1, 0);
    printf("%d", ans);
    return 0;
}