hdu 2883 kebab(存个最大流模板)

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

const int N = 11111 ;
const int M = 2222222 ;
const ll INF = (ll) 11111111 * 11111111 ;

struct Task {
    int l , r , t , id ;
} task
 ;
struct Edge {
    int to , next ;
    ll cap ;
} edge[M] ;
int head
 , tot , x
 ;

void new_edge ( int from , int to , ll cap ) {
 //   printf ( "from = %d , to = %d , cap = %I64d\n" , from , to , cap ) ;
    edge[tot].to = to ;
    edge[tot].cap = cap ;
    edge[tot].next = head[from] ;
    head[from] = tot ++ ;
    edge[tot].to = from ;
    edge[tot].cap = 0 ;
    edge[tot].next = head[to] ;
    head[to] = tot ++ ;
} ;

struct Max_Flow {
    queue<int> Q ;
    ll dis
 ; int cur
 ;
    int s , t ;
    bool bfs ( int n ) {
        int u , v , i ;
        for ( i = 1 ; i <= n ; i ++ ) dis[i] = INF ;
        Q.push ( s ) ; dis[s] = 0 ;
        while ( !Q.empty () ) {
            u = Q.front () , Q.pop () ;
            for ( i = head[u] ; i != -1 ; i = edge[i].next ) {
                v = edge[i].to ;
                if ( edge[i].cap && dis[v] == INF ) {
                    dis[v] = dis[u] + 1 ;
                    Q.push ( v ) ;
                }
            }
        }
        return dis[t] != INF ;
    }
    ll dfs ( int u , ll a ) {
        if ( u == t || a == 0 ) return a ;
        ll flow = 0 , f ;
        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))) ) {
                edge[i].cap -= f ;
                edge[i^1].cap += f ;
                flow += f ;
                a -= f ;
                if ( a == 0 ) break ;
            }
        }
        return flow ;
    }
    ll dinic ( int s , int t , int n ) {
        this->s = s ; this->t = t ;
        ll ret = 0 ;
        while ( bfs ( n ) ){
            for ( int i = 1 ; i <= n ; i ++ ) cur[i] = head[i] ;
            ret += dfs ( s , INF ) ;
        }
   //     printf ( "ret = %d\n" , ret ) ;
        return ret ;
    }
} AC ;

int cnt ;
void init () {
    cnt = tot = 0 ;
    memset ( head , -1 , sizeof ( head ) ) ;
}
int main () {
    int n , m ;
    while ( scanf ( "%d%d" , &n , &m ) != EOF ) {
        init () ;
        int s = ++ cnt , t = ++ cnt ;
        int T = 0 ;
        ll need = 0 ;
        for ( int i = 1 ; i <= n ; i ++ ) {
            int a , b , c , d ;
            scanf ( "%d%d%d%d" , &a , &b , &c , &d ) ;
            a ++ ;
            x[++T] = a , x[++T] = c ;
            task[i].l = a , task[i].r = c ;
            task[i].t = b * d ;
            task[i].id = ++ cnt ;
            new_edge ( s , cnt , task[i].t ) ;
            need += task[i].t ;
        }
        sort ( x + 1 , x + T + 1 ) ;
        T = unique ( x + 1 , x + T + 1 ) - x - 1 ;
        for ( int i = 1 ; i <= T ; i ++ ) {
            cnt ++ ;
            new_edge ( cnt , t , m ) ;
         //   printf ( "cnt = %d , m = %d\n" , cnt , m ) ;
            for ( int j = 1 ; j <= n ; j ++ ) {
             //   printf ( "l = %d , r = %d , i = %d\n" ) ;
                if ( task[j].l <= x[i] && task[j].r >= x[i] ) {
                    new_edge ( task[j].id , cnt , INF ) ;
               //     printf ( "id = %d\n" , task[j].id ) ;
                }
            }
            if ( i == T || x[i] + 1 >= x[i+1] ) continue ;
            cnt ++ ;
            new_edge ( cnt , t , m * (x[i+1] - x[i] - 1) ) ;
       //     printf ( "cnt = %d , fuck = %d\n" , m * (x[i+1] - x[i] - 1) ) ;
            int l = x[i] + 1 , r = x[i+1] - 1 ;
            for ( int j = 1 ; j <= n ; j ++ ) {
                if ( task[j].l <= l && task[j].r >= r ) {
                    new_edge ( task[j].id , cnt , m * ( r - l + 1 ) ) ;
                }
            }
        }
        if ( need == AC.dinic ( s , t , cnt ) ) puts ( "Yes" ) ;
        else puts ( "No" ) ;
    }
    return 0 ;
}
/*
1 1
1 1 4 4
No
1 2
1 1 4 4
Yes
1 1
1 1 1 1

4 4
1 1 6 2
3 2 8 2
4 3 7 1
5 4 10 1

4 4
1 1 6 3
3 2 8 3
4 3 7 2
5 4 10 2

4 3
1 1 6 3
3 2 8 3
4 3 7 2
5 4 10 2
*/