数据关联-匈牙利算法C++源码以及用法(附源码)

已于 2024-08-21 15:46:42 修改
阅读量404 收藏
点赞数 16
文章标签： 算法 c++ 开发语言
于 2024-08-21 15:43:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64293675/article/details/141393742
版权

数据关联--匈牙利算法C++源码以及用法详解

代码

  • 编译运行
mkdir build
cd build
cmake ..
make
./data_associate
  • 头文件 — hungarian.h
#ifndef HUNGARIAN_H
#define HUNGARIAN_H

#include <iostream>
#include <vector>

class HungarianAlgorithm
{
public:
	HungarianAlgorithm();
	~HungarianAlgorithm();
	std::vector<float> Solve(std::vector<std::vector<float>> &DistMatrix, std::vector<int> &Assignment);

private:
	void assignmentoptimal(int *assignment, std::vector<float> &cost, float *distMatrix, int nOfRows, int nOfColumns);
	void buildassignmentvector(int *assignment, bool *starMatrix, int nOfRows, int nOfColumns);
	void computeassignmentcost(int *assignment, std::vector<float> &cost, float *distMatrix, int nOfRows);
	void step2a(int *assignment, float *distMatrix, bool *starMatrix, bool *newStarMatrix, bool *primeMatrix, bool *coveredColumns, bool *coveredRows, int nOfRows, int nOfColumns, int minDim);
	void step2b(int *assignment, float *distMatrix, bool *starMatrix, bool *newStarMatrix, bool *primeMatrix, bool *coveredColumns, bool *coveredRows, int nOfRows, int nOfColumns, int minDim);
	void step3(int *assignment, float *distMatrix, bool *starMatrix, bool *newStarMatrix, bool *primeMatrix, bool *coveredColumns, bool *coveredRows, int nOfRows, int nOfColumns, int minDim);
	void step4(int *assignment, float *distMatrix, bool *starMatrix, bool *newStarMatrix, bool *primeMatrix, bool *coveredColumns, bool *coveredRows, int nOfRows, int nOfColumns, int minDim, int row, int col);
	void step5(int *assignment, float *distMatrix, bool *starMatrix, bool *newStarMatrix, bool *primeMatrix, bool *coveredColumns, bool *coveredRows, int nOfRows, int nOfColumns, int minDim);
};

#endif
  • 源文件 — hungarian.cpp
#include <stdlib.h>
#include <cfloat> // for DBL_MAX
#include <cmath>  // for fabs()
#include "hungarian.h"

HungarianAlgorithm::HungarianAlgorithm() {}
HungarianAlgorithm::~HungarianAlgorithm() {}

// 输入 关联矩阵 
// 输出 匹配位置 
// 返回 每一个匹配的cost 
std::vector<float> HungarianAlgorithm::Solve(std::vector<std::vector<float>> &DistMatrix, std::vector<int> &Assignment)
{

	unsigned int nRows = DistMatrix.size();
	unsigned int nCols = DistMatrix[0].size();
	int cost_size = std::max(nRows, nCols);

	// 初始化cost值为0
	std::vector<float> cost(cost_size, 0.0);

	float *distMatrixIn = new float[nRows * nCols];
	int *assignment = new int[nRows];
	
	for (unsigned int i = 0; i < nRows; i++)
		for (unsigned int j = 0; j < nCols; j++)
			distMatrixIn[i + nRows * j] = DistMatrix[i][j];

	assignmentoptimal(assignment, cost, distMatrixIn, nRows, nCols);

	Assignment.clear();
	for (unsigned int r = 0; r < nRows; r++)
		Assignment.push_back(assignment[r]);

	delete[] distMatrixIn;
	delete[] assignment;
	return cost;
}

