关于二分匹配的几道简单题

最新推荐文章于 2020-12-06 03:43:44 发布
最新推荐文章于 2020-12-06 03:43:44 发布
阅读量234 收藏 2
点赞数
分类专栏： ACM-图论 文章标签： 图论 二分匹配
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GYH0730/article/details/80489523
版权

最近重新学习了二分匹配的算法，并趁热打铁做了几道简单的题。

这个博客讲的二分匹配的算法比较通俗易懂，https://blog.csdn.net/dark_scope/article/details/8880547

HDU 1150

把每一个任务在两种机器下的模式看作一条边，建图之后求最小顶点覆盖集（用最少的点，使每一条边都与其中一个点相关联），而最小顶点覆盖集=最大匹配，此题在输入的时候把模式为0的去掉，因为两种机器初始状态为0。

#include <stdio.h>
#include <string.h>

const int maxn = 110;
int G[maxn][maxn],vis[maxn],match[maxn];
int nx,ny,m;

bool find(int u)
{
    for(int i = 0; i < ny; i++){
        if(G[u][i] && !vis[i]){
            vis[i] = 1;
            if(match[i] == -1 || find(match[i])){
                match[i] = u;
                return true;
            }
        }
    }
    return false;
}
int max_match()
{
    int ans = 0;
    memset(match,-1,sizeof(match));
    for(int i = 0; i < nx; i++){
        memset(vis,0,sizeof(vis));
        if(find(i)){
            ans++;
        }
    }
    return ans;
}
int main(void)
{
    while(scanf("%d",&nx) != EOF && nx){
        scanf("%d%d",&ny,&m);
        memset(G,0,sizeof(G));
        for(int i = 1; i <= m; i++){
            int id,x,y;
            scanf("%d%d%d",&id,&x,&y);
            if(x && y){
                G[x][y] = 1;
            }
        }
        printf("%d\n",max_match());
    }
    return 0;
}

HDU 1151

给出一个有向图，士兵沿着路的方向走，问至少需要多少士兵，能把所有边都走一遍。其实就是求有向无环图的最小路径覆盖，有向无环图的最小路径覆盖=顶点数-最大匹配数

#include <stdio.h>
#include <string.h>

const int maxn = 150;
int match[maxn],G[maxn][maxn],vis[maxn];
int n,m;

bool find(int u)
{
    for(int i = 1; i <= n; i++){
        if(G[u][i] && !vis[i]){
            vis[i] = 1;
            if(match[i] == -1 || find(match[i])){
                match[i] = u;
                return true;
            }
        }
    }
    return false;
}
int max_match()
{
    int ans = 0;
    memset(match,-1,sizeof(match));
    for(int i = 1; i <= n; i++){
        memset(vis,0,sizeof(vis));
        if(find(i)){
            ans++;
        }
    }
    return ans;
}
int main(void)
{
    int T;
    scanf("%d",&T);
    while(T--){
        scanf("%d%d",&n,&m);
        memset(G,0,sizeof(G));
        for(int i = 1; i <= m; i++){
            int a,b;
            scanf("%d%d",&a,&b);
            G[a][b] = 1;
        }
        printf("%d\n",n - max_match());
    }
    return 0;
}

HDU 1068

找出一个最大的集合，使这个集合的任意两个同学都没有浪漫的关系。求的是最大独立集（在n个点的图中，选出一个最大点集m，并且这m个点任意两点之间都没有边相连），最大独立集=顶点数-最大匹配数，这道题并没有指定性别，所以要减去最大匹配/2。

#include <stdio.h>
#include <string.h>

const int maxn = 1005;
int match[maxn],G[maxn][maxn],vis[maxn];
int n,m;

bool find(int u)
{
    for(int i = 0; i < n; i++){
        if(G[u][i] && !vis[i]){
            vis[i] = 1;
            if(match[i] == -1 || find(match[i])){
                match[i] = u;
                return true;
            }
        }
    }
    return false;
}
int max_match()
{
    int ans = 0;
    memset(match,-1,sizeof(match));
    for(int i = 0; i < n; i++){
        memset(vis,0,sizeof(vis));
        if(find(i)){
            ans++;
        }
    }
    return ans;
}
int main(void)
{
    while(scanf("%d",&n) != EOF){
        memset(G,0,sizeof(G));
        int id,num;
        for(int i = 0; i < n; i++){
            scanf("%d: (%d)",&id,&num);
            while(num--){
                scanf("%d",&id);
                G[i][id] = 1;
            }
        }
        printf("%d\n",n -  max_match() / 2);
    }
    return 0;
}

