BZOJ 3073 [Pa2011]Journeys 最短路 线段树优化建图

题目大意：给出n个点，1~n编号，给出m个建边操作，以如下方式建边：(a,b),(c,d)表示，对于任意两个点x,y，如果a<=x<=b,c<=y<=d，那么在xy之间连边。给定源点求单源最短路
n<=500000,m<=100000

边1表示权值为1的边，边0表示权值为0的边

最暴力的建图需要$n^2m$条边……

想一会以后，可以用两个辅助点来表示一次建边操作，两个辅助点分别表示(a,b)->(c,d)/(c,d)->(a,b)。对于(a,b)->(c,d)来说，(a,b)内的点向辅助点连边1，辅助点向(c,d)内的点连边0。
可是这样做仍然需要$nm$条边。

区间加边想到线段树优化建图
线段树的每个节点代表一个区间，一棵线段树表示不了进出关系，所以建两棵线段树。
出线段树每个点向父节点连边0，表示如果能从这个区间出发也就可以从父区间出发。
入线段树每个点向子节点连边0，表示如果能到达这个区间也就可以到达子区间。
入线段树每个点向出线段树的平行结点连边0，表示如果能到达这个区间也可以从这个区间出发。
然后每个操作在线段树上连一连就好了..

最后答案即为出线段树的每个叶子的最短路

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#define N 5000000
using namespace std;
struct Edge {
    int to,nxt,val;
    Edge() {}
    Edge(int _to,int _nxt,int _val):
        to(_to),nxt(_nxt),val(_val) {}
}e[N*6];
int n,m,p,cnt,tot=-1,d[N],fir[N],pos[N];
bool k[N];
void Add_Edge(int from,int to,int val) {
    e[++tot]=Edge(to,fir[from],val), fir[from]=tot;
    return ;
}
struct Data {
    int ord,val;
    Data(int _ord,int _val):
        ord(_ord),val(_val) {}
    bool operator < (const Data& rhs) const { return val>rhs.val; }
};
void Dijkstra(int st) {
    priority_queue<Data> q;
    memset(d,0x7f,sizeof d);
    d[st]=0, q.push(Data(st,0));
    while(!q.empty()) {
        Data tmp=q.top(); q.pop();
        int x=tmp.ord;
        if(k[x]) continue;
        k[x]=true;
        for(int i=fir[x];~i;i=e[i].nxt)
            if(d[e[i].to]>d[x]+e[i].val)
                d[e[i].to]=d[x]+e[i].val, q.push(Data(e[i].to,d[e[i].to]));
    }
    return ;
}
struct Node {
    Node* ch[2];
    int l,r,num;
    Node() {}
    Node(int _l,int _r):l(_l),r(_r),num(cnt) {
        ch[0]=ch[1]=NULL;
    }
    void* operator new(size_t) {
        static Node *mempool,*C;
        if(mempool==C) mempool=(C=new Node[1<<20])+(1<<20);
        ++cnt;
        return C++;
    }
}*root;
void init(Node*& o,int l,int r) {
    o=new Node(l,r);
    if(l==r) {
        pos[l]=cnt;
        return ;
    }
    int mid=l+r>>1;
    init(o->ch[0],l,mid), init(o->ch[1],mid+1,r);
    return ;
}
void build(Node* o) {
    Add_Edge(o->num+cnt,o->num,0);
    if(o->l==o->r) return ;
    for(int i=0;i<2;++i) {
        Add_Edge(o->ch[i]->num,o->num,0);
        Add_Edge(o->num+cnt,o->ch[i]->num+cnt,0);
        build(o->ch[i]);
    }
    return ;
}
void Link(Node* o,int l,int r,int ord,int mode) {
    if(o->l==l && o->r==r) {
        if(!mode) Add_Edge(o->num,ord,1);
        else Add_Edge(ord,o->num+cnt,0);
        return ;
    }
    int mid=o->l+o->r>>1;
    if(r<=mid) Link(o->ch[0],l,r,ord,mode);
    else if(l>mid) Link(o->ch[1],l,r,ord,mode);
    else Link(o->ch[0],l,mid,ord,mode), Link(o->ch[1],mid+1,r,ord,mode);
    return ;
}
int main() {
    memset(fir,-1,sizeof fir);
    scanf("%d%d%d",&n,&m,&p);
    init(root,1,n);
    build(root);
    for(int i=1,x,y;i<=m;++i)
        for(int j=0;j<2;++j)
            scanf("%d%d",&x,&y), Link(root,x,y,i+cnt*2,j), Link(root,x,y,i+cnt*2+m,j^1);
    Dijkstra(pos[p]);
    for(int i=1;i<=n;++i) printf("%d\n",d[pos[i]]);
    return 0;
}