图算法——二部图&网络流

已于 2023-06-08 23:44:33 修改
阅读量137 收藏
点赞数
文章标签： 算法
于 2023-06-08 11:34:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/K_Kelly_/article/details/131037740
版权
本文介绍了图论中的最大二分匹配问题，包括匈牙利算法的实现细节，并提供了多个相关例题，如ZoJ1137、ZoJ1002、ZoJ1654和ZoJ1516。同时，还讨论了网络流算法中的Ford-Fulkerson算法，用于寻找图的最大流。这些算法在解决资源分配、路径规划等问题中有着广泛应用。
摘要由CSDN通过智能技术生成

二部图算法

最大二分匹配

匈牙利算法 

算法思路：

代码(template): 

#include<iostream>
#include<vector>
#include<bits/stdc++.h>
using namespace std;

#define maxn 105

int G[maxn][maxn];//存储图
bool vis[maxn];//访问数组
int match[maxn];//匹配数组
vector<int> V[maxn];//存储每个点的相邻节点

bool dfs(int start) {//深度优先搜索寻找匹配点
	for (int i = 0; i<int(V[start].size()); i++) {//遍历每一个与start相邻的节点
		int v = V[start][i];//存储与start相邻的节点
		if (!vis[v]) {//假如没有被访问过，才可进一步寻求匹配
			vis[v] = 1;//标记访问
			int tmp = match[v];//存储目前v的匹配点
			match[v] = start;//给v新的匹配点start
			if (tmp == -1 || dfs(tmp)) {//如果v没有匹配或原来v的匹配点能够匹配到其他节点
				return true;//说明v可以匹配start
			}
			match[v] = tmp;//如果不能匹配start，则回退，让v的匹配恢复原来
		}
	}
	return false;//从start节点找不到匹配顶点
}

int main() {
	int n1, n2;
	while (cin >> n1 >> n2 && n1 != 0 && n2 != 0) {
		//建图
		memset(G, -1, sizeof(G));
		int m;
		cin >> m;
		while (m--) {
			int a, b;
			cin >> a >> b;
			G[a][b] = 0;
		}
		int num = 0;
		for (int i = 1; i <= n1; i++) {
			for (int j = 1; j <= n2; j++) {
				if (G[i][j] == -1) {
					G[i][j] = ++num;
				}
			}
		}
		for (int i = 1; i <= num; i++) {//初始化每一个顶点的相邻节点
			V[i].clear();
		}

		//横
		for (int i = 1; i <= n1; i++) {
			for (int j = 1; j <= n2 - 1; j++) {
				if (G[i][j] != 0 && G[i][j + 1] != 0) {
					V[G[i][j]].push_back(G[i][j + 1]);
					V[G[i][j + 1]].push_back(G[i][j]);
				}
			}
		}

		//竖
		for (int j = 1; j <= n2; j++) {
			for (int i = 1; i <= n1 - 1; i++) {
				if (G[i][j] != 0 && G[i + 1][j] != 0) {
					V[G[i][j]].push_back(G[i + 1][j]);
					V[G[i + 1][j]].push_back(G[i][j]);
				}
			}
		}

		//最大匹配
		int ans = 0;//初始化解
		memset(match, -1, sizeof(match));//初始化匹配数组
		for (int i = 1; i <= num; i++) {
			memset(vis, 0, sizeof(vis));//初始化访问数组
			if (dfs(i)) ans++;//若存在匹配，则ans++
		}
		cout << ans / 2 << endl;//每个顶点都进行了匹配，因此最后一条边匹配了2次，所以要/2
	}
	return 0;
}

相关例题

zoj1137 Girls and boys

#include<bits/stdc++.h>
using namespace std;
#define maxn 10005

bool vis[maxn];//访问 
int match[maxn];//匹配 
set<int> V[maxn];//记录每个点的邻接顶点集 

