Harry Potter and the Forbidden Forest HDU - 3987

Harry Potter notices some Death Eaters try to slip into Castle. The Death Eaters hide in the most depths of Forbidden Forest. Harry need stop them as soon as.

The Forbidden Forest is mysterious. It consists of N nodes numbered from 0 to N-1. All of Death Eaters stay in the node numbered 0. The position of Castle is node n-1. The nodes connected by some roads. Harry need block some roads by magic and he want to minimize the cost. But it’s not enough, Harry want to know how many roads are blocked at least.

InputInput consists of several test cases.

The first line is number of test case.

Each test case, the first line contains two integers n, m, which means the number of nodes and edges of the graph. Each node is numbered 0 to n-1.

Following m lines contains information about edges. Each line has four integers u, v, c, d. The first two integers mean two endpoints of the edges. The third one is cost of block the edge. The fourth one means directed (d = 0) or undirected (d = 1).

Technical Specification

1. 2 <= n <= 1000
2. 0 <= m <= 100000
3. 0 <= u, v <= n-1
4. 0 < c <= 1000000
5. 0 <= d <= 1
OutputFor each test case:
Output the case number and the answer of how many roads are blocked at least.
Sample Input

3

4 5
0 1 3 0
0 2 1 0
1 2 1 1
1 3 1 1
2 3 3 1

6 7
0 1 1 0
0 2 1 0
0 3 1 0
1 4 1 0
2 4 1 0
3 5 1 0
4 5 2 0

3 6
0 1 1 0
0 1 2 0
1 1 1 1
1 2 1 0
1 2 1 0
2 1 1 1

Sample Output

Case 1: 3
Case 2: 2
Case 3: 2
题解：跑一遍最大流，根据正向边的容量是否为0，来判断哪些边包含在最小割里面。然后令最小割里面的边的容量为1，反向边的容量为0，而其它不属于最小割的边的容量为INF。再跑一遍最大流。

// ConsoleApplication3.cpp: 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<queue>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

const int maxn = 1005;
const int maxm = 400005;        //注意是4倍，因为有双向边存在，否则会TLE！！！！
const int INF = 0x3f3f3f3f;

struct node {
    int to, cap, next;
}e[maxm];

int n, m, kase, tot, src, des;
int head[maxn],dep[maxn];

void Inite() {
    des = n - 1;
    src = tot = 0;
    memset(head, -1, sizeof(head));
}

void addedge(int u, int v, int w) {
    e[tot].to = v, e[tot].cap = w, e[tot].next = head[u], head[u] = tot++;
    e[tot].to = u, e[tot].cap = 0, e[tot].next = head[v], head[v] = tot++;
}

int BFS() {
    memset(dep, -1, sizeof(dep));
    dep[src] = 0;
    queue<int> q;
    q.push(src);
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        for (int i = head[u]; i != -1; i = e[i].next) {
            int v = e[i].to;
            if (e[i].cap > 0 && dep[v] == -1) {
                dep[v] = dep[u] + 1;
                q.push(v);
            }
        }
    }
    return dep[des] != -1;
}

int DFS(int u, int minx) {
    if (u == des) return minx;
    int temp;
    for (int i = head[u]; i != -1; i = e[i].next) {
        int v = e[i].to;
        if (e[i].cap > 0 && dep[v] == dep[u] + 1 && (temp = DFS(v, min(minx, e[i].cap)))) {
            e[i].cap -= temp;
            e[i ^ 1].cap += temp;
            return temp;
        }
    }
    return 0;
}

int Dinic() {
    int ans = 0, temp;
    while (BFS()) {
        while (true) {
            temp = DFS(src, INF);
            if (temp <= 0) break;
            ans += temp;
        }
    }
    return ans;
}

void Solve() {
    int temp=Dinic();
    for (int i = 0; i < tot; i += 2) {
        if (!e[i].cap)
            e[i].cap = 1;
        else
            e[i].cap = INF;
        e[i ^ 1].cap = 0;
    }
    int ans = Dinic();
    printf_s("%d\n", ans);
}

int main()
{
    scanf_s("%d", &kase);
    for (int t = 1; t <= kase; t++) {
        scanf_s("%d%d", &n, &m);
        Inite();
        for (int i = 1; i <= m; i++) {
            int u, v, w, d;
            scanf_s("%d%d%d%d", &u, &v, &w, &d);
            addedge(u, v, w);
            if (d) addedge(v, u, w);
        }
        printf_s("Case %d: ", t);
        Solve();
    }
    return 0;
}