HDU 1281

对于一个点（i，j），如果放上车，就在i，j之间连上一条边，放的车的最大个数就是最大匹配数，先求出最大匹配数，然后枚举每一个点，求出去掉这个点之后的最大匹配数，如果比之前的少，说明是重要点。

#include <stdio.h>
#include <string.h>

int match[105];
int x[10005],y[10005];
int n,m,k;
int vis[105];
int a[105][105];
int b[105][105];

int find(int u){
	
	for(int i=1;i<=m;i++){
		
		if(vis[i] == 0 && a[u][i] && !b[u][i]){
			vis[i] = 1;
			if(match[i] == 0 || find(match[i])){
				match[i] = u;
				return 1;
			}
		}
	}
	return 0;
}
int main(void){
	int count = 0;
	while(scanf("%d%d%d",&n,&m,&k)!=EOF){
		
		
		memset(match,0,sizeof(match));
		memset(a,0,sizeof(a));
		memset(b,0,sizeof(b));
		
		
		for(int i=1;i<=k;i++){
			scanf("%d%d",&x[i],&y[i]);
			a[x[i]][y[i]] = 1;
		}
		
		int ans=0;
		for(int i=1;i<=n;i++){
			memset(vis,0,sizeof(vis));
			if(find(i)){
				ans++;
			}
		}
		int anss = 0;
		for(int i=1;i<=k;i++){
			
			b[x[i]][y[i]] = 1;
			memset(match,0,sizeof(match));
			int temp=0;
			for(int j=1;j<=n;j++){
				memset(vis,0,sizeof(vis));
				if(find(j)){
					temp++;
				}
			}
			if(temp < ans){
				anss++;
			}
			b[x[i]][y[i]] = 0;
		}
		printf("Board %d have %d important blanks for %d chessmen.\n",++count,anss,ans);
	}
	return 0;
}

HDU 1498

给出一个矩阵，每一个数代表一种气球，求有多少种气球，每次刷掉一行或一列，在最多刷k次的情况下刷不完，按字典序输出，不存在则输出-1。还是根据行列坐标建图，并且图里存储的是哪种气球，选出最少的行号或列号覆盖所有储存这种颜色的所有边，最小点覆盖集，即求最大匹配，然后与k比较。

#include <stdio.h>
#include <string.h>
#include <algorithm>

using namespace std;

const int maxn = 105;
int ans[maxn];
int match[maxn],G[maxn][maxn],vis[maxn],used[maxn];
int n,c,k;

bool find(int u)
{
    for(int i = 1; i <= n; i++){
        if(G[u][i] == c && !vis[i]){
            vis[i] = 1;
            if(match[i] == -1 || find(match[i])){
                match[i] = u;
                return true;
            }
        }
    }
    return false;
}
int max_match()
{
    int ans = 0;
    memset(match,-1,sizeof(match));
    for(int i = 1; i <= n; i++){
        memset(vis,0,sizeof(vis));
        if(find(i)){
            ans++;
        }
    }
    return ans;
}
int main(void)
{
    while(scanf("%d%d",&n,&k) != EOF){
        if(n == 0 && k == 0){
            break;
        }
        memset(G,0,sizeof(G));
        memset(used,0,sizeof(used));
        for(int i = 1; i <= n; i++){
            for(int j = 1; j <= n; j++){
                scanf("%d",&G[i][j]);
            }
        }
        int cnt = 0;
        for(int i = 1; i <= n; i++){
            for(int j = 1; j <= n; j++){
                if(!used[G[i][j]]){
                    used[G[i][j]] = 1;
                    c = G[i][j];
                    int num = max_match();
                    if(num > k){
                        ans[cnt++] = c;
                    }
                }
            }
        }
        if(cnt == 0){
            printf("-1\n");
        }
        else{
            sort(ans,ans + cnt);
            for(int i = 0; i < cnt; i++){
                if(i == cnt - 1){
                    printf("%d\n",ans[i]);
                }
                else{
                    printf("%d ",ans[i]);
                }
            }
        }

    }
    return 0;
}

HDU 1528

很明显的求最大匹配，就是需要判断一下两张牌的大小关系。

#include <stdio.h>
#include <string.h>
#include <map>

using namespace std;

