[SDOI2017]天才黑客 (虚树+最短路)

可以看到与\(trie\)树上的字母以及\(lcp\)并没有关系。。

以边作为点，可以写出一个非常简单的最短路\(dis_i=min \lbrace dis_j+dep_{LCA(d_i,d_j)}+c_i|v_j=u_i\rbrace\)，还可以建立\(u_0=v_0=1,d_0=1,c_0=0\)作为原点

但是恶意卡的话有\(m^2\)条边...

所以要考虑优化连边

对于每个点\(x\)，把所有\(u_i=x\)或\(v_i=x\)的\(d_i\)提出来，建出一棵虚树，然后我们在虚树上连边

对于虚树上的点，我们建立正点和反点，正点向虚树上的父亲连边，反点向儿子连边，边权均为\(0\)

所有\(v_i=x\)的边向虚树上\(d_i\)的正点连一条为\(0\)的边

所有\(u_i=x\)的边，虚树上\(d_i\)的反点连过来一条为\(c_i\)的边

考虑\(LCA\)的三种情况，在走到\(LCA\)时将\(dep_{LCA(d_i,d_j)}\)考虑进来

1.对于\(LCA(d_i,d_j)=d_i\)的情况，直接让\(i\)向\(d_i\)的反点连一条权为\(dep_{d_i}\)的边，在反点间转移即可

2.对于\(LCA(d_i,d_j)=d_j\)的情况，同理的，让\(d_j\)的正点向\(j\)连一条权为\(dep_{d_j}\)的边即可

3.最后一种情况比较复杂，因为我们要从\(LCA\)走过去，考虑枚举\(LCA\)，让转移直接跳过\(LCA\)，在\(LCA\)的儿子之间转移。这样能够保证转移无误，但是如果直接连边依然会被菊花图卡到\(n^2\)，如果我们建立一个虚点连边的话，会存在自己向自己转移的非法情况。所以我们考虑前缀后缀连边，把所有儿子打成一个序列\(son_i\)，然后建立两个虚点列\(a_i,b_i\)，然后让\(a_i\rightarrow a_{i-1},b_i \rightarrow b_{i+1}\)，\(son_i \rightarrow a_{i-1},son_i \rightarrow b_{i+1}\)，把其中\(son_i\)出发的边边权设为\(dep_{LCA}\)即可

注意类似的连边方式都要避免产生负边，否则不能使用\(Dijkstra\)，会因为\(SPFA\)而被卡掉..

#include<bits/stdc++.h>
using namespace std;

#define pb push_back
#define reg register
typedef long long ll;
#define rep(i,a,b) for(reg int i=a,i##end=b;i<=i##end;++i)
#define drep(i,a,b) for(reg int i=a,i##end=b;i>=i##end;--i)
char IO;
int rd(){
    int s=0;
    while(!isdigit(IO=getchar()));
    do s=(s<<1)+(s<<3)+(IO^'0');
    while(isdigit(IO=getchar()));
    return s;
}

const int N=1e6+10,M=N/20+4;
const ll INF=1e18;

bool be;
int n,m,k;
struct Edge{
    int from,to,pos,w,id;
}e[M];
vector <Edge> S[M],T[M];
void AddEdge(int u,int v,int c,int d,int id) {
    S[u].pb(e[id]=(Edge){u,v,d,c,id});
    T[v].pb(e[id]);
}

int fa[M],dep[M],sz[M],top[M],son[M],L[M],R[M],dfn;
vector <int> G[M];
typedef pair<int,int> Pii;
vector <Pii> E[N];

void dfs(int u,int f) {
    fa[u]=f,L[u]=++dfn,sz[u]=1,son[u]=0;
    for(int v:G[u]) {
        dep[v]=dep[u]+1;
        dfs(v,u);
        sz[u]+=sz[v];
        if(sz[son[u]]<sz[v]) son[u]=v;
    }
    R[u]=dfn;
}
void dfs2(int u,int t) {
    top[u]=t;
    if(son[u]) dfs2(son[u],t);
    for(int v:G[u]) if(v!=son[u]) dfs2(v,v);
}
int LCA(int x,int y) {
    while(top[x]!=top[y]) {
        if(dep[top[x]]<dep[top[y]]) y=fa[top[y]];
        else x=fa[top[x]];
    }
    return dep[x]<dep[y]?x:y;
}

int line[M],le[M],lc,cnt;