bool dfs(int start)
{//深搜的含义是能够找到下一个节点进行匹配
	for (set<int>::iterator it = V[start].begin(); it != V[start].end(); it++) //逐个节点进行分析，分析是否能匹配
	{
		int v = *it;
		if (!vis[v])
		{ //若没有被访问过
			vis[v] = 1;
			int tmp = match[v]; //保留当前的匹配情况
			match[v] = start;   //尝试填写新的匹配关系
			if (tmp == -1 || dfs(tmp))
			{ //分析这个新匹配是否有效
				return true;
			}
			match[v] = tmp;
		}
	}
	return false;
}

int str2int(string str){
	int ans = 0;
	for (int i = 0; i < int(str.size()); i++) {
		ans = ans * 10 + str[i] - '0';
	}
	return ans;
}

int substr(string str) {//获取()里面的数字 
	string s = "";
	for (int i = 0; i < int(str.size()); i++) {
		if (i != 0 && i != int(str.size()) - 1) {
			s += str[i];
		}
	}
	return str2int(s);
}

int main() {
	//建图 
	int n;
	while (cin >> n) {
		for(int i=0;i<n;i++){
			V[i].clear();
		}
		for (int i = 0; i < n; i++) {
			string str;
			cin >> str;//读入0: 
			cin >> str;//读入() 
			int m = substr(str);
			while (m--) {//注意这里，直接改int就不用str转int 
				int nn;
				cin >> nn;
				V[i].insert(nn);
			}
		}
		memset(match, -1, sizeof(match));
		//深搜遍历 
		for (int i = 0; i < n; i++)
		{
			memset(vis, 0, sizeof(vis));
			dfs(i);
		}

		//求出最大匹配数 
		int num = 0; //记录匹配个数
		for (int i = 0; i < n; i++)
		{
			if (match[i] != -1)
				num++;
		}
		cout << n - (num / 2) << endl;
	}
	return 0;
}

zoj1002 Fire Net

#include <iostream>
#include <bits/stdc++.h>
#include <vector>
using namespace std;
#define maxn 100

int Gr[maxn][maxn];
int Gc[maxn][maxn];
char G[maxn][maxn];
vector<int> V[maxn]; //点集
bool vis[maxn];      //标记访问
int match[maxn];     //标记匹配
int cnt2;            //记录最大点

bool dfs(int start)
{                                             //深搜的含义是能够找到下一个节点进行匹配
    for (int i = 0; i < V[start].size(); i++) //逐个节点进行分析，分析是否能匹配
    {
        int v = V[start][i];
        if (!vis[v])
        { //若没有被访问过
            vis[v] = 1;
            int tmp = match[v]; //保留当前的匹配情况
            match[v] = start;   //尝试填写新的匹配关系
            if (tmp == -1 || dfs(tmp))
            { //分析这个新匹配是否有效
                return true;
            }
            match[v] = tmp;
        }
    }
    return false;
}

int main()
{
    int n;
    while (cin >> n && n)
    {
        int cnt1 = 0; //开两个计数器
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= n; j++)
            {
                cin >> G[i][j];
            }
        }
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= n; j++)
            {
                if (G[i][j] == 'X')
                {
                    Gr[i][j] = 0; //表示黑格
                    Gc[i][j] = 0;
                }
                else
                {
                    if (j == 1 || (j != 1 && G[i][j - 1] == 'X'))
                        cnt1++;
                    Gr[i][j] = cnt1; //横
                }
            }
        }
        cnt2 = cnt1;
        for (int j = 1; j <= n; j++)
        {
            for (int i = 1; i <= n; i++)
            {
                if (G[i][j] == 'X')
                {
                    continue;
                }
                else
                {
                    if (i == 1 || (i != 0 && G[i - 1][j] == 'X'))
                        cnt2++;
                    Gc[i][j] = cnt2; //列
                }
            }
        }
        for (int i = 1; i <= cnt2; i++)
        {
            V[i].clear();
        }
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= n; j++)
            {
                if (G[i][j] == 'X')
                    continue;
                else
                {
                    V[Gr[i][j]].push_back(Gc[i][j]);
                    V[Gc[i][j]].push_back(Gr[i][j]);
                }
            }
        }

        //		for(int i=0;i<n;i++){
        //			for(int j=0;j<n;j++){
        //				cout<<Gr[i][j]<<" ";
        //			}
        //			cout<<endl;
        //		}
        //		for(int i=0;i<n;i++){
        //			for(int j=0;j<n;j++){
        //				cout<<Gc[i][j]<<" ";
        //			}
        //			cout<<endl;
        //		}
        //		for(int i=0;i<=cnt2;i++){
        //			for(int j=0;j<V[i].size();j++){
        //				cout<<V[i][j]<<" ";
        //			}
        //			cout<<endl;
        //		}
		memset(match, -1, sizeof(match));
        for (int i = 1; i <= cnt2; i++)
        {
            memset(vis, 0, sizeof(vis));
            dfs(i);
        }
        int num = 0; //记录匹配个数
        for (int i = 1; i <= cnt2; i++)
        {
            if (match[i] != -1)
                num++;
        }
        cout << num / 2 << endl;
    }
    return 0;
}

