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

[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();
	}
}