HDU 4309 Seikimatsu Occult Tonneru (枚举+最大流)

题目：

http://acm.hdu.edu.cn/showproblem.php?pid=4309

题意：

方法：

用二进制枚举所有p>0的边是否修，然后按下面建图，跑最大流，输出最大的最大流及其对应的修桥费用

建图：

对于每个城市顶点i，连边S->i，流量为城市的人数

如果p<0，连u->v，流量inf；u->T，流量w

如果p==0，连u->v，流量inf；

如果p>0，如果此桥被标记修，则连u->v，流量inf；否则连u->v，流量1；

void solve()
{
    for (int i = 0; i < (1 << rec.size()); i++)
    {
        tcost = 0;
        for (int j = 0; j < rec.size(); j++)
            if (i & (1 << j)) e[rec[j]].flag = 1, tcost += e[rec[j]].w;
        cal();
        for (int j = 0; j < rec.size(); j++)
            if (i & (1 << j)) e[rec[j]].flag = 0;
    }
}

void build()
{
    dinic.init(n + 2);
    dinic.st = 0;
    dinic.ed = 1;
    for (int i = 0; i < n; i++)
        dinic.adde(dinic.st, i + 2, a[i]);
    for (int i = 0; i < m; i++)
    {
        int u = e[i].u;
        int v = e[i].v;
        int w = e[i].w;
        int p = e[i].p;
        if (p < 0)
        {
            dinic.adde(u + 2, v + 2, inf);
            dinic.adde(u + 2, dinic.ed, w);
        }
        else if (p == 0) dinic.adde(u + 2, v + 2, inf);
        else
        {
            if (e[i].flag) dinic.adde(u + 2, v + 2, inf);
            else dinic.adde(u + 2, v + 2, 1);
        }
    }
}

代码：

/*************************************
*ACM Solutions
*@Author: xysmlx
*@Blog: http://www.cnblogs.com/xysmlx
*************************************/
// #pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <iostream>
#include <cstring>
#include <string>
#include <cmath>
#include <set>
#include <list>
#include <map>
#include <iterator>
#include <cstdlib>
#include <vector>
#include <queue>
#include <stack>
#include <algorithm>
#include <functional>
using namespace std;
typedef long long LL;
#define pb push_back
#define ROUND(x) round(x)
#define FLOOR(x) floor(x)
#define CEIL(x) ceil(x)
// const int maxn = 0;
// const int maxm = 0;
// const int inf = 0x3f3f3f3f;
const LL inf64 = 0x3f3f3f3f3f3f3f3fLL;
const double INF = 1e30;
const double eps = 1e-6;
const int P[4] = {0, 0, -1, 1};
const int Q[4] = {1, -1, 0, 0};
const int PP[8] = { -1, -1, -1, 0, 0, 1, 1, 1};
const int QQ[8] = { -1, 0, 1, -1, 1, -1, 0, 1};