zoj1654 Place the Robots 

#include<bits/stdc++.h>
using namespace std;
#define maxn 5555

char G[maxn][maxn];
int Gr[maxn][maxn];
int Gc[maxn][maxn];
bool vis[maxn];
int match[maxn];
vector<int> V[maxn];

bool dfs(int start){
	for(int i=0;i<int(V[start].size());i++){
		int v = V[start][i];
		if(!vis[v]){
			vis[v] = 1;
			int tmp = match[v];
			match[v] = start;
			if(tmp==-1 || dfs(tmp)){
				return true;
			}
			match[v] = tmp;
		}
	}
	return false;
}

int main(){
	int m;
	cin>>m;
	for(int w=1;w<=m;w++){
		int r,c;
		cin>>r>>c;
		for(int i=0;i<r;i++){
			cin>>G[i];
		}
		//建立图模型
		int cnt1=0,cnt2;

		//横
		for(int i=0;i<r;i++){
			for(int j=0;j<c;j++){
				if(G[i][j]=='#'){//不能放
					Gc[i][j] = Gr[i][j] = 0;
				}else{
					if(j==0 || (j!=0 && G[i][j-1]=='#')){//若为第一列或不是第一列但前面有#
						cnt1++;
					}
					Gr[i][j] = cnt1;
				}
			}
		}
		
		//竖 
		cnt2 = cnt1;
		for(int j=0;j<c;j++){
			for(int i=0;i<r;i++){
				if(G[i][j]!='#'){
					if(i==0 || (i!=0 && G[i-1][j]=='#')){//若为第一行或不是第一行但上面有#
						cnt2++;
					}
					Gc[i][j] = cnt2;
				}
			}
		}
		
		//建图
		for(int i=0;i<cnt2;i++){
			V[i].clear();
		} 
		
		for(int i=0;i<r;i++){
			for(int j=0;j<c;j++){
				if(G[i][j]=='o'){//只有为o才可放
					V[Gr[i][j]].push_back(Gc[i][j]);
                    V[Gc[i][j]].push_back(Gr[i][j]);
				}
			}
		}
		
		//求最大匹配
		int ans=0;
		memset(match,-1,sizeof(match));
		for(int i=1;i<=cnt2;i++){
			memset(vis,0,sizeof(vis));
			if(dfs(i)){
				ans++;
			}
		}
		
		cout<<"Case :"<<w<<endl;
		cout<<ans/2<<endl;
	} 
	return 0;
}

zoj1516 Uncle Tom's Inherited Land

#include<iostream>
#include<vector>
#include<bits/stdc++.h>
using namespace std;

#define maxn 105

int G[maxn][maxn];
bool vis[maxn];
int match[maxn];
vector<int> V[maxn];

bool dfs(int start) {
	for (int i = 0; i<int(V[start].size()); i++) {
		int v = V[start][i];
		if (!vis[v]) {
			vis[v] = 1;
			int tmp = match[v];
			match[v] = start;
			if (tmp == -1 || dfs(tmp)) {
				return true;
			}
			match[v] = tmp;
		}
	}
	return false;
}

