最大权值匹配算法

最新推荐文章于 2024-08-28 18:40:20 发布
最新推荐文章于 2024-08-28 18:40:20 发布
阅读量1.2k 收藏 4
点赞数
分类专栏： 算法 文章标签： 算法 深度优先 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36892712/article/details/130002291
版权

最大权值匹配算法

算法描述

最大权值匹配算法（Maximum Weight Matching Algorithm）指的是在一个带权图中，选取一些边，并使这些边两端所连的节点不同，使这些边上的权值之和最大化的一个问题。

常用的算法有两种：匈牙利算法和KM算法。

题目描述

以下是一道最大权值匹配算法题目：

有一个公司需要为 N 个员工分配任务，对于员工 i，可以完成任务 j 并获得收益 w(i, j)。为了使公司得到最大的收益，你需要将 N 个员工分配到 N 个任务上，使得总收益最大。注意，每个员工只能被分配一项任务，每项任务也只能由一个员工完成。

请编写一个优化算法，计算出最大收益，并输出员工和任务的匹配情况。

输入格式：
第一行一个整数 N，表示员工和任务的数量。
接下来 N 行，每行 N 个整数，表示 w(i, j)，表示第 i 个员工完成第 j 个任务可以获得的收益。

输出格式：
第一行输出最大收益，第二行输出员工和任务的匹配情况，每行两个数 i 和 j，表示员工 i 被分配到任务 j 上。

解答

匈牙利算法

匈牙利算法是解决二分图最大权值匹配问题的一种经典算法。在一个二分图中，每个节点都被划分为左右两个部分，我们需要在左部节点和右部节点之间建立一一对应的匹配，使得匹配边的权值之和最大。

匈牙利算法的基本思路是通过不断增广匹配来寻找最大权值匹配。它的步骤如下：

初始化：将所有匹配边的权值设为0，找到所有未匹配的左部节点，将它们依次作为增广路径的起点。

找增广路径：对于每个未匹配的左部节点，尝试通过DFS或BFS寻找一条增广路径。具体来说，我们从该左部节点开始，依次考虑与它相邻的右部节点，如果该右部节点未匹配或存在未访问过的增广路径，就将其匹配到当前左部节点，否则我们尝试沿着当前右部节点已匹配的边继续寻找增广路径，直到找到一条新的未匹配的右部节点为止。如果找到了一条增广路径，就将该路径上所有已匹配的边反转成未匹配的边，将该路径上所有未匹配的边匹配起来，然后返回步骤2。

最大匹配：重复执行步骤2，直到没有增广路径可以找到为止。此时所有已匹配的边就组成了最大权值匹配。

匈牙利算法的时间复杂度为 O ( n 3 ) O(n^3) O(n3)，其中 n n n 是二分图中节点的总数。具体来说，每次寻找增广路径需要遍历整个图，而最多需要增广 n n n 次才能找到最大匹配。

代码

以下是使用 C++ 实现最大权值匹配算法的代码示例：

#include <iostream>
#include <cstring>
#include <string>
#include <format>
#include <string_view>
using namespace std;

const int MAXN = 1005; // 最大点数
const int INF = 0x3f3f3f3f;

int weight[MAXN][MAXN];  // 二分图的邻接矩阵
int lx[MAXN], ly[MAXN];  // 顶标
bool sx[MAXN], sy[MAXN]; // 是否在匹配中
int match[MAXN];         // 记录右部点的匹配左部点编号，-1 表示未匹配

int n; // 点的总数，左部点编号 0~n-1，右部点编号 n~2n-1

template <typename T>
string GetArrInfo(T &arr)
{
    string res = "";
    for (size_t i = 0; i < n; i++)
    {
        res += to_string(arr[i]);
        if (i != n - 1)
            res += ' ';
    }
    return res;
}