char a[50][2],b[50][2];
int match[50],vis[50];
int n;
map <char,int> mp;
void init()
{
    for(char i = '2'; i <= '9'; i++){
        mp[i] = i - '0';
    }
    mp['T'] = 10;
    mp['J'] = 11;
    mp['Q'] = 12;
    mp['K'] = 13;
    mp['A'] = 14;
    mp['H'] = 3;
    mp['S'] = 2;
    mp['D'] = 1;
    mp['C'] = 0;
}
bool cmp(int i,int j)
{
    int ansb = mp[b[i][0]];
    int ansa = mp[a[j][0]];
    if(ansa == ansb){
        ansb += mp[b[i][1]];
        ansa += mp[a[j][1]];
    }
    else{
        return ansb > ansa;
    }
    return ansb > ansa;
}
bool find(int u)
{
    for(int i = 1; i <= n; i++){
        if(cmp(u,i) && !vis[i]){
            vis[i] = 1;
            if(match[i] == -1 || find(match[i])){
                match[i] = u;
                return true;
            }
        }
    }
    return false;
}
int max_match()
{
    int ans = 0;
    memset(match,-1,sizeof(match));
    for(int i = 1; i <= n; i++){
        memset(vis,0,sizeof(vis));
        if(find(i)){
            ans++;
        }
    }
    return ans++;
}
int main(void)
{
    int T;
    init();
    scanf("%d",&T);
    while(T--){
        scanf("%d",&n);
        for(int i = 1; i <= n; i++){
            scanf("%s",a[i]);
        }
        for(int i = 1; i <= n; i++){
            scanf("%s",b[i]);
        }
        printf("%d\n",max_match());
    }
    return 0;
}

HDU 1507

这道题建出二分图是关键，先给每个空白点编号，然后横纵坐标相加为奇数的空白点为X集合，横纵坐标相加为偶数的的空白点为Y集合，如果两个点，一个属于X，一个属于Y，并且这两个点上或下或左或右相邻，两个点连接一条边，这样就构建除了二分图，求最大匹配即可，如何打印出结果看代码。

#include <stdio.h>
#include <string.h>

const int maxn = 105;
int G[maxn][maxn],vis[maxn];
int bin[maxn][maxn],match[maxn];
int num[maxn][maxn];
int node[maxn][2];
int n,m;
int to[4][2] = {0,1,1,0,-1,0,0,-1};
int cnt;

bool find(int u)
{
    for(int i = 1; i < cnt; i++){
        if(bin[u][i] && !vis[i]){
            vis[i] = 1;
            if(match[i] == -1 || find(match[i])){
                match[i] = u;
                return true;
            }
        }
    }
    return false;
}
int max_match()
{
    int ans = 0;
    memset(match,-1,sizeof(match));
    for(int i = 1; i < cnt; i++){
        memset(vis,0,sizeof(vis));
        if(find(i)){
            ans++;
        }
    }
    return ans;
}
int main(void)
{
    while(scanf("%d%d",&n,&m) != EOF){
        if(n + m == 0){
            break;
        }
        int k;
        scanf("%d",&k);
        memset(G,0,sizeof(G));
        memset(bin,0,sizeof(bin));
        memset(node,0,sizeof(node));
        memset(num,0,sizeof(num));
        for(int i = 1; i <= k; i++){
            int a,b;
            scanf("%d%d",&a,&b);
            G[a][b] = 1;
        }
        cnt = 1;
        for(int i = 1; i <= n; i++){
            for(int j = 1; j <= m; j++){
                if(!G[i][j]){
                    node[cnt][0] = i;
                    node[cnt][1] = j;
                    num[i][j] = cnt++;
                }
            }
        }
        for(int i = 1; i <= n; i++){
            for(int j = 1; j <= m; j++){
                if((i + j) & 1 && num[i][j]){
                    for(int q = 0; q <= 3; q++){
                        int x = i + to[q][0];
                        int y = j + to[q][1];

                        if(x >= 1 && y >= 1 && x <= n && y <= m && num[x][y]){
                            //printf("%d___%d\n",num[i][j],num[x][y]);
                            bin[num[i][j]][num[x][y]] = 1;
                        }
                    }
                }
            }
        }
        printf("%d\n",max_match());
        for(int i = 1; i < cnt; i++){
            if(match[i] != -1){
                printf("(%d,%d)--(%d,%d)\n",node[i][0],node[i][1],node[match[i]][0],node[match[i]][1]);
            }
        }
        printf("\n");
    }
    return 0;
}