void HungarianAlgorithm::assignmentoptimal(int *assignment, std::vector<float> &cost, float *distMatrixIn, int nOfRows, int nOfColumns)
{
	float *distMatrix, *distMatrixTemp, *distMatrixEnd, *columnEnd, value, minValue;
	bool *coveredColumns, *coveredRows, *starMatrix, *newStarMatrix, *primeMatrix;
	int nOfElements, minDim, row, col;
	
	for (row = 0; row < nOfRows; row++)
		assignment[row] = -1;


	nOfElements = nOfRows * nOfColumns;
	distMatrix = (float *)malloc(nOfElements * sizeof(float));
	distMatrixEnd = distMatrix + nOfElements;

	for (row = 0; row < nOfElements; row++)
		distMatrix[row] = distMatrixIn[row];
	;

	/* memory allocation */
	coveredColumns = (bool *)calloc(nOfColumns, sizeof(bool));
	coveredRows = (bool *)calloc(nOfRows, sizeof(bool));
	starMatrix = (bool *)calloc(nOfElements, sizeof(bool));
	primeMatrix = (bool *)calloc(nOfElements, sizeof(bool));
	newStarMatrix = (bool *)calloc(nOfElements, sizeof(bool)); /* used in step4 */

	/* preliminary steps */
	if (nOfRows <= nOfColumns)
	{
		minDim = nOfRows;

		for (row = 0; row < nOfRows; row++)
		{
			/* find the smallest element in the row */
			distMatrixTemp = distMatrix + row;
			minValue = *distMatrixTemp;
			distMatrixTemp += nOfRows;
			while (distMatrixTemp < distMatrixEnd)
			{
				value = *distMatrixTemp;
				if (value < minValue)
					minValue = value;
				distMatrixTemp += nOfRows;
			}

			/* subtract the smallest element from each element of the row */
			distMatrixTemp = distMatrix + row;
			while (distMatrixTemp < distMatrixEnd)
			{
				*distMatrixTemp -= minValue;
				distMatrixTemp += nOfRows;
			}
		}

		/* Steps 1 and 2a */
		for (row = 0; row < nOfRows; row++)
			for (col = 0; col < nOfColumns; col++)
				if (fabs(distMatrix[row + nOfRows * col]) < DBL_EPSILON)
					if (!coveredColumns[col])
					{
						starMatrix[row + nOfRows * col] = true;
						coveredColumns[col] = true;
						break;
					}
	}
	else /* if(nOfRows > nOfColumns) */
	{
		minDim = nOfColumns;

		for (col = 0; col < nOfColumns; col++)
		{
			/* find the smallest element in the column */
			distMatrixTemp = distMatrix + nOfRows * col;
			columnEnd = distMatrixTemp + nOfRows;

			minValue = *distMatrixTemp++;
			while (distMatrixTemp < columnEnd)
			{
				value = *distMatrixTemp++;
				if (value < minValue)
					minValue = value;
			}

			/* subtract the smallest element from each element of the column */
			distMatrixTemp = distMatrix + nOfRows * col;
			while (distMatrixTemp < columnEnd)
				*distMatrixTemp++ -= minValue;
		}

		/* Steps 1 and 2a */
		for (col = 0; col < nOfColumns; col++)
			for (row = 0; row < nOfRows; row++)
				if (fabs(distMatrix[row + nOfRows * col]) < DBL_EPSILON)
					if (!coveredRows[row])
					{
						starMatrix[row + nOfRows * col] = true;
						coveredColumns[col] = true;
						coveredRows[row] = true;
						break;
					}
		for (row = 0; row < nOfRows; row++)
			coveredRows[row] = false;
	}

	/* move to step 2b */
	step2b(assignment, distMatrix, starMatrix, newStarMatrix, primeMatrix, coveredColumns, coveredRows, nOfRows, nOfColumns, minDim);

	/* compute cost and remove invalid assignments */
	computeassignmentcost(assignment, cost, distMatrixIn, nOfRows);

	/* free allocated memory */
	free(distMatrix);
	free(coveredColumns);
	free(coveredRows);
	free(starMatrix);
	free(primeMatrix);
	free(newStarMatrix);

	return;
}

void HungarianAlgorithm::buildassignmentvector(int *assignment, bool *starMatrix, int nOfRows, int nOfColumns)
{
	int row, col;

	for (row = 0; row < nOfRows; row++)
		for (col = 0; col < nOfColumns; col++)
			if (starMatrix[row + nOfRows * col])
			{
#ifdef ONE_INDEXING
				assignment[row] = col + 1; /* MATLAB-Indexing */
#else
				assignment[row] = col;
#endif
				break;
			}
}