bool dfs(int u, bool isUpSearch = false)
{
    sx[u] = true;
    cout << "sx: " + GetArrInfo(sx) + "  sy: " + GetArrInfo(sy) + "  lx: " + GetArrInfo(lx) + "  ly: " + GetArrInfo(ly) + "  match:" + GetArrInfo(match) + " --change sx u=" + to_string(u) + (isUpSearch ? " --UpSearch" : "") + "\n";
    for (int v = 0; v < n; v++)
        if (!sy[v] && lx[u] + ly[v] == weight[u][v])
        {
            sy[v] = true;
            cout << "sx: " + GetArrInfo(sx) + "  sy: " + GetArrInfo(sy) + "  lx: " + GetArrInfo(lx) + "  ly: " + GetArrInfo(ly) + "  match:" + GetArrInfo(match) +
                        " --change sy " + "lx[" + to_string(u) + "] + ly[" + to_string(v) + "]=" + to_string(weight[u][v]) + " \n";
            if (match[v] == -1 || dfs(match[v], true))
            {
                match[v] = u;
                cout << "sx: " + GetArrInfo(sx) + "  sy: " + GetArrInfo(sy) + "  lx: " + GetArrInfo(lx) + "  ly: " + GetArrInfo(ly) + "  match:" + GetArrInfo(match) + " --change match \n";
                return true;
            }
        }
    return false;
}

int HungaryMatch(bool maxsum = true)
{
    int i, j;
    if (!maxsum)
    {
        for (i = 0; i < n; i++)
            for (j = 0; j < n; j++)
                weight[i][j] = -weight[i][j];
    }

    // 初始化标号
    for (i = 0; i < n; i++)
    {
        lx[i] = -0x1FFFFFFF;
        ly[i] = 0;
        for (j = 0; j < n; j++)
            if (lx[i] < weight[i][j])
                lx[i] = weight[i][j];
    }

    memset(match, -1, sizeof(match));
    for (int u = 0; u < n; u++)
    {
        cout << "Left Point Index:" + to_string(u) + "\n";
        while (true)
        {
            // 重置sx,sy状态 都置为未访问
            memset(sx, 0, sizeof(sx));
            memset(sy, 0, sizeof(sy));

            // 深度优先搜索DFS
            bool is_find = dfs(u);
            cout << "sx: " + GetArrInfo(sx) + "  sy: " + GetArrInfo(sy) + "  lx: " + GetArrInfo(lx) + "  ly: " + GetArrInfo(ly) + "  match:" + GetArrInfo(match) + " --After dfs isfind=" + to_string(is_find) + " \n";
            if (is_find)
                break;

            // 修改标号  DFS未能找到可分配项
            // 对已访问的左侧节点，求他们与未访问的右侧节点的权值最小差值
            int dx = 0x7FFFFFFF;
            for (i = 0; i < n; i++)
                if (sx[i])
                    for (j = 0; j < n; j++)
                        if (!sy[j])
                            dx = min(lx[i] + ly[j] - weight[i][j], dx);

            // 对DFS搜索路径中访问过的左侧节点和右侧节点 更新标号 lx, ly  
            // 主要用于便于递归遍历时查找 lx[u] + ly[v] == weight[u][v] 且 ly[v]==0的匹配项
            for (i = 0; i < n; i++)
            {
                if (sx[i])
                    lx[i] -= dx;
                if (sy[i])
                    ly[i] += dx;
            }

            cout << "sx: " + GetArrInfo(sx) + "  sy: " + GetArrInfo(sy) + "  lx: " + GetArrInfo(lx) + "  ly: " + GetArrInfo(ly) + "  match:" + GetArrInfo(match) + " -- change lx and ly, dx = " + to_string(dx) + "\n";
        }
    }

    int sum = 0;
    for (i = 0; i < n; i++)
        sum += weight[match[i]][i];

    if (!maxsum)
    {
        sum = -sum;
        for (i = 0; i < n; i++)
            for (j = 0; j < n; j++)
                weight[i][j] = -weight[i][j]; // 如果需要保持 weight [ ] [ ] 原来的值，这里需要将其还原
    }
    return sum;
}

