HDU 5619 Jam's store

Jam's store

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 61    Accepted Submission(s): 18

 

Problem Description

Jam didn't study well,then he go to repair the computer in a store,there are M staffs and N guests, given each guests have to spend Tij time to repair the computer by the j staffs.
Now ask the total of time the guest at least to wait.
The staff wiil do the next work after he has done the current work

 

Input

The first line is T(1≤T≤100) means T Case
For each case
The first line is M and N(1≤M,N≤20) means the number of staffs and guests
Now given a Matrix with N∗M each number means the i guests to the j staff time (1≤Tij≤1000)

 

Output

Output one line about the time at least they need to wait

 

Sample Input

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

 

Sample Output

7

Hint

the first guest choose the third staff the second guest choose the second staff the third gurst choose the third staff the total of time is 4+2+1=7

 

思路：

很经典的建图，需要记住。

此题中，顾客的修理时间会影响到后续顾客的等待时间，而该名顾客何时修理并不能确定，所以枚举该位顾客在所有店员的修理队伍的位置以及对后续顾客的时间影响。

所以我们如下建图：先建立虚拟起点到每个顾客的边，然后我们将每个店员拆成 N 个点，第 i 个顾客是电源 j 的倒数第 k 个顾客：add( i, j‘, k * c )，其中 j' 是拆点后的点的编号，c 即是顾客在该店员修理花费的时间。最后将所有店员都连接到虚拟汇点即可。

 

代码如下：

#include <bits/stdc++.h>
using namespace std;
typedef int MyType;
const MyType INF = 0x7F7F7F7F;
const int MAXN = 1000 + 10;
const int MAXM = 1000000 + 10;

struct Edge { int to, next; MyType cap, cost; };
Edge es[MAXM];
int head[MAXN], dis[MAXN], pre[MAXN], que[MAXM], a[MAXN][MAXN];
bool vis[MAXN];
int n, m, cnt, src, des;

void add( int u, int v, MyType f, MyType c ) {
    es[cnt].to = v; es[cnt].cap = f; es[cnt].cost = c;
    es[cnt].next = head[u]; head[u] = cnt++;
    es[cnt].to = u; es[cnt].cap = 0; es[cnt].cost = -c;
    es[cnt].next = head[v]; head[v] = cnt++;
    return ;
}

bool spfa() {
    int mf, me;
    memset( vis, false, sizeof( vis ) );
    memset( dis, 0x7F, sizeof( dis ) );
    memset( pre, -1, sizeof( pre ) );
    mf = me = 0;
    que[me++] = src; dis[src] = 0; vis[src] = true;
    while( mf != me ) {
        int u = que[mf++]; vis[u] = false;
        if( mf >= MAXM ) mf -= MAXM;
        for( int i = head[u]; ~i; i = es[i].next ) {
            int v = es[i].to;
            if( es[i].cap > 0 && dis[v] > dis[u] + es[i].cost ) {
                dis[v] = dis[u] + es[i].cost;
                pre[v] = i;
                if( !vis[v] ) {
                    vis[v] = true;
                    que[me++] = v;
                    if( me >= MAXM ) me -= MAXM;
                }
            }
        }
    }
    return dis[des] != INF;
}

MyType cflow() {
    MyType flow = INF;
    int u = des;
    while( ~pre[u] ) {
        u = pre[u];
        flow = min( flow, es[u].cap );
        u = es[u ^ 1].to;
    }
    u = des;
    while( ~pre[u] ) {
        u = pre[u];
        es[u].cap -= flow;
        es[u ^ 1].cap += flow;
        u = es[u ^  1].to;
    }
    return flow;
}

MyType MCMF() {
    MyType mincost, maxflow;
    mincost = maxflow = 0;
    while( spfa() ) {
        MyType flow = cflow();
        maxflow += flow;
        mincost += flow * dis[des];
    }
    return mincost;
}

int main() {
    int t;
    scanf( "%d", &t );
    while( t-- ) {
        scanf( "%d%d", &m, &n );
        memset( head, -1, sizeof( head ) ); cnt = 0;
        for( int i = 1; i <= n; ++i ) {
            for( int j = 1; j <= m; ++j )
                scanf( "%d", &a[i][j] );
        }
        src = 0; des = 1000;
        int ncnt = n + 1;
        for( int i = 1; i <= n; ++i ) add( src, i, 1, 0 );
        for( int i = 1; i <= m; ++i ) {
            for( int j = 1; j <= n; ++j ) {
                ++ncnt;
                for( int k = 1; k <= n; ++k ) {
                    add( k, ncnt, 1, a[k][i] * j );
                }
                add( ncnt, des, 1, 0 );
            }
        }
        printf( "%d
", MCMF() );
    }
    return 0;
}