void HungarianAlgorithm::computeassignmentcost(int *assignment, std::vector<float> &cost, float *distMatrix, int nOfRows)

{
	int row, col;

	for (row = 0; row < nOfRows; row++)
	{
		col = assignment[row];
		if (col >= 0)
		{
			cost[row] = distMatrix[row + nOfRows * col];
			// std::cout << "cost_" << std::to_string(row) << ":" << distMatrix[row + nOfRows * col] << std::endl;
		}
	}
}

void HungarianAlgorithm::step2a(int *assignment, float *distMatrix, bool *starMatrix, bool *newStarMatrix, bool *primeMatrix, bool *coveredColumns, bool *coveredRows, int nOfRows, int nOfColumns, int minDim)
{
	if (assignment == NULL || distMatrix == NULL || starMatrix == NULL || newStarMatrix == NULL || primeMatrix == NULL || coveredColumns == NULL || coveredRows == NULL)
	{
		return;
	}
	bool *starMatrixTemp, *columnEnd;
	int col;

	/* cover every column containing a starred zero */
	for (col = 0; col < nOfColumns; col++)
	{
		starMatrixTemp = starMatrix + nOfRows * col;
		columnEnd = starMatrixTemp + nOfRows;
		while (starMatrixTemp < columnEnd)
		{
			if (*starMatrixTemp++)
			{
				coveredColumns[col] = true;
				break;
			}
		}
	}

	/* move to step 3 */
	step2b(assignment, distMatrix, starMatrix, newStarMatrix, primeMatrix, coveredColumns, coveredRows, nOfRows, nOfColumns, minDim);
}

/********************************************************/
void HungarianAlgorithm::step2b(int *assignment, float *distMatrix, bool *starMatrix, bool *newStarMatrix, bool *primeMatrix, bool *coveredColumns, bool *coveredRows, int nOfRows, int nOfColumns, int minDim)
{
	if (assignment == NULL || distMatrix == NULL || starMatrix == NULL || newStarMatrix == NULL || primeMatrix == NULL || coveredColumns == NULL || coveredRows == NULL)
	{
		return;
	}
	int col, nOfCoveredColumns;

	/* count covered columns */
	nOfCoveredColumns = 0;
	for (col = 0; col < nOfColumns; col++)
		if (coveredColumns[col])
			nOfCoveredColumns++;

	if (nOfCoveredColumns == minDim)
	{
		/* algorithm finished */
		buildassignmentvector(assignment, starMatrix, nOfRows, nOfColumns);
	}
	else
	{
		/* move to step 3 */
		step3(assignment, distMatrix, starMatrix, newStarMatrix, primeMatrix, coveredColumns, coveredRows, nOfRows, nOfColumns, minDim);
	}
}

void HungarianAlgorithm::step3(int *assignment, float *distMatrix, bool *starMatrix, bool *newStarMatrix, bool *primeMatrix, bool *coveredColumns, bool *coveredRows, int nOfRows, int nOfColumns, int minDim)
{
	if (assignment == NULL || distMatrix == NULL || starMatrix == NULL || newStarMatrix == NULL || primeMatrix == NULL || coveredColumns == NULL || coveredRows == NULL)
	{
		return;
	}
	bool zerosFound;
	int row, col, starCol;

	zerosFound = true;
	while (zerosFound)
	{
		zerosFound = false;
		for (col = 0; col < nOfColumns; col++)
			if (!coveredColumns[col])
				for (row = 0; row < nOfRows; row++)
					if ((!coveredRows[row]) && (fabs(distMatrix[row + nOfRows * col]) < DBL_EPSILON))
					{
						/* prime zero */
						primeMatrix[row + nOfRows * col] = true;

						/* find starred zero in current row */
						for (starCol = 0; starCol < nOfColumns; starCol++)
							if (starMatrix[row + nOfRows * starCol])
								break;

						if (starCol == nOfColumns) /* no starred zero found */
						{
							/* move to step 4 */
							step4(assignment, distMatrix, starMatrix, newStarMatrix, primeMatrix, coveredColumns, coveredRows, nOfRows, nOfColumns, minDim, row, col);
							return;
						}
						else
						{
							coveredRows[row] = true;
							coveredColumns[starCol] = false;
							zerosFound = true;
							break;
						}
					}
	}

	/* move to step 5 */
	step5(assignment, distMatrix, starMatrix, newStarMatrix, primeMatrix, coveredColumns, coveredRows, nOfRows, nOfColumns, minDim);
}

