[网络流]poj1698 Alice's chance

题目大意：

Alice要去拍电影，要拍很多场电影，每部电影在一周中只有其中的几天可以拍，需要拍D天，最多必须在W周之内完成，Alice每天只能拍一场电影，如果Alice可以满足所有电影的要求，输出“Yes”，否则输出“No”

输入格式：

先输入T，有T组数据

每组数据第一行是N,表示有N部电影

接下来N行，每行有9个数字，前7个代表一周中的每一天是否能拍，第八是D，第九是W

思路：

首先要构图，从源点开始，连向每一部电影，容量为D，接着每一部电影连到可以拍的天，容量为1，每一天连到汇点，容量为1，做一次最大流即可。

判断最大流是否等于所有电影的D的和，等于就输出“Yes”，否则输出“No”

可以这样理解，Alice有无限个……每一部电影需要D个Alice……每一天只能有一个Alice……最后汇点有多少个Alice就是可以拍完的天……

那么只要这样，代码就很简单，只要套用模板就行。

这里还有一个技巧要注意：

因为最多会有20周，所以天数就是1 ~350，

最多有20部电影，所以电影就是351~370

所以把源点设为0，汇点设为371

就可以做最大流了

#include <queue>
#include <vector>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int MAXN = 1000 + 10,
          INF = 0x7ffffff;

const int s = 0,
          t = 381;

struct Edge {
    int from, to , cap , flow;
    Edge(int u, int v, int c, int f) : from(u), to(v), cap(c), flow(f) {}
};

struct EdmondsKarp {
    int n, m;
    vector < Edge > edges;
    vector < int > G[MAXN];
    int a[MAXN];
    int p[MAXN];

    void init(int n) {
        for(int i = 0; i < n; ++i) {
            G[i].clear();
        }

        edges.clear();
    }

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

    int Maxflow(int s, int t) {
        int flow = 0;

        for(;;) {
            memset(a, 0, sizeof a);
            queue < int > Q;
            Q.push(s);
            a[s] = INF;

            while(!Q.empty()) {
                int x = Q.front();
                Q.pop();

                for(int i = 0; i < G[x].size(); ++i) {
                    Edge &e = edges[G[x][i]];

                    if(!a[e.to] && e.cap > e.flow) {
                        p[e.to] = G[x][i];
                        a[e.to] = min(a[x], e.cap - e.flow);
                        Q.push(e.to);
                    }
                }

                if(a[t]) {
                    break;
                }
            }

            if(!a[t]) {
                break;
            }

            for(int u = t; u != s; u = edges[p[u]].from) {
                edges[p[u]].flow += a[t];
                edges[p[u] ^ 1].flow -= a[t];
            }

            flow += a[t];
        }

        return flow;
    }
};

int main(void) {
    int t;
    cin >> t;

    for(; t; --t) {
        int n;
        int sum = 0;
        cin >> n;
        EdmondsKarp ek;
        ek.init(MAXN);

        for(int i = 0; i < n; ++i) {
            int film_n = i + 361;
            int a[10];

            for(int j = 1; j <= 7; ++j) {
                cin >> a[j];
            }

            int D, W;
            cin >> D >> W;

            sum += D;

            for(int k = 1; k <= 7; ++k) {
                if(a[k]) {
                    for(int j = 0; j < W; ++j) {
                        ek.AddEdge(film_n, 7 * j + k + 1, 1); // ? 不加1会错 加1又好像不对，但是又过了
                    }
                }
            }

            ek.AddEdge(s, film_n, D);
        }

        for(int i = 1; i < 361; ++i) {
            ek.AddEdge(i, t, 1);
        }

        int maxFlow = ek.Maxflow(s, t);

        if(maxFlow == sum) {
            cout << "Yes" << endl;
        } else {
            cout << "No" << endl;
        }
    }

    return 0;
}

实际操作时为了避免天数超出影响到后面的电影所在的点，是将原本的350改成了360

最后还有一个疑问，加从电影连到天的边的时候必须用周数*7加第几天还要再加1，不然就会WA，不知原因，加了就对了……

也许是因为程序的某个细节问题吧……

总结：

网络流的题都要使劲地想，想出一个套路才行。而且网络流的模板打得显然不够熟练，要多打几次，不然在真正比赛中调几个小时都调不对……

讲道理，这样的题还是要多做才熟练……