codeforces 700C Break Up 暴力枚举边+边双缩点（有重边）

题意：n个点，m条无向边，每个边有权值，给你 s 和 t，问你至多删除两条边，让s，t不连通，问方案的权值和最小为多少，并且输出删的边

分析：n<=1000，m是30000  s,t有4种情况（首先定义完全不相同的路径，即两条路径上没有一条边是一样的）

1. s,t本就不连通，输出0即可

2. s,t连通但是只有一条完全不相同的路径

3. s,t连通但是只有两条条完全不相同的路径

4. s,t连通但是有>=3条完全不相同的路径（这种情况无解）

情况1预处理即可，要解决的问题是2，3，4乍一看，情况很多，其实可以用枚举法

首先找出一条从s到t的路径，发现s到t，如果不连通，必须删除这条路径中一条边

于是可以枚举删除的第一条边，剩下的做边双缩点，这时分开讨论

（1）删边后，s和t在一个双连通分量，此时符合上述情况4，无解

（2）本身就不连通，这时只删除枚举的边就好了

（3）连通的话，找到s连通分量到t连通分量中最小的桥就好了，删除的是枚举的边和最小的桥边

最终把合法的方案取最小即可

#include <cstdio>
#include <vector>
#include <stack>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 1e3+;
const int INF = 1e9+;
typedef long long LL;
int s,t,n,m;
int a[N*],b[N*],c[N*];
vector<int>g[N];
bool ban[*N];
int dfn[N],low[N],clk,bel[N],cnt;
stack<int>st;
void targin(int u,int f){
  dfn[u]=low[u]=++clk;
  bool flag=;st.push(u);
  for(int i=;i<g[u].size();++i){
      if(ban[g[u][i]])continue;
      int v=u==a[g[u][i]]?b[g[u][i]]:a[g[u][i]];
      if(v==f&&!flag){flag=;continue;}
      if(!dfn[v]){
        targin(v,u);
        low[u]=min(low[u],low[v]);
      }
      else low[u]=min(low[u],dfn[v]);
  }
  if(dfn[u]==low[u]){
    ++cnt;int x;
    do{
      x=st.top();
      st.pop();
      bel[x]=cnt;
    }while(x!=u);
  }
}
int path[N*];
int vis[N];
bool find_pre(int u,int d){
  vis[u]=d;
  if(u==t)return true;
  for(int i=;i<g[u].size();++i){
    int v=u==a[g[u][i]]?b[g[u][i]]:a[g[u][i]];
    if(vis[v])continue;
    path[d]=g[u][i];
    if(find_pre(v,d+))return true;
  }
  return false;
}
vector<int>G[N];
int find_brige(int u,int f,int id){
   if(bel[t]==u)return id;
   for(int i=;i<G[u].size();++i){
     int x=bel[a[G[u][i]]],y=bel[b[G[u][i]]];
     int v=u==x?y:x;
     if(v==f)continue;
     int tmp=id;if(c[G[u][i]]<c[id])tmp=G[u][i];
     tmp=find_brige(v,u,tmp);
     if(tmp)return tmp;
   }
   return ;
}
int main(){
    c[]=INF;
    scanf("%d%d%d%d",&n,&m,&s,&t);
    for(int i=;i<=m;++i){
       scanf("%d%d%d",&a[i],&b[i],&c[i]);
       if(a[i]!=b[i])
        g[a[i]].push_back(i),g[b[i]].push_back(i);
    }
    if(!find_pre(s,)){printf("0\n0\n");return ;}
    int ans1=-,id;
    int ans2=-,id1,id2;
    for(int i=;i<vis[t];++i){
      ban[path[i]]=true;
      memset(dfn,,sizeof(dfn));cnt=clk=;
      for(int j=;j<=n;++j)if(!dfn[j])targin(j,);
      if(bel[s]==bel[t]){ban[path[i]]=false;continue;}
      for(int j=;j<N;++j)G[j].clear();
      for(int j=;j<=m;++j){
         if(ban[j]||bel[a[j]]==bel[b[j]])continue;
         G[bel[a[j]]].push_back(j);
         G[bel[b[j]]].push_back(j);
      }
      int cur=find_brige(bel[s],,);
      if(!cur){
        if(ans1==-||ans1>c[path[i]])
          ans1=c[path[i]],id=path[i];
      }
      else{
         if(ans2==-||ans2>c[path[i]]+c[cur]){
           ans2=c[path[i]]+c[cur];
           id1=cur;id2=path[i];
         }
      }
      ban[path[i]]=false;
    }
    if(ans1==-&&ans2==-)printf("-1\n");
    else if(ans1!=-&&ans2==-){
       printf("%d\n1\n%d\n",ans1,id);
    }
    else if(ans1==-&&ans2!=-){
       printf("%d\n2\n%d %d\n",ans2,id1,id2);
    }
    else{
      if(ans1<=ans2)printf("%d\n1\n%d\n",ans1,id);
      else printf("%d\n2\n%d %d\n",ans2,id1,id2);
    }
    return ;
}