[UOJ 87] #87. mx的仙人掌

#87. mx的仙人掌

UOJ 87

题目大意

给出一个 \(n\) 个点，\(m\) 条边的带边权的仙人掌，定义两点之间距离为最短路长度，\(Q\) 次询问，每次给出 \(cnt\) 个点，问它们之间最远点对的距离。

数据范围

边权不超过 \(2^{31} - 1\)

\(n, \sum cnt \le 300000\)

时空限制

5s， 512MB

分析

此题如果不是仙人掌，那就是每次建出虚树来 DP

仙人掌求最短路也就是建出圆方树后根据 \(lca\) 分类讨论，那么，我们就根据圆方树建一个虚树，如果当前节点是圆点那么就和树的情况 ，如果当前节点为方点那么它的儿子提出来，在环上用单调队列更新答案即可

#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
inline char nc() {
    return getchar();
    static char buf[100000], *l = buf, *r = buf;
    return l==r&&(r=(l=buf)+fread(buf,1,100000,stdin),l==r)?EOF:*l++;
}
template<class T> void read(T & x) {
    x = 0; int f = 1, ch = nc();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=nc();}
    while(ch>='0'&&ch<='9'){x=x*10-'0'+ch;ch=nc();}
    x *= f;
}
typedef long long ll;
const int maxn = 300000 + 5;
const int maxm = maxn * 2;
const int maxe = maxm * 2;
const int maxnode = maxn * 2;
const int maxlog = 20;
const int sigma_cnt = 300000 + 5;
int n, m, Q, cnt, p[sigma_cnt]; ll an;
int sta[sigma_cnt], que[sigma_cnt << 1];
ll f[maxnode];
int head[maxnode], ecnt;
int dfc, dfn[maxnode], low[maxn], anc[maxn]; ll dist[maxn];
int dep[maxnode], parent[maxnode][maxlog]; ll dis[maxnode];
int bcnt; ll sum[maxn];
map<int, int> E[maxn];
vector<int> adj[maxnode];
struct edge {
    int to, nex; ll cost;
    edge(int to=0, int nex=0, ll cost=0) : to(to), nex(nex), cost(cost) {}
} g[maxe];
inline void addedge1(int u, int v, int w) {
    if(E[u].count(v)) E[u][v] = min(E[u][v], w); else E[u][v] = w;
    if(E[v].count(u)) E[v][u] = min(E[v][u], w); else E[v][u] = w;
}
inline void addedge2(int u, int v, ll w) {
    g[ecnt] = edge(v, head[u], w), head[u] = ecnt++;
    g[ecnt] = edge(u, head[v], w), head[v] = ecnt++;
}
inline void addedge3(int u, int v) {
    adj[u].push_back(v);
}
void tarjan(int u) {
    low[u] = dfn[u] = ++dfc;
    for(map<int, int> :: iterator it = E[u].begin(); it != E[u].end(); ++it) {
        int v = it->first;
        if(!dfn[v]) {   
            dist[v] = dist[u] + it->second;
            anc[v] = u; tarjan(v);
            low[u] = min(low[u], low[v]);
            if(low[v] > dfn[u]) {
                addedge2(u, v, it->second);
            }
        }
        else if(anc[u] != v) {
            low[u] = min(low[u], dfn[v]);
        } 
    }
    for(map<int, int> :: iterator it = E[u].begin(); it != E[u].end(); ++it) {
        int v = it->first;
        if(anc[v] != u && dfn[v] >= dfn[u]) {
            int now = ++bcnt; sum[now] = dist[v] - dist[u] + it->second;
            for(int x = v; ; x = anc[x]) {
                ll t = dist[x] - dist[u]; addedge2(now + n, x, min(t, sum[now] - t));
                if(x == u) break;
            }
        }
    }
}
void dfs(int u) {
    dfn[u] = ++dfc;
    for(int i = 1; i < maxlog; ++i) {
        parent[u][i] = parent[ parent[u][i - 1] ][i - 1];
    }
    for(int i = head[u]; ~ i; i = g[i].nex) {
        int v = g[i].to; if(v == parent[u][0]) continue;
        dep[v] = dep[u] + 1, dis[v] = dis[u] + g[i].cost;
        parent[v][0] = u; dfs(v);
    }
}
void jump(int & u, int k) {
    for(int i = maxlog - 1; ~ i; --i) {
        if(k >= (1 << i)) {
            k -= 1 << i;
            u = parent[u][i];
        }
    }
}
int lca(int u, int v) {
    if(dep[u] > dep[v]) swap(u, v);
    jump(v, dep[v] - dep[u]);
    if(u == v) return u;
    for(int i = maxlog - 1; ~ i; --i) {
        if(parent[u][i] != parent[v][i]) {
            u = parent[u][i];
            v = parent[v][i];
        }
    }
    return parent[u][0];
}
void update(int u, int n) {
    static ll f[sigma_cnt << 1], g[sigma_cnt << 1];
    for(int i = 1; i <= n; ++i) {
        f[i] = dist[ sta[i] ], f[n + i] = f[i] + sum[u - ::n];
        g[i] = ::f[ sta[i] ], g[n + i] = g[i];
    }
    n <<= 1; int l = 0, r = -1;
    for(int i = 1; i <= n; ++i) {
        while(l <= r && (f[i] - f[ que[l] ]) * 2 > sum[u - ::n]) l++;
        if(l <= r) an = max(an, g[ que[l] ] - f[ que[l] ] + g[i] + f[i]);
        while(l <= r && g[ que[r] ] - f[ que[r] ] <=  g[i] - f[i]) r--;
        que[++r] = i;
    }
}
void dp(int u) {
    f[u] = 0; int top = 0;
    for(unsigned int i = 0; i < adj[u].size(); ++i) {
        int v = adj[u][i]; dp(v);
    }
    for(unsigned int i = 0; i < adj[u].size(); ++i) {
        int v = adj[u][i];
        if(u <= n) an = max(an, f[u] + f[v] + dis[v] - dis[u]);
        else {
            int s = v; jump(s, dep[v] - dep[u] - 1);
            f[s] = f[v] + dis[v] - dis[s]; sta[++top] = s;
        }
        f[u] = max(f[u], f[v] + dis[v] - dis[u]);

    }
    if(u > n) update(u, top);
    adj[u].clear();
}
int cmp(const int & a, const int & b) {
    return dfn[a] < dfn[b];
}
void solve() {
    read(cnt);
    for(int i = 1; i <= cnt; ++i) read(p[i]);
    sort(p + 1, p + cnt + 1, cmp), cnt = unique(p + 1, p + cnt + 1) - p - 1;
    int top = 0; sta[++top] = p[1];
    for(int i = 2; i <= cnt; ++i) {
        int w = lca(sta[top], p[i]);
        while(top > 1 && dep[ sta[top - 1] ] > dep[w]) {
            addedge3(sta[top - 1], sta[top]); top--;
        }
        if(dep[sta[top]] > dep[w]) addedge3(w, sta[top--]);
        if(w != sta[top]) sta[++top] = w;
        sta[++top] = p[i];
    }
    while(top > 1) {
        addedge3(sta[top - 1], sta[top]); top--;
    }
    an = 0; dp(sta[top]); printf("%lld\n", an);
}
int main() {
    read(n), read(m);
    for(int i = 1; i <= m; ++i) {
        int u, v, w;
        read(u), read(v), read(w);
        addedge1(u, v, w);
    }
    memset(head, -1, sizeof(head)); tarjan(1);
    for(int i = 1; i <= n; ++i) E[i].clear(); 
    dfc = 0; dfs(1);
    read(Q);
    for(int i = 1; i <= Q; ++i) solve();
    return 0;
}