Fixed Partition Memory Management UVALive

/**
题目: Fixed Partition Memory Management UVALive - 2238
链接：https://vjudge.net/problem/UVALive-2238
题意：lv
思路：lrjP352.
来自lrj训练指南。

n个程序作为左边结点， n*m个结点在右边；
由于只要求n个程序在右边能找到的匹配点，km算法可以求解。
修改nx,ny的值。

if(f[i][j]==-1){
   for(int k = 1; k <= n; k++)
       love[i][j*n+k-1] = -INF;///!!!注意这里不能少，相比于左右两边相同节点数的情况，那个时候，love数组所有值都赋值满了。
                               ///而本题右侧节点数更多，所以要自己初始化那些不合法的情况，要不然随机值会影响计算。
       continue;
}
*/

#include <iostream>
#include <cstring>
#include <cstdio>
#include <vector>
#include <cmath>
#include <queue>
using namespace std;
const int MAXN = 505;
const int INF = 0x3f3f3f3f;

struct node
{
    int st, ed;
    int region;
}ans[MAXN];///表示第i个程序，在region区域运行，时间为[st,ed]:
int a[MAXN][MAXN];///a[i][j]表示第i个区域块，倒数第j次运行的程序编号。

int love[MAXN][MAXN];   // 记录每个妹子和每个男生的好感度
int ex_girl[MAXN];      // 每个妹子的期望值
int ex_boy[MAXN];       // 每个男生的期望值
bool vis_girl[MAXN];    // 记录每一轮匹配匹配过的女生
bool vis_boy[MAXN];     // 记录每一轮匹配匹配过的男生
int match[MAXN];        // 记录每个男生匹配到的妹子 如果没有则为-1
int slack[MAXN];        // 记录每个汉子如果能被妹子倾心最少还需要多少期望值
int nx, ny;  //左边的为nx个点，右边的为ny个点。
int N;

