【HDU】4322 Candy 【最小费用流——给每条边一个被流优先级】

传送门：【HDU】4322 Candy

前言：

这道题我做了近两个星期，终于艹出来了，真的是太弱了……
在上周日的时候，想到一个$O(N*3^N)$的BFS算法，然后果不其然的TLE了，然后测了下发现这题有超过200组数据，真是‘哔——’了狗了……

题目分析：
首先，我们只考虑糖果对喜欢该糖果的小朋友的贡献，如果小朋友i喜欢糖果j，那么我们建边j->i，容量1，费用0。如果这条边被流过，说明糖果j被分配给了小朋友i。对于每个糖果，从源点向其建边，容量1，费用0。

然后我们需要考虑的是怎么分配糖果来满足我们的要求。考虑一个小朋友可以接受的喜欢的糖果数量为$\lfloor \frac{B[i]-1}{k}\rfloor+1$，考虑其接受的每一个糖果都有一个优先级，值小的优先级大。第一个接收的糖果的值为$k-B[i]$，第二个的值为$2k-B[i]$，依次类推。对于每一个小孩我们都是优先选择值小的，也就是用最小费用流模拟选糖过程。然后多个小孩一起选糖，也是一个道理。

于是我们只要建好边，跑最小费用最大流就可以了，这样被流过的糖就被当做被小朋友喜爱的糖分配出去了。剩下的M-flow颗糖，我们只要当做普通的糖分配给还没满B[i]的小朋友就可以了。

最后看一下所有的糖分配完后是不是所有小朋友都能达到大于等于B[i]的happy值即可。

为什么这样建图可以呢？我们考虑把所有边造成的费用加起来（值之和取反），然后跑完费用流后，得到的是最大的被使用的费用（取绝对值），删去这个最大的费用，我们剩下的就是最小的没被使用的费用了。

PS：有错请及时提醒本人，thx~

$my~~code:$

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std ;

typedef long long LL ;

#define clr( a , x ) memset ( a , x , sizeof a )

const int MAXN = 35 ;
const int MAXE = 1000000 ;
const int INF = 0x3f3f3f3f ;

struct Edge {
    int v , c , w , n ;
    Edge () {}
    Edge ( int v , int c , int w , int n ) : v ( v ) , c ( c ) , w ( w ) , n ( n ) {}
} ;

Edge E[MAXE] ;
int H[MAXN] , cntE ;
int d[MAXN] , cur[MAXN] , vis[MAXN] ;
int Q[MAXN] , head , tail ;
int flow , cost ;
int s , t ;
int n , m , k ;
int val[MAXN] ;
int f[MAXN] ;

void init () {
    cntE = 0 ;
    clr ( H , -1 ) ;
}

void addedge ( int u , int v , int c , int w ) {
    E[cntE] = Edge ( v , c , +w , H[u] ) ;
    H[u] = cntE ++ ;
    E[cntE] = Edge ( u , 0 , -w , H[v] ) ;
    H[v] = cntE ++ ;
}

int spfa () {
    head = tail = 0 ;
    clr ( vis , 0 ) ;
    clr ( d , INF ) ;
    Q[tail ++] = s ;
    cur[s] = -1 ;
    d[s] = 0 ;
    while ( head != tail ) {
        int u = Q[head ++] ;
        if ( head == MAXN ) head = 0 ;
        vis[u] = 0 ;
        for ( int i = H[u] ; ~i ; i = E[i].n ) {
            int v = E[i].v ;
            if ( E[i].c && d[v] > d[u] + E[i].w ) {
                d[v] = d[u] + E[i].w ;
                cur[v] = i ;
                if ( !vis[v] ) {
                    Q[tail ++] = v ;
                    if ( tail == MAXN ) tail = 0 ;
                    vis[v] = 1 ;
                }
            }
        }
    }
    if ( d[t] == INF ) return 0 ;
    cost += d[t] ;
    flow ++ ;
    for ( int i = cur[t] ; ~i ; i = cur[E[i ^ 1].v] ) {
        E[i].c -- ;
        E[i ^ 1].c ++ ;
    }
    return 1 ;
}

int mcmf () {
    flow = cost = 0 ;
    while ( spfa () ) ;
    return cost ;
}

void solve () {
    int x ;
    init () ;
    scanf ( "%d%d%d" , &m , &n , &k ) ;
    s = 0 ;
    t = n + m + 1 ;
    for ( int i = 1 ; i <= n ; ++ i ) {
        scanf ( "%d" , &val[i] ) ;
        int s = ( ( val[i] - 1 ) / k + 1 ) * k ;
        while ( s ) {
            addedge ( i + m , t , 1 , s - val[i] ) ;
            s -= k ;
        }
    }
    for ( int i = 1 ; i <= m ; ++ i ) {
        addedge ( s , i , 1 , 0 ) ;
    }
    for ( int i = 1 ; i <= n ; ++ i ) {
        for ( int j = 1 ; j <= m ; ++ j ) {
            scanf ( "%d" , &x ) ;
            if ( x == 1 ) addedge ( j , i + m , 1 , 0 ) ;
        }
    }
    mcmf () ;
    clr ( f , 0 ) ;
    for ( int i = H[t] ; ~i ; i = E[i].n ) {
        if ( E[i].c ) f[E[i].v - m] += k ;
    }
    int has = m - flow ;
    for ( int i = 1 ; i <= n ; ++ i ) {
        //printf ( "%d %d\n" , val[i] , f[i] ) ;
        has -= max ( 0 , val[i] - f[i] ) ;
    }
    if ( has < 0 ) printf ( "NO\n" ) ;
    else printf ( "YES\n" ) ;
}

int main () {
    int T ;
    scanf ( "%d" , &T ) ;
    for ( int i = 1 ; i <= T ; ++ i ) {
        printf ( "Case #%d: " , i ) ;
        solve () ;
    }
    return 0 ;
}