2018 UESTC Training for Graph Theory

E - 北极的猴子

给出n个点，m条边的带权无向图，问从点s到点t，删除至多两条边，是否能够使得点s到点t不连通，即无法双向来回，求最小花费。cf原题 先用dfs找到从s到t的任意一条路径，因为要删的1条或两条边，一定在这条路径上，否则一定会连通的，然后枚举这条路径上的每一条边，即这是要删除的第一条边，跑一次tarjan找到在删除这一条边的情况下的所有的桥(删掉桥是能将图分成两个或多个子图)，然后在判断一次连通（这里用另一个数组去存放第二次跑的任意一条从s到t的路径，而且是在删除第一条边的情况下），如果已经不连通了，就可以直接取值了，如果还是连通，那么就要在删除这一条边的情况下，判断上面所说的另一个数组中的所有路径是否存在桥，如果存在，那么第一条删的边+这个桥就是一个可行解，遍历所有桥，就可以得出答案了。这里要注意，在tarjan里面找桥的算法要判重边，下面代码是将无向边拆分成两个有向边，所以你从u->v,pre=u,然后一定会有一条边是可以从v->u的，所以这就是原来的边，flag的作用就是排除自身的有向边，找出其它的重边。

找桥的条件  Low[v]>DFN[u]  下面是bi哥的cf代码...读了好久才懂

#include<bits/stdc++.h>
using namespace std;
const int MAXN=1005;
const int MAXM=30005*2;
struct Edge
{
    int to,next,va,f;
}edge[MAXM];
int head[MAXN],tot=0;
int Low[MAXN],DFN[MAXN],vis[MAXN]={0},bridge[MAXM]={0};
int Index=0,n,m,s,t,a,b,c;
void addedge(int u,int v,int c)
{
    edge[tot].to=v;edge[tot].next=head[u];edge[tot].va=c;
    edge[tot].f=u;
    head[u]=tot++;
}
bool dfs(int u,int fa,int del,vector<int> &path)
{
	vis[u]=1;
	if(u==t)
	{
		return true;
	}
	for(int i=head[u];~i;i=edge[i].next)
	{
		int v=edge[i].to;
		if(v==fa||(i>>1)==del)
		{
			continue;
		}
		if(!vis[v]&&dfs(v,u,del,path))
		{
			path.push_back(i>>1);
			return true;
		}
	}
	return false;
}
void Tarjan(int u,int fa,int del){
    DFN[u]=Low[u]=++Index;
    int flag=0;
    for(int i=head[u];i!=-1;i=edge[i].next){
        int v=edge[i].to;
        if((i>>1)==del) continue;
        if(v==fa&&!flag){
            flag=1;
            continue;
        }
        if(!DFN[v]){
            Tarjan(v,u,del);
            if(Low[u]>Low[v])Low[u]=Low[v];
            if(Low[v]>DFN[u]) bridge[i>>1]=1;
        }
        else Low[u]=min(DFN[v],Low[u]);
    }
}
void init()
{
	memset(DFN,0,sizeof(DFN));
	memset(vis,0,sizeof(vis));
	memset(bridge,0,sizeof(bridge));
	Index=0;
}
int main()
{
	memset(head,-1,sizeof(head));
	memset(vis,0,sizeof(vis));
	scanf("%d%d",&n,&m);
	scanf("%d%d",&s,&t);
	for(int i=0;i<m;i++)
	{
		scanf("%d%d%d",&a,&b,&c);
		addedge(a,b,c);
		addedge(b,a,c);
	}
	vector<int> path;
	if(!dfs(s,-1,-1,path))
	{
		printf("0\n0\n");
	}
	else
	{
		int ans=2e9+5;
		vector<int> ret;
		for(int i=0;i<path.size();i++)
		{
			init();
			for(int j=1;j<=n;j++)
			{
				if(!DFN[j])
				{
					Tarjan(j,-1,path[i]);
				}
			}
			vector<int> tmp;
			if(!dfs(s,-1,path[i],tmp))
			{
				if(ans>edge[path[i]*2].va)
				{
					ans=edge[path[i]*2].va;
					ret.clear();
					ret.push_back(path[i]+1);
				}
			}
			else
			{
				for(int j=0;j<tmp.size();j++)
				{
					if(bridge[tmp[j]])
					{
                        if(ans>edge[path[i]*2].va+edge[tmp[j]*2].va)
						{
                            ans=edge[path[i]*2].va+edge[tmp[j]*2].va;
                            ret.clear();
                            ret.push_back(path[i]+1);
                            ret.push_back(tmp[j]+1);
                		}
					}
				}
			}
		}
		if(ans>2e9) cout<<-1<<endl;
		else
		{
			cout<<ans<<endl<<ret.size()<<endl;
			for(int i=0;i<ret.size();i++)
			{
				printf("%d",ret[i]);
				if(i==ret.size()-1)
					cout<<endl;
				else
					cout<<" ";
			}
		}
	}
}