BZOJ3073: [Pa2011]Journeys(线段树优化建图 Dijkstra)

题意

\(n\)个点的无向图，构造\(m\)次边，求\(p\)到任意点的最短路。

每次给出\(a, b, c, d\)

对于任意\((x_{a \leqslant x \leqslant b}, y_{c \leqslant y \leqslant d})\)连边

Sol

暴力建图的话边数为\(O(MN^2)\)

考虑一种优化。

\(link(a, b, x)\)表示在\((a, b)\)之间连权值为\(x\)的边

设置虚点\(p_1, p_2\)，

\(link(i_{a \leqslant i \leqslant b}, p_1, 0)\)

\(link(p_1, p_2, 1)\)

\(link(p_2, i_{c \leqslant i \leqslant d}, 0)\)

这样的复杂度变为\(O(nm)\)，还是会TLE。。。

接下来就要用一种非常骚的操作了！——线段树优化建图。

考虑到我们每次需要加边的都是一段区间，我们可以把这段区间用\(log n\)段线段树上的区间表示

具体可以么干：

建两棵线段树。

第一棵线段树的儿子向父亲连边，第二棵线段树的父亲向儿子连边。

第二棵线段的儿子节点向第一棵线段树的儿子节点连边，

每次连边的时候新建两个节点。

从第一棵线段树对应的区间向第一个点连边。

从第一个点向第二个点连边。

从第二个点向第二棵线段树对应的区间连边。

把第一棵线段树对应的节点当做每个点的起点。

跑Dijkstra或01BFS

时间复杂度：\(O((NlogN + 2M) * log(NlogN + 2M))\)

空间复杂度：\(O(n logm)\)

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#define Pair pair<int, int> 
#define MP(x, y) make_pair(x, y)
using namespace std;
const int MAXN = 300010, MAXM = 2500010;
inline int read() {
    char c = getchar(); int x = 0, f = 1;
    while(c < '0' || c > '9') {if(c == '-') f = -1; c = getchar();}
    while(c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
    return x * f;
}
int N, M, P, tot;
struct Edge {
    int u, v, w, nxt;
}E[MAXM << 3];
int head[MAXM], num = 0;
inline void AddEdge(int x, int y, int z) {E[num] = (Edge) {x, y, z, head[x]}; head[x] = num++;}
struct Node {
    int ls, rs, l, r;
}T[MAXM];
int ra, rb, pos[MAXM], vis[MAXM], dis[MAXM];
void Build(int &k, int ll, int rr, int opt) {
    k = ++tot;
    T[k].l = ll; T[k].r = rr; 
    if(ll == rr) {if(opt == 1) pos[ll] = k; return ;}
    int mid = (ll + rr) >> 1;
    Build(T[k].ls, ll, mid, opt); Build(T[k].rs, mid + 1, rr, opt);
    if(opt == 1) AddEdge(T[k].ls, k, 0), AddEdge(T[k].rs, k, 0);
    else AddEdge(k, T[k].ls, 0), AddEdge(k, T[k].rs, 0);
}
void AddLeaf(int k) {
    if(T[k].l == T[k].r) {AddEdge(k, pos[T[k].l], 0); return ;}
    AddLeaf(T[k].ls); AddLeaf(T[k].rs);
}
void TreeAdd(int k, int ll, int rr, int to, int opt) {
    if(ll <= T[k].l && T[k].r <= rr) {opt == 1 ? AddEdge(k, to, 0) : AddEdge(to, k, 0); return ;}
    int mid = (T[k].l + T[k].r) >> 1;
    if(ll <= mid) TreeAdd(T[k].ls, ll, rr, to, opt); 
    if(rr >  mid) TreeAdd(T[k].rs, ll, rr, to, opt);
}
 
void Dijstra() {
    memset(dis, 0x7f, sizeof(dis)); dis[pos[P]] = 0; 
    priority_queue<Pair> q; 
    q.push(MP(0, pos[P]));
    while(!q.empty()) {
        int p = q.top().second; q.pop();
        if(vis[p]) continue; vis[p] = 1;
        for(int i = head[p]; ~i; i = E[i].nxt) {
            int to = E[i].v;
            if(!vis[to] && (dis[to] > dis[p] + E[i].w)) 
                dis[to] = dis[p] + E[i].w, q.push(MP(-dis[to], to));
        }
    }
}
void Add(int a, int b, int c, int d) {
    int p1 = ++tot, p2 = ++tot;
    TreeAdd(ra, a, b, p1, 1); 
    AddEdge(p1, p2, 1);
    TreeAdd(rb, c, d, p2, 0);   
}
int main() {    
    memset(head, -1, sizeof(head));
    N = read(); M = read(); P = read();
    Build(ra, 1, N, 1); Build(rb, 1, N, 0); AddLeaf(rb);
    for(int i = 1; i <= M; i++) {
        int a = read(), b = read(), c = read(), d = read();
        Add(a, b, c, d); Add(c, d, a, b);
    }
    Dijstra();
    for(int i = 1; i <= N; i++) printf("%d\n", dis[pos[i]]);
    return 0;
}
/*
 
*/