POJ_1698_Alice's Chance(最大流)

Alice's Chance

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 6400		Accepted: 2615

Description

Alice, a charming girl, have been dreaming of being a movie star for long. Her chances will come now, for several filmmaking companies invite her to play the chief role in their new films. Unfortunately, all these companies will start making the films at the same time, and the greedy Alice doesn't want to miss any of them!! You are asked to tell her whether she can act in all the films.

As for a film,

1. it will be made ONLY on some fixed days in a week, i.e., Alice can only work for the film on these days;
   
2. Alice should work for it at least for specified number of days;
   
3. the film MUST be finished before a prearranged deadline.

For example, assuming a film can be made only on Monday, Wednesday and Saturday; Alice should work for the film at least for 4 days; and it must be finished within 3 weeks. In this case she can work for the film on Monday of the first week, on Monday and Saturday of the second week, and on Monday of the third week.

Notice that on a single day Alice can work on at most ONE film.

Input

The first line of the input contains a single integer T (1 <= T <= 20), the number of test cases. Then T cases follow. Each test case begins with a single line containing an integer N (1 <= N <= 20), the number of films. Each of the following n lines is in the form of "F1 F2 F3 F4 F5 F6 F7 D W". Fi (1 <= i <= 7) is 1 or 0, representing whether the film can be made on the i-th day in a week (a week starts on Sunday): 1 means that the film can be made on this day, while 0 means the opposite. Both D (1 <= D <= 50) and W (1 <= W <= 50) are integers, and Alice should go to the film for D days and the film must be finished in W weeks.

Output

For each test case print a single line, 'Yes' if Alice can attend all the films, otherwise 'No'.

Sample Input

2
2
0 1 0 1 0 1 0 9 3
0 1 1 1 0 0 0 6 4
2
0 1 0 1 0 1 0 9 4
0 1 1 1 0 0 0 6 2

Sample Output

Yes
No

Hint

A proper schedule for the first test case:



date     Sun    Mon    Tue    Wed    Thu    Fri    Sat

week1          film1  film2  film1         film1

week2          film1  film2  film1         film1

week3          film1  film2  film1         film1

week4          film2  film2  film2

题意：爱丽丝要去拍一些电影，这些电影只能在指定的星期几拍摄，并且电影需要在指定的W个星期内拍完D次，问她能否拍完这些电影？

分析：转化为最大流来做。这样子来建图：加入超级源点s连向需要拍的电影，容量为Di；每个电影都指向它能够开拍的那一天，容量为1；加入超级汇点t，让所有的日期指向t，容量为1。.然后判断最大流是否为拍电影需要天数的总和。

题目链接：http://poj.org/problem?id=1698

代码清单：

#include<map>
#include<set>
#include<cmath>
#include<queue>
#include<stack>
#include<ctime>
#include<cctype>
#include<string>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;

#define end() return 0

typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;

const int maxn = 5000 + 5;
const int INF = 0x7f7f7f7f;

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 dinic{
    int n,m,s,t; //结点数，边数(包括反向弧)，源点，汇点
    vector<Edge>edge;//边表。edge[e]和edge[e^1]互为反向弧
    vector<int>G[maxn];//邻接表。G[i][j]表示结点i的第j条边在e数组的序号
    bool vis[maxn]; //bfs用
    int d[maxn]; //从起点到i的距离
    int cur[maxn]; //当前弧下标

    void init(int n,int s,int t){
        this -> n = n;
        this -> s = s;
        this -> t = t;
        for(int i=0;i<=n;i++) G[i].clear();
        edge.clear();
    }

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

    bool bfs(){
        memset(vis,false,sizeof(vis));
        queue<int>q;
        q.push(s);
        d[s]=0;
        vis[s]=true;
        while(!q.empty()){
            int x=q.front();q.pop();
            for(int i=0;i<G[x].size();i++){
                Edge& e=edge[G[x][i]];
                if(!vis[e.to]&&e.cap>e.flow){ //只考虑残量网络中的弧
                    vis[e.to]=true;
                    d[e.to]=d[x]+1;
                    q.push(e.to);
                }
            }
        }
        return vis[t];
    }

    int dfs(int x,int a){
        if(x==t||a==0) return a;
        int flow=0,f;
        for(int& i=cur[x];i<G[x].size();i++){ // & -> 从上次考虑的弧
            Edge& e=edge[G[x][i]];
            if(d[x]+1==d[e.to]&&(f=dfs(e.to,min(a,e.cap-e.flow)))>0){
                e.flow+=f;
                edge[G[x][i]^1].flow-=f;
                flow+=f;
                a-=f;
                if(a==0) break;
            }
        }
        return flow;
    }

    int maxflow(){
        int flow=0;
        while(bfs()){
            memset(cur,0,sizeof(cur));
            flow+=dfs(s,INF);
        }
        return flow;
    }
};

int T;
int N,tail;
int ma[25][15];
int D[25],W[25];
int Ma,sum;
dinic dc;

void input(){
    scanf("%d",&N);
    for(int i=1;i<=N;i++){
        for(int j=1;j<=7;j++)
            scanf("%d",&ma[i][j]);
        scanf("%d%d",&D[i],&W[i]);
    }
}

void createGraph(){
    Ma=-1,sum=0;
    for(int i=1;i<=N;i++){
        Ma=max(Ma,W[i]);
        sum+=D[i];
    }
    tail=N+7*Ma+1;
    dc.init(tail+1,0,tail);
    for(int i=1;i<=N;i++){
        dc.addEdge(0,i,D[i]);
    }
    for(int i=N+1;i<=tail-1;i++){
        dc.addEdge(i,tail,1);
    }
    for(int i=1;i<=N;i++){
        for(int j=1;j<=7;j++){
            if(ma[i][j]){
                for(int k=1;k<=W[i];k++){
                    dc.addEdge(i,N+Ma*(j-1)+k,1);
                }
            }
        }
    }
}

void solve(){
    createGraph();
    if(dc.maxflow()==sum) puts("Yes");
    else puts("No");
}

int main(){
    scanf("%d",&T);
    while(T--){
        input();
        solve();
    }
    end();
}