void HungarianAlgorithm::step4(int *assignment, float *distMatrix, bool *starMatrix, bool *newStarMatrix, bool *primeMatrix, bool *coveredColumns, bool *coveredRows, int nOfRows, int nOfColumns, int minDim, int row, int col)
{
	if (assignment == NULL || distMatrix == NULL || starMatrix == NULL || newStarMatrix == NULL || primeMatrix == NULL || coveredColumns == NULL || coveredRows == NULL)
	{
		return;
	}
	int n, starRow, starCol, primeRow, primeCol;
	int nOfElements = nOfRows * nOfColumns;

	/* generate temporary copy of starMatrix */
	for (n = 0; n < nOfElements; n++)
		newStarMatrix[n] = starMatrix[n];

	/* star current zero */
	newStarMatrix[row + nOfRows * col] = true;

	/* find starred zero in current column */
	starCol = col;
	for (starRow = 0; starRow < nOfRows; starRow++)
		if (starMatrix[starRow + nOfRows * starCol])
			break;

	while (starRow < nOfRows)
	{
		/* unstar the starred zero */
		newStarMatrix[starRow + nOfRows * starCol] = false;

		/* find primed zero in current row */
		primeRow = starRow;
		for (primeCol = 0; primeCol < nOfColumns; primeCol++)
			if (primeMatrix[primeRow + nOfRows * primeCol])
				break;

		/* star the primed zero */
		newStarMatrix[primeRow + nOfRows * primeCol] = true;

		/* find starred zero in current column */
		starCol = primeCol;
		for (starRow = 0; starRow < nOfRows; starRow++)
			if (starMatrix[starRow + nOfRows * starCol])
				break;
	}

	/* use temporary copy as new starMatrix */
	/* delete all primes, uncover all rows */
	for (n = 0; n < nOfElements; n++)
	{
		primeMatrix[n] = false;
		starMatrix[n] = newStarMatrix[n];
	}
	for (n = 0; n < nOfRows; n++)
		coveredRows[n] = false;

	/* move to step 2a */
	step2a(assignment, distMatrix, starMatrix, newStarMatrix, primeMatrix, coveredColumns, coveredRows, nOfRows, nOfColumns, minDim);
}

/********************************************************/
void HungarianAlgorithm::step5(int *assignment, float *distMatrix, bool *starMatrix, bool *newStarMatrix, bool *primeMatrix, bool *coveredColumns, bool *coveredRows, int nOfRows, int nOfColumns, int minDim)
{
	if (assignment == NULL || distMatrix == NULL || starMatrix == NULL || newStarMatrix == NULL || primeMatrix == NULL || coveredColumns == NULL || coveredRows == NULL)
	{
		return;
	}
	float h, value;
	int row, col;

	/* find smallest uncovered element h */
	h = DBL_MAX;
	for (row = 0; row < nOfRows; row++)
		if (!coveredRows[row])
			for (col = 0; col < nOfColumns; col++)
				if (!coveredColumns[col])
				{
					value = distMatrix[row + nOfRows * col];
					if (value < h)
						h = value;
				}

	/* add h to each covered row */
	for (row = 0; row < nOfRows; row++)
		if (coveredRows[row])
			for (col = 0; col < nOfColumns; col++)
				distMatrix[row + nOfRows * col] += h;

	/* subtract h from each uncovered column */
	for (col = 0; col < nOfColumns; col++)
		if (!coveredColumns[col])
			for (row = 0; row < nOfRows; row++)
				distMatrix[row + nOfRows * col] -= h;

	/* move to step 3 */
	step3(assignment, distMatrix, starMatrix, newStarMatrix, primeMatrix, coveredColumns, coveredRows, nOfRows, nOfColumns, minDim);
}
  • 源文件 — main.cpp
