hdu - 4322 - Candy - 网络流

题意：http://acm.hdu.edu.cn/showproblem.php?pid=4322

   like[i][j]表示第i个孩子喜欢第j个糖果（总共m个孩子，n个糖）。 如果孩子拿到他喜欢的糖果，那么他将会增加k个欢乐值；拿到不喜欢的，增加1。 如果孩子i的欢乐值大于B[i]，那么他才是开心的。

  问，能否有一种分配方案，让所有孩子都开心。

解：

首先声明，由于被小孩子不喜欢的糖果的对小孩产生的效力是一样的，所以我们在网络流的时候先不考虑。

1 - 源点0到1~N个糖果,容量为1,费用为0

2 - 根据like数组，like[i][j] == 1时在糖果j和人N+i之间建立有一条边，容量为1，费用为0

3*- 根据b[i]和K的值建立小孩和汇点之间的边:

如果b[i] 是 K 的倍数， 说明花费b[i] / K个喜欢的糖果可以达到b[i]，建立一条边，费用为K，容量为b[i] / K;

否则，将这条边拆为两部分，第一部分是b[i] / K的部分，第二部分根据b[i] % K的部分。（如果b[i] % k == 0，说明b[i]是k的倍数;

若b[i] % k == 1, 特殊糖果和一般糖果价值一样，没必要当做特殊糖果处理）

建好图后，求最大费用最大流（只需将费用改为负的，然后套最小费用最大流即可）.。得出特殊糖果匹配b[i]的最大值。看剩余的普通糖果是否满足缺少的b[i]。

#include <cstring>
#include <cstdio>
const int maxn = 100;
const int maxm = maxn * maxn * 2;
const int inf = 1000000000;

int n, m, k;
int b[maxn], sumB;
int c[maxn][maxn];
int src, des;

struct Edge{
    int u, v, w, f, nxt;
}edge[maxm];
int edgeNum, head[maxn];

inline void initEdge(){
    edgeNum = 0;
    memset(head, - 1, sizeof(head));
}

inline void addEdgeSub(int u, int v, int w, int f){
    edge[edgeNum].u = u;
    edge[edgeNum].v = v;
    edge[edgeNum].w = w;
    edge[edgeNum].f = f;
    edge[edgeNum].nxt = head[u];
    head[u] = edgeNum ++;
}

inline void addEdge(int u, int v, int w, int f){
    addEdgeSub(u,v,w,f);
    addEdgeSub(v,u,-w,0);
}

void buildGraph(){
    initEdge();
    src = 0;
    des = n + m + 1;
    for(int i = 0; i < n; i ++){
        addEdge(src, i + 1, 0, 1);
    }
    for(int i = 0; i < m; i ++){
        for(int j = 0; j < n; j ++){
            if(c[i][j]){
                addEdge(j + 1, i + n + 1,0,1);//
            }
        }
        addEdge(i + n + 1, des, k, b[i] / k);
        if(b[i] % k > 1){
            addEdge(i + n + 1, des, b[i] % k, 1);
        }
    }
}

int dis[maxn];
int queue[maxn];
bool vis[maxn];
int back[maxn];

bool bfs(){
    int front = 0, rear = 1;
    memset(vis, false, sizeof(vis));
    memset(dis, -1, sizeof(dis));
    queue[0] = src;
    dis[src] = 0;
    vis[src] = true;
    back[src] = -1;
    bool flag = false;
    while(front != rear){
        int u = queue[front];
        for(int i = head[u]; i != -1; i = edge[i].nxt){
            int v = edge[i].v;
            int w = edge[i].w;
            if(edge[i].f){
                if(dis[v] < dis[u] + w){
                    dis[v] = dis[u] + w;
                    back[v] = i;
                    if(!vis[v]){
                        vis[v] = true;
                        queue[rear] = v;
                        if(++ rear >= maxn){
                            rear = 0;
                        }
                    }
                }
            }
        }
        vis[u] = false;
        if(++ front >=  maxn){
            front = 0;
        }
    }
    return dis[des] != -1;
}

int getFlow(){
    int tmp = des;
    int Min = inf;
    while(back[tmp] != -1){
        if(edge[back[tmp]].f < Min){
            Min = edge[back[tmp]].f;
        }
        tmp = edge[back[tmp]].u;
    }
    tmp = des;
    while(back[tmp] != -1){
        edge[back[tmp]].f -= Min;
        edge[back[tmp] ^ 1].f += Min;
        tmp = edge[back[tmp]].u;
    }
    return Min;
}

bool judge(){
    int cost = 0, flow = 0;
    while(bfs()){
        cost += dis[des];
        flow += getFlow();
    }
    return n - flow >= sumB - cost;
}

int main(){
    int T;
    scanf("%d",&T);
    for(int ca = 1; ca <= T; ca ++){
        scanf("%d%d%d",&n,&m,&k);
        sumB = 0;
        for(int i = 0; i < m; i ++){
            scanf("%d",&b [i]);
            sumB += b[i];
        }
        for(int i = 0; i < m; i ++){
            for(int j = 0; j < n; j ++){
                scanf("%d",&c[i][j]);
            }
        }
        buildGraph();
        printf("Case #%d: ",ca);
        if(judge())
            puts("YES");
        else
            puts("NO");
    }
    return 0;
}