hlg1392Leyni, LOLI and Houses【网络流+二分+floyed】

今天过了几道网络流的题， 下面下一下解题报告， 题目难易不是梯度的 ，还有一些题目的代码在 voj上 等有空会补上的

 

Leyni, LOLI and Houses

Time Limit: 2000 MS

Memory Limit: 65536 K

Total Submit: 43(12 users)

Total Accepted: 19(11 users)

Rating:

Special Judge: No

Description

Leyni likes to play with LOLIs.

Leyni is playing with LOLIs outdoors, but suddenly it begins to rain, so the LOLI s need to enter some house in order to shelter from the rain.

 

There are m houses and n LOLIs. The houses locations are numbered by 1..m; the LOLIs are numbered by m+1..m+n. Each house can accommodate up to c LOLIs.

There are some paths among the LOLIs and the houses. You can think the distance and the time required to walk is equal.(e.g. Distance between LOLI_x and LOLI_y are d, then the time required for walking from LOLI_x to LOLI_y is d.)

LOLIs can also traverse several paths on the way to their houses.(e.g. There are paths LOLI_x=> LOLI_y and LOLI_y => house_z, then LOLI_x can reach house_z by the paths LOLI_x => LOLI_y => house_z)

 

In order to express his love and care for LOLIs, Leyni needs to wait until all LOLIs have entered the houses. Then he will go home. (The LOLIs begin to walk at the same time and concurrently)

Leyni wants to find an assignment for each LOLI to some house so that the time for him to wait is minimized (and, of course, the houses are not over utilized).

Please help him calculate the minimum time to wait.

Input

There are multiple test cases. The first line of input is an integer T indicating the number of test cases. Then T test cases follow.

For each test case:

Line 1. This line contains three space-separated integers, m(1 ≤ m ≤ 30), n(1 ≤ n ≤ 200), and c(1 ≤ c ≤ 15).

Lines 2..1+m+n. There is an (m + n) * (m + n) matrix MAT (0 ≤ MAT_ij ≤ 200), the element MAT_ij means the distance between entity i and entity j. It means that entity i and entity j is not directly connected if MAT_ij = 0.

(It is guaranteed that the element on the diagonal line will always be 0 and MAT_ij = MAT_ji)

Output

For each test case:

Line 1. Output the minimum possible total distance for the furthest walking LOLI. 

Sample Input

1

2 3 2

0 3 2 1 1

3 0 3 2 0

2 3 0 1 0

1 2 1 0 2

1 0 0 2 0

Sample Output

2

Source

哈理工2012春季校赛 - 现场赛

Author

齐达拉图@HRBUST

 

大意：

有m个房子和n个萝莉（房子编号1--m，萝莉编号m + 1 -- m + n)

现在萝莉要走到房间里去，但是， 你每个房间最多能容纳c个萝莉，并且萝莉跟每个房间都有一定的距离，我们还知道萝莉能够穿过一个房间到另一个房间

求所走距离最大的那个萝莉的距离最小值（前提是所有萝莉都能到房间并且房间不会超过上限）

 

模型：

1、任意两点都要求距离：floyed算法  n*n*n

2、最大距离的最小值：二分

3、所有萝莉都能到大房间，房间还有上限：网络流

 

思路：

用floyed处理处两点之间的最短距离，然后二分最大距离的最小值，建图求最大流是否等于萝莉数

 

wrong的原因：房屋和萝莉的编号搞错了

全都是泪啊

 

代码：

//1392
#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;

const int maxn = 30 * 200 + 10;
const int INF = 1000000000;

const int maxm = 30 + 200 + 10;
int a[maxn][maxn];
int m, n, c;
int ss, tt;

struct Edge
{
    int from, to, cap, flow;
};

struct Dinic
{
    int n, m, s, t;
    vector<Edge> edges;
    vector<int>G[maxn];
    bool vis[maxn];
    int d[maxn];
    int cur[maxn];

