hdu 5294 Tricks Device（2015多校第一场第7题）最大流+最短路

 

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=5294

 

 

题意：给你n个墓室，m条路径，一个人在1号墓室（起点），另一个人在n号墓室（终点），起点的那个人只有通过最短路径才能追上终点的那个人，而终点的那个人能切断任意路径。

 

第一问——终点那人要使起点那人不能追上的情况下可以切的最少的路径数，输出最少的路径数

 

第二问——起点那人能追上终点那人的情况下，终点那人能切断的最多的路径数，输出最多的路径数

 

 

 

思路：要使起点那人无法追上，只要使他的最短路径不存在就好了，那么只要在最短路径上使每条路的流量为1，并球出1-n的最大流就是，能切断的最少的路径数；

 

要是起点那人能追上，那么只要他的最短路径存在就可以了，并在这些最短路径中求出路径数最少的那条，那么最多的路径数就是m-路径数最少的那条的路径数。

 

代码：

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <iostream>
#include <queue>
#include <algorithm>
#include <vector>
using namespace std;
#define LL __int64
#define INF 0x3f3f3f3f
const int MAXN=20005;
struct qnode
{
    int v;
    int c;
    qnode(int _v=0,int _c=0):v(_v),c(_c){}
    bool operator <(const qnode &r)const
    {
        return c>r.c;
    }
};
bool vis[2005];
int dist[2005];
int mp[2005][2005];
void Dijkstra(int n,int start)//求最短路径大小
{
    memset(vis,false,sizeof(vis));
    for(int i=1;i<=n;i++)dist[i]=INF;
    priority_queue<qnode>que;
    while(!que.empty())que.pop();
    dist[start]=0;
    que.push(qnode(start,0,0));
    qnode tmp;
    while(!que.empty())
    {
        tmp=que.top();
        que.pop();
        int u=tmp.v;
        if(vis[u])continue;
        vis[u]=true;
        for(int i=1;i<=n;i++)
        {
            if(!vis[i]&&mp[u][i]<INF&&dist[i]>dist[u]+mp[u][i])
            {
                dist[i]=dist[u]+mp[u][i];
                que.push(qnode(i,dist[i]));
            }
        }
    }
}

int mp2[2005][2005];
void Dijkstra1(int n,int start)//求最短的路数
{
    memset(vis,false,sizeof(vis));
    for(int i=1;i<=n;i++)dist[i]=INF;
    priority_queue<qnode>que;
    while(!que.empty())que.pop();
    dist[start]=0;
    que.push(qnode(start,0,0));
    qnode tmp;
    while(!que.empty())
    {
        tmp=que.top();
        que.pop();
        int u=tmp.v;
        int gg=tmp.flag+1;
        if(vis[u])continue;
        vis[u]=true;
        for(int i=1;i<=n;i++)
        {
            if(!vis[i]&&mp2[u][i]<INF&&dist[i]>dist[u]+mp2[u][i])
            {
                dist[i]=dist[u]+mp2[u][i];
                que.push(qnode(i,dist[i]));
            }
        }
    }
}
struct edge
{
    int from,to,cap,flow;
    edge(){}
    edge(int f,int t,int c,int fl):from(f),to(t),cap(c),flow(fl){}
};

struct Dinic
{
    int n,m,s,t;
    vector<edge> edges;
    vector<int> G[MAXN];
    int cur[MAXN];
    int d[MAXN];
    bool vis[MAXN];
    void init(int n,int s,int t)
    {
        this->n=n, this->s=s, this->t=t;
        edges.clear();
        for(int i=0;i<n;i++) G[i].clear();
    }
    void AddEdge(int from,int to,int cap)
    {
        edges.push_back( edge(from,to,cap,0) );
        edges.push_back( edge(to,from,0,0) );
        m = edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }
    bool BFS()
    {
        queue<int> Q;
        Q.push(s);
        memset(vis,0,sizeof(vis));
        d[s]=0;
        vis[s]=true;
        while(!Q.empty())
        {
            int x=Q.front(); Q.pop();
            for(int i=0;i<G[x].size();++i)
            {
                edge& e=edges[G[x][i]];
                if(!vis[e.to] && e.cap>e.flow)
                {
                    d[e.to]=1+d[x];
                    vis[e.to]=true;
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }
    int DFS(int x,int a)
    {
        if(x==t || a==0) return a;
        int flow=0,f;
        for(int& i=cur[x];i<G[x].size();++i)
        {
            edge& e=edges[G[x][i]];
            if(d[e.to]==d[x]+1 && (f=DFS(e.to,min(a,e.cap-e.flow) ) )>0)
            {
                e.flow +=f;
                edges[G[x][i]^1].flow -=f;
                flow +=f;
                a-=f;
                if(a==0) break;
            }
        }
        return flow;
    }
    int max_flow()
    {
        int ans=0;
        while(BFS())
        {
            memset(cur,0,sizeof(cur));
            ans += DFS(s,INF);
        }
        return ans;
    }
}DC;
int ggg[2005][2005];

int main()
{
    int n,m,i,j,a,b,c;
    while(~scanf("%d%d",&n,&m))
    {
        DC.init(n,1,n);
        memset(ggg,0,sizeof(ggg));
        for(i=1;i<=n;i++)
            for(j=1;j<=n;j++)
                mp[i][j]=mp2[i][j]=INF;
        for(i=0;i<m;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            if(mp[a][b]>c)
            {
                mp[a][b]=c;
                mp[b][a]=c;
                ggg[a][b]=1;
                ggg[b][a]=1;
            }
            else if(mp[a][b]==c)
            {
                ggg[a][b]++;
                ggg[b][a]++;
            }
        }
        Dijkstra(n,1);
        for(i=1;i<=n;i++)
        {
            for(j=1;j<=n;j++)
            {
                if(mp[i][j]+dist[i]==dist[j])
                {
                    for(int k=0;k<ggg[i][j];k++)
                        DC.AddEdge(i,j,1);
                    mp2[i][j]=1;
                }
            }
        }
        Dijkstra1(n,1);
        printf("%d %d\n",DC.max_flow(),m-dist[n]);
    }
    return 0;
}