SDOI2006仓库管理员的烦恼

题目描述

仓库管理员M最近一直很烦恼，因为他的上司给了他一个艰难的任务：让他尽快想出一种合理的方案，把公司的仓库整理好。

已知公司共有n个仓库和n种货物，由于公司进货时没能很好的归好类，使得大部分的仓库里面同时装有多种货物，这就给搬运工作人员搬运货物时带来了很多的麻烦。

仓库管理员M的任务就是设计一种合理的方案，把仓库里面的货物重新整理，把相同的货物放到同一个仓库，以便于日后的管理，在整理过程中肯定需要把某些货物从一个仓库搬运到另一个仓库，已知每一次搬运货物所付出的代价等于搬运该货物的重量。

编程任务：

请你帮助仓库管理员M设计搬运方案，使得把所有的货物归好类：使每种货物各自占用一个仓库，或者说每个仓库里只能放一种货物。同时要求搬运货物时所付出的所有的总的代价最小。

输入输出格式

输入格式：

 

第一行为n (1 <= n <= 150)，仓库的数量。

以下为仓库货物的情况。第i+1行依次为第i个仓库中n种货物的数量x(0 <= x <= 100)。

 

输出格式：

 

把所有的货物按要求整理好所需的总的最小代价。

 

输入输出样例

输入样例#1： 

4
62 41 86 94 
73 58 11 12 
69 93 89 88 
81 40 69 13 

输出样例#1： 

650

说明

样例说明：

方案是：第1种货物放到仓库2中；第2种货物放到仓库3中；

第3种货物放到仓库4中；第4种货物放到仓库1中

 

首先简化题目，求出cos[i][j]货物i放到j仓库所需的值

然后发现这其实是一道最小费用最大流的题目

然后就AC吧（好短的解释）

参考代码

// luogu-judger-enable-o2
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <queue> 

using namespace std ;

namespace IO {
    inline int read() {
        int x = 0 , f = 0 ; char s = getchar() ;
        while ( !isdigit(s) ) f |= s=='-' , s = getchar() ;
        while (  isdigit(s) ) x = (x<<1)+(x<<3)+(s-48) , s = getchar() ;
        return !f ? x : -x ;
    }
    int ss , aa[21] ; 
    inline void write ( int x ) {
        if ( !x ) putchar('0') ; ss = 0 ;
        if ( x < 0 ) putchar('-') , x = -x ;
        while ( x ) aa[++ss] = x%10 , x /= 10 ;
        for ( int i = ss ; i > 0 ; i -- ) putchar(aa[i]+'0') ;
        puts ( "" ) ;
    }
}
using namespace IO ;

const int N = 315 ;

int n , a[N][N] ;
int cos[N][N] , s[N] ;

namespace MAP {
    struct edge {
        int v , w , k , nxt ;
    } e[N*N] ; int tot , last[N] , cur[N] ;
    inline void add ( int u , int v , int w , int k ) {
        e[++tot] = (edge){ v , w , k , last[u] } ;
        last[u] = tot ;
        e[++tot] = (edge){ u , 0 , -k , last[v] } ;
        last[v] = tot ;
    }
}
using namespace MAP ;

bool vis[N] ; int dis[N] ;
int S , T ; int cost = 0 ;

inline bool SPFA() {
    memset ( vis , 0 , sizeof(vis) ) ; vis[T] = 1 ;
    memset ( dis , -1 , sizeof(dis) ) ; dis[T] = 0 ;
    queue<int> q ; q.push ( T ) ;
    while ( !q.empty() ) {
        int u = q.front() ; q.pop () ; vis[u] = 0 ;
        for ( int i = last[u] ; i != -1 ; i = e[i].nxt ) {
            int v = e[i].v ;
            if ( e[i^1].w  && ( dis[v] > dis[u]-e[i].k || dis[v] == -1 ) ) {
                dis[v] = dis[u] - e[i].k ;
                if ( !vis[v] ) vis[v] = 1 , q.push ( v ) ;
            }
        }
    }
    return dis[S] != -1 ;
}

int dfs ( int u , int f ) {
    vis[u] = 1 ;
    if ( u == T ) return f ;
    int ans = 0 , t = 0 ;
    for ( int i = cur[u] ; i != -1 ; i = e[i].nxt ) {
        int v = e[i].v ;
        if ( !vis[v] && e[i].w && dis[u]-e[i].k == dis[v] ) {
            ans += ( t=dfs( v , min( e[i].w , f-ans )) ) ;
            e[i].w -= t , e[i^1].w += t ;
            cost += t*e[i].k ; cur[u] = i ;
            if ( ans == f ) break ;
        }
    }
    vis[u] = 0 ; return ans ;
}

int main() {
    n = read() ;
    for ( int i = 1 ; i <= n ; i ++ ) 
        for ( int j = 1 ; j <= n ; j ++ ) 
            a[i][j] = read() , s[j] += a[i][j] ;
    for ( int i = 1 ; i <= n ; i ++ ) 
        for ( int j = 1 ; j <= n ; j ++ ) 
            cos[i][j] = s[i] - a[j][i] ;
    S = 2*n+1 , T = S + 1 ;
    tot = -1 , memset ( last , -1 , sizeof(last) ) ;
    for ( int i = 1 ; i <= n ; i ++ ) 
        add ( S , i , 1 , 0 ) , add ( i+n , T , 1 , 0 ) ;
    for ( int i = 1 ; i <= n ; i ++ )
        for ( int j = 1 ; j <= n ; j ++ ) 
            add ( i , j+n , 1 , cos[i][j] ) ;
    int ans = 0 ;
    while ( SPFA() ) {
        memcpy ( cur , last , sizeof(cur) ) ;
        ans += dfs ( S , 999999999 ) ;
    }
    write ( cost ) ; return 0 ;
}