[2018冬令营模拟测试赛（二十一）]Problem A: Decalcomania

[2018冬令营模拟测试赛（二十一）]Problem A: Decalcomania

试题描述

输入

见“试题描述”

输出

见“试题描述”

输入示例

见“试题描述”

输出示例

见“试题描述”

数据规模及约定

见“试题描述”

题解

最优解一定是在一段连续的包含 \(0\) 号点的区间中选择最小的 \(k\) 个印花，其中一边需要折返（即代价为两倍距离）。

所以我们先将一边的距离 \(\times 2\)，然后两边分别求出 \(f_k\) 表示印 \(k\) 个花至少需要花费的代价，最后枚举一边的答案，并通过剩余步数二分得到另一边的答案即可。

考虑一边的 \(f_k\) 如何处理，这个方案其实就是确定一个点 \(u\)，然后印 \(0\) 到 \(u\) 之间的最小的 \(k\) 个花，不难发现随着 \(k\) 增加，\(u\) 也是单调移动的。由于不好确定最优解具体在哪，我们考虑分治解决这个问题，令 \(solve(l, r, ql, qr)\) 表示答案在区间 \([l, r]\) 中，询问区间为 \([ql, qr]\)，这个时候我们询问一下 \([ql, qr]\) 的中点（这个询问就是暴力扫一遍 \([l, r]\) 然后再数据结构查询一下前 \(k\) 小的总和，找到最优的位置 \(p\)，下次左半部分的询问归到 \([l, p]\) 中，右半部分归到 \([p, r]\) 中），然后继续递归下去就好了。我们需要一个数据结构支持查询区间内前 \(k\) 小的数之和，主席树就可以实现。

最后总复杂度是 \(O(n \log^2 n)\)，那个分治是 \(O(n \log n)\) 的，因为每层最多询问 \(O(n)\) 次，有 \(\log n\) 层。

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <algorithm>
using namespace std;
#define rep(i, s, t) for(int i = (s), mi = (t); i <= mi; i++)
#define dwn(i, s, t) for(int i = (s), mi = (t); i >= mi; i--)
#define LL long long
 
LL read() {
    LL x = 0, f = 1; char c = getchar();
    while(!isdigit(c)){ if(c == '-') f = -1; c = getchar(); }
    while(isdigit(c)){ x = x * 10 + c - '0'; c = getchar(); }
    return x * f;
}
 
#define maxn 100010
#define maxnode 2000010
#define ool (1ll << 60)
#define pli pair <LL, int>
#define x first
#define y second
#define mp(x, y) make_pair(x, y)
 
int n, dis[maxn], Time[maxn], num[maxn];
LL lim;
 
pli Info[maxn];
LL sumv[maxnode];
int ToT, rt[maxn], lc[maxnode], rc[maxnode], siz[maxnode];
void update(int& y, int x, int l, int r, int p) {
    sumv[y = ++ToT] = sumv[x] + num[p];
    siz[y] = siz[x] + 1;
    if(l == r) return ;
    int mid = l + r >> 1; lc[y] = lc[x]; rc[y] = rc[x];
    if(p <= mid) update(lc[y], lc[x], l, mid, p);
    else update(rc[y], rc[x], mid + 1, r, p);
    return ;
}
LL query(int o, int l, int r, int k) {
    if(!o) return 0;
    if(siz[o] == k) return sumv[o];
    int mid = l + r >> 1;
    if(k <= siz[lc[o]]) return query(lc[o], l, mid, k);
    else return sumv[lc[o]] + query(rc[o], mid + 1, r, k - siz[lc[o]]);
}
LL Query(int p, int k) {
    if(k > p) return ool;
    return query(rt[p], 1, n, k) + Info[p].x;
}
void process(int l, int r, int ql, int qr, LL *ans) {
    int mid = ql + qr >> 1;
    LL res = ool, opt;
    rep(i, l, r) {
        LL tmp = Query(i, mid);
        if(res > tmp) res = tmp, opt = i;
    }
    ans[mid] = res;
    if(ql == qr) return ;
    process(l, opt, ql, mid, ans);
    process(opt, r, mid + 1, qr, ans);
    return ;
}
void solve(LL *ans, int N) {
    ToT = 0; memset(lc, 0, sizeof(lc)); memset(rc, 0, sizeof(rc));
    rep(i, 1, N) update(rt[i], rt[i-1], 1, n, Info[i].y);
    process(1, N, 1, N, ans);
    return ;
}
 
LL ans1[maxn], ans2[maxn];
int main() {
    n = read(); lim = read();
    rep(i, 1, n) dis[i] = read(), num[i] = Time[i] = read();
     
    sort(num + 1, num + n + 1);
    rep(i, 1, n) Time[i] = lower_bound(num + 1, num + n + 1, Time[i]) - num;
     
    int ans = 0;
     
    Info[1] = mp(0, Time[1]);
    rep(i, 2, n) Info[i] = mp(Info[i-1].x + (dis[i-1] << 1), Time[i]);
    solve(ans1, n);
    Info[1] = mp(dis[n], Time[n]);
    rep(i, 2, n - 1) Info[i] = mp(Info[i-1].x + dis[n-i+1], Time[n-i+1]);
    solve(ans2, n - 1);
    rep(i, 1, n) if(ans1[i] <= lim) ans = max(ans, (int)(i + upper_bound(ans2 + 1, ans2 + n, lim - ans1[i]) - ans2 - 1));
    rep(i, 1, n - 1) if(ans2[i] <= lim) ans = max(ans, i);
     
    Info[1] = mp(0, Time[1]);
    rep(i, 2, n) Info[i] = mp(Info[i-1].x + dis[i-1], Time[i]);
    solve(ans1, n);
    Info[1] = mp(dis[n] << 1, Time[n]);
    rep(i, 2, n - 1) Info[i] = mp(Info[i-1].x + (dis[n-i+1] << 1), Time[n-i+1]);
    solve(ans2, n - 1);
    rep(i, 1, n) if(ans1[i] <= lim) ans = max(ans, (int)(i + upper_bound(ans2 + 1, ans2 + n, lim - ans1[i]) - ans2 - 1));
    rep(i, 1, n - 1) if(ans2[i] <= lim) ans = max(ans, i);
     
    printf("%d\n", ans);
     
    return 0;
}