int main() {
	int n1, n2;
	while (cin >> n1 >> n2 && n1 != 0 && n2 != 0) {
		//建图
		memset(G, -1, sizeof(G));
		int m;
		cin >> m;
		while (m--) {
			int a, b;
			cin >> a >> b;
			G[a][b] = 0;
		}
		int num = 0;
		for (int i = 1; i <= n1; i++) {
			for (int j = 1; j <= n2; j++) {
				if (G[i][j] == -1) {
					G[i][j] = ++num;
				}
			}
		}
		for (int i = 1; i <= num; i++) {//初始化V
			V[i].clear();
		}

		//横
		for (int i = 1; i <= n1; i++) {
			for (int j = 1; j <= n2 - 1; j++) {
				if (G[i][j] != 0 && G[i][j + 1] != 0) {
					V[G[i][j]].push_back(G[i][j + 1]);
					V[G[i][j + 1]].push_back(G[i][j]);
				}
			}
		}

		//竖
		for (int j = 1; j <= n2; j++) {
			for (int i = 1; i <= n1 - 1; i++) {
				if (G[i][j] != 0 && G[i + 1][j] != 0) {
					V[G[i][j]].push_back(G[i + 1][j]);
					V[G[i + 1][j]].push_back(G[i][j]);
				}
			}
		}

		//最大匹配
		int ans = 0;
		memset(match, -1, sizeof(match));
		for (int i = 1; i <= num; i++) {
			memset(vis, 0, sizeof(vis));
			if (dfs(i)) ans++;
		}
		cout << ans / 2 << endl;
	}
	return 0;
}

zoj1364 Machine Schedule

#include<bits/stdc++.h>
using namespace std;
#define maxn 205

bool vis[maxn];
int match[maxn];
set<int> V[maxn];

bool dfs(int start){
	for(set<int>::iterator it=V[start].begin();it!=V[start].end();it++){
		int v = *it;
		if(!vis[v]){
			vis[v] = 1;
			int tmp = match[v];
			match[v] = start;
			if(tmp==-1 || dfs(tmp)){
				return true;
			}
			match[v] = tmp;
		}
	}
	return false;
}

int main(){
	int n,m,k;
	while(cin>>n>>m>>k && n){
		//初始化 
		for(int i=0;i<n+m;i++){
			V[i].clear();
		}
		//建图 
		while(k--){
			int a,b,c;
			cin>>a>>b>>c;
			V[b].insert(c+n);
			V[c+n].insert(b);
		}
		
		//最大匹配 
		int ans=0;
		memset(match,-1,sizeof(match));
		for(int i=1;i<n+m;i++){//注意初始时0已经开机 
			memset(vis,0,sizeof(vis));
			if(dfs(i)) ans++;
		}
		cout<<ans/2<<endl;
	}
	return 0;
}

网络流算法（max-flow-min-cut）

构造残存网络

 Ford-Fulkerson算法

算法思路：

推广：

 代码(template)：

#include<bits/stdc++.h>
using namespace std;
const int maxn=205;//最大结点数
const int inf=0x7fffffff;

int r[maxn][maxn]; //残留网络，初始化为原图
bool visit[maxn];//是否被访问过
int pre[maxn];//前驱子图，记录了从顶点s到终点的一条可行路径上的其它顶点的前一个顶点，从前驱子图中找到从s到t的一条完整路径
int m,n;//边数，顶点数

bool bfs(int s,int t)  //广度优先寻找一条从s到t的增广路，若找到返回true
{
    int p;
    queue<int> q;//创建一个队列的对象
    memset(pre,-1,sizeof(pre));//初始化前驱子图数组pre
    memset(visit,false,sizeof(visit));//初始化访问数组 
    pre[s]=s;//让源点的前驱节点为本身 
    visit[s]=true;//标记访问 
    q.push(s);//把源点放进队列里面
    while(!q.empty())//当队列不为空，继续找下一个结点
    {
        p=q.front();//取出队首
        q.pop();
        for(int i=1;i<=n;i++)
        {
            if(r[p][i]>0 && !visit[i])//如果从p出发到其他顶点，有残留容量大于0，并且没有被标记
            {
                pre[i]=p;//标记选出点的前驱节点为p 
                visit[i]=true;//标记访问 
                if(i==t) //如果找到汇点就结束
                    return true;
                q.push(i);//接着将该点进栈
            }
        }
    }
    return false;
}

