hdoj 4289 Control（最小割模板题）（拆点）

最新推荐文章于 2024-07-15 07:43:36 发布

原创最新推荐文章于 2024-07-15 07:43:36 发布 · 159 阅读

0 ·

CC 4.0 BY-SA版权

网络流专栏收录该内容

6 篇文章

订阅专栏

本文介绍了一种使用网络流算法解决最小割问题的方法。通过将点权转换为边权，利用Dinic算法找到使两个特定点不连通所需的最小花费。文章详细解释了拆点技巧、边的构造及Dinic算法实现。

题目链接：hdoj 4289 Control

Dinic模板：hdoj 3549 FlowProblem(Dinic+当前弧优化模板)

题意：给出一个N个点M条边的无向图，给定两个点。要去掉图中的点，使给定的两个点不连通。去掉某个点需要一定的花费，求最小花费。

解题思路：去掉图中的点使源点和汇点不连通，正是网络流的割，本题即求最小割。因为网络流处理的是弧上的容量，所以将每个点拆成两个点，边上的容量即为去掉该点的花费——也就是将点权转换为边权（本题中拆点的意义）。

#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<sstream>
#include<algorithm>
#include<string>
#include<cstring>
#include<cmath>
#include<vector>
#include<stack>
#include<queue>
#include<set>
#include<map>
#include<utility>
#define JOJO cout<<"JOJO"<<endl;
#define TW system("pause");
using namespace std;

const long long INF = ~0ull>>2;
const int Inf = 0x3f3f3f3f;
const int maxn = 1e3+5;
int head[maxn], cur[maxn];
int lev[maxn];
int S = 0, T;
int t;

struct tagedge{
    int to, next;
    long long cap;
}edge[maxn*maxn];

bool LevelGraph()
{
    queue<int> q;
    fill(lev, lev+maxn, -1);
    lev[S] = 0;
    q.push(S);
    while (!q.empty()){
        int k = q.front();
        q.pop();

        for (int i = head[k]; i != -1; i = edge[i].next){
            int v = edge[i].to;

            if (lev[v] == -1 && edge[i].cap > 0){
                lev[v] = lev[k] + 1;
                q.push(v);
            }
        }
    }

    if (lev[T] == -1)
        return false;
    else
        return true;
}

int FindPath(int k, long long flow_in)
{
    if (k == T)
        return flow_in;

    long long flow_out = 0;
    for (int i = cur[k]; i != -1; i = edge[i].next){
        cur[k] = i;
        int v = edge[i].to;

        if (lev[v] == lev[k]+1 && edge[i].cap > 0){
            long long flow = FindPath(v, min(flow_in, edge[i].cap));
            if (flow == 0)  continue;

            flow_in -= flow;
            flow_out += flow;

            edge[i].cap -= flow;
            edge[i^1].cap += flow;

            if (flow_in == 0)   break;
        }
    }
    return flow_out;
}

long long Dinic()
{
    long long res = 0;
    while (LevelGraph()){
        memcpy(cur, head, sizeof(head));
        res += FindPath(0, Inf);
    }
    return res;
}

void AddEdge(int u, int v, long long w)
{
    edge[t].to = v;
    edge[t].cap = w;
    edge[t].next = head[u];
    head[u] = t++;
    return;
}

void init()
{
    fill(head, head+maxn, -1);
    memset(edge, 0, sizeof(edge));
    t = 0;
    return;
}

int main()
{
    int N, M, s, d;
    while (scanf("%d%d%d%d", &N, &M, &s, &d) != EOF){
        init();
        T = 2*N+5;
        AddEdge(S, s, INF);
        AddEdge(s, S, 0);
        AddEdge(d+N, T, INF);
        AddEdge(T, d+N, 0);
        for (int i = 1; i <= N; i++){
            long long val;
            scanf("%lld", &val);
            /*拆点，一个点为i，一个点为i+N，
            边上的容量为点权，将点权转换为边权*/
            AddEdge(i, i+N, val);
            AddEdge(i+N, i, 0);
        }
        while (M--){
            int a, b;
            scanf("%d%d", &a, &b);
            /*拆点后，一个点拆成的两个点之间是有向的*/
            AddEdge(b+N, a, INF);
            AddEdge(a, b+N, 0);
            AddEdge(a+N, b, INF);
            AddEdge(b, a+N, 0);
        }
        printf("%lld\n", Dinic());
    }
    return 0;
}