#include "hungarian.h"
using namespace std;

int main()
{
	HungarianAlgorithm HungAlgo;
	
    vector<float> A = {1.9, 2.9, 3.9, 4.9};
    vector<float> B = {21.1, 3.1, 10.1, 2.1};
    vector<vector<float>> costMatrix(A.size(), vector<float>(B.size()));
    // 关联矩阵
    for (int i = 0; i < A.size(); i++) // current_target
    {
        for (int j = 0; j < B.size(); j++) // predicted_target
        {
            double dist = abs(A[i] - B[j]);
            costMatrix[i][j] = dist;
            cout << costMatrix[i][j] << ",";
        }
        cout << endl;
    }

    vector<int> assignment;
    vector<float> cost = HungAlgo.Solve(costMatrix, assignment);

    for (int i = 0; i < cost.size(); i++)
    {
        cout << "cost:" << cost[i] << endl;
    }

    for (int i = 0; i < assignment.size(); i++)
    {
        cout << "assignment:" << assignment[i] << endl;
    }
	return 0;
}
  • CmakeLists.txt
cmake_minimum_required(VERSION 3.0)
project(data_associate)

add_definitions(-std=c++11)
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_BUILD_TYPE Release)
include_directories("include/")

add_executable(data_associate
               src/hungarian.cpp
               src/main.cpp
               )

用法

具体调用见main.cpp，测试情况如下图
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

