HDU 5294 Tricks Device （最短路，最大流）

题意：给一个无向图（连通的），张在第n个点，吴在第1个点，‘吴’只能通过最短路才能到达‘张’，两个问题：（1）张最少毁掉多少条边后，吴不可到达张（2）吴在张毁掉最多多少条边后仍能到达张。

思路：注意是最短路才可达，但是最短路径可能有多条（即权值相等的）！！

　　第二个问题好回答，来次最短路，记录下到达每个点在最低权值的情况下的最少次用边。

　　第一个问题，同样只要砍掉最短路的某些边即可。要根据第2个问题所跑的SSSP，将不是最短路的边的剔除，重新建图，跑最大流，得到结果。

　　当然要考虑重边！

#include <bits/stdc++.h>
#define LL long long
#define pii pair<int,int>
#define INF 0x7f7f7f7f
using namespace std;
const int N=62000;
vector<int> vect[10000], vect2[10000];
int g[2100][2100];
struct node
{
    int from,to,cap,flow;
    node(){};
    node(int from,int to,int cap,int flow):from(from),to(to),cap(cap),flow(flow){};
}edge[N*4];
struct node2//跑最短路用的
{
    int from,to,cost;
    node2(){};
    node2(int from,int to,int cost):from(from),to(to),cost(cost){};
}oldedge[N*2];


int edge_cnt,edge_cnt2, n, m;
void add_node(int from,int to,int cap,int flow)
{
    edge[edge_cnt]=node(from, to, cap, flow);
    vect[from].push_back(edge_cnt++);
}
void add_node2(int from,int to,int cost)//跑最短路用的
{
    oldedge[edge_cnt2]=node2(from, to, cost);
    vect2[from].push_back(edge_cnt2++);
}



int flow[10000], path[10000];
int cost[10000], inq[10000], times[10000];

int BFS(int s,int e)
{
    deque<int> que(1,s);
    flow[s]=INF;
    while(!que.empty())
    {
        int x=que.front();
        que.pop_front();
        for(int i=0; i<vect[x].size(); i++)
        {
            node e=edge[vect[x][i]];
            if(!flow[e.to] && e.cap>e.flow)
            {
                flow[e.to]=min(flow[e.from], e.cap-e.flow);
                path[e.to]=vect[x][i];
                que.push_back(e.to);
            }
        }
        if(flow[e]) return flow[e];
    }
    return flow[e];
}
int max_flow(int s,int e)
{
    int ans_flow=0;
    while(true)
    {
        memset(path,0,sizeof(path));
        memset(flow,0,sizeof(flow));

        int tmp=BFS(s,e);
        if(!tmp)    return ans_flow;
        ans_flow+=tmp;

        int ed=e;
        while(ed!=s)
        {
            int t=path[ed];
            edge[t].flow+=tmp;
            edge[t^1].flow-=tmp;
            ed=edge[t].from;
        }
    }
}

int spfa(int s,int e)
{
    memset(cost,0x7f,sizeof(cost));
    memset(inq,0,sizeof(inq));
    memset(times,0x7f,sizeof(times));//记录到达每个点的最少用边，前提是权最少

    deque<int> que(1,s);
    cost[s]=0;
    times[s]=0;
    while(!que.empty())
    {
        int x=que.front();que.pop_front();
        inq[x]=0;
        for(int i=0; i<vect2[x].size(); i++)
        {
            node2 e=oldedge[vect2[x][i]];
            if(cost[e.to]>=cost[e.from]+e.cost)
            {
                if( cost[e.to]>cost[e.from]+e.cost) times[e.to]=times[e.from]+1;
                else   times[e.to]=min(times[e.to],  times[e.from]+1);

                cost[e.to]=cost[e.from]+e.cost;
                if(!inq[e.to])
                {
                    inq[e.to]=1;
                    que.push_back(e.to);
                }
            }
        }
    }
    return times[e];
}

void build_graph()
{
    for(int i=1; i<=n; i++)
    {
        for(int j=0; j<vect2[i].size(); j++)
        {
            node2 e=oldedge[vect2[i][j]];
            if(cost[e.to]==cost[e.from]+e.cost)
            {
                add_node(e.from,e.to,1,0);
                add_node(e.to,e.from,0,0);
            }
        }
    }
}



int main()
{
    freopen("input.txt", "r", stdin);
    int a, b, c;
    while(~scanf("%d%d", &n, &m))
    {
        edge_cnt=0;
        edge_cnt2=0;
        memset(edge,0,sizeof(edge));
        memset(oldedge,0,sizeof(oldedge));
        for(int i=n; i>=0; i--)   vect[i].clear(),vect2[i].clear();

        for(int i=0; i<m; i++)
        {
            scanf("%d %d %d", &a, &b, &c);
            add_node2(a,b,c);
            add_node2(b,a,c);
        }
        int ans2=spfa(1,n);
        build_graph();//重新建图
        int ans1=max_flow(1,n);
        printf("%d %d
", ans1, m-ans2);
    }
    return 0;
}