int EK(int s,int t)//计算最大流
{
   int flow=0;
   while(bfs(s,t))//当可以找到时
   {
       int d=inf;
       for(int i=t;i!=s;i=pre[i])//从后往前找 
           d=d<r[pre[i]][i]? d:r[pre[i]][i];//找到增广路径中最小流量
       for(int i=t;i!=s;i=pre[i])//从后往前更新 
       {
           r[pre[i]][i]-=d;//正
           r[i][pre[i]]+=d;//反
       }
       flow+=d;//流量++ 
   }
   return flow;
}
int main()
{
    while(scanf("%d%d",&m,&n)!=EOF)
    {
        int u,v,w;
        memset(r,0,sizeof(r));//初始化残留网络 
        for(int i=0;i<m;i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            r[u][v] = w;
        }
        printf("最大流：");
        printf("%d\n",EK(1,n));
    }
    return 0;
}

相关例题

zoj1734 Power Network

#include<bits/stdc++.h>
using namespace std;
#define maxn 50000
#define MAX 120
int n,np,nc,m;//节点个数 生产点个数 消费点个数 中转点个数 
int cap[MAX][MAX];//边容量 

int EKarp(int s,int t)//s--源点 t---终点 
{
	queue<int> Q;//创建队列 
	int flow[MAX][MAX];//流量 
	int pre[MAX];//前导点 
	int node[MAX];//记录能够到index节点的最大流 
	int maxflow = 0;//初始化最大流为0 
	memset(flow,0,sizeof(flow));//初始化流量数组为0 
	while (true)
	{
		Q.push(s);//将起点放入队列 
		memset(node,0,sizeof(node));//初始化 
		node[s] = maxn;//初始化能够到起点的最大流 
		while(!Q.empty())
		{
			int u = Q.front();//取出队列第一个节点 
			Q.pop();
			for (int v=0; v<=t; v++){//遍历所有点 
				if (!node[v] && cap[u][v]>flow[u][v])//如果v没有被访问过且能够正向流 
				{
					Q.push(v);//假如邻接顶点 
					node[v] = min(node[u], cap[u][v]-flow[u][v]);//更新能够流到v的最大流 
					pre[v] = u;//标记v的前导节点为u 
				}
			}
		}
		if (node[t] == 0) break;//若更新后流向终点的流量无增加,则说明已达到最大流 
		for (int u=t; u!=s; u=pre[u])//流量更新 
		{
			flow[pre[u]][u] += node[t];
			flow[u][pre[u]] -= node[t];
		}
		maxflow += node[t];//最大流更新 
	}
	return maxflow;
}

int main()
{
	int from,to,value;
	while(scanf("%d%d%d%d",&n,&np,&nc,&m)!=EOF)
	{
		memset(cap,0,sizeof(cap));//初始化边容量 
		while (m--)
		{
			scanf(" (%d,%d)%d",&from,&to,&value);
			cap[from][to] = value;
		}
		while (np--)
		{
			scanf(" (%d)%d",&from,&value);
			cap[n][from] = value;//记起点index为 n 
		}
		while (nc--)
		{
			scanf(" (%d)%d",&from,&value);
			cap[from][n+1] = value;//记终点index为 n+1 
		}
		printf("%d\n", EKarp(n,n+1));
	}
	return 0;
}

Dog 路径与点连边

#include <bits/stdc++.h>
using namespace std;
#define maxn 500

vector<int> V[maxn]; //存储图
bool vis[maxn];      //访问
int match[maxn];     //匹配

struct node
{
    int x, y;
} nd[maxn];