jessie的垃圾桶
关注
  • 16
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
多目标跟踪之数据关联算法——匈牙利算法
hello world
04-13 9802
一、匈牙利算法维基百科：https://zh.wikipedia.org/wiki/匈牙利算法 匈牙利算法最早是由匈牙利数学家Dénes Kőnig康尼格和Jenő Egerváry用来求矩阵中0元素的个数的一种方法。由此他证明『矩阵中独立0元素的最多个数等于能覆盖cover所有0元素的最少直线数』 匈牙利算法是一种在多项式时间内求解任务分配问题的组合优化算法，并推动了后来的原始对偶方法。 1955年，美国数学家哈罗德·库恩W.W.Kuhn（库恩）Harold W. Kuhn在求解著名的指派问题时引.
匈牙利算法的C++实现（基于OpenCV）
j56754gefge的专栏
11-04 5544
Hungarian Algorithm
Apollo perception源码阅读 | fusion之匈牙利算法
weixin_43152152的博客
02-28 4836
Apollo perception代码 匈牙利匹配源码剖析 leox24 / perception_learn 单独把Apollo perception6.0中的匈牙利匹配的代码单独拿出来了，换了下数据结构，可以简单调试用，test文件夹中cmake一下就行。项目里面也有perception的其他代码注释 hungarian-algorithm-cpp 这个里面也是匈牙利的实现，将二维矩阵转成了一维数组，用指针数组来实现的，可供参考。 匈牙利算法原理 关于匈牙利算法原理可以参考这篇博客，用Python和二分
用C++实现匈牙利算法
斯坦福-MIT-Harvard-CMU
06-02 1616
匈牙利算法（也称为增广路径算法）是一种解决二分图最大匹配问题的经典算法。请注意，这只是匈牙利算法的一种简单实现方式，实际应用中可能需要根据具体情况进行适当的修改和优化。函数来测试匈牙利算法并输出最大匹配数。函数来查找增广路径。是一个表示二分图的邻接矩阵，其中。计算二分图的最大匹配数，它调用。个节点之间是否有边。在上面的示例代码中，
匈牙利算法相关介绍
IT菜鸟
08-18 1053
匈牙利算法相关介绍
匈牙利算法的C++实现
YU_Xianguo的博客
11-09 4937
这篇文章最初发表在http://blog.csdn.net/j56754gefge/article/details/40793633，均是我原创，转载请注明出处！     Hungarian/Munkres Algorithm，即著名的匈牙利算法，常用来解决矩形分配问题：我有一些工作jobs，也有一些工人workers，我已经知道每个worker做各个job的耗费cost，那么我如何
匈牙利算法证明+原理+C++代码
热门推荐
qq_25379821的博客
11-05 1万+
介绍 匈牙利算法用于解决求最大分配的分配问题，不等权重的二分图中求最大权分配的分配问题，使用KM算法。 本文首先介绍匈牙利算法所针对的二分问题 然后介绍匈牙利算法的原理 最后有匈牙利算法证明，证明为何使用该算法可以找到最大匹配 一个典型的分配问题是工作分配，假设有M份工作，总共有N个候选人，假设M小于等于N，表示候选人n胜任工作m，因此我们得到一个关联矩阵： 对应的图G为 二...
C++实现匈牙利算法指派问题（输入一个dat文件，输出一个dat文件）
weixin_44284545的博客
10-08 602
c++实现匈牙利算法指派问题，后续考虑纯c语言实现
【算法应用】匈牙利算法c++代码（最优匹配）
开源节流
05-12 2166
直接上代码 广度搜索（DFS） 特点： 优点，实现简洁，理解容易。适用：稠密图，由于边多，DFS找增广路很快。复杂度O（n3） 程序运行结果： #include <iostream> #include <string.h> using namespace std; #define MAXN 10 //MAXN表示X集合和Y集合顶点个数的最大值 int nx,ny; ...
基于匈牙利匹配和卡尔曼滤波的SORT多目标跟踪算法C++源码+文档说明
03-25
基于匈牙利匹配和卡尔曼滤波的SORT多目标跟踪算法C++源码+文档说明 - 不懂运行，下载完可以私聊问，可远程教学 该资源内项目源码是个人的毕设，代码都测试ok，都是运行成功后才上传资源，答辩评审平均分达到96分，...
matlab的egde源代码-hungarian-algorithm-cpp:匈牙利算法实现的C++包装器
05-22
【描述】提到的"matlab的egde源代码"表明这是一个MATLAB与C++结合的项目，可能包含MATLAB M文件以及C++源代码，用于在MATLAB环境中调用和执行匈牙利算法。这样的设计通常是为了利用C++的高效计算能力来加速MATLAB中...
指派问题的匈牙利算法
03-01
在这个场景中，我们关注的是“匈牙利算法”，它是一种解决完全匹配问题的有效方法，常用于解决一对一匹配的问题，如工人与任务、学生与课程等的分配。 匈牙利算法的核心思想是通过增广路径来寻找并消除匹配中的不...
易语言-高效数据结构及算法模块
06-29
易语言官方支持库以及网上流传的很多模块中的很多命令或数据结构仅仅是实现了功能，但是并不怎么高效，再有就是有人将本来时间复杂度就高的算法使用汇编进行优化，然并卵，O(n^2)的复杂度和O(nlogn)的复杂度根本不是...
MOG+KCF的多目标跟踪,kcf目标跟踪算法,Visual C++源码.rar
10-10
- 为了处理目标的出生、死亡和重识别，可能还需要引入ID交换管理策略和数据关联算法，如匈牙利算法或最近邻算法。 4. **Visual C++源码**： - 提供的源码是使用Visual C++开发的，这是一个强大的Windows应用程序...
代码随想录算法训练营第十七天（二叉树 五）
b1ankwall的博客
08-16 766
参加代码随想录第43期算法训练营day17|654.最大二叉树，617.合并二叉树，700.二叉搜索树中的搜索，98.验证二叉搜索树
【Python】生成二维迷宫的算法
HarryXYC的博客
08-16 320
基于Pygame和PIL的迷宫生成器
【算法】马踏棋盘（骑士周游）问题回溯算法实现以及使用贪心算法优化
2302_78914800的博客
08-18 495
将马儿随机放在国际象棋的 8*8 棋盘的某个方格中，马儿按照“马走日”进行移动，要求每个方格只进入一次，走遍棋盘上全部 64 个方格。注意：马儿不同的走法会得到不同的结果，效率也会有影响。
Leetcode 219. 存在重复元素 II
最新发布
铁马冰河入梦来
08-20 199
哈希表解决存在重复元素二问题
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值