传送门

【题目分析】

树剖好题。

首先按题意做出最小生成树，如果做不出，那么所有询问都是"Not connected"。

同样，如果删的是非生成树上的边，对答案不会造成影响，直接输出最小生成树的权值即可。

那么考虑生成树上的边被删的情况：

很明显，对于一个环上的所有边，如果删掉一条，剩下的点仍然会保持联通。

所以这个环上的所有边都是可以互相替代的。

按照这个思路，我们将所有非生成树上的边在树剖的线段树上打上标记，表示如果dfn[x]~dfn[y]间有边被拆掉就可以用权值为x的边进行替换，query的时候如果结果为INF，那么删了之后两个联通块是不连通的，输出"Not connected"即可。

注意最后query的时候其实只用做一次，分这条边是轻边还是重边，重边直接返回即可，轻边只能返回深度较深的那条链的结果。

细节稍多，但好调。

【代码~】

#include<bits/stdc++.h>
using namespace std;
const int MAXN=1e5+10;
const int MAXM=2e5+10;
const int INF=0x3f3f3f3f;

int n,m,cnt,q;
int flag=1;
int ori,on[MAXN],on1[MAXN];
int fat[MAXN];
int head[MAXN],depth[MAXN],fa[MAXN],son[MAXN],siz[MAXN],top[MAXN];
int nxt[MAXM],to[MAXM],w[MAXM];
int dfn[MAXN],ys[MAXN],tot;
struct Edge{
	int from,to,w;
	int id;
	friend inline bool operator<(const Edge &a,const Edge &b){
		return a.w<b.w;
	}
}edge[MAXM],cedge[MAXM];
struct Tree{
	int l,r;
	int minn;
	int tag;
}tr[MAXN<<2];

int Read(){
	int i=0,f=1;
	char c;
	for(c=getchar();(c>'9'||c<'0')&&c!='-';c=getchar());
	if(c=='-')
	  f=-1,c=getchar();
	for(;c>='0'&&c<='9';c=getchar())
	  i=(i<<3)+(i<<1)+c-'0';
	return i*f;
}

void add(int x,int y,int z){
	nxt[cnt]=head[x];
	head[x]=cnt;
	to[cnt]=y;
	w[cnt]=z;
	cnt++;
}

int find(int x){
	if(x==fat[x])
	  return x;
	return fat[x]=find(fat[x]);
}

void kruskal(){
	for(int i=1;i<=n;++i)
	  fat[i]=i;
	sort(edge+1,edge+m+1);
	int sum=0;
	for(int i=1;i<=m;++i){
		int u=edge[i].from,v=edge[i].to;
		int fu=find(u),fv=find(v);
		if(fu!=fv){
			add(u,v,edge[i].w);
			add(v,u,edge[i].w);
			on[i]=1;
			on1[edge[i].id]=1;
			fat[fv]=fu;
			ori+=edge[i].w;
			sum++;
			if(sum==n-1)
			  return ;
		}
	}
	if(sum<n-1)
	  flag=0;
}

void dfs1(int u,int f){
	siz[u]=1;
	for(int i=head[u];i!=-1;i=nxt[i]){
		int v=to[i];
		if(v==f)
		  continue;
		depth[v]=depth[u]+1;
		fa[v]=u;
		dfs1(v,u);
		siz[u]+=siz[v];
		if(siz[v]>siz[son[u]])
		  son[u]=v;
	}
}

void dfs2(int u,int tp){
	top[u]=tp;
	dfn[u]=++tot;
	ys[tot]=u;
	if(!son[u])
	  return ;
	dfs2(son[u],tp);
	for(int i=head[u];i!=-1;i=nxt[i]){
		int v=to[i];
		if(v==fa[u]||v==son[u])
		  continue;
		dfs2(v,v);
	}
}

void push_now(int root,int key){
	tr[root].minn=min(tr[root].minn,key);
	tr[root].tag=min(tr[root].tag,key);
}

void push_down(int root){
	if(tr[root].tag!=INF){
		push_now(root<<1,tr[root].tag);
		push_now(root<<1|1,tr[root].tag);
		tr[root].tag=INF;
	}
}

void build(int root,int l,int r){
	tr[root].l=l,tr[root].r=r;
	tr[root].minn=tr[root].tag=INF;
	if(l==r)
	  return ;
	int mid=l+r>>1;
	build(root<<1,l,mid);
	build(root<<1|1,mid+1,r);
}

void update(int root,int l,int r,int L,int R,int key){
	if(l>R||r<L)
	  return ;
	if(L<=l&&r<=R){
		push_now(root,key);
		return ;
	}
	push_down(root);
	int mid=l+r>>1;
	if(R<=mid)
	  update(root<<1,l,mid,L,R,key);
	else{
		if(L>mid)
		  update(root<<1|1,mid+1,r,L,R,key);
		else
		  update(root<<1,l,mid,L,mid,key),update(root<<1|1,mid+1,r,mid+1,R,key);
	}
}

int query(int root,int l,int r,int L,int R){
	if(l>R||r<L)
	  return INF;
	if(L<=l&&r<=R)
	  return tr[root].minn;
	push_down(root);
	int mid=l+r>>1;
	if(R<=mid)
	  return query(root<<1,l,mid,L,R);
	else{
		if(L>mid)
		  return query(root<<1|1,mid+1,r,L,R);
		else
		  return min(query(root<<1,l,mid,L,mid),query(root<<1|1,mid+1,r,mid+1,R));
	}
}

void updatepath(int x,int y,int key){
	while(top[x]!=top[y]){
		if(depth[top[x]]<depth[top[y]])
		  swap(x,y);
		update(1,1,n,dfn[top[x]],dfn[x],key);
		x=fa[top[x]];
	}
	if(depth[x]<depth[y])
	  swap(x,y);
	update(1,1,n,dfn[y]+1,dfn[x],key);
}

int querypath(int x,int y){
	int tx=top[x],ty=top[y];
	if(tx!=ty){
		if(depth[tx]<depth[ty])
		  swap(x,y),swap(tx,ty);
		return query(1,1,n,dfn[tx],dfn[x]);
	}
	else{
		if(depth[x]<depth[y])
		  swap(x,y);
		return query(1,1,n,dfn[y]+1,dfn[x]);
	}
}

int main(){
	memset(head,-1,sizeof(head));
	n=Read(),m=Read();
	for(int i=1;i<=m;++i){
		edge[i].from=Read();
		edge[i].to=Read();
		edge[i].w=Read();
		edge[i].id=i;
		cedge[i]=edge[i];
	}
	kruskal();
	if(!flag){
		q=Read();
		while(q--){
			int x=Read();
			puts("Not connected");
		}
		return 0;
	}
	q=Read();
	dfs1(1,-1),dfs2(1,1);
	build(1,1,n);
	for(int i=1;i<=m;++i){
		if(!on[i])
		  updatepath(edge[i].from,edge[i].to,edge[i].w);
	}
	while(q--){
		int x=Read();
		if(!on1[x]){
			cout<<ori<<'\n';
			continue;
		}
		int ans=querypath(cedge[x].from,cedge[x].to);
		if(ans==INF)
		  puts("Not connected");
		else
		  cout<<ori-cedge[x].w+ans<<'\n';
	}
}