hdu3572 Task Schedule (最大流)

题意：有n个task，要交给m个机器完成。task[i]需要p[i]天完成，必须在第t[i]天或第t[i]天之后开始，在e[i]天或e[i]天之前结束。每个task每天只能被一个机器处理，每个机器每天只能处理一个任务，问是否能按要求完成所有的task。

解题思路：最大流。每个task建一个点，然后每天建一个点，源点向task建边，容量为p[i]，表示每个task最多被处理p[i]次。task向[ s[i] , e[i] ]区间内的天建边，每条边容量为1，表示每个任务每天只能被处理一次。每天向汇点建边，容量为m。表示每天最多可以有m个任务被分配出来给m个机器处理，至于这一天是哪台机器处理了哪个task，我们不关心。然后跑最大流，总流量等于p[i]之和则可行。

代码：

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

const int INF = 1111111111 ;
struct Task {
    int s , p , t ;
} task[555] ;

struct Edge {
    int from , to , cap , next ;
} edge[800000] ;
int head[1220] , tot ;

void new_edge ( int from , int to , int cap ) {
    edge[tot].from = from ;
    edge[tot].to = to ;
    edge[tot].cap = cap ;
    edge[tot].next = head[from] ;
    head[from] = tot ++ ;
}

struct Max_Flow {
    int dis[1220] , s , t , cur[1220] ;
    queue<int> Q ;
    bool bfs ( int n ) {
        int i , u , v ;
        for ( i = 1 ; i <= n ; i ++ ) dis[i] = INF ;
        dis[s] = 0 ; Q.push ( s ) ;
        while ( !Q.empty () ) {
            u = Q.front () ; Q.pop () ;
            for ( i = head[u] ; i != -1 ; i = edge[i].next ) {
                v = edge[i].to ;
                if ( dis[v] == INF && edge[i].cap ) {
                    dis[v] = dis[u] + 1 ;
                    Q.push ( v ) ;
                }
            }
        }
        return dis[t] != INF ;
    }
    int dfs ( int u , int a ) {
        if ( u == t || !a ) return a ;
        int f , flow = 0 ;
        for ( int& i = cur[u] ; i != -1 ; i = edge[i].next ) {
            int v = edge[i].to ;
            if ( dis[v] == dis[u] + 1 && ( f = dfs ( v , min ( a , edge[i].cap ) ) ) ) {
                flow += f ;
                edge[i].cap -= f ;
                edge[i^1].cap += f ;
                a -= f ;
                if ( a == 0 ) break ;
            }
        }
        return flow ;
    }
    int dinic ( int s , int t , int n ) {
        this->s = s ; this->t = t ;
        int flow = 0 ;
        while ( bfs ( n ) ) {
            for ( int i = 1 ; i <= n ; i ++ )
                cur[i] = head[i] ;
            flow += dfs ( s , INF ) ;
        }
        return flow ;
    }
} ac ;

int main () {
    int n , m , mx , i , j ;
    int t , ca = 0 , cnt ;
    scanf ( "%d" , &t ) ;
    while ( t -- ) {
        scanf ( "%d%d" , &n , &m ) ;
        mx = tot = cnt = 0 ;
        memset ( head , -1 , sizeof ( head ) ) ;
        for ( i = 1 ; i <= n ; i ++ ) {
            scanf ( "%d%d%d" , &task[i].p , &task[i].s , &task[i].t ) ;
            cnt += task[i].p ;
            mx = max ( mx , task[i].t ) ;
        }
        int s = n + mx + 1 , t = n + mx + 2 ;
        for ( i = 1 ; i <= n ; i ++ ) {
            new_edge ( s , i , task[i].p ) ;
            new_edge ( i , s , 0 ) ;
            for ( j = task[i].s ; j <= task[i].t ; j ++ ) {
                new_edge ( i , n + j , 1 ) ;
                new_edge ( n + j , i , 0 ) ;
            }
        }
        for ( i = 1 ; i <= mx ; i ++ ) {
            new_edge ( n + i , t , m ) ;
            new_edge ( t , n + i , 0 ) ;
        }
        printf ( "Case %d: " , ++ ca ) ;
        if ( ac.dinic ( s , t , n + mx + 2 ) != cnt ) puts ( "No" ) ;
        else puts ( "Yes" ) ;
        puts ( "" ) ;
    }
    return 0 ;
}