@loj - 2987@ 「CTSC2016」时空旅行

Posted 2020-11-27 tiw-air-oao

目录

• @description@
• @solution@
• @accepted code@
• @details@

---

@description@

2045 年，人类的技术突飞猛进，已经找到了进行时空旅行的方法。小 R 得到了一台时空旅行仪，他想用它调查不同时空中人类的发展状况。

根据平行时空理论，宇宙中存在着很多独立的时空，每个时空在下一个时间点还会分化出若干个不同的时空。宇宙是一个三维空间，人类使用空间直角坐标系来描述空间中的一个位置，三维坐标分别是 x,y,z。

我们假设在初始的时空（编号为 0）中，人类存在于地球上（地球的坐标为 (0,0,0)），其他的时空都是从一个现有的时空发展而来的。一个时空发生一个时间之后会发展成为另外一个时空（原来的时空不发生任何变化）。会影响小 R 的时间包括两类：

人类殖民了一个新的星球，该星球的状态变成“已被殖民”。
人类放弃了一个已被殖民的星球，该星球的状态变成“未被殖民”。

每次进行时空旅行时，小 R 会先选定一个时空。在这个时空中，人类已经殖民了一些星球。小 R 只要到达该时空中任意一个已被殖民的星球，就能调查人类的发展状况。

小 R 的时空旅行仪出现了一些问题，调整 x 坐标的按钮坏掉了，因此到达点的 x 坐标被固定了（每次旅行的 x 坐标值可能不同）。与此同时，他仍能任意调整到达点的 y 坐标和 z 坐标。

这个问题大大增大了小 R 的花费：因为时空旅行没有花费，但在太空中航行却需要花钱；同时，在不同星球进行调查也可能会产生不同的费用。

假设小 R 将时空旅行的终点设为 A，他要进行调查的星球为 B：如果 A 与 B 的欧几里得距离为 d，那么他太空航行的花费就是 d^2；又如果星球 B 上进行调查的费用为 c，那么小 R 此次调查的总花费就是 d^2 + c。

现在给定小 R 每次旅行到达的时空以及时空旅行仪上固定的 x 坐标值，请你计算出小 R 每次旅行完成调查的最小总花费。

原题传送门。

@solution@

首先不难发现 y, z 都是来唬你的，其实代价函数为 (xi - x0)^2 + ci；接着你发现代价函数是个明显的斜率优化。

考虑一个点的影响范围：它第一次被加入的位置对应的子树 T，扣掉它被删除的位置集合 S 对应的子树集合 Ts。
可以用 dfs 序把影响范围拆解成若干区间。如果该点被删除了 x 次，则会产生最多 x + 1 个区间。

注意到一个树点恰好对应增/删一次，所以拆解出来的区间总数是 O(n) 的。

那么问题转化成：首先区间加点，然后单点询问凸包。
如果我们把 dfs 序看成从左往右的时间轴，则可以变成凸包加/删点，给定斜率进行询问。
凸包并不能删点（李超线段树也不行），所以考虑一个不用能把删除去掉辅助的算法，比如线段树分治（当然这一步并不是必需的转化，你可以直接联想到线段树）。

使用线段树分治后，线段树上每一个结点有着若干点以及若干询问。
如果使用在每个结点内部使用 O(nlogn) 的算法，总复杂度为 O(nlog^2n)。

考虑在最外层排好序后再插入到线段树中，这样最终线段树上每一个结点内部的点集与询问都是有序的，直接单调队列可以做到 O(n)。
因此总复杂度 O(nlogn)。

@accepted code@

#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;

const int MAXN = 500000;
const double INF = 1E18;

typedef long long ll;

ll ans[MAXN + 5]; int n, m;

struct point{
    ll x, y; point() {}
    point(ll _x, ll _y) : x(_x), y(_y) {}
    friend bool operator < (const point &a, const point &b) {
        return (a.x == b.x ? a.y < b.y : a.x < b.x);
    }
};
struct query{
    ll k; int id, pos; query() {}
    query(ll _k, int _i) : k(_k), id(_i) {}
    friend bool operator < (const query &a, const query &b) {
        return a.k < b.k;
    }
}b[MAXN + 5];
struct node{
    int l, r; point p; node() {}
    node(int _l, int _r, point _p) : l(_l), r(_r), p(_p) {}
    friend bool operator < (const node &a, const node &b) {
        return a.p < b.p;
    }
}a[2*MAXN + 5]; int acnt;

