hdu 4067 Random Maze（费用流）

hdu 4067 Random Maze（费用流）

先贪心选边，然后根据平衡条件建图。

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

const int N = 2222 ;
const int M = 222222 ;
const int INF = 1111111111 ;

struct Edge {
    int from , to , next , flow , cap , cost ;
    Edge () {}
    Edge (int a,int b,int c,int d,int e) {
        from = a , to = b , flow = c , cap = d , cost = e ;
    }
} edge[M] ;
int head[N] , tot ;

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

int vis[N] , dis[N] , pre[N] , add[N] ;
queue<int> Q ;
int spfa ( int s , int t , int& flow , int& cost , int n ) {
    int i , u , v ;
    for ( i = 1 ; i <= n ; i ++ ) dis[i] = INF ;
    dis[s] = 0 , add[s] = INF ;
    Q.push ( s ) ; vis[s] = 1 ;
    while ( !Q.empty () ) {
        u = Q.front () ; Q.pop () , vis[u] = 0 ;
  //      printf ( "fuck head[%d] = %d\n" , u , head[u] ) ;
        for ( i = head[u] ; i != -1 ; i = edge[i].next ) {
            Edge e = edge[i] ;
            v = e.to ;
   //         printf ( "v = %d\n" , v ) ;
            if ( e.cap > e.flow && dis[v] > dis[u] + edge[i].cost ) {
   //             printf ( "u = %d , v = %d\n" , u , v ) ;
                dis[v] = dis[u] + edge[i].cost ;
                add[v] = min ( add[u] , e.cap - e.flow ) ;
                pre[v] = i ;
                if ( !vis[v] ) Q.push (v) , vis[v] = 1 ;
            }
        }
    }
 //   printf ( "dis[%d] = %d\n" , t , dis[t] ) ;
    if ( dis[t] == INF ) return 0 ;
    flow += add[t] ; cost += add[t] * dis[t] ;
 //   printf ( "flow = %d , cost = %d\n" , flow , cost ) ;
    u = t ;
    while ( u != s ) {
        edge[pre[u]].flow += add[t] ;
        edge[pre[u]^1].flow -= add[t] ;
        u = edge[pre[u]].from ;
    }
    return 1 ;
}

int mincost_maxflow ( int s , int t , int n , int need ) {
    int flow = 0 , cost = 0 ;
    while ( spfa ( s , t , flow , cost , n ) ) ;
//    printf ( "flow = %d\n" , flow ) ;
    if ( flow != need ) return -1 ;
    return cost ;
}

int in[N] , out[N] ;

int main () {
    int n , m , k ;
    int cas , ca = 0 ;
    scanf ( "%d" , &cas ) ;
    while ( cas -- ) {
        int s , t ;
        scanf ( "%d%d%d%d" , &n , &m , &s , &t ) ;
        tot = 0 ;
        memset ( head , -1 , sizeof ( head ) ) ;
        memset ( in , 0 , sizeof (in) ) ;
        memset ( out , 0 , sizeof (out) ) ;
        out[s] ++ , in[t] ++ ;
        s = n + 1 , t = n + 2 ;
        int sum = 0 ;
        while ( m -- ) {
            int a , b , c , d ;
            scanf ( "%d%d%d%d" , &a , &b , &c , &d ) ;
            if ( c > d ) {//默认删除，若恢复，则会提供in[b],out[a]各1，故建反边
                sum += d ;
                new_edge ( b , a , 0 , 1 , c - d ) ;
            }
            else {//默认为保留，若删除，则会使in[b],out[a]各减1
                sum += c ;
                in[a] ++ , out[b] ++ ;
                new_edge ( a , b , 0 , 1 , d - c ) ;
            }
        }
        int need = 0 ;
        for ( int i = 1 ; i <= n ; i ++ ) {
    //        printf ( "in[%d] = %d , out[%d] = %d\n" , i , in[i] , i , out[i] ) ;
            if ( in[i] >= out[i] ) {
                new_edge ( s , i , 0 , in[i] - out[i] , 0 ) ;
                need += in[i] - out[i] ;
            }
            else new_edge ( i , t , 0 , out[i] - in[i] , 0 ) ;
        }
        printf ( "Case %d: " , ++ ca ) ;
        int fuck = mincost_maxflow ( s , t , n + 2 , need ) ;
        if ( fuck == -1 ) puts ( "impossible" ) ;
        else printf ( "%d\n" , sum + fuck ) ;
    }
    return 0 ;
}
/*
100
3 2 1 3
1 2 6 5
2 3 3 4
*/