double dis(node n1, node n2)
{
    return sqrt(pow(n1.x - n2.x, 2) + pow(n1.y - n2.y, 2));
}

bool dfs(int u)
{
    for (int i = 0; i < int(V[u].size()); i++)
    {
        int v = V[u][i]; //找出相邻结点
        if (!vis[v])
        {
            int tmp1 = match[v]; //保存
            match[v] = u;
            int tmp2 = match[u];
            match[u] = v;
            vis[v] = true;
            if (tmp1 == -1 || dfs(tmp1))
            {
                return true;
            }
            match[v] = tmp1;
            match[u] = tmp2;
        }
    }
    return false;
}

int main()
{
    int n, m;
    while (cin >> n >> m)
    {
        int cnt = 0;
        for (int i = 0; i < n; i++)
        {                                  //输入人的结点
            cin >> nd[cnt].x >> nd[cnt].y; // cnt=0为起点，cnt=n-1为终点
            cnt++;
        }
        for (int i = 0; i < m; i++)
        { //输入狗的结点
            cin >> nd[cnt].x >> nd[cnt].y;
            cnt++;
        }
        //建立图模型
        //初始化
        for (int i = 0; i < maxn; i++)
        {
            V[i].clear();
        }
        //人的每个相邻间隔标结点0~(n-2),狗结点(n-1)~(n+m-2)
        //人的坐标0~(n-1)，狗的坐标n~(n+m-1)
        //连边
        for (int i = n; i < n + m; i++)
        { //遍历所有狗结点
            for (int j = 0; j < n - 1; j++)
            { //遍历所有人间隔
                if (dis(nd[j], nd[j + 1]) * 2 >= dis(nd[j], nd[i]) + dis(nd[i], nd[j + 1]))
                { //满足条件，V[j]与V[i-1]连边
                    V[j].push_back(i - 1);
                    V[i - 1].push_back(j);
                }
            }
        }
        //求解最大匹配
        memset(match, -1, sizeof(match));
        int ans = 0;
        for (int i = n - 2; i >= 0; i--)
        {
            memset(vis, 0, sizeof(vis));
            if (dfs(i))
            {
                ans++;
            }
        }
        cout << n + ans << endl;
        for (int i = 0; i < n - 1; i++)
        {
            cout << nd[i].x << " " << nd[i].y << " ";
            if (match[i] != -1)
            {
                cout << nd[match[i] + 1].x << " " << nd[match[i] + 1].y << " ";
            }
        }
        cout << nd[n - 1].x << " " << nd[n - 1].y;
    }
    return 0;
}