/**
*最大流最小割：加各种优化的Dinic算法($O(V^2E)$)
*输入：图(链式前向星),n(顶点个数,包含源汇),st(源),ed(汇)
*输出：Dinic(NdFlow)(最大流),MinCut()(最小割)(需先求最大流)
*打印路径方法：按反向边(i&1)的flow 找，或者按边的flow找
*/
const int maxn = 510;
const int maxm = 20010;
const int inf = 0x3f3f3f3f;
struct DINIC
{
    struct Edge
    {
        int u, v;
        int cap, flow;
        int next;
    } edge[maxm];
    int head[maxn], en; //需初始化
    int n, m, d[maxn], cur[maxn];
    int st, ed;
    bool vis[maxn];
    void init(int _n = 0)
    {
        n = _n;
        memset(head, -1, sizeof(head));
        en = 0;
    }
    void addse(int u, int v, int cap, int flow)
    {
        edge[en].u = u;
        edge[en].v = v;
        edge[en].cap = cap;
        edge[en].flow = flow;
        edge[en].next = head[u];
        head[u] = en++;
        cur[u] = head[u];
    }
    void adde(int u, int v, int cap)
    {
        addse(u, v, cap, 0);
        addse(v, u, 0, 0); //注意加反向0 边
    }
    bool BFS()
    {
        queue<int> Q;
        memset(vis, 0, sizeof(vis));
        Q.push(st);
        d[st] = 0;
        vis[st] = 1;
        while (!Q.empty())
        {
            int u = Q.front();
            Q.pop();
            for (int i = head[u]; i != -1; i = edge[i].next)
            {
                int v = edge[i].v;
                int w = edge[i].cap - edge[i].flow;
                if (w > 0 && !vis[v])
                {
                    vis[v] = 1;
                    Q.push(v);
                    d[v] = d[u] + 1;
                    if (v == ed) return 1;
                }
            }
        }
        return false;
    }
    int Aug(int u, int a)
    {
        if (u == ed) return a;
        int aug = 0, delta;
        for (int &i = cur[u]; i != -1; i = edge[i].next)
        {
            int v = edge[i].v;
            int w = edge[i].cap - edge[i].flow;
            if (w > 0 && d[v] == d[u] + 1)
            {
                delta = Aug(v, min(a, w));
                if (delta)
                {
                    edge[i].flow += delta;
                    edge[i ^ 1].flow -= delta;
                    aug += delta;
                    if (!(a -= delta)) break;
                }
            }
        }
        if (!aug) d[u] = -1;
        return aug;
    }
    int Dinic(int NdFlow)
    {
        int flow = 0;
        while (BFS())
        {
            memcpy(cur, head, sizeof(int) * (n + 1));
            flow += Aug(st, inf);
            /*如果超过指定流量就return 掉*/
            if (NdFlow == inf) continue;
            if (flow > NdFlow) break;
        }
        return flow;
    }
    /*残余网络*/
    void Reduce()
    {
        for (int i = 0; i < en; i++) edge[i].cap -= edge[i].flow;
    }
    /*清空流量*/
    void ClearFlow()
    {
        for (int i = 0; i < en; i++) edge[i].flow = 0;
    }
    /*求最小割*/
    vector<int> MinCut()
    {
        BFS();
        vector<int> ans;
        for (int u = 0; u < n; u++)
        {
            if (!vis[u]) continue;
            for (int i = head[u]; i != -1; i = edge[i].next)
            {
                if (i & 1) continue; /*忽略反向边*/
                int v = edge[i].v;
                int w = edge[i].cap;
                if (!vis[v] && w > 0) ans.push_back(i);
            }
        }
        return ans;
    }
} dinic;

int kase;
int n, m;
int a[maxn];
int cost;
int flow;
int tcost;
struct Edge
{
    int u, v;
    int w;
    int p;
    int flag;
    Edge(int _u, int _v, int _w, int _p): u(_u), v(_v), w(_w), p(_p) {}
    Edge() {}
};
vector<Edge> e;
vector<int> rec;
void init()
{
    kase++;
    e.clear();
    rec.clear();
    flow = 0;
    cost = inf;
}
void input()
{
    for (int i = 0; i < n; i++)
        scanf("%d", &a[i]);
    for (int i = 0; i < m; i++)
    {
        int u, v, w, p;
        scanf("%d%d%d%d", &u, &v, &w, &p);
        u--, v--;
        e.pb(Edge(u, v, w, p));
        e[i].flag = 0;
        if (p > 0) rec.pb(i);
    }
}
void debug()
{
    //
}
void build()
{
    dinic.init(n + 2);
    dinic.st = 0;
    dinic.ed = 1;
    for (int i = 0; i < n; i++)
        dinic.adde(dinic.st, i + 2, a[i]);
    for (int i = 0; i < m; i++)
    {
        int u = e[i].u;
        int v = e[i].v;
        int w = e[i].w;
        int p = e[i].p;
        if (p < 0)
        {
            dinic.adde(u + 2, v + 2, inf);
            dinic.adde(u + 2, dinic.ed, w);
        }
        else if (p == 0) dinic.adde(u + 2, v + 2, inf);
        else
        {
            if (e[i].flag) dinic.adde(u + 2, v + 2, inf);
            else dinic.adde(u + 2, v + 2, 1);
        }
    }
}
void cal()
{
    build();
    int tmp = dinic.Dinic(inf);
    if (tmp > flow)
    {
        flow = tmp;
        cost = tcost;
    }
}
void solve()
{
    for (int i = 0; i < (1 << rec.size()); i++)
    {
        tcost = 0;
        for (int j = 0; j < rec.size(); j++)
            if (i & (1 << j)) e[rec[j]].flag = 1, tcost += e[rec[j]].w;
        cal();
        for (int j = 0; j < rec.size(); j++)
            if (i & (1 << j)) e[rec[j]].flag = 0;
    }
}
void output()
{
    cost = cost == inf ? 0 : cost;
    if (flow == 0) puts("Poor Heaven Empire");
    else printf("%d %d
", flow, cost);
}
int main()
{
    // int size = 256 << 20; // 256MB
    // char *p = (char *)malloc(size) + size;
    // __asm__("movl %0, %%esp
" :: "r"(p));

    // std::ios_base::sync_with_stdio(false);
#ifdef xysmlx
    freopen("in.cpp", "r", stdin);
#endif

    kase = 0;
    while (~scanf("%d%d", &n, &m))
    {
        init();
        input();
        solve();
        output();
    }
    return 0;
}