/*
5
3 4 6 4 9
6 4 5 3 8
7 5 3 4 2
6 3 2 2 5
8 4 5 4 7
//执行bestmatch (true) ，结果为 29
*/

int main()
{
    // 读入二分图
    cin >> n;
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            cin >> weight[i][j];
        }
    }

    int ans = HungaryMatch();
    cout << ans << endl;

    return 0;
}

执行结果（重点看 --change match的输出，可以便于理解）：

5
3 4 6 4 9
6 4 5 3 8
7 5 3 4 2
6 3 2 2 5
8 4 5 4 7

Left Point Index:0
sx: 1 0 0 0 0  sy: 0 0 0 0 0  lx: 9 8 7 6 8  ly: 0 0 0 0 0  match:-1 -1 -1 -1 -1 --change sx u=0
sx: 1 0 0 0 0  sy: 0 0 0 0 1  lx: 9 8 7 6 8  ly: 0 0 0 0 0  match:-1 -1 -1 -1 -1 --change sy lx[0] + ly[4]=9
sx: 1 0 0 0 0  sy: 0 0 0 0 1  lx: 9 8 7 6 8  ly: 0 0 0 0 0  match:-1 -1 -1 -1 0 --change match
sx: 1 0 0 0 0  sy: 0 0 0 0 1  lx: 9 8 7 6 8  ly: 0 0 0 0 0  match:-1 -1 -1 -1 0 --After dfs isfind=1
Left Point Index:1
sx: 0 1 0 0 0  sy: 0 0 0 0 0  lx: 9 8 7 6 8  ly: 0 0 0 0 0  match:-1 -1 -1 -1 0 --change sx u=1
sx: 0 1 0 0 0  sy: 0 0 0 0 1  lx: 9 8 7 6 8  ly: 0 0 0 0 0  match:-1 -1 -1 -1 0 --change sy lx[1] + ly[4]=8
sx: 1 1 0 0 0  sy: 0 0 0 0 1  lx: 9 8 7 6 8  ly: 0 0 0 0 0  match:-1 -1 -1 -1 0 --change sx u=0 --UpSearch
sx: 1 1 0 0 0  sy: 0 0 0 0 1  lx: 9 8 7 6 8  ly: 0 0 0 0 0  match:-1 -1 -1 -1 0 --After dfs isfind=0
sx: 1 1 0 0 0  sy: 0 0 0 0 1  lx: 7 6 7 6 8  ly: 0 0 0 0 2  match:-1 -1 -1 -1 0 -- change lx and ly, dx = 2
sx: 0 1 0 0 0  sy: 0 0 0 0 0  lx: 7 6 7 6 8  ly: 0 0 0 0 2  match:-1 -1 -1 -1 0 --change sx u=1
sx: 0 1 0 0 0  sy: 1 0 0 0 0  lx: 7 6 7 6 8  ly: 0 0 0 0 2  match:-1 -1 -1 -1 0 --change sy lx[1] + ly[0]=6
sx: 0 1 0 0 0  sy: 1 0 0 0 0  lx: 7 6 7 6 8  ly: 0 0 0 0 2  match:1 -1 -1 -1 0 --change match
sx: 0 1 0 0 0  sy: 1 0 0 0 0  lx: 7 6 7 6 8  ly: 0 0 0 0 2  match:1 -1 -1 -1 0 --After dfs isfind=1
Left Point Index:2
sx: 0 0 1 0 0  sy: 0 0 0 0 0  lx: 7 6 7 6 8  ly: 0 0 0 0 2  match:1 -1 -1 -1 0 --change sx u=2
sx: 0 0 1 0 0  sy: 1 0 0 0 0  lx: 7 6 7 6 8  ly: 0 0 0 0 2  match:1 -1 -1 -1 0 --change sy lx[2] + ly[0]=7
sx: 0 1 1 0 0  sy: 1 0 0 0 0  lx: 7 6 7 6 8  ly: 0 0 0 0 2  match:1 -1 -1 -1 0 --change sx u=1 --UpSearch
sx: 0 1 1 0 0  sy: 1 0 0 0 1  lx: 7 6 7 6 8  ly: 0 0 0 0 2  match:1 -1 -1 -1 0 --change sy lx[1] + ly[4]=8
sx: 1 1 1 0 0  sy: 1 0 0 0 1  lx: 7 6 7 6 8  ly: 0 0 0 0 2  match:1 -1 -1 -1 0 --change sx u=0 --UpSearch
sx: 1 1 1 0 0  sy: 1 0 0 0 1  lx: 7 6 7 6 8  ly: 0 0 0 0 2  match:1 -1 -1 -1 0 --After dfs isfind=0
sx: 1 1 1 0 0  sy: 1 0 0 0 1  lx: 6 5 6 6 8  ly: 1 0 0 0 3  match:1 -1 -1 -1 0 -- change lx and ly, dx = 1
sx: 0 0 1 0 0  sy: 0 0 0 0 0  lx: 6 5 6 6 8  ly: 1 0 0 0 3  match:1 -1 -1 -1 0 --change sx u=2
sx: 0 0 1 0 0  sy: 1 0 0 0 0  lx: 6 5 6 6 8  ly: 1 0 0 0 3  match:1 -1 -1 -1 0 --change sy lx[2] + ly[0]=7
sx: 0 1 1 0 0  sy: 1 0 0 0 0  lx: 6 5 6 6 8  ly: 1 0 0 0 3  match:1 -1 -1 -1 0 --change sx u=1 --UpSearch
sx: 0 1 1 0 0  sy: 1 0 1 0 0  lx: 6 5 6 6 8  ly: 1 0 0 0 3  match:1 -1 -1 -1 0 --change sy lx[1] + ly[2]=5
sx: 0 1 1 0 0  sy: 1 0 1 0 0  lx: 6 5 6 6 8  ly: 1 0 0 0 3  match:1 -1 1 -1 0 --change match
sx: 0 1 1 0 0  sy: 1 0 1 0 0  lx: 6 5 6 6 8  ly: 1 0 0 0 3  match:2 -1 1 -1 0 --change match
sx: 0 1 1 0 0  sy: 1 0 1 0 0  lx: 6 5 6 6 8  ly: 1 0 0 0 3  match:2 -1 1 -1 0 --After dfs isfind=1
Left Point Index:3
sx: 0 0 0 1 0  sy: 0 0 0 0 0  lx: 6 5 6 6 8  ly: 1 0 0 0 3  match:2 -1 1 -1 0 --change sx u=3
sx: 0 0 0 1 0  sy: 0 0 0 0 0  lx: 6 5 6 6 8  ly: 1 0 0 0 3  match:2 -1 1 -1 0 --After dfs isfind=0
sx: 0 0 0 1 0  sy: 0 0 0 0 0  lx: 6 5 6 5 8  ly: 1 0 0 0 3  match:2 -1 1 -1 0 -- change lx and ly, dx = 1
sx: 0 0 0 1 0  sy: 0 0 0 0 0  lx: 6 5 6 5 8  ly: 1 0 0 0 3  match:2 -1 1 -1 0 --change sx u=3
sx: 0 0 0 1 0  sy: 1 0 0 0 0  lx: 6 5 6 5 8  ly: 1 0 0 0 3  match:2 -1 1 -1 0 --change sy lx[3] + ly[0]=6
sx: 0 0 1 1 0  sy: 1 0 0 0 0  lx: 6 5 6 5 8  ly: 1 0 0 0 3  match:2 -1 1 -1 0 --change sx u=2 --UpSearch
sx: 0 0 1 1 0  sy: 1 0 0 0 0  lx: 6 5 6 5 8  ly: 1 0 0 0 3  match:2 -1 1 -1 0 --After dfs isfind=0
sx: 0 0 1 1 0  sy: 1 0 0 0 0  lx: 6 5 5 4 8  ly: 2 0 0 0 3  match:2 -1 1 -1 0 -- change lx and ly, dx = 1
sx: 0 0 0 1 0  sy: 0 0 0 0 0  lx: 6 5 5 4 8  ly: 2 0 0 0 3  match:2 -1 1 -1 0 --change sx u=3
sx: 0 0 0 1 0  sy: 1 0 0 0 0  lx: 6 5 5 4 8  ly: 2 0 0 0 3  match:2 -1 1 -1 0 --change sy lx[3] + ly[0]=6
sx: 0 0 1 1 0  sy: 1 0 0 0 0  lx: 6 5 5 4 8  ly: 2 0 0 0 3  match:2 -1 1 -1 0 --change sx u=2 --UpSearch
sx: 0 0 1 1 0  sy: 1 1 0 0 0  lx: 6 5 5 4 8  ly: 2 0 0 0 3  match:2 -1 1 -1 0 --change sy lx[2] + ly[1]=5
sx: 0 0 1 1 0  sy: 1 1 0 0 0  lx: 6 5 5 4 8  ly: 2 0 0 0 3  match:2 2 1 -1 0 --change match
sx: 0 0 1 1 0  sy: 1 1 0 0 0  lx: 6 5 5 4 8  ly: 2 0 0 0 3  match:3 2 1 -1 0 --change match
sx: 0 0 1 1 0  sy: 1 1 0 0 0  lx: 6 5 5 4 8  ly: 2 0 0 0 3  match:3 2 1 -1 0 --After dfs isfind=1
Left Point Index:4
sx: 0 0 0 0 1  sy: 0 0 0 0 0  lx: 6 5 5 4 8  ly: 2 0 0 0 3  match:3 2 1 -1 0 --change sx u=4
sx: 0 0 0 0 1  sy: 0 0 0 0 0  lx: 6 5 5 4 8  ly: 2 0 0 0 3  match:3 2 1 -1 0 --After dfs isfind=0
sx: 0 0 0 0 1  sy: 0 0 0 0 0  lx: 6 5 5 4 6  ly: 2 0 0 0 3  match:3 2 1 -1 0 -- change lx and ly, dx = 2
sx: 0 0 0 0 1  sy: 0 0 0 0 0  lx: 6 5 5 4 6  ly: 2 0 0 0 3  match:3 2 1 -1 0 --change sx u=4
sx: 0 0 0 0 1  sy: 1 0 0 0 0  lx: 6 5 5 4 6  ly: 2 0 0 0 3  match:3 2 1 -1 0 --change sy lx[4] + ly[0]=8
sx: 0 0 0 1 1  sy: 1 0 0 0 0  lx: 6 5 5 4 6  ly: 2 0 0 0 3  match:3 2 1 -1 0 --change sx u=3 --UpSearch
sx: 0 0 0 1 1  sy: 1 0 0 0 0  lx: 6 5 5 4 6  ly: 2 0 0 0 3  match:3 2 1 -1 0 --After dfs isfind=0
sx: 0 0 0 1 1  sy: 1 0 0 0 0  lx: 6 5 5 3 5  ly: 3 0 0 0 3  match:3 2 1 -1 0 -- change lx and ly, dx = 1
sx: 0 0 0 0 1  sy: 0 0 0 0 0  lx: 6 5 5 3 5  ly: 3 0 0 0 3  match:3 2 1 -1 0 --change sx u=4
sx: 0 0 0 0 1  sy: 1 0 0 0 0  lx: 6 5 5 3 5  ly: 3 0 0 0 3  match:3 2 1 -1 0 --change sy lx[4] + ly[0]=8
sx: 0 0 0 1 1  sy: 1 0 0 0 0  lx: 6 5 5 3 5  ly: 3 0 0 0 3  match:3 2 1 -1 0 --change sx u=3 --UpSearch
sx: 0 0 0 1 1  sy: 1 1 0 0 0  lx: 6 5 5 3 5  ly: 3 0 0 0 3  match:3 2 1 -1 0 --change sy lx[3] + ly[1]=3
sx: 0 0 1 1 1  sy: 1 1 0 0 0  lx: 6 5 5 3 5  ly: 3 0 0 0 3  match:3 2 1 -1 0 --change sx u=2 --UpSearch
sx: 0 0 1 1 1  sy: 1 1 1 0 0  lx: 6 5 5 3 5  ly: 3 0 0 0 3  match:3 2 1 -1 0 --change sy lx[4] + ly[2]=5
sx: 0 1 1 1 1  sy: 1 1 1 0 0  lx: 6 5 5 3 5  ly: 3 0 0 0 3  match:3 2 1 -1 0 --change sx u=1 --UpSearch
sx: 0 1 1 1 1  sy: 1 1 1 0 1  lx: 6 5 5 3 5  ly: 3 0 0 0 3  match:3 2 1 -1 0 --change sy lx[1] + ly[4]=8
sx: 1 1 1 1 1  sy: 1 1 1 0 1  lx: 6 5 5 3 5  ly: 3 0 0 0 3  match:3 2 1 -1 0 --change sx u=0 --UpSearch
sx: 1 1 1 1 1  sy: 1 1 1 0 1  lx: 6 5 5 3 5  ly: 3 0 0 0 3  match:3 2 1 -1 0 --After dfs isfind=0
sx: 1 1 1 1 1  sy: 1 1 1 0 1  lx: 5 4 4 2 4  ly: 4 1 1 0 4  match:3 2 1 -1 0 -- change lx and ly, dx = 1
sx: 0 0 0 0 1  sy: 0 0 0 0 0  lx: 5 4 4 2 4  ly: 4 1 1 0 4  match:3 2 1 -1 0 --change sx u=4
sx: 0 0 0 0 1  sy: 1 0 0 0 0  lx: 5 4 4 2 4  ly: 4 1 1 0 4  match:3 2 1 -1 0 --change sy lx[4] + ly[0]=8
sx: 0 0 0 1 1  sy: 1 0 0 0 0  lx: 5 4 4 2 4  ly: 4 1 1 0 4  match:3 2 1 -1 0 --change sx u=3 --UpSearch
sx: 0 0 0 1 1  sy: 1 1 0 0 0  lx: 5 4 4 2 4  ly: 4 1 1 0 4  match:3 2 1 -1 0 --change sy lx[3] + ly[1]=3
sx: 0 0 1 1 1  sy: 1 1 0 0 0  lx: 5 4 4 2 4  ly: 4 1 1 0 4  match:3 2 1 -1 0 --change sx u=2 --UpSearch
sx: 0 0 1 1 1  sy: 1 1 0 1 0  lx: 5 4 4 2 4  ly: 4 1 1 0 4  match:3 2 1 -1 0 --change sy lx[2] + ly[3]=4
sx: 0 0 1 1 1  sy: 1 1 0 1 0  lx: 5 4 4 2 4  ly: 4 1 1 0 4  match:3 2 1 2 0 --change match
sx: 0 0 1 1 1  sy: 1 1 0 1 0  lx: 5 4 4 2 4  ly: 4 1 1 0 4  match:3 3 1 2 0 --change match
sx: 0 0 1 1 1  sy: 1 1 0 1 0  lx: 5 4 4 2 4  ly: 4 1 1 0 4  match:4 3 1 2 0 --change match
sx: 0 0 1 1 1  sy: 1 1 0 1 0  lx: 5 4 4 2 4  ly: 4 1 1 0 4  match:4 3 1 2 0 --After dfs isfind=1
29
lqjun0827
关注
专栏目录
二分图最大权匹配——KM算法
weixin_30306905的博客
08-05 623
前言 这东西虽然我早就学过了，但是最近才发现我以前学的是假的，心中感慨万千（雾），故作此篇。 简介 带权二分图：每条边都有权值的二分图 最大权匹配：使所选边权和最大的匹配 KM算法，全称Kuhn-Munkres算法，是用于解决最大权匹配的一种算法。 根据我的理解，该算法算是一种基于贪心的松弛算法，它通过设置顶标将原问题转化为求一个完备匹配（完备匹配：匹配数=min(左部点数，右部点数）...
最大权匹配算法（km）
ruleless的专栏
08-17 1478
二分图的最大权匹配就是求所有匹配中权值最大的匹配。 char str[105][105]; int node[105][105],w[105][105],n,lx[105],ly[105],link[105]; bool visx[105],visy[105]; bool Find(int a) { visx[a]=true; int j; for(j=1;j<=n;j+
二分图最大权匹配（KM算法）
youngkl博客
03-13 2077
KM算法是通过给每个顶点一个标号（叫做顶标）来把求最大权匹配的问题转化为求完备匹配的问题的。设顶点Xi的顶标为A[i]，顶点Yi的顶标为B [i]，顶点Xi与Yj之间的边权为w[i,j]。在算法执行过程中的任一时刻，对于任一条边(i,j)，A[i]+B[j]>=w[i,j]始终 成立。KM算法的正确性基于以下定理：  　　若由二分图中所有满足A[i]+B[j]=w[i,j]的边(i,j)构成的子
一般图最大权匹配
最新发布
dingjiapeng1234的博客
08-28 964
匹配：对于图 G=(V,E)G=(V,E) 的一个匹配 MM 是边集 EE 的子集，其中两两不共用顶点。最大匹配：边数最多的匹配。完美匹配：包含原图所有点的匹配。最大权匹配：对于图 G(V,E)G(V,E)，边 e∈Ee∈E 的权重为 w(e)w(e)，最大权匹配 M=(V′,E′)M=(V′,E′) 为 ∑ew(e)∑e​w(e) 最大的匹配。最大权最大匹配：最大权最大匹配 M(V′,E′)M(V′,E′) 为 ∑ew(e)∑e​w(e) 最大的最大匹配。
干货 ||（小白入门+进阶）最全二分图总结（最大匹配、最大权匹配、点覆盖、独立集、路径覆盖，带证明和例题）
Here_SDUT的博客
05-27 6803
刚学完二分图感觉总结一下比较好，图论确实让人头秃，差不多一个多星期大概理解了二分图的内容，但还是挺生涩，还是多打点题吧 由于第一次学可能有些地方有出错欢迎大家指正！ 大纲 概念汇总 一、二分图的定义 二分图又称作二部图，是图论中的一种特殊模型。 设G=(V,E)是一个无向图，如果顶点V可分割为两个互不相交的子集(A,B)，并且图中的每条边（i，j）所关联的两个顶点i和j分别属于这两个不同的顶点集(i in A,j in B)，则称图G为一个二分图。简而言之，就是顶点集V可分割为两个互不相交的子集，并且图.
二分图最大匹配及最大权匹配（km算法）
06-14
看过很多二分图匹配的ppt，感觉就这个说的最清楚了，是一个叫刘汝佳的人写的，百度搜了一下貌似挺牛逼的，不管那么多，对km算法还抓耳挠腮的同志可以看看这个。
最大权值匹配算法（Hungarian算法）
qq_36892712的博客
06-18 477
基本思想：左边有节点n个，右边有节点m个，每个节点之间有一条边，每条边有一个权值，求一个匹配，使得匹配的边的权值和最大。
HDU2255（最全权完美匹配）
Keep_Trying_Go的博客
04-24 338
最大权完美匹配：二分图最大匹配是寻找最大匹配数，用匈牙利算法。当连 接的边带有权值时，要寻找匹配后权值和最大的方案，且保证 A 集合中的点均有 B 中的点能匹配。此时问题就转化为二分图最大权完美匹配。 KM 算法核心为: 为每一点添加顶标, 在顶标的限制下用匈牙利算法处理出最大匹配数, 若最大匹配数 =n, 则达到最优解, 输出。否则修改 顶标, 再用匈牙利算法处理, 如此重复。 设二分图的两部分点集分别为 X={X1,X2,…,Xn}X={X1,X2,…,Xn} 和 Y={Y1,Y2,…,Ym}
hdu3722Card Game(KM最大带权匹配)
ophunter的专栏
10-08 1401
题目请戳这里 题目大意：给n个字符串，再给一个n的排列：p1,p2....pn。然后将第i个字符串贴到第pi个字符串后面，然后形成一个环。pi的首字符和第i个字符串的末尾字符就相邻，如果这2个字符相等，各自再向内延伸一个位置，知道这个环首尾字符不等为止。延伸的位置为该环的得分（如果pi == i，得分为0），对于每个排列，有n个这样的环，求得分和最大为多少。 题目分析：最大带权匹配！！以为是个
左侧带权凸二分图动态最大权值匹配算法优化
传统凸二分图的动态基数匹配算法并不适用于权值匹配，因此，本文关注的是在左侧顶点带有权重的凸二分图中实现动态最大权值匹配的问题。 论文的核心贡献在于提出了一种问题求解框架，着重于维护参与匹配的顶点集合，...
Maximum Weight Matching
09-07
Uniform traffic Uniform cyclic Random permutation Wait-until-full Non-uniform traffic, known traffic matrix Birkhoff-von-Neumann Unknown traffic matrix Maximum Size Matching Maximum Weight Matching
二分图最大匹配算法：匈牙利、KM
Shilong的博客
01-09 1101
二分图最大匹配：匈牙利算法 二分图最大权匹配：KM算法
利用Kuhn-Munkras算法求最小权值匹配
u012348692的博客
07-20 4191
本文参考博客： http://blog.csdn.net/zhangpinghao/article/details/12242823 http://philoscience.iteye.com/blog/1754498KM算法求的是基于带权二分图中完备匹配下的最大权值匹配。关于km算法的讲解网上资料比较丰富，此处就不详述啦。这里主要整理一些用KM算法求最小权值匹配的一些问题。 在求最大权值匹配时
卡尔曼滤波在多目标跟踪中的应用及最大权值匹配数据关联Python代码
即，当多个检测器检测到多个目标时，最大权值匹配算法会选择一个最优的匹配方案，使得总的权值最大，从而有效地将检测结果与跟踪目标关联起来。 本项目适用于计算机科学与技术、人工智能、通信工程、自动化、电子...
Tour HDU - 3488（最大权值匹配）
babing2770的博客
07-15 117
Tour In the kingdom of Henryy, there are N (2 <= N <= 200) cities, with M (M <= 30000) one-way roads connecting them. You are lucky enough to have a chance to have a tour in the kingdom...
二分图最大权匹配（maximum weight matching in a  bipartite graph）
※夏日星空※
12-24 5835
二分图最大权匹配（maximum weight matching in a  bipartite graph） 带权二分图：二分图的连线被赋予一点的权值，这样的二分图就是带权二分图 KM算法求的是完备匹配下的最大权匹配: 在一个二分图内，左顶点为X，右顶点为Y，现对于每组左右连接XiYj有权wij，求一种匹配使得所有wij的和最大。 完备（美）匹配：二分图中左右子图中的各点都有对应的匹配。 ...
二分图最大权匹配：KM算法
wangqianqianya的博客
08-23 2927
转：https://blog.csdn.net/k_young1997/article/details/77193544 KM算法用来求二分图最大权完美匹配。 本文配合该博文服用更佳：趣写算法系列之--匈牙利算法 本文没有给出KM算法的原理，只是模拟了一遍算法的过程。另，博主水平较差，发现问题欢迎指出，谢谢！！！！ 现在有N男N女，有些男生和女生之间互相有好感，我们将其好感程度定义为好感度...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值