一天只能上一天班
关注
matlab实现匈牙利算法二分图最大匹配的程序
02-02
标题中的“matlab实现匈牙利算法二分图最大匹配的程序”指的是使用MATLAB编程语言来实现一种经典的图论算法——匈牙利算法，它主要用于解决二分图的最大匹配问题。二分图是一种特殊的图，其中的节点可以分为两个不...
二分图和网络流
weixin_45874139的博客
08-15 1141
网络流和二分匹配 二分图 如果一张图的n个节点能分成两部分，使每个部分的点之间没有连边，这个图就是二分图。 二分图的判断 定理：一张无向图是二分图，当且仅当图中不存在奇环。 简单证明：如果一张图里不存在环，可以将节点沿着链以左右交替的顺序放入左右两部分，此时图明显是一个二分图。如果一张图存在环，也可以从任意一节点开始将节点沿环放入左右部分，但是起始点和最终点应该属于不同部分，不然当连接起始点和最终点的时候就会产生同一个部分中的连边，不符合二分图定义。显然，当环的长度奇数时起始点最终点一定在同一部分，而偶环
数据结构与算法学习笔记15：最大流问题 / 二分图 / 有权无权二分图的匹配 / 匈牙利算法 / 银行家算法 / 稳定婚配
h0327x的博客
06-16 551
无权图中，如何找到图中点与点之间的最短路径？（前提：有边 有权重）最大流问题是一种组合最优化问题，指的是如何充分利用装置的能力，使得运输的流量最大以取得最好的效果。1、构建残量图2、找一条简单路径，找到路径上的瓶颈值（当前路径所允许流过的最大流量），更新残量图路径权值，并将瓶颈值所在边擦除，重复该操作，直到无简单路径。1、构建残量图2、找一条简单路径，找到路径上的瓶颈值（当前路径所允许流过的最大流量），更新残量图路径权值，并将瓶颈值所在边擦除。3、添加反向路径上例左图为原图，根据原图可容易看出最大流为走s→
专题 | 二分图/二部图问题
hzx616599的博客
03-19 858
最大匹配 匈牙利算法网络流初步：费用流（带权最大匹配）Edmonds-Karp 增广路算法。
二分图&网络流
....
04-19 939
二分图 定义 二分图，又称二部图，英文名叫 Bipartite graph。 二分图是什么？节点由两个集合组成，且两个集合内部没有边的图。 换言之，存在一种方案，将节点划分成满足以上性质的两个集合。 性质 如果两个集合中的点分别染成黑色和白色，可以发现二分图中的每一条边都一定是连接一个黑色点和一个白色点。 二分图不存在长度为奇数的环 因为每一条边都是从一个集合走到另一个集合，只有走偶数次才可能回到同一个集合。 二分图判定 染色法 O(m+n)O(m+n)O(m+n) 题目链接 首先随意选取一个未染色的
二分图最大流（小白都能看懂系列２）
weixin_44001203的博客
08-22 1272
二分图最大流 前传 一个队讲一个算法，，，很不幸到我们队讲了，，可以说是看的最认真的算法了，这篇博客要好好写； （更不幸的事发生了，，，摇色子我上去讲，难受的一批，硬着头皮讲完了） 二分图是啥咧？？ 二分图又称作二部图，是图论中的一种特殊模型。 设G=(V,E)是一个无向图，如果顶点V可分割为两个互不相交的子集(A,B)，并且图中的每条边（i，j）所关联的两个顶点i和j分别属于这两个不同的顶点集(...
基于本体和二部图的网格服务发现算法研究
10-14
针对这些问题，本文提出了一种新的服务发现算法——OGSDA-BG（Ontology-based Grid Service Discovery Algorithm with Bipartite Graph），该算法结合了本体技术和二部图理论，旨在进一步提高服务发现的查全率和查准...
经典算法大全——-pdf
09-12
《经典算法大全》是一部深入探讨计算机算法的权威著作，它涵盖了算法设计、分析以及实现的各个方面，是IT行业内程序员和学者的重要参考资料。本书旨在帮助读者理解并掌握算法的核心概念，提高解决问题的能力，对于...
数字图像处理课设—图像增强算法
03-08
### 数字图像处理课设——图像增强算法 #### 一、设计目的与背景 在数字图像处理领域，图像增强技术是一种非常重要的手段，用于改善图像的视觉效果或为后续的图像分析提供更好的基础。该课程设计的目标是通过一...
MIT算法导论——算法顶尖经典教材
02-28
《MIT算法导论》是计算机科学领域的一部权威教材，由世界知名学府麻省理工学院（MIT）的专家编著。这本书深入浅出地介绍了算法设计与分析的基础理论，旨在帮助读者掌握解决复杂问题的关键技能。以下是该书涉及的一些...
子图，生成子图和导出子图
flt_ustc的博客
10-08 4万+
所有的顶点和边都属于图G的图称为G的子图。含有G的所有顶点的子图称为G的生成子图。 设V1是V的一个非空子集，以V1为顶点集，以两端点均在V1中的边的全体为边集的子图称为G的导出子图，记作G[V1]。导出子图G[V\V1]记为G-V1，它是从G中删去V1中的顶点以及与这些顶点相关的边所得到的子图。若V1={v}，则把G-{v}简记为G-v， 称为主子图。在图1-13中，G1是G的生成子图，G2是G
二部图实现的简单例子源码
pingpangbingo的专栏
10-26 835
问题 google code jam 上的一个简单的问题 http://code.google.com/codejam/contest/635101/dashboard#s=p0   #include #include #include #define MAXNAMELENGTH  100 #define MAXEDGES 100 typedef struct inner
基于BA网络模型的二部图数据集生成
weixin_33716941的博客
12-07 553
1 import random 2 import networkx as nx 3 import matplotlib.pyplot as plt 4 5 6 def ba_bip_graph(n): 7 g = nx.DiGraph() 8 f = open("start.txt") 9 line = f.readline() ...
POJ3692 最大完全二分子图
paul08colin
01-30 734
1 、最大独立集＋最小点覆盖=顶点数1、 最大独立集＝顶点数－最大匹配数2、最大完美二分子图＝补图的最大独立集3、独立集：表示集合里任意两边都没有连接关系4、补图的独立集（没有连接），反过来正是一个完全图
二分图大合集——二分图最大匹配（最小覆盖数），完美匹配以及最优匹配（带权最大匹配）
热门推荐
ling_wang的博客
04-06 4万+
二分图： 定义：二分图又称作二部图，是图论的一种特殊模型。设G=(V, E)是一个无向图，如果顶点V可分割为两个互不相交的子集（A , B），且图中的每条边（i, j）所关联的两个定点分别属于这两个不同的顶点集（i in A, j in B），则称图G为一个二分图。 简单的说，一个图被分成了两部分，相同的部分没有边，那这个图就是二分图，二分图是特殊的图。（不含奇环） 由定义可知，二分图没有自...
二分图最大匹配问题之网络流算法
H煊的博客
07-30 4986
实质：把多源，多汇网络，构造成单源单汇网络，同时置所有边的容量为1。 操作：（G=（X∪Y，E）） （1）增加一个源点s和一个汇点t； （2）从s向集合X的每一个顶点引一条有向边，从集合Y的每一个顶点向t引一条有向边； （3）将原图的每条边改为从集合X向集合Y的有向边； （4）置每条边的容量为1； 代码中的函数参见最大流模板点击打开链接 代码： //输入 int N,K;/
二分图/二部图（bipartite graph）
weixin_41361950的博客
08-10 4706
二分图定义： 对于一个无向图G（V，E），V为顶点集合，E为边集合，存在两个集合，V1,V2∈V，且V1，V2互不相交 ，且E的两个端点分别属于V1，V2，那么顶点集合V与边集合E构成一个二分图，也叫二部图。 匹配： 在图论中，一个匹配（matching）是一个边的集合，其中任意两条边都没有公共结点。 如下图（u1-v1,1; u2-v1,2;u4-v2,2; ）构成一个匹配 匹配点： 构成匹配的顶点，如上图中（u1,u2,u4,v1,1,v1,2,v2,2） 匹配边： 构成匹配的边..
图论进阶——二分图匹配（匈牙利+网络流算法）
wljoi的博客
09-26 1521
前置知识 二分图染色 注意事项 首先，这张图需要是一个二分图 二分图匹配定义 在一个二分图内找出一些边，使得任何一个图中的点都被至多一条边连接，这些边的集合叫做一个二分图匹配。 如果存在一种二分图匹配方案，使得选出的边的数量最多，那么这就叫做二分图的最大匹配。 如果该二分图的最大匹配方案中，所有的顶点均被一条边所连接，那么这个方案就叫做二分图的一个完美匹配。 二分图匹配算法 1.1.1.匈牙利算法...
数据结构—排序
最新发布
2302_81258662的博客
10-03 699
在数据结构中，排序是一种将数据元素重新排列的过程，通常是为了使它们按照特定的顺序（如升序或降序）组织起来。排序在计算机科学中非常重要，下面是一些常见的数据结构排序方法和它们的特点。
图论算法详解：二部图判定与图的同构
本文主要探讨了图论中的一个重要概念——二部图，并通过实际例子，如艾默生ups电源nx系列，来阐述其重要性和应用。二部图是指一个无向图，其中的顶点可以被分成两个不相交的集合，且图中的每条边都连接这两个集合中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值