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;
}
时间: 2024-11-05 14:38:37

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

UVALive 2238 Fixed Partition Memory Management 固定分区内存管理(KM算法,变形)

题意:目前有一部分可用内存,分为m个大小固定的区域.现有n个程序要执行,每个程序在不同大小的内存中运行所需的时间不同,要使运行完所有程序所耗时最少,问每个程序在哪块区域中从什么时间运行到什么时间,以及运行完所有程序的平均周转时间. 思路:各种记录有点麻烦! m个区域看成m台内存大小为该区域大小的计算机,然后n个程序分别要选择在其中一台计算机中运行.由于运行有先后顺序,这也很影响平均周转时间,所以最极端时,其中某台计算机可能有n个程序要运行,那么每台计算机就得有n个位置供挑选.所以一共有n*m个位

UVA1006 Fixed Partition Memory Management

题意: 题目链接 有N个程序需要运行,同一个程序在不同的运行空间大小中运行时间不同(一个程序在2G的内存下运行5s,5G的内存下运行2s .etc) 给出M个运行区域,每个区域有各自的空间,同一时间一个区域只能运行一个程序 求如何安排使得所有程序的结束时间之和最小 N<=10 M<=50 (这样说好像也说不太清楚,其实看样例最好懂了/xyx) 思路: 这道题的建模极为经典 对于一个运行区域,设每个程序依次用时t1,t2....tk 那么这个区域的总用时为ri=kt1+(k-1)t2+....+

[ACM] POJ 3686 The Windy&#39;s (二分图最小权匹配,KM算法,特殊建图)

The Windy's Time Limit: 5000MS   Memory Limit: 65536K Total Submissions: 4158   Accepted: 1777 Description The Windy's is a world famous toy factory that owns M top-class workshop to make toys. This year the manager receivesN orders for toys. The man

POJ 3686 The Windy&#39;s【最小权匹配(神建图啊)】

大意:有n个任务m个机器,告诉你n*m的矩阵表示每个任务在每个机器上完成需要的时间 问所有任务完成的总时间最少?(比如第一个任务在第一分钟完成第二个任务在第二分钟完成   则总时间为1 + 2 = 3 分析: 该题自己做的时候没有思路 后来在网上搜题解,感觉建图真是太厉害了 假设最优情况下,个个任务需要的时间分别为a1, a2, a3, ……,an 那么总时间t = n * a1 + (n - 1) * a2 + ……+ 2 * an - 1 + an 也就是说只需要考虑系数就可以了 我们先假设

Random Maze (hdu 4067 最小费用流 好题 贪心思想建图)

Random Maze Time Limit: 10000/3000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 1373    Accepted Submission(s): 514 Problem Description In the game "A Chinese Ghost Story", there are many random mazes which

POJ 2724 奶酪消毒机 二分匹配 建图 比较难想

Purifying Machine Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 5004   Accepted: 1444 Description Mike is the owner of a cheese factory. He has 2N cheeses and each cheese is given a binary number from 00...0 to 11...1. To keep his chee

poj3592 Instantaneous Transference tarjan缩点+建图

//给一个n*m的地图,坦克从(0 , 0)开始走 //#表示墙不能走,*表示传送门可以传送到指定地方,可以选择也可以选择不传送 //数字表示该格的矿石数, //坦克从(0,0)开始走,只能往右和往下走, //问最多能得到多少矿石 //直接建图,但由于有传送门,需要缩点 //然后用dfs直接搜一条权值最大的路 #include<cstdio> #include<cstring> #include<iostream> #include<vector> #inc

网络流建图

最大流问题变形:多汇点多源点:加一个超级源点S与超级汇点TS到每个源点建立一条容量为对应的最大流出容量的边每个汇点到T建立一条容量为对应的最大流入容量的边无向图:把无向图的一条边拆成两个反向的容量相等的有向边顶点上有流量限制:把每个顶点拆成两个顶点,一个入,一个出,然后入->出连接一条容量为顶点流量限制c的边有最小流量限制:最小费用流问题变形:与最大流类似 最小权匹配问题:两类物体之间的对应关系,把两类物体看成顶点,并在顶点之间连接权重为对应花费的边,就转化为最小权匹配问题.可以使用最小费用流解

SYSU-4, UVA 12711, 一般图最大(小)权匹配

题目大意:给你一个100个点的图,划分成两个点集,要求A点集所有点的度为奇数,B点集的点为偶数,求一个最小边权边集满足这个约束. 解:我们要先抽象提炼一些性质,才能得到这题一般图最小匹配的做法 首先一点,偶数点完全不用考虑,要么他们不选取,要么他们作为路径上的点即可(出度=入度),所以直接做一遍flyod,就可以把图变成只剩A点集的图了. 第二点,就是对于一个合法答案,一条边不可能被选取两遍或以上,因为这样可以可以去掉两次这条边,依然可以得到一个合法图,而且答案更小,这是用来证明上面抽象图的做法