POJ 3308, ZOJ 2874

题意：

R×C的网格中有N个点，选取其中的若干行和若干列将这些点全部覆盖（选取一行/列可以覆盖该行/列的所有点，要求每个点至少被覆盖一次）。

选取第i行的代价为r[i]，选取第i列的代价为c[i]，求代价乘积的最小值。

R, C, N≤50，r[i], c[i]均为≥1.0的正实数。

转化成最小割问题。建图方法如下：

（1）设立源点S和汇点T，对于每行、每列分别建立一个对应的节点；

（2）从源点出发，向每行连一条边，权值为r[i]的对数（底数自拟）。转化成对数可以将乘积最优问题转化为和最优。

（3）从每列出发，分别向汇点连一条边，权值为c[i]的对数；

（4）对于网格中的每一个点，设它在第x行第y列，在图中从第x行向第y列连一条边，权值为＋∞。

注意：由于诡异的精度误差，inf的值取太大可能会导致WA！

代码如下：（前50行是个比较通用的大型边表模板，在赛场上如果有多道图论题的话可以省点时间……吧（这玩意儿会有卵用么））

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <cmath>

#define FILL(a, c) memset(a, c, sizeof(a))

template <int V, int E> //V为最大节点数，E为最大边数
struct EList
{
    struct Edge { int to; double flow; };
    struct Node: Edge
    {
        int next;
        void assign(int t, int n, double f) { this->to = t; next = n; this->flow = f; }
    };
    struct Iter //迭代从节点v出发的所有边
    {
        EList *par;
        int e;
        Iter& operator ++ () { e = par->elist[e].next; return *this; }
        bool operator != (const Iter& rhs) const { return e != rhs.e; }
        //operator*返回的是引用类型
        Edge& operator * () const { return par->elist[e]; } //只保留基类部分，不含next
        Edge* operator -> () const { return par->elist + e; }
        //（适用于网络流等问题）返回反向边
        Edge& inv() const { return par->elist[e ^ 1]; }
    };
    struct View //用于遍历从某个节点出发的所有边的视图，配合C++11的range-based for使用
    {
        EList *par;
        int v;
        Iter begin() const { return { par, par->head[v] }; }
        Iter end() const { return { par, -1 }; } //用-1表示结束
    };

    Node elist[E];
    int head[V];
    int ecnt;

    void init()
    {
        FILL(head, -1); //用-1表示结束
        ecnt = 0;
    }
    void add(int u, int v, double f)
    {
        elist[ecnt].assign(v, head[u], f);
        head[u] = ecnt++;
        elist[ecnt].assign(u, head[v], 0.0);
        head[v] = ecnt++;
    }
    //返回从v节点出发的所有边的视图
    View view(int v) { return { this, v }; } //如果编译错误，试着将this指针const_cast一下
    //迭代从v出发的所有边的另一种方式，对于网络流等需要访问反向边的场合，View就不太适合了
    Iter begin(int v) { return { this, head[v] }; }
    Iter end(int v = -1) { return { this, -1 }; }
};

int R, C, N, S, T;
EList<110, 123456> elist;

void input()
{
    scanf("%d%d%d", &R, &C, &N);
    elist.init();
    S = 0;
    T = R + C + 1;

    for (int i = 1; i <= R; i++)
    {
        double v;
        scanf("%lf", &v);
        elist.add(S, i, log2(v));
    }
    for (int i = 1; i <= C; i++)
    {
        double v;
        scanf("%lf", &v);
        elist.add(i + R, T, log2(v));
    }

    for (int u, v, i = 1; i <= N; i++)
    {
        scanf("%d%d", &u, &v);
        elist.add(u, R + v, 1e50);
    }
}

int layer[110];
std::queue<int> que;

bool bfs()
{
    FILL(layer, -1);
    que.push(S);
    layer[S] = 0;

    while (!que.empty())
    {
        int cur = que.front();
        que.pop();

        for (auto& e: elist.view(cur))
        {
            if (layer[e.to] == -1 && e.flow > 0.0)
            {
                layer[e.to] = layer[cur] + 1;
                que.push(e.to);
            }
        }
    }
    return layer[T] != -1;
}

//#include <fmt/format.h>
//using namespace fmt::literals;

double dfs(int cur, double rem)
{
    if (cur == T)
        return rem;

    double origRem = rem;
    for (auto it = elist.begin(cur); rem > 0.0 && it != elist.end(); ++it)
    {
        if (layer[it->to] == layer[cur] + 1 && it->flow > 0.0)
        {
            double n = dfs(it->to, std::min(rem, it->flow));
            //fmt::print("cur = {cur}, to = {to}, flow = {flow:.3f}
", "cur"_a = cur, "to"_a = it->to, "flow"_a = n);
            rem -= n;
            it->flow -= n;
            it.inv().flow += n;
        }
    }
    return origRem - rem;
}

double solve()
{
    double ans = 0.0;
    while (bfs())
        ans += dfs(S, 100);
    return pow(2.0, ans);
}

int main()
{
    int T;
    for (scanf("%d", &T); T; T--)
    {
        input();
        printf("%.4f
", solve());
    }
    return 0;
}