Fixed Partition Memory Management UVALive - 2238 建图很巧妙 km算法左右顶点个数不等模板以及需要注意的问题求最小权匹配

Posted 2020-09-28 天道酬勤007

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Fixed Partition Memory Management UVALive - 2238 建图很巧妙 km算法左右顶点个数不等模板以及需要注意的问题求最小权匹配相关的知识，希望对你有一定的参考价值。

/**
题目: 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\\n",cas++);
        printf("Average turnaround time = %.2lf\\n",1.0*sum/n);
        for(int i = 0; i < n; i++){
            printf("Program %d runs in region %d from %d to %d\\n",i+1,ans[i].region+1,ans[i].st,ans[i].ed);
        }
        printf("\\n");
    }
    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;
}

以上是关于Fixed Partition Memory Management UVALive - 2238 建图很巧妙 km算法左右顶点个数不等模板以及需要注意的问题求最小权匹配的主要内容，如果未能解决你的问题，请参考以下文章

Fixed Partition Memory Management UVALive - 2238 建图很巧妙 km算法左右顶点个数不等模板以及需要注意的问题求最小权匹配

A1113 | Integer Set Partition (25)

CodeForces 712D Memory and Scores

map/reduce之间的shuffle，partition，combiner过程的详解

DPDK — MEMPOOL（librte_mempool，Memory Pool Manager，内存池管理组件）

Fixed Partition Memory Management UVALive - 2238 建图很巧妙 km算法左右顶点个数不等模板以及需要注意的问题 求最小权匹配

Fixed Partition Memory Management UVALive - 2238 建图很巧妙 km算法左右顶点个数不等模板以及需要注意的问题求最小权匹配