【LOJ】#2032. 「SDOI2016」游戏

题解

看错题了，以为单次修改相当于一个覆盖，后来才明白“添加”……

就相当于添加很多线段求最小值

首先这个等差数列添加的方式比较烦人，我们拆开两条链，一条s到lca，一条lca到t

那么s到lca上的点x值就是\(-A * dis[x] + A * dis[s] + B\)
lca到t上的点x值就是\(A * dis[x] + A * (dis[s] - 2 * dis[lca]) +B\)
这个时候就是点值代入的一次函数的形式，考虑怎么插入一条线段

这个线段树上的节点原来维护着一条直线，如果新加入的线段两端都小于原来线段，那么原来线段就替换掉
如果两端都大于，那么这条线段没用，退出

如果有交点，那么求出交点的位置，下取整，保留靠下的长度较长的一条线段，另一条线段根据交点的位置分到左右区间递归处理

听说叫什么李超线段树。。。

用可持久化处理区间最大值，每次询问的时候查询区间在当前节点的线段能取到的最小值

加上树链剖分，复杂度是\(O(n \log^3 n)\)

代码

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <queue>
#define enter putchar('\n')
#define space putchar(' ')
#define MAXN 100005
//#define ivorysi
using namespace std;
typedef long long int64;
template<class T>
void read(T &res) {
    res = 0;char c = getchar();T f = 1;
    while(c < '0' || c > '9') {
        if(c == '-') f = -1;
        c = getchar();
    }
    while(c >= '0' && c <= '9') {
        res = res * 10 + c - '0';
        c = getchar();
    }
    res *= f;
}
template<class T>
void out(T x) {
    if(x < 0) {putchar('-');x = -x;}
    if(x >= 10) {
        out(x / 10);
    }
    putchar('0' + x % 10);
}
int N,M;
struct Line {
    int64 A,B;
    Line(int64 _A = 0,int64 _B = 0){A = _A;B = _B;}
    int64 cal(int64 x) {return A * x + B;}
};
struct node {
    int to,next;
    int64 val;
}E[MAXN * 2];
struct Tr_node {
    int L,R;
    Line f;int64 val;
    bool cover;
}tr[MAXN * 4];
int sumE,head[MAXN];
int64 dis[MAXN];
int fa[MAXN],dep[MAXN],siz[MAXN],son[MAXN],top[MAXN],dfn[MAXN],idx,id[MAXN];
void build(int u,int l,int r) {
    tr[u].L = l;tr[u].R = r;
    tr[u].cover = 0;tr[u].val = 123456789123456789LL;
    if(l == r) return;
    int mid = (l + r) >> 1;
    build(u << 1,l,mid);
    build(u << 1 | 1,mid + 1,r);
}
int64 down(int64 A,int64 B) {
    if(B < 0) A = -A,B = -B;
    int64 C = A / B;
    return C - (C * B > A);
} 
int64 cross(Line f,Line g) {
    return down(f.B - g.B,g.A - f.A);
}
void Add_Line(int u,Line g) {
    int64 l = dis[id[tr[u].L]],r = dis[id[tr[u].R]];
    tr[u].val = min(tr[u].val,min(g.cal(l),g.cal(r)));
    if(!tr[u].cover) {tr[u].f = g;tr[u].cover = 1;return;}
    else {
        int64 mid = (tr[u].L + tr[u].R) >> 1;
        mid = dis[id[mid]];
        if(tr[u].f.cal(l) >= g.cal(l) && tr[u].f.cal(r) >= g.cal(r)) {
            tr[u].f = g;return;
        }
        else if(tr[u].f.cal(l) <= g.cal(l) && tr[u].f.cal(r) <= g.cal(r)) return;
        else if(tr[u].f.cal(l) <= g.cal(l)) {
            if(cross(tr[u].f,g) <= mid) {Add_Line(u << 1,tr[u].f);tr[u].f = g;}
            else Add_Line(u << 1 | 1,g);
        }
        else {
            if(cross(tr[u].f,g) <= mid) {Add_Line(u << 1,g);}
            else {Add_Line(u << 1 | 1,tr[u].f);tr[u].f = g;}
        }
    }
}
void Modify(int u,int l,int r,Line g) {
    tr[u].val = min(tr[u].val,min(g.cal(dis[id[l]]),g.cal(dis[id[r]])));
    if(tr[u].L == l && tr[u].R == r) {
        Add_Line(u,g);
        return ;
    }
    int mid = (tr[u].L + tr[u].R) >> 1;
    if(r <= mid) Modify(u << 1,l,r,g);
    else if(l > mid) Modify(u << 1 | 1,l,r,g);
    else {Modify(u << 1,l,mid,g);Modify(u << 1 | 1,mid + 1,r,g);}
}
int64 Query(int u,int l,int r) {
    int64 res = 123456789123456789LL;
    if(tr[u].cover) {
        res = min(res,tr[u].f.cal(dis[id[l]]));
        res = min(res,tr[u].f.cal(dis[id[r]]));
    }
    if(tr[u].L == l && tr[u].R == r) {
        res = min(res,tr[u].val);
        return res;
    }
    int mid = (tr[u].L + tr[u].R) >> 1;
    if(r <= mid) res = min(res,Query(u << 1,l,r));
    else if(l > mid) res = min(res,Query(u << 1 | 1,l,r));
    else {
        res = min(res,Query(u << 1,l,mid));
        res = min(res,Query(u << 1 | 1,mid + 1,r));
    }
    return res;
}
void Modify_Path(int s,int t,int64 A,int64 B) {
    while(top[s] != top[t]) {
        if(dep[top[s]] < dep[top[t]]) swap(s,t);
        Modify(1,dfn[top[s]],dfn[s],Line(A,B));
        s = fa[top[s]];
    }
    if(dep[s] > dep[t]) swap(s,t);
    Modify(1,dfn[s],dfn[t],Line(A,B));
}
int64 Query_Path(int s,int t) {
    int64 res = 123456789123456789LL;
    while(top[s] != top[t]) {
        if(dep[top[s]] < dep[top[t]]) swap(s,t);
        res = min(res,Query(1,dfn[top[s]],dfn[s]));
        s = fa[top[s]];
    }
    if(dep[s] > dep[t]) swap(s,t);
    res = min(res,Query(1,dfn[s],dfn[t]));
    return res;
}
void add(int u,int v,int64 c) {
    E[++sumE].to = v;
    E[sumE].next = head[u];
    E[sumE].val = c;
    head[u] = sumE;
}
void dfs1(int u) {
    dep[u] = dep[fa[u]] + 1;
    siz[u] = 1;
    for(int i = head[u] ; i ; i = E[i].next) {
        int v = E[i].to;
        if(v != fa[u]) {
            fa[v] = u;
            dis[v] = dis[u] + E[i].val;
            dfs1(v);
            siz[u] += siz[v];
            if(siz[v] > siz[son[u]]) son[u] = v;
        }
    }
    return;
}
void dfs2(int u) {
    dfn[u] = ++idx;
    id[idx] = u;
    if(!top[u]) top[u] = u;
    if(son[u]) {
        top[son[u]] = top[u];
        dfs2(son[u]);
    }
    for(int i = head[u] ; i ; i = E[i].next) {
        int v = E[i].to;
        if(v != fa[u] && v != son[u]) dfs2(v);
    }
}
int find_lca(int a,int b) {
    while(top[a] != top[b]) {
        if(dep[top[a]] < dep[top[b]]) swap(a,b);
        a = fa[top[a]];
    }
    return dep[a] < dep[b] ? a : b;
}
void Init() {
    read(N);read(M);
    int u,v;int64 w;
    for(int i = 1 ; i < N ; ++i) {
        read(u);read(v);read(w);
        add(u,v,w);add(v,u,w);
    }
    dfs1(1);dfs2(1);
    build(1,1,N);
}
void Solve() {
    int op,s,t;
    int64 A,B;
    while(M--) {
        read(op);read(s);read(t);
        if(op == 1) {
            read(A);read(B);
            int f = find_lca(s,t);
            Modify_Path(s,f,-A,A * dis[s] + B);
            Modify_Path(f,t,A,A * (dis[s] - 2 * dis[f]) + B);
        }
        else {
            out(Query_Path(s,t));enter;
        }
    }
}
int main() {
#ifdef ivorysi
    freopen("f1.in","r",stdin);
#endif
    Init();
    Solve();
}

昨天真是奇颓无比

三体真好看