POJ 2724

因为*同时消毒两次，所以尽量用*，将所有操作解码，用一个vis数组标记，对于二进制只有一位不同的两个点连接一条边，求最大独立集，注意这个图是有向图，因为两个只差一位的数合并成一个，建图时是遍历所有的点，一个点用完后和它连接的点会再次出现，而我们要求只匹配一次即可。

#include <stdio.h>
#include <string.h>
#include <vector>

using namespace std;
const int maxn = 1 << 11;
int vis[maxn],used[maxn];
int match[maxn],n,m,cnt;
vector<int> G[maxn];


void input(){
	for(int i = 0; i < (1 << n); i++){
		G[i].clear();
		vis[i] = 0;
	}
	
	int flag;
	char op[15];
	int val;
	for(int i = 0; i < m; i++){
		flag = -1;
		val = 0;
		scanf("%s",op);
		for(int j = 0; j < n; j++){
			if(op[j] == '*'){
				flag = j;
			}
			else if(op[j] == '1'){
				val |= (1 << j);
			}
		}
		vis[val] = 1;
		if(flag != -1){
			val |= (1 << flag);
			vis[val] = 1;
		}
	}
	cnt = 0;
	for(int i = 0; i < (1 << n); i++){
		if(vis[i]){
			cnt++;
			for(int j = 0; j < (1 << n); j++){
				if(vis[j]){
					int temp = i ^ j;
					if(temp && !((temp) & (temp - 1))){
						G[i].push_back(j);
						G[j].push_back(i);
					}
				}
			}
		}
	}
}
bool find(int i){
	for(int j = 0; j < G[i].size(); j++){
		int v = G[i][j];
		if(!used[v]){
			used[v] = 1;
			if(match[v] == -1 || find(match[v])){
				match[v] = i;
				return true;
			}
		}
	}
	return false;
}
int max_match(){
	memset(match,-1,sizeof(match));
	int ans = 0;
	for(int i = 0; i < (1 << n); i++){
		if(vis[i]){
			memset(used,0,sizeof(used));
		    if(find(i)){
		    	ans++;
			}
		}
		
	}
	return ans;
}
int main(void){
	
	while(scanf("%d%d",&n,&m) != EOF && (n + m)){
		input();
		printf("%d\n",cnt - max_match() / 2);
	}
	return 0;
}

POJ　３２１６

先对任意两条街道求最短路，用ｆｌｏｙｄ就行，然后建图，两个任务ｉ，ｊ，如果完成ｉ之后在到达ｊ时的时间小于最晚到达ｊ的时间，则ｉ与ｊ之间加一条边，求最小路径覆盖即可。

#include <stdio.h>
#include <string.h>
#include <algorithm>

using namespace std;


const int INF = 0x3f3f3f3f;
int dis[25][25];
int G[205][205],match[205],vis[205];
int p[205],t[205],d[205];

int Q,M;
void floyd()
{
    for(int k = 1; k <= Q; k++){
        for(int i = 1; i <= Q; i++){
            for(int j = 1; j <= Q; j++){
                if(dis[i][j] > dis[i][k] + dis[k][j]){
                    dis[i][j] = dis[i][k] + dis[k][j];
                }
            }
        }
    }
}

void input()
{
    for(int i = 1; i <= Q; i++){
        for(int j = 1; j <= Q; j++){
            scanf("%d",&dis[i][j]);
            if(dis[i][j] == -1){
                dis[i][j] = INF;
            }
        }
    }
    for(int i = 1; i <= M; i++){
        scanf("%d%d%d",&p[i],&t[i],&d[i]);
    }
}
void get_map()
{
    for(int i = 1; i <= M; i++){
        for(int j = 1; j <= M; j++){
            if(t[i] + dis[p[i]][p[j]] + d[i] <= t[j]){
                G[i][j] = 1;
            }
        }
    }
}
void init()
{
    for(int i = 1; i <= M; i++){
        for(int j = 1; j <= M; j++){
            G[i][j] = 0;
        }
    }
}
bool find(int u)
{
    for(int i = 1; i <= M; i++){
        if(G[u][i] && !vis[i]){
            vis[i] = 1;
            if(match[i] == -1 || find(match[i])){
                match[i] = u;
                return true;
            }
        }
    }
    return false;
}
int max_match()
{
    int ans = 0;
    memset(match,-1,sizeof(match));
    for(int i = 1; i <= M; i++){
        memset(vis,0,sizeof(vis));
        if(find(i)){
            ans++;
        }
    }
    return ans;
}

