HDU-4289-контроль (максимальный поток, точка разделения)

Ссылка:

https://vjudge.net/problem/HDU-4289

Значение вопросов:

Вы, руководитель Департамента по вопросам безопасности, недавно получил сверхсекретную информацию о том , что группа террористов планируют перевезти какой - либо ОМП 1 из одного города (источник) на другой (адресат). Вы знаете , их дата, источник и место назначения, и они используют сеть шоссе.
　　Сеть шоссе состоит из двунаправленных магистралей, соединяющая два различных города. Транспортное средство может только вход / выход из сети шоссейных дорог в городах только.
　　Вы можете найти некоторые SA (специальные агенты) в некоторых отдельных городах, так что , когда террористы войти в город под наблюдением (то есть, SA находится в этом городе), они будут пойманы сразу.
　　Можно найти SA во всех городах, но так как контроль города с SA может стоить вашего отдела определенной суммы денег, которая может варьироваться от города к городу, и ваш бюджет не может быть в состоянии нести полную стоимость контроля всех города, вы должны определить набор городов, что:
　　* весь трафик из террористов должен пройти , по крайней мере один город множество.
　　* Сумма стоимости контроля всех городов в наборе минимальна.
　　Можно считать , что всегда можно получить от источника террористов к месту назначения.
-------------------------------------------------- ----------
1 оружие массового поражения

Идеи:

Искомый минимум оригинального названия CutPoint Пусть S и Т теперь может быть разделен на две точки каждое, одно входного отверстия выходного отверстия, подключены к стороне, даже неориентированное ребро между любыми двумя точками.
Стал в минимальный разрез, в соответствии с максимальным потоком, максимальный поток может работать.

Код:

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
//#include <memory.h>
#include <queue>
#include <set>
#include <map>
#include <algorithm>
#include <math.h>
#include <stack>
#include <string>
#define MINF 0x3f3f3f3f
using namespace std;
typedef long long LL;

const int MAXN = 200+10;
const int INF = 1e9;

struct Edge
{
    int from, to, cap;
};
vector<Edge> edges;
vector<int> G[MAXN*4];
int Dis[MAXN*4];
int n, m, s, t;

void AddEdge(int from, int to, int cap)
{
    edges.push_back(Edge{from, to, cap});
    edges.push_back(Edge{to, from, 0});
    G[from].push_back(edges.size()-2);
    G[to].push_back(edges.size()-1);
}

bool Bfs()
{
    memset(Dis, -1, sizeof(Dis));
    queue<int> que;
    que.push(s);
    Dis[s] = 0;
    while (!que.empty())
    {
        int u = que.front();
        que.pop();
//        cout << u << endl;
        for (int i = 0;i < G[u].size();i++)
        {
            Edge &e = edges[G[u][i]];
            if (e.cap > 0 && Dis[e.to] == -1)
            {
                Dis[e.to] = Dis[u]+1;
                que.push(e.to);
            }
        }
    }
    return Dis[t] != -1;
}

int Dfs(int u, int flow)
{
    if (u == t)
        return flow;
    int res = 0;
    for (int i = 0;i < G[u].size();i++)
    {
        Edge &e = edges[G[u][i]];
        if (e.cap > 0 && Dis[u]+1 == Dis[e.to])
        {
            int tmp = Dfs(e.to, min(flow, e.cap));
//            cout << "flow:" << e.from << ' ' << e.to << ' ' << tmp << endl;
            e.cap -= tmp;
            flow -= tmp;
            edges[G[u][i]^1].cap += tmp;
            res += tmp;
            if (flow == 0)
                break;
        }
    }
    if (res == 0)
        Dis[u] = -1;
    return res;
}

int MaxFlow()
{
    int res = 0;
    while (Bfs())
    {
        res += Dfs(s, INF);
//        cout << res << endl;
    }
    return res;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    while (cin >> n >> m)
    {
        cin >> s >> t;
        for (int i = 0;i <= n*2;i++)
            G[i].clear();
        edges.clear();
        s = s*2-1;
        t = t*2;
        int w;
        for (int i = 1;i <= n;i++)
        {
            cin >> w;
            AddEdge(i*2-1, i*2, w);
        }
        int u, v;
        for (int i = 1;i <= m;i++)
        {
            cin >> u >> v;
            AddEdge(u*2, v*2-1, INF);
            AddEdge(v*2, u*2-1, INF);
        }
        LL res = MaxFlow();
        cout << res << endl;
    }

    return 0;
}