bool dfs(int girl)
{
    vis_girl[girl] = true;

    for (int boy = 0; boy < ny; ++boy) {

        if (vis_boy[boy]) continue; // 每一轮匹配 每个男生只尝试一次

        int gap = ex_girl[girl] + ex_boy[boy] - love[girl][boy];

        if (gap == 0) {  // 如果符合要求
            vis_boy[boy] = true;
            if (match[boy] == -1 || dfs( match[boy] )) {    // 找到一个没有匹配的男生 或者该男生的妹子可以找到其他人
                match[boy] = girl;
                return true;
            }
        } else {
            slack[boy] = min(slack[boy], gap);  // slack 可以理解为该男生要得到女生的倾心 还需多少期望值 取最小值 备胎的样子【捂脸
        }
    }

    return false;
}
///妹子在左边，男生在右边。
int KM()
{
    memset(match, -1, sizeof match);    // 初始每个男生都没有匹配的女生
    memset(ex_boy, 0, sizeof ex_boy);   // 初始每个男生的期望值为0

    // 每个女生的初始期望值是与她相连的男生最大的好感度
    for (int i = 0; i < nx; ++i) {
        ex_girl[i] = love[i][0];
        for (int j = 1; j < ny; ++j) {
            ex_girl[i] = max(ex_girl[i], love[i][j]);
        }
    }

    // 尝试为每一个女生解决归宿问题
    for (int i = 0; i < nx; ++i) {

        fill(slack, slack + ny, INF);    // 因为要取最小值 初始化为无穷大

        while (1) {
            // 为每个女生解决归宿问题的方法是 ：如果找不到就降低期望值，直到找到为止

            // 记录每轮匹配中男生女生是否被尝试匹配过
            memset(vis_girl, false, sizeof vis_girl);
            memset(vis_boy, false, sizeof vis_boy);

            if (dfs(i)) break;  // 找到归宿 退出

            // 如果不能找到 就降低期望值
            // 最小可降低的期望值
            int d = INF;
            for (int j = 0; j < ny; ++j)
                if (!vis_boy[j]) d = min(d, slack[j]);

            for (int j = 0; j < nx; ++j) {
                // 所有访问过的女生降低期望值
                if (vis_girl[j]) ex_girl[j] -= d;
            }
            for(int j = 0; j < ny; j++){
                // 所有访问过的男生增加期望值
                if (vis_boy[j]) ex_boy[j] += d;
                // 没有访问过的boy 因为girl们的期望值降低，距离得到女生倾心又进了一步！
                else slack[j] -= d;
            }

        }
    }

    // 匹配完成 求出所有配对的好感度的和
    int res = 0;
    for (int i = 0; i < ny; ++i){
        if(match[i]!=-1)
            res += love[ match[i] ][i];
    }

    return res;
}
int region[11];
typedef pair<int,int> P;
vector<P> program[MAXN];
int f[MAXN][MAXN];///f[i][j]表示第i个程序在第j个区域块的运行时间，如果为-1说明无法运行。
int main()
{
    int n, m;
    int cas = 1;
    while (scanf("%d%d",&m,&n)==2) {//N外部变量
        if(n==0&&m==0) break;
        nx = n, ny = n*m;
        for(int i = 0; i < m; i++){
            scanf("%d",&region[i]);
        }
        for(int i = 0; i < n; i++) program[i].clear();
        for(int i = 0; i < n; i++){
            int k;
            scanf("%d",&k);
            int v, t;
            for(int j = 0; j < k; j++){
                scanf("%d%d",&v,&t);///区域大小，时间。
                program[i].push_back(P(v,t));
            }
        }
        memset(f, -1, sizeof f);
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                int len = program[i].size();
                if(program[i][0].first>region[j]) continue;
                for(int k = 0; k < len; k++){
                    if(program[i][k].first>region[j]){
                        f[i][j] = program[i][k-1].second;
                        break;
                    }
                }
                if(f[i][j]==-1){
                    f[i][j] = program[i][len-1].second;
                }
            }
        }

        for(int i = 0; i < n; i++){///第i个程序
            for(int j = 0; j < m; j++){///第j个区域块
                if(f[i][j]==-1){
                    for(int k = 1; k <= n; k++)
                        love[i][j*n+k-1] = -INF;///!!!注意这里不能少，相比于左右两边相同节点数的情况，那个时候，love数组所有值都赋值满了。
                                                ///而本题右侧节点数更多，所以要自己初始化那些不合法的情况，要不然随机值会影响计算。
                    continue;
                }
                for(int k = 1; k <= n; k++){///倒数第k次运行。
                    love[i][j*n+k-1] = -k*f[i][j];
                }
            }
        }

        int sum = -KM();
        memset(a, -1, sizeof a);
        for(int i = 0; i < ny; i++){
            if(match[i]==-1) continue;
            int rg, pg, dao;
            rg = i/n;
            pg = match[i];
            dao = i%n+1;
            a[rg][dao] = pg;
        }
        for(int i = 0; i < m; i++){
            int time = 0;
            for(int j = n; j >= 1; j--){
                if(a[i][j]==-1) continue;
                ans[a[i][j]].region = i;
                ans[a[i][j]].st = time;
                time += f[a[i][j]][i];
                ans[a[i][j]].ed = time;
            }
        }


        printf("Case %d
",cas++);
        printf("Average turnaround time = %.2lf
",1.0*sum/n);
        for(int i = 0; i < n; i++){
            printf("Program %d runs in region %d from %d to %d
",i+1,ans[i].region+1,ans[i].st,ans[i].ed);
        }
        printf("
");
    }
    return 0;
}

模板转自：http://www.cnblogs.com/wenruo/p/5264235.html

n个程序作为左边结点， n*m个结点在右边；
由于只要求n个程序在右边能找到的匹配点，km算法可以求解。
修改nx,ny的值。 特别注意love[i][j]的初始化，全部自己初始化，不要出现随机值，或者上次的残余值的情况。

if(f[i][j]==-1){
   for(int k = 1; k <= n; k++)
       love[i][j*n+k-1] = -INF;///!!!注意这里不能少，相比于左右两边相同节点数的情况，那个时候，love数组所有值都赋值满了。
                               ///而本题右侧节点数更多，所以要自己初始化那些不合法的情况，要不然随机值会影响计算。
       continue;
}



const int MAXN = 505;
const int INF = 0x3f3f3f3f;

int love[MAXN][MAXN];   // 记录每个妹子和每个男生的好感度
int ex_girl[MAXN];      // 每个妹子的期望值
int ex_boy[MAXN];       // 每个男生的期望值
bool vis_girl[MAXN];    // 记录每一轮匹配匹配过的女生
bool vis_boy[MAXN];     // 记录每一轮匹配匹配过的男生
int match[MAXN];        // 记录每个男生匹配到的妹子 如果没有则为-1
int slack[MAXN];        // 记录每个汉子如果能被妹子倾心最少还需要多少期望值
int nx, ny;  //左边的为nx个点，右边的为ny个点。

bool dfs(int girl)
{
    vis_girl[girl] = true;

    for (int boy = 0; boy < ny; ++boy) {

        if (vis_boy[boy]) continue; // 每一轮匹配 每个男生只尝试一次

        int gap = ex_girl[girl] + ex_boy[boy] - love[girl][boy];

        if (gap == 0) {  // 如果符合要求
            vis_boy[boy] = true;
            if (match[boy] == -1 || dfs( match[boy] )) {    // 找到一个没有匹配的男生 或者该男生的妹子可以找到其他人
                match[boy] = girl;
                return true;
            }
        } else {
            slack[boy] = min(slack[boy], gap);  // slack 可以理解为该男生要得到女生的倾心 还需多少期望值 取最小值 备胎的样子【捂脸
        }
    }

    return false;
}
///妹子在左边，男生在右边。
int KM()
{
    memset(match, -1, sizeof match);    // 初始每个男生都没有匹配的女生
    memset(ex_boy, 0, sizeof ex_boy);   // 初始每个男生的期望值为0

    // 每个女生的初始期望值是与她相连的男生最大的好感度
    for (int i = 0; i < nx; ++i) {
        ex_girl[i] = love[i][0];
        for (int j = 1; j < ny; ++j) {
            ex_girl[i] = max(ex_girl[i], love[i][j]);
        }
    }

    // 尝试为每一个女生解决归宿问题
    for (int i = 0; i < nx; ++i) {

        fill(slack, slack + ny, INF);    // 因为要取最小值 初始化为无穷大

        while (1) {
            // 为每个女生解决归宿问题的方法是 ：如果找不到就降低期望值，直到找到为止

            // 记录每轮匹配中男生女生是否被尝试匹配过
            memset(vis_girl, false, sizeof vis_girl);
            memset(vis_boy, false, sizeof vis_boy);

            if (dfs(i)) break;  // 找到归宿 退出

            // 如果不能找到 就降低期望值
            // 最小可降低的期望值
            int d = INF;
            for (int j = 0; j < ny; ++j)
                if (!vis_boy[j]) d = min(d, slack[j]);

            for (int j = 0; j < nx; ++j) {
                // 所有访问过的女生降低期望值
                if (vis_girl[j]) ex_girl[j] -= d;
            }
            for(int j = 0; j < ny; j++){
                // 所有访问过的男生增加期望值
                if (vis_boy[j]) ex_boy[j] += d;
                // 没有访问过的boy 因为girl们的期望值降低，距离得到女生倾心又进了一步！
                else slack[j] -= d;
            }

        }
    }

    // 匹配完成 求出所有配对的好感度的和
    int res = 0;
    for (int i = 0; i < ny; ++i){
        if(match[i]!=-1)
            res += love[ match[i] ][i];
    }

    return res;
}
int main()
{
    int n, m;
    int cas = 1;
    while (scanf("%d%d",&m,&n)==2) {//N外部变量
        if(n==0&&m==0) break;
        nx = n, ny = n*m;///视具体情况初始化。nx表示左边结点个数，ny表示右边结点个数。
　　　　　　for(int i = 0; i < nx; i++){  ///视具体情况初始化。///视具体情况初始化。///视具体情况初始化。///视具体情况初始化。
　　　　　　　　for(int j = 0; j < ny; j++){///视具体情况初始化。
　　　　　　　　　　scanf("%d",&love[i][j]);
　　　　　　　　}
　　　　　　}
　　int sum = KM();
    return 0;
}