#define lch (x << 1)
#define rch (x << 1 | 1)
int le[4*MAXN + 5], ri[4*MAXN + 5];
vector<int>v1[4*MAXN + 5], v2[4*MAXN + 5];
void build(int x, int l, int r) {
    le[x] = l, ri[x] = r;
    if( l == r ) return ;
    int m = (l + r) >> 1;
    build(lch, l, m), build(rch, m + 1, r);
}
void insert(int x, int l, int r, int k) {
    if( r < le[x] || l > ri[x] )
        return ;
    if( l <= le[x] && ri[x] <= r ) {
        v1[x].push_back(k);
        return ;
    }
    insert(lch, l, r, k), insert(rch, l, r, k);
}
void add(int x, int p, int k) {
    v2[x].push_back(k);
    if( le[x] == ri[x] ) return ;
    int m = (le[x] + ri[x]) >> 1;
    add(p <= m ? lch : rch, p, k);
}
point que[MAXN + 5];
double slope(point a, point b) {
    if( a.x == b.x )
        return a.y < b.y ? INF : -INF;
    else return 1.0 *(a.y - b.y) / (a.x - b.x);
}
void get(int x) {
    int s = 1, t = 0;
    for(int i=0;i<v1[x].size();i++) {
        point p = a[v1[x][i]].p;
        if( s <= t && que[t].x == p.x && que[t].y == p.y ) continue;
        while( s < t && slope(que[t - 1], que[t]) >= slope(que[t], p) )
            t--;
        que[++t] = p;
    }
    for(int i=0;i<v2[x].size();i++) {
        int id = b[v2[x][i]].id; ll k = b[v2[x][i]].k;
        while( s < t && slope(que[s], que[s + 1]) <= k )
            s++;
        if( s <= t ) ans[id] = min(ans[id], que[s].y - k*que[s].x + k*k);
    }
}
void solve(int x) {
    get(x);
    if( le[x] == ri[x] ) return ;
    solve(lch), solve(rch);
}


int x[MAXN + 5]; ll c[MAXN + 5];
point pnt(int i) {
    return point(2*x[i], 1LL*x[i]*x[i] + c[i]);
}

struct edge{
    int to; edge *nxt;
}edges[MAXN + 5], *adj[MAXN + 5], *ecnt = edges;
void addedge(int u, int v) {
    edge *p = (++ecnt);
    p->to = v, p->nxt = adj[u], adj[u] = p;
}
bool type[MAXN + 5]; int id[MAXN + 5], fa[MAXN + 5];
int dfn[MAXN + 5], tid[MAXN + 5], dcnt;
int nw[MAXN + 5];
void dfs(int x) {
    tid[x] = dcnt, dfn[dcnt++] = x;
    if( !type[x] ) nw[id[x]] = tid[x];
    else a[++acnt] = node(nw[id[x]], tid[x] - 1, pnt(id[x]));
    for(edge *p=adj[x];p;p=p->nxt) {
        dfs(p->to);
    }
    if( !type[x] ) a[++acnt] = node(nw[id[x]], dcnt - 1, pnt(id[x]));
    else nw[id[x]] = dcnt;
}

int readi() {
    int x = 0, f = 1; int ch = getchar();
    while( (ch != '-') && (ch > '9' || ch < '0') ) ch = getchar();
    if( ch == '-' ) f = -1, ch = getchar();
    while( '0' <= ch && ch <= '9' ) x = 10*x + ch - '0', ch = getchar();
    return x * f;
}
ll readl() {
    ll x = 0; int ch = getchar();
    while( ch > '9' || ch < '0' ) ch = getchar();
    while( '0' <= ch && ch <= '9' ) x = 10*x + ch - '0', ch = getchar();
    return x;
}
void write(ll x) {
    if( !x ) return ;
    write(x / 10);
    putchar(x % 10 + '0');
}
int main() {
    freopen("travel.in", "r", stdin);
    freopen("travel.out", "w", stdout);
    
    n = readi(), m = readi(), c[0] = readl(), type[0] = id[0] = 0;
    for(int i=1;i<n;i++) {
        type[i] = readi(), fa[i] = readi(), id[i] = readi();
        if( type[i] == 0 )
            x[id[i]] = readi(), readi(), readi(), c[id[i]] = readl();
        addedge(fa[i], i);
    }
    build(1, 0, n - 1), dfs(0);
    sort(a + 1, a + acnt + 1);
    for(int i=1;i<=acnt;i++)
        insert(1, a[i].l, a[i].r, i);
    for(int i=1;i<=m;i++) {
        int s = readi(), x0 = readi();
        ans[i] = INF, b[i] = query(x0, i), b[i].pos = tid[s];
    }
    sort(b + 1, b + m + 1);
    for(int i=1;i<=m;i++)
        add(1, b[i].pos, i);
    solve(1);
    for(int i=1;i<=m;i++)
        write(ans[i]), puts("");
}

@details@

没事儿不要在这种大数据范围情况下用 vector。

第一次直接存点和询问用 vector 结果 MLE 了，后来改成存点和询问的编号虽然 AC 了，但是常数还是比较大。