POJ 1459 Power Network 网络流

最新推荐文章于 2018-01-21 23:10:00 发布

原创最新推荐文章于 2018-01-21 23:10:00 发布 · 255 阅读

0 ·

CC 4.0 BY-SA版权

POJ 同时被 2 个专栏收录

14 篇文章

订阅专栏

网络流

3 篇文章

订阅专栏

本文介绍了一种基于电力网络的最大流算法实现方案。通过构造一个包含发电站、消耗站及转发点的网络，并引入超级源点与超级汇点，利用最大流算法计算消耗站能够获取的最大电量。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

给几个发电站，给几个消耗站，再给几个转发点。
发电站只发电，消耗站只消耗电，转发点只是转发电，再给各个传送线的传电能力。

问你消耗站能获得的最多电是多少

很明显电能跟流是类似的，点能从中转站流走可以看出网络流的影子

所以就增加一个超级源点，和超级汇点再把所给的发电站都和超级源点相连，把所给的消耗战都和超级汇点相连最后求最大流即可

#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
#include <algorithm>
#define rep(i, j, k) for(int i = j; i <= k; i++)
#define inf 0x7fffffff
#define sc(x) scanf("%d", &x)

using namespace std;

int n, s, t, to[30009], head[309], flow[30009], tot, done[309], d[309];
int na, nb, m, next[30009], Count[309];

void add (int u, int v, int w)
{
    //printf ("add %d %d %d\n", u, v, w);
    to[++tot] = v;
    next[tot] = head[u];
    flow[tot] = w;
    head[u] = tot;

    to[++tot] = u;
    next[tot] = head[v];
    flow[tot] = 0;
    head[v] = tot;
}

bool bfs ()
{
    queue <int> q;
    memset (done, 0, sizeof (done));
    done[s] = 1;
    d[s] = 1;
    q.push (s);
    while (!q.empty ())
    {
        int now = q.front ();
        q.pop ();
        for (int i = head[now]; i; i = next[i])
            if (!done[to[i]] && flow[i] > 0)
            {
                done[to[i]] = 1;
                d[to[i]] = d[now] + 1;
                q.push (to[i]);
            }
    }
    return done[t];
}

int dfs (int x, int a)
{
    if (x == t || !a)
        return a;
    int ret = 0, f;
    for (int i = head[x]; i; i = next[i])
        if (d[to[i]] == d[x] + 1 && (f = dfs (to[i], min (a, flow[i]))) > 0)
        {
            flow[i] -= f;
            flow[i ^ 1] += f;
            ret += f;
            a -= f;
            if (!a)
                break;
        }
    return ret;
}

int MaxFlow ()
{
    int ret = 0;
    while (bfs ())
    {
        ret += dfs (s, inf);
    }
    return ret;
}

int main ()
{
    while (scanf ("%d%d%d%d", &n, &na, &nb, &m) == 4)
    {
        s = 0, t = n + 1;
        tot = 1;
        memset (head, 0, sizeof (head));
        rep (i, 1, n)
            Count[i] = inf;
        int u, v, w;
        rep (i, 1, m)
        {
            char ch = getchar ();
            while (ch != '(')
                ch = getchar ();
            sc (u), getchar (), sc (v), getchar (), sc (w), add (u + 1, v + 1, w);
        }
        rep (i, 1, na)
        {
            char ch = getchar ();
            while (ch != '(')
                ch = getchar ();
            sc (u), getchar (), sc (v), add (s, u + 1, v);
        }
        rep (i, 1, nb)
        {
            char ch = getchar ();
            while (ch != '(')
                ch = getchar ();
            sc (u), getchar (), sc (v), add (u + 1, t, v);
            Count[u] = v;
        }
        cout << MaxFlow () << endl;
    }
    return 0;
}