[Luogu P4602] [BZOJ 5343] [CTSC2018]混合果汁

洛谷传送门

BZOJ传送门

题目描述

小 R 热衷于做黑暗料理，尤其是混合果汁。

商店里有 $n$ 种果汁，编号为 $0,1,\cdots,n-1$ 。 $i$ 号果汁的美味度是 $d_i$ ，每升价格为 $p_i$ 。小 R 在制作混合果汁时，还有一些特殊的规定，即在一瓶混合果汁中， $i$ 号果汁最多只能添加 $l_i$ 升。

现在有 $m$ 个小朋友过来找小 R 要混合果汁喝，他们都希望小 R 用商店里的果汁制作成一瓶混合果汁。其中，第 $j$ 个小朋友希望他得到的混合果汁总价格不大于 $g_j$ ，体积不小于 $L_j$ 。在上述这些限制条件下，小朋友们还希望混合果汁的美味度尽可能地高，一瓶混合果汁的美味度等于所有参与混合的果汁的美味度的最小值。请你计算每个小朋友能喝到的最美味的混合果汁的美味度。

输入输出格式

输入格式：

输入第一行包含两个正整数 $n, m$ ，表示果汁的种数和小朋友的数量。接下来 $n$ 行，每行三个正整数 $d_i, p_i, l_i$ ，表示 $i$ 号果汁的美味度为 $d_i$ ，每升价格为 $p_i$ ，在一瓶果汁中的添加上限为 $l_i$ 。

接下来 $m$ 行依次描述所有小朋友：每行两个数正整数 $g_j, L_j$ 描述一个小朋友，表示他最多能支付 $g_j$ 元钱，他想要至少 $L_j$ 升果汁。

输出格式：

对于所有小朋友依次输出：对于每个小朋友，输出一行，包含一个整数，表示他能喝到的最美味的混合果汁的美味度。如果无法满足他的需求，则输出 $-1$ 。

输入输出样例

输入样例#1：

输出样例#1：

说明

对于所有的测试数据，保证 $n, m \le 100000$ ， $1 \le d_i,p_i,l_i \le 10^5$ , $1 \le g_j, L_j \le 10^{18}$ 。

测试点编号	n=	m=	其他限制
1,2,3	10	10	无
4,5,6	500	500	无
7,8,9	5000	5000	无
10,11,12	100000	100000	$p_i=1$
13,14,15	100000	100000	$l_i=1$
16,17,18,19,20	100000	100000	无

解题分析

一开始想用整体二分搞，然后发现似乎复杂度不太对，只好用主席树。

具体而言，先预处理出从大到小 $\ge d_i$ 美味度的饮品各个价格和花费的总和，用线段树维护这个花费和和总量，线段树每个叶节点表示单价离散化出来为第 $k$ 小的饮品的数量和总花费。这样处理后每个询问我们二分答案，贪心取便宜的就好。

总复杂度 $O(Nlog^2(N))$ 。

代码如下：

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cctype>
#include <cmath>
#include <algorithm>
#define R register
#define IN inline
#define W while
#define gc getchar()
#define MX 100500
#define ll long long
#define db double
template <class T>
IN void in(T &x)
{
    x = 0; R char c = gc;
    for (; !isdigit(c); c = gc);
    for (;  isdigit(c); c = gc)
    x = (x << 1) + (x << 3) + c - 48;
}
template <class T> IN T max(T a, T b) {return a > b ? a : b;}
template <class T> IN T min(T a, T b) {return a < b ? a : b;}
int n, m, cnt, dif;
int root[MX], id[MX], buf[MX];
struct Node {int son[2]; ll sum, tot;} tree[MX * 40];
struct INFO {ll cost, val, lim;} dat[MX];
IN bool operator < (const INFO &x, const INFO &y) {return x.val == y.val ? x.cost < y.cost : x.val > y.val;}
namespace PT
{
    #define ls tree[now].son[0]
    #define rs tree[now].son[1]
    IN void pushup(R int now)
    {
        tree[now].tot = tree[ls].tot + tree[rs].tot;
        tree[now].sum = tree[ls].sum + tree[rs].sum;
    }
    void insert(R int pre, int &now, R int lef, R int rig, R int tar, ll num)
    {
        now = ++cnt;
        tree[now] = tree[pre];
        if (lef == rig) return tree[now].tot += num, tree[now].sum += num * buf[tar], void();
        int mid = lef + rig >> 1;
        if (tar <= mid) insert(tree[pre].son[0], ls, lef, mid, tar, num);
        else insert(tree[pre].son[1], rs, mid + 1, rig, tar, num);
        pushup(now);
    }
    db query(R int now, R int lef, R int rig, db tar)
    {
        if (lef == rig) return min(1.0 * tree[now].tot, tar / buf[rig]);
        int mid = lef + rig >> 1;
        if (tree[ls].sum >= tar) return query(ls, lef, mid, tar);
        else return query(rs, mid + 1, rig, tar - tree[ls].sum) + tree[ls].tot;
    }
    #undef ls
    #undef rs
}
int main(void)
{
    ll mon, lim; int lef, rig, ans, mid;
    in(n), in(m);
    for (R int i = 1; i <= n; ++i)
    in(dat[i].val), in(dat[i].cost), in(dat[i].lim), buf[i] = dat[i].cost;
    ++n; dat[n].val = -1, dat[n].cost = 0, dat[n].lim = 1e18, buf[n] = dat[n].cost;
    std::sort(dat + 1, dat + 1 + n);
    std::sort(buf + 1, buf + 1 + n);
    dif = std::unique(buf + 1, buf + 1 + n) - buf - 1;
    for (R int i = 1; i <= n; ++i) id[i] = std::lower_bound(buf + 1, buf + 1 + dif, dat[i].cost) - buf;
    for (R int i = 1; i <= n; ++i) PT::insert(root[i - 1], root[i], 1, dif, id[i], dat[i].lim);
    W (m--)
    {
        in(mon), in(lim);
        lef = 1, rig = n; db res;
        W (lef <= rig)
        {
            mid = lef + rig >> 1;
            if (res = PT::query(root[mid], 1, dif, mon) >= lim)
            ans = mid, rig = mid - 1;
            else lef = mid + 1;
        }
        printf("%d\n", dat[ans].val);
    }
}