int id[M],to[N],stk[M],Top;
void Insert(int x){
    int lca=LCA(stk[Top],x);
    if(stk[Top]==lca) {
        stk[++Top]=x,id[x]=++cnt;to[cnt]=x;
        cnt++;to[cnt]=x;
        return;
    }
    while(Top>1 && dep[stk[Top-1]]>=dep[lca]) {
        E[id[stk[Top]]].pb((Pii){id[stk[Top-1]],0});
        E[id[stk[Top-1]]+1].pb((Pii){id[stk[Top]]+1,0});
        Top--;
    }
    if(stk[Top]==lca) {
        stk[++Top]=x,id[x]=++cnt;to[cnt]=to[cnt+1]=x;
        cnt++;
        return;
    }
    if(dep[stk[Top]]>dep[lca]) {
        id[lca]=++cnt;to[cnt]=to[cnt+1]=lca;
        cnt++;

        E[id[stk[Top]]].pb((Pii){id[lca],0});
        E[id[lca]+1].pb((Pii){id[stk[Top]]+1,0});
        Top--;
        stk[++Top]=lca;
        stk[++Top]=x;
        id[x]=++cnt;to[cnt]=to[cnt+1]=x;
        cnt++;
    }
}


void PreMake() {
    rep(u,1,n) {
        if(!T[u].size() || !S[u].size()) continue;
        lc=0;
        rep(i,0,T[u].size()-1) line[++lc]=T[u][i].pos;
        rep(i,0,S[u].size()-1) line[++lc]=S[u][i].pos;
        sort(line+1,line+lc+1,[&](int x,int y){return L[x]<L[y];});
        lc=unique(line+1,line+lc+1)-line-1;
        int tcnt=cnt;
        stk[Top=1]=1,id[1]=++cnt;to[cnt]=to[cnt+1]=1;
        cnt++;
        rep(i,1,lc) if(line[i]!=1) Insert(line[i]); //建立虚树
        while(Top>1) {
            E[id[stk[Top]]].pb((Pii){id[stk[Top-1]],0});
            E[id[stk[Top-1]]+1].pb((Pii){id[stk[Top]]+1,0});
            Top--;
        }
        rep(i,0,T[u].size()-1) {
            E[T[u][i].id].pb((Pii){id[T[u][i].pos],0}); // 向正点连边
            E[T[u][i].id].pb((Pii){id[T[u][i].pos]+1,dep[T[u][i].pos]}); //直接向反点连边，考虑dep
        }
        rep(i,0,S[u].size()-1) {
            E[id[S[u][i].pos]+1].pb((Pii){S[u][i].id,S[u][i].w}); //反点连过来
            E[id[S[u][i].pos]].pb((Pii){S[u][i].id,dep[S[u][i].pos]+S[u][i].w});//直接从正点连过来
        }
        rep(i,tcnt+1,cnt) if(~(i-tcnt)&1) {
            lc=0;
            rep(j,0,E[i].size()-1)
                if(E[i][j].first>tcnt && E[i][j].first<=iend)
                    line[++lc]=E[i][j].first; //提出儿子的序列
            if(lc<=1) continue;
            int lst=-1;
            rep(j,1,lc) {
                cnt++;
                E[cnt].pb((Pii){line[j],0});
                if(~lst) {
                    E[line[j]-1].pb((Pii){lst,dep[to[i]]});
                    E[cnt].pb((Pii){lst,0});
                }
                lst=cnt;//连接ai
            }
            lst=-1;
            drep(j,lc,1) {
                cnt++;
                E[cnt].pb((Pii){line[j],0});
                if(~lst) {
                    E[line[j]-1].pb((Pii){lst,dep[to[i]]});
                    E[cnt].pb((Pii){lst,0});
                }
                lst=cnt; //连接bi
            }
        }
    }
}

struct Node{
    int x;
    ll d;
    bool operator < (const Node __) const{
        return d>__.d;
    }
};
priority_queue <Node> que;
ll dp[N],Ans[M];
void Dijkstra(int st) {
    rep(i,0,cnt) dp[i]=INF;
    rep(i,1,n) Ans[i]=INF;
    dp[0]=0;
    que.push((Node){st,0});
    while(!que.empty()) {
        int u=que.top().x;
        ll d=que.top().d;que.pop();
        if(dp[u]<d) continue;
        rep(i,0,E[u].size()-1) {
            int v=E[u][i].first,w=E[u][i].second;
            if(dp[v]>dp[u]+w) dp[v]=dp[u]+w,que.push((Node){v,dp[v]});
        }
    }
    rep(i,1,m) Ans[e[i].to]=min(Ans[e[i].to],dp[i]);
}

bool ed;
int main(){
    rep(kase,1,rd()) {
        n=rd(),m=rd(),k=rd();
        AddEdge(1,1,0,1,0);
        rep(i,1,m) {
            int u=rd(),v=rd(),c=rd(),d=rd();
            AddEdge(u,v,c,d,i);
        }
        rep(i,2,k) {
            int u=rd(),v=rd(); rd();
            G[u].pb(v);
        }
        dfn=0,dfs(1,0),dfs2(1,1);
        cnt=m;
        PreMake();
        Dijkstra(0);
        fprintf(stderr,"%d\n",cnt);
        rep(i,2,n) printf("%lld\n",Ans[i]);
        rep(i,0,cnt) E[i].clear();
        rep(i,0,n) S[i].clear(),T[i].clear();
        rep(i,0,k) G[i].clear();
    }
}