    void ClearAll(int n) {
        for(int i = 0; i <= n; i++) {
            G[i].clear();
        }
        edges.clear();
    }

    void AddEdge(int from, int to, int cap) {
        edges.push_back((Edge){from, to, cap, 0} );
        edges.push_back((Edge){to, from, 0, 0} );
        m = edges.size();
        G[from].push_back(m - 2);
        G[to].push_back(m - 1);
        //printf("%din end\n",m);
    }

    bool BFS()
    {
        memset(vis, 0, sizeof(vis) );
        queue<int> Q;
        Q.push(s);
        vis[s] = 1;
        d[s] = 0;
        while(!Q.empty() ){
            int x = Q.front(); Q.pop();
            for(int i = 0; i < G[x].size(); i++) {
                Edge& e = edges[G[x][i]];
                if(!vis[e.to] && e.cap > e.flow) {
                    vis[e.to] = 1;
                    d[e.to] = d[x] + 1;
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }

    int DFS(int x, int a) {
        if(x == t || a == 0) return a;
        int flow = 0, f;
        for(int& i = cur[x]; i < G[x].size(); i++) {
            Edge& e = edges[G[x][i]];
            if(d[x] + 1 == d[e.to] && (f = DFS(e.to, min(a, e.cap - e.flow))) > 0) {
                e.flow += f;
                edges[G[x][i]^1].flow -= f;
                flow += f;
                a -= f;
                if(a == 0) break;
            }
        }
        return flow;
    }

    int MaxFlow(int s, int t) {
        this -> s = s; this -> t = t;
        int flow = 0;
        while(BFS()) {
            memset(cur, 0, sizeof(cur));
            flow += DFS(s, INF);
        }
        return flow;
    }
};

Dinic g;

bool Check(int num) {
    if(n > m * c)
    return false;
    //printf("*%d\n",num);
    g.ClearAll(maxn);

    for(int i = m + 1; i <= m + n; i++) {
        g.AddEdge(ss, i, 1);
    }

    for(int i = 1; i <= m; i++) {
        g.AddEdge(i, tt, c);
    }

    for(int i = m + 1; i <= m + n; i++) {
        for(int j = 1; j <= m; j++) {
            if(a[i][j] <= num) {
                //printf("(%d,%d)\n",i, j);
                g.AddEdge(i, j, INF);
            }
        }
    }
    int ans = g.MaxFlow(ss, tt);
    //printf("%d %d\n",ans, n);
    if(ans == n)
        return true;
    else
        return false;
}


void Floyed() {
    int nNode = n + m;
    for(int k = 1; k <= nNode; k++) {
        for(int i = 1; i <= nNode; i++) {
            for(int j = 1; j <= nNode; j++) {
                if(k == i || k == j ) continue;
                if(a[i][j] > a[i][k] + a[k][j]) {
                    a[i][j] = a[i][k] + a[k][j];
                }
            }
        }
    }
}

int main() {
    int t;
    //freopen("b.txt","r",stdin);
    scanf("%d",&t);
    while(t--) {
        scanf("%d %d %d",&m, &n, &c);
        ss = 0; tt = n + m + 1;
        for(int i = 1; i <= m + n; i++) {
            for(int j = 1; j <= m + n; j++) {
                scanf("%d",&a[i][j]);
                if(a[i][j] == 0) {
                    a[i][j] = INF;
                }
            }
        }
        Floyed();
        //Check(0);
        /*
        for(int i = 1; i <= m + n; i++) {
            for(int j = 1; j <= m + n; j++) {
                printf("%d ",a[i][j]);
            }
            puts("");
        }*/
        //puts("END");
        int low = 0, high = maxn;
        while(low <= high) {
            int mid = (low + high) >> 1;
            //printf("%d %d\n",mid, Check(mid));
            if(!Check(mid)) {
                low = mid + 1;
            } else {
                high = mid - 1;
            }
        }
        //puts("");
        //printf("%d %d\n",low, high);
        printf("%d\n",high + 1);
    }
    return 0;
}