【HDU5889】最短路+网络流

1.​​题目链接​​。题目大意：国王位于点1，敌人位于点n。敌人要进攻，会选择最短路。国王可以在途中设置障碍，但是在设置障碍的时候会根据每条边的花费是不同的，现在国王想花费最少的费用来设置障碍，使得敌人在进攻的路上至少会遇到一个障碍，求出这个最小的费用。

2.这个题，首先我们可以想到的是，n到1的最短路可能存在的不止一条，所以我们找出所有的最短路，然后找到每一条最短路上的最小的费用，加起来就是答案。不过，稍微仔细思考一下就知道这是错的。为啥？因为可能存在几条最短路共用一条边啊，那么这个时候如果这条公共边就是最小的费用，我们只需要切断它就行了。等等，切断，好像发现了什么？这nm不就是个最小割嘛，根据最大流最小割定理，我们只需要把原图的最短路找到，然后用这些最短路建图，在这个新图上跑最大流。问题解决。但是这里扣除最短路成了很棘手的一个问题，但是注意到，我们题中的一个很重要的条件，就是每条边的边权都是一样的，那么我们直接bfs寻找最短路即可。

#include<bits/stdc++.h>
#include<queue>
using namespace std;

struct dinic 
{
  static const int maxn = 1e3 + 5;
  static const int maxm = 2e5;
  static const int inf = 1e9;

  int cnt;
  struct edge 
  {
    int v, nex, c;
  }g[2 * maxm];
  int lv[maxn], current[maxn], head[maxn];
  void add_edge(int u, int v, int c) {
    g[cnt].v = v;
    g[cnt].c = c;
    g[cnt].nex = head[u];
    head[u] = cnt++;

    g[cnt].v = u;
    g[cnt].c = 0;
    g[cnt].nex = head[v];
    head[v] = cnt++;
  }
  void ini() {
    memset(head, -1, sizeof(head));
    cnt = 0;
  }
  void bfs(int s, int*lv) 
  {
    for (int i = 0; i < maxn; i++)
    {
      lv[i] = -1;
    }
    lv[s] = 0;
    queue<int>q;
    q.push(s);
    while (!q.empty()) {
      int u = q.front();
      q.pop();
      for (int i = head[u]; ~i; i = g[i].nex) {
        edge&e = g[i];
        if (e.c <= 0 || lv[e.v] >= 0) {
          continue;
        }
        lv[e.v] = lv[u] + 1;
        q.push(e.v);
      }
    }
  }
  int dfs(int u, int t, int f) {
    if (u == t) {
      return f;
    }
    for (int&i = current[u]; ~i; i = g[i].nex) {
      edge&e = g[i], &rev = g[i ^ 1];
      if (e.c == 0 || lv[u] >= lv[e.v])
        continue;
      int d = dfs(e.v, t, min(f, e.c));
      if (d == 0)continue;
      e.c -= d;
      rev.c += d;
      return d;
    }
    return 0;
  }
  int maxflow(int s, int t) {
    int flow = 0;
    while (true) {
      memmove(current, head, sizeof(head));
      bfs(s, lv);
      if (lv[t] < 0)
        return flow;
      int f;
      while ((f = dfs(s, t, inf))) {
        flow += f;
      }
    }
  }
}g1, g2;


const int maxn = 1e3 + 5;
int ways[maxn];
int wayt[maxn];

int main() {
  int T;;
  scanf("%d", &T);
  while (T--) {
    int n, m;
    scanf("%d%d", &n, &m);

    g1.ini();
    g2.ini();

    for (int i = 0; i < m; i++) {
      int u, v, w;
      scanf("%d %d %d", &u, &v, &w);
      g1.add_edge(u, v, w);
      g1.add_edge(v, u, w);
    }
    g1.bfs(1, ways);
    g1.bfs(n, wayt);

    for (int u = 1; u <= n; u++) {
      for (int i = g1.head[u]; ~i; i = g1.g[i].nex) {
        int v = g1.g[i].v;
        int w = g1.g[i].c;
        if (ways[u] + wayt[u] == ways[n] &&
          ways[v] + wayt[v] == ways[n] &&
          ways[u] + 1 == ways[v]
          )
        {
          g2.add_edge(u, v, w);
        }
      }
    }

    cout << g2.maxflow(1, n) << endl;;
  }
}