int main(void)
{
    while(scanf("%d%d",&Q,&M) && (Q + M)){
        init();
        input();
        floyd();
        get_map();
        printf("%d\n",M - max_match());
    }
    return 0;
}




hahahahhahello
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《网络安全与管理第二版》-网络安全试题5.doc
06-07
单项选择题（每题1分，共60分） 1. 在以下人为的恶意攻击行为中，属于主动攻击的是（ ） A、数据篡改及破坏 B、数据窃听 C、数据流分析 D、非法访问 2. 数据完整性指的是（ ） A、保护网络中各系统之间交换的数据，...
我对KM算法的理解
茅屋
12-26 2271
一般对KM算法的描述，基本上可以概括成以下几个步骤： （1） 初始化可行标杆 （2） 用匈牙利算法寻找完备匹配 （3） 若未找到完备匹配则修改可行标杆 （4） 重复（2）（3）直到找到相等子图的完备匹配 关于该算法的流程及实施，网上有很多介绍，基本上都是围绕可行标杆如何修改而进行的讨论，至于原理并没有给出深入的探讨。 KM算法是用于寻找带权二分图最佳匹配的算法。 二分图是...
趣写算法系列之--匈牙利算法
热门推荐
DarkScope从这里开始
07-18 16万+
【书本上的算法往往讲得非常复杂，我和我的朋友计划用一些简单通俗的例子来描述算法的流程，这只是刚开始的样稿，其实我们也才刚开始】 匈牙利算法是由匈牙利数学家Edmonds于1965年提出，因而得名。匈牙利算法是基于Hall定理中充分性证明的思想，它是部图匹配最常见的算法，该算法的核心就是寻找增广路径，它是一种用增广路径求二分图最大匹配的算法。 -------等等，看得头大？那么请看下
匈牙利算法（二分图的最大匹配）
September_的博客
03-26 195
超易懂讲解博客：https://blog.csdn.net/dark_scope/article/details/8880547 模板：题目链接 #include<iostream> #include<algorithm> #include<cstring> #include<vector> #include<queue> #in...
二分图最大匹配例题
jhljx的专栏
02-12 5221
例题1：HDU 1083&&POJ 1469 Courses Time Limit: 20000/10000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 4034    Accepted Submission(s): 1928 Problem Des
python 二分法调试代码_二分法调试代码具体指什么？
weixin_39637589的博客
12-06 98
举个例子，我写了一个一万行的函数然后崩溃了，而且由于某些神奇的原因VC++就是不告诉我崩在了哪里，那怎么办呢？我先注释掉后面一半的代码，然后崩溃了，就证明蹦在这里了，如果没崩溃，就证明崩在了后面。于是你立刻就把范围缩小了一半。剩下如法炮制，直到定位到一行为止。==========================================================我还有一次，是跟一个人合...
网络安全与管理(第二版)-网络安全试题4.doc
最新发布
06-09
单项选择题（每题1分，共50分） 1. 在以下人为的恶意攻击行为中，属于主动攻击的是（ ） A. 数据篡改及破坏 B. 数据窃听 C. 数据流分析 D. 非法访问 2. 数据完整性指的是（ ） A. 保护网络中各系统之间交换的数据，...
千方百计笔试题大全
11-30
14、编程题: 用最有效率的方法算出2 乘以8 等於几? 9 15、有没有length()这个方法? String 有没有length()这个方法？ 9 16、在JAVA 中，如何跳出当前的多重嵌套循环？ 9 17、构造器Constructor 是否可被override? 9 ...
会计理论考试题
03-07
3.硬盘格式化分二个阶段,低级格式化和高级格式化。（ N ） 4.硬盘格式化分三个阶段,其先后顺序为低级格式化、分区、高级格式化。（ Y ） 5.西文工作方式下不可输入汉字。（ Y ） 6.微机的键盘是一种分离式的智能键盘...
语言程序设计课后习题答案
12-27
采用二进制码表示信息，有如下几个优点：1.易于物理实现；2.二进制数运算简单；3.机器可靠性高；4.通用性强。其缺点是它表示数的容量较小，表示同一个数，二进制较其他进制需要更多的位数。 1-9 请将以下十进制数值...
匈牙利算法
Arcobaleno
05-20 4801
英文版的讲的很详细： http://www.hungarianalgorithm.com/examplehungarianalgorithm.php 中文版的可以参考该博主： https://blog.csdn.net/qq_33829154/article/details/62425921 匈牙利算法的流程： 匈牙利算法包含四步。前两步一次执行完，第三步和第三步会重复执行直到最优...
指派问题：匈牙利算法
Wonz
06-13 5万+
匈牙利法的基本思路：对费用矩阵C的行和列减去某个常数，将C化为有n个位于不同行不同列的零元素，令这些零元素对应的变量取1，其余变量取0，即得到指派问题的最优解。 匈牙利法是基于指派问题的标准型的，标准型需满足以下3个条件： （1）目标函数求min； （2）效率矩阵为n阶方阵； （3）效率矩阵中所有元素Cij≥0，且为常数。 匈牙利法的计算步骤： （1）变换效率矩阵C，使每行每列至少有一...
二分图及其判定丶匈牙利算法求最大匹配
森宝的博客
05-30 449
二分图 在图论中，二分图是一类特殊的图，又称为双分图、二部图、偶图。二分图的顶点可以分成两个互斥的独立集U 和 V 的图，使得所有边都是连结一个 U 中的点和一个 V 中的点。顶点集 U、V 被称为是图的两个部分。等价的，二分图可以被定义成图中所有的环都有偶数个顶点 。(来源维基百科) 如果某个图为二分图，那么它至少有两个顶点，且其所有回路的长度均为偶数，任何无回路的的图均是二分图。 ...
HDU - 2063 过山车（匈牙利算法）
LLL_yx的博客
12-20 213
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2063 题意：中文题。 思路：这就是匈牙利算法算二分图最大匹配的算法，具体思想可以参考这个博客，我觉得很不错：http://blog.csdn.net/dark_scope/article/details/8880547 代码： #include #include #include
二分图匹配——匈牙利算法
Young_Fan
05-31 1万+
匈牙利算法是由匈牙利数学家Edmonds于1965年提出，因而得名。匈牙利算法是基于Hall定理中充分性证明的思想，它是部图匹配最常见的算法，该算法的核心就是寻找增广路径，它是一种用增广路径求二分图最大匹配的算法。 基本原则就是在原有匹配（最开始的按优先顺序匹配）基础上重新分配，看是否可以添加一个新的匹配。 预备知识 我们需要了解一下图论的一些知识。 1 无向图 边没有方向的图称为无向图...
程序员快速处理代码bug的5大技巧
weixin_33910385的博客
10-31 782
不管是项目团队出现了bug，还是前辈留下的代码出现bug，这个锅反正程序员是背定了。 不少的程序员被代码虐杀的痛苦万分。但从积极的方面来看，代码bug也是绝佳的学习机会。 处理bug能力重要性不言而喻，通常也是面试的考察范围。 下面w3cschool给小伙伴们分享5个处理bug技巧： 0、二分法定位 二分法定位是比较常用的bug处理技巧。 通过二分法，...
匈牙利算法，拓扑排序，并查集。
空与白的博客
07-16 242
拓扑排序 https://blog.csdn.net/swust5120171204/article/details/95957712 确定比赛名次 有N个比赛队（1<=N<=500），编号依次为1，2，3，。。。。，N进行比赛，比赛结束后，裁判委员会要将所有参赛队伍从前往后依次排名，但现在裁判委员会不能直接获得每个队的比赛成绩，只知道每场比赛的结果，即P1赢P2，用P1，P2表示，排...
二分图匹配相关算法及例题分析 最大匹配匈牙利算法 最大权匹配KM算法（二分图类型问题汇总）...
weixin_34185364的博客
08-10 495
二分图最大匹配： 问题描述：给出一个二分图，找一个边数最大的匹配。就是选择尽量多的边，使得选中的边中任意两条边均没有公共点。如果所有的点都是匹配点那就是一个完美匹配。 解决方案：增广路定理 增广路：从一个未匹配的点开始，依次走过未匹配边，匹配边，未匹配边，匹配边，。。。。。。 如果最后的终点是一个未匹配点（即最后一条边是一条未匹配边），那么这条路就是一条增...
出简单匹配系数的习题并告诉我答案
03-13
简单匹配系数是指两个字符串中相同字符的数量除以两个字符串总长度的比值。例如，字符串 "hello" 和 "world" 中相同字符的数量为 1，总长度为 10，因此简单匹配系数为 0.1。另一个例子是字符串 "cat" 和 "hat"，它们...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值