Crowd Control

我的图论还是只会套模板 嘤嘤嘤

题目描述

The BAPC draws a large number of visitors to Amsterdam. Many of these people arrive at the train station, then walk from intersection to intersection through the streets of Amsterdam in a big parade until they reach the BAPC location.

A street can only allow a certain number of people per hour to pass through. This is called the capacity of the street. The number of people going through a street must never exceed its capacity, otherwise accidents will happen. People may walk through a street in either direction.

The BAPC organizers want to prepare a single path from train station to BAPC location. They choose the path with maximum capacity, where the capacity of a path is defined to be the minimum capacity of any street on the path. To make sure that nobody walks the wrong way, the organizers close down the streets which are incident

1 to an intersection on the path,but not part of the path.

Can you write a program to help the organizers decide which streets to block? Given a graph of the streets and intersections of Amsterdam, produce the list of streets that need to be closed down in order to create a single maximum-capacity path from the train station to the BAPC. The path must be simple, i.e. it may not visit any intersection more than once.

输入

• The first line contains two integers: n, the number of intersections in the city, and m,the number of streets (1 ≤ n, m ≤ 1000).

• The following m lines each specify a single street. A street is specified by three integers, ai, bi and ci, where ai and bi are ids of the two intersections that are connected by this street (0 ≤ ai, bi < n) and ci is the capacity of this street (1 ≤ ci ≤ 500000). Streets are numbered from 0 to m − 1 in the given order.

You may assume the following:

• All visitors start walking at the train station which is the intersection with id 0. The BAPC is located at the intersection with id n − 1.

• The intersections and streets form a connected graph.

• No two streets connect the same pair of intersections.

• No street leads back to the same intersection on both ends.

• There is a unique simple path of maximum capacity.

输出

Output a single line containing a list of space separated street numbers that need to be blocked in order to create a single maximum-capacity path from train station to BAPC. Sort these street numbers in increasing order.

If no street must be blocked, output the word “none” instead.

样例输入

7 10

0 1 800

1 2 300

2 3 75

3 4 80

4 5 50

4 6 100

6 1 35

0 6 10

0 2 120

0 3 100

样例输出

0 2 4 6 7 8

审题！不要看到流量就差点把网络流模板套上去了！

首先思考怎样才能使流量最大呢？就要让这条路上最小的边最大，然后就想到最大生成树。

审题！为什么1 2不用封，因为他不想让人走岔路，所以正确道路上的所有岔路都要封住，其他不用管。找到正确道路了怎么办？用一个bfs标记每个点的父亲，然后再用dfs从汇点开始向上找源点，于是就找到了这条道路的点。然后再判断边是否与该点相连。

#include<bits/stdc++.h>
typedef long long ll;
using namespace std;
const int maxn=1010;
int N,M;
int fa[maxn];
int dist[maxn][maxn];
struct edge
{
    int u,v,w,id;
    edge(int u=0,int v=0,int w=0):u(u),v(v),w(w){}
}e[maxn];
int getfather(int x)
{
    if(x==fa[x]) return x;
    else return fa[x]=getfather(fa[x]);
}
bool cmp(edge x,edge y)
{
    return x.w>y.w;
}
void kruscal()
{
    sort(e,e+M,cmp);
    int cnt=0;
    for(int i=0;i<N;i++){
        fa[i]=i;
    }
    for(int i=0;i<M;i++){
        int t1=getfather(e[i].u);
        int t2=getfather(e[i].v);
        if(t1!=t2){
            fa[t1]=t2;
            dist[e[i].u][e[i].v]=dist[e[i].v][e[i].u]=e[i].w;
            cnt++;
        }
        if(cnt==N-1) break;
    }
    return ;
}
bool vis[maxn];
int d[maxn];
int ans[maxn][maxn];
bool selct[maxn];
bool del[maxn];
queue<int>q;
void bfs(int u)
{
    q.push(u);
    vis[u]=true;
    while(!q.empty()){
    u=q.front();
    q.pop();
    for(int i=0;i<N;i++){
        if(!vis[i]&&dist[u][i]>0){
            d[i]=u;
            vis[i]=true;
            q.push(i);
        }
    }
    }
}
void dfs(int u){
    int v=d[u];
    del[u]=1;
    if(v==0){
        ans[0][u]=1;
        ans[u][0]=1;
        del[0]=1;
        return;
    }
    else{
        ans[v][u]=1;
        ans[u][v]=1;
        dfs(v);
    }
    return;
}
int main()
{
    int u,v,w;
    //freopen("in.txt","r",stdin);
    scanf("%d%d",&N,&M);
    for(int i=0;i<M;i++){
        scanf("%d%d%d",&u,&v,&w);
        edge k(u,v,w);
        k.id=i;
        e[i]=k;
    }
    kruscal();
    bfs(0);
    dfs(N-1);
    bool flag=0;
    //for(int i=0;i<N;i++) cout<<del[i]<<" ";
    //cout<<endl;
    for(int i=0;i<M;i++){
        if(del[e[i].u]||del[e[i].v])
        if(ans[e[i].u][e[i].v]==0){
            selct[e[i].id]=true;
            flag=1;
        }
    }
    if(flag)
    for(int i=0;i<M;i++){
        if(selct[i]){
            printf("%d ",i);
        }
    }
    else{
        printf("none");
    }
    printf("\n");
    //fclose(stdin);
    return 0;
}