POJ 1149 PIGS 用了三种求最大流的方法

最新推荐文章于 2019-08-10 21:41:18 发布
最新推荐文章于 2019-08-10 21:41:18 发布
阅读量738 收藏
点赞数
分类专栏： 最大流 POJ 图论 文章标签： struct 算法 网络 c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Drecik__/article/details/7400577
版权
POJ 同时被 3 个专栏收录
3 篇文章 0 订阅
订阅专栏
图论
3 篇文章 0 订阅
订阅专栏
最大流
2 篇文章 0 订阅
订阅专栏

转载请注明出处：http://blog.csdn.net/drecik__/article/details/7400577

/*
 * 第一道最大流, 写的有点挫, 按照Ford算法来做;
 * 也没用什么改进的最短增广算法;
 * 转化为网络流的模型时稍微有点麻烦;
 */


#include <iostream>
#include <queue>
#include <cstring>
#include <cstdio>
using namespace std;

#define MAXN 1005
#define INF 9999999
#define INF2 999999
#define MIN( a, b ) ( (a) <= (b)? (a):(b) )
#define ABS( a ) ( (a) >= 0? (a) : -(a) )

// 边的属性结构;
struct EdgeType
{
	int c;
	int f;      // 容量和流量; 
};

EdgeType Edges[MAXN][MAXN]; // 邻接矩阵, 当两点之间不存在边时，c和f都赋值为INF; 

int flag[MAXN];             // 标记， -1：未标记，0：已标记未检查，1：标记并检查;
int prar[MAXN];             // 标号的第一个分量，用于存放父节点;
int alpha[MAXN];            // 标号的第二个分量，存放可改进a;

// 第一个参数为源点，第二个为汇点; 
int Ford( int s, int t, int iPointNum )
{
	// 进行寻找增广路径; 
	while( true )
	{
		// 对标号进行初始化;
		memset( flag, 0xff, sizeof(flag) );

		// 对分量进行初始化;
		memset( prar, 0xff, sizeof(prar) );
		memset( alpha, 0xff, sizeof(alpha) ); 

		// 初始化源点;
		flag[s] = 0;
		prar[s] = s;
		alpha[s] = INF;

		queue<int> queInt;
		queInt.push( s );
		while( !queInt.empty() && flag[t] == -1 )
		{
			int u = queInt.front();
			queInt.pop();

			// 循环每条边; 
			for ( int i = 0; i < iPointNum; ++i )
			{
				// 未标号; 
				if ( flag[i] == -1 )
				{
					// 正向且未满;
					if ( Edges[u][i].c < INF && Edges[u][i].f < Edges[u][i].c )
					{
						// 进行标记;
						flag[i] = 0;
						prar[i] = u;
						alpha[i] = MIN( alpha[u], Edges[u][i].c-Edges[u][i].f );

						queInt.push( i );
					}

					// 反向且有流量;
					if ( Edges[i][u].c < INF && Edges[i][u].f > 0 )
					{
						// 进行标记;
						flag[i] = 0;
						prar[i] = -u;
						alpha[i] = MIN( alpha[u], Edges[i][u].f );

						queInt.push( i );
					} 
				}
			}

			flag[u] = 1;        // 标号为检查完毕; 
		}

		// 当汇点没有进行标号，或调整量为0， 退出循环; 
		if ( flag[t] == -1 || alpha[t] == 0 )
			break;

		// 进行调整;
		int k1 = t, k2 = ABS(prar[t]);
		while ( true )
		{
			if ( Edges[k2][k1].f < INF )    // 正向;
				Edges[k2][k1].f = Edges[k2][k1].f + alpha[t];
			else
				Edges[k1][k2].f = Edges[k1][k2].f - alpha[t];

			if ( k2 == s )
				break;

			k1 = k2;
			k2 = ABS( prar[k1] );
		}

	}

	// 存放最大流; 
	int iMaxFlow = 0;
	for ( int i = 0; i < iPointNum; ++i )
	{
		if ( Edges[0][i].f < INF )
			iMaxFlow += Edges[0][i].f;
	}

	return iMaxFlow;
}

int main()
{
	int iSet[MAXN] = {0};
	int Pigs[MAXN] = {0};
	int m;
	int n;
	scanf( "%d%d", &m, &n );

	for ( int i = 0; i < n+2; ++i )
	{
		for ( int j = 0; j < n+2; ++j )
			Edges[i][j].c = Edges[i][j].f = INF;
	}
	for ( int i = 1; i <= m; ++i )
		scanf( "%d", &Pigs[i] );
	for ( int i = 1; i <= n; ++i )
	{
		int t;
		scanf( "%d", &t );
		int num;
		while ( t-- )
		{
			scanf( "%d", &num );
			if ( iSet[num] != 0 )
			{
				Edges[iSet[num]][i].f = 0;
				Edges[iSet[num]][i].c = INF2;
				iSet[num] = i;
			}
			else
			{
				iSet[num] = i;
				if ( Edges[0][i].c != INF )
					Edges[0][i].c += Pigs[num];
				else
				{
					Edges[0][i].c = Pigs[num];
					Edges[0][i].f = 0;
				}
			}
		}

		scanf( "%d", &Edges[i][n+1].c );
		Edges[i][n+1].f = 0;
	}

	cout << Ford( 0, n+1, n+2 ) << endl;

	return 0;
}
/*
 * 改写用最短路增广算法;
 * 效率有点提高, 上面的为63ms, 这个为47ms;
 * 接下去再写个连续最短增广路试试;
 */


#include <iostream>
#include <queue>
#include <cstring>
#include <cstdio>
using namespace std;

#define MAXN 1005
#define INF 9999999
#define INF2 999999
#define MIN( a, b ) ( (a) <= (b)? (a):(b) )
#define ABS( a ) ( (a) >= 0? (a) : -(a) )

// 边的属性结构;
struct EdgeType
{
	int c;
	int f;      // 容量和流量; 
};

EdgeType Edges[MAXN][MAXN]; // 邻接矩阵, 当两点之间不存在边时，c和f都赋值为INF; 

int flag[MAXN];             // 标记， -1：未标记，0：已标记未检查，1：标记并检查;
int prar[MAXN];             // 标号的第一个分量，用于存放父节点;
int alpha[MAXN];            // 标号的第二个分量，存放可改进a;

int level[MAXN];			// 各个顶点的等级;
void BFS( int s, int n )
{
	memset( level, 0, sizeof(level) );

	queue<int> queInt;
	queInt.push( s );
	while ( !queInt.empty() )
	{
		int u = queInt.front();
		queInt.pop();

		for ( int i = 0; i < n; ++i )
		{
			if ( i == s )
				continue;
			if ( !level[i] && Edges[u][i].c < INF && Edges[u][i].f < Edges[u][i].c )
			{
				level[i] = level[u]+1;
				queInt.push(i);
			}

			if ( !level[i] && Edges[i][u].c < INF && Edges[i][u].f > 0 )
			{
				level[i] = level[u]+1;
				queInt.push(i);
			}
		}
	}
}

// 第一个参数为源点，第二个为汇点, 第三个为顶点个数; 
int Ford( int s, int t, int n )
{
	// 进行寻找增广路径;
	while ( true )
	{
		BFS( s, n );
		if ( !level[t] )
			break;

		while( true )
		{
			// 对标号进行初始化;
			memset( flag, 0xff, sizeof(flag) );

			// 对分量进行初始化;
			memset( prar, 0xff, sizeof(prar) );
			memset( alpha, 0xff, sizeof(alpha) ); 

			// 初始化源点;
			flag[s] = 0;
			prar[s] = s;
			alpha[s] = INF;

			queue<int> queInt;
			queInt.push( s );
			while( !queInt.empty() && flag[t] == -1 )
			{
				int u = queInt.front();
				queInt.pop();

				// 循环每条边; 
				for ( int i = 0; i < n; ++i )
				{
					// 未标号; 
					if ( flag[i] == -1 && level[i] == level[u]+1 )
					{
						// 正向且未满;
						if ( Edges[u][i].c < INF && Edges[u][i].f < Edges[u][i].c )
						{
							// 进行标记;
							flag[i] = 0;
							prar[i] = u;
							alpha[i] = MIN( alpha[u], Edges[u][i].c-Edges[u][i].f );

							queInt.push( i );
						}

						// 反向且有流量;
						if ( Edges[i][u].c < INF && Edges[i][u].f > 0 )
						{
							// 进行标记;
							flag[i] = 0;
							prar[i] = -u;
							alpha[i] = MIN( alpha[u], Edges[i][u].f );

							queInt.push( i );
						} 
					}
				}

				flag[u] = 1;        // 标号为检查完毕; 
			}

			// 当汇点没有进行标号，或调整量为0， 退出循环; 
			if ( flag[t] == -1 || alpha[t] == 0 )
				break;

			// 进行调整;
			int k1 = t, k2 = ABS(prar[t]);
			while ( true )
			{
				if ( Edges[k2][k1].f < INF )    // 正向;
					Edges[k2][k1].f = Edges[k2][k1].f + alpha[t];
				else
					Edges[k1][k2].f = Edges[k1][k2].f - alpha[t];

				if ( k2 == s )
					break;

				k1 = k2;
				k2 = ABS( prar[k1] );
			}
		}
	}

	// 存放最大流; 
	int iMaxFlow = 0;
	for ( int i = 0; i < n; ++i )
	{
		if ( Edges[0][i].f < INF )
			iMaxFlow += Edges[0][i].f;
	}

	return iMaxFlow;
}

int main()
{
	int iSet[MAXN] = {0};
	int Pigs[MAXN] = {0};
	int m;
	int n;
	scanf( "%d%d", &m, &n );

	for ( int i = 0; i < n+2; ++i )
	{
		for ( int j = 0; j < n+2; ++j )
			Edges[i][j].c = Edges[i][j].f = INF;
	}
	for ( int i = 1; i <= m; ++i )
		scanf( "%d", &Pigs[i] );
	for ( int i = 1; i <= n; ++i )
	{
		int t;
		scanf( "%d", &t );
		int num;
		while ( t-- )
		{
			scanf( "%d", &num );
			if ( iSet[num] != 0 )
			{
				Edges[iSet[num]][i].f = 0;
				Edges[iSet[num]][i].c = INF2;
				iSet[num] = i;
			}
			else
			{
				iSet[num] = i;
				if ( Edges[0][i].c != INF )
					Edges[0][i].c += Pigs[num];
				else
				{
					Edges[0][i].c = Pigs[num];
					Edges[0][i].f = 0;
				}
			}
		}

		scanf( "%d", &Edges[i][n+1].c );
		Edges[i][n+1].f = 0;
	}

	cout << Ford( 0, n+1, n+2 ) << endl;

	return 0;
}

/*
 * 用了连续最短增广算法;
 * 之前WA了一次, 也不知道改了哪里, 就稀里糊涂的对了;
 * 用了16ms, 果然要快点;
 */


#include <iostream>
#include <queue>
#include <cstring>
#include <cstdio>
using namespace std;

#define MAXN 1005
#define INF 9999999
#define INF2 999999
#define MIN( a, b ) ( (a) <= (b)? (a):(b) )
#define ABS( a ) ( (a) >= 0? (a) : -(a) )

// 边的属性结构;
struct EdgeType
{
	int c;
	int f;      // 容量和流量; 
};

EdgeType Edges[MAXN][MAXN]; // 邻接矩阵, 当两点之间不存在边时，c和f都赋值为INF; 

int flag[MAXN];             // 标记， -1：未标记，0：已标记未检查，1：标记并检查, 回溯之后要标记为-1;
int prar[MAXN];             // 标号的第一个分量，用于存放父节点;
int alpha[MAXN];            // 标号的第二个分量，存放可改进a;

int level[MAXN];			// 各个顶点的等级;
void BFS( int s, int n )
{
	memset( level, 0, sizeof(level) );

	queue<int> queInt;
	queInt.push( s );
	while ( !queInt.empty() )
	{
		int u = queInt.front();
		queInt.pop();

		for ( int i = 0; i < n; ++i )
		{
			if ( i == s )
				continue;
			if ( !level[i] && Edges[u][i].c < INF && Edges[u][i].f < Edges[u][i].c )
			{
				level[i] = level[u]+1;
				queInt.push(i);
			}

			if ( !level[i] && Edges[i][u].c < INF && Edges[i][u].f > 0 )
			{
				level[i] = level[u]+1;
				queInt.push(i);
			}
		}
	}
}

// 进行深搜, 搜索的点, 汇点, 顶点个数;
int DFS( int s, int t, int n )
{
	if ( s == t )
		return alpha[t];

	// 标记为已读;
	flag[s] = 0;

	// 用于存放回溯是的增量;
	int sumAlpha = 0;

	for ( int i = 0; i < n; ++i )
	{
		if ( flag[i] == -1 && level[i] == level[s]+1 )
		{
			// 正向边;
			if ( Edges[s][i].c < INF && Edges[s][i].f < Edges[s][i].c )
			{
				// 进行标记;
				prar[i] = s;
				alpha[i] = MIN( alpha[s], Edges[s][i].c-Edges[s][i].f );

				int x = DFS( i, t, n );

				Edges[s][i].f += x;
				alpha[s] -= x;
				sumAlpha += x;
			}

			// 反向边;
			if ( Edges[i][s].c < INF && Edges[i][s].f > 0 )
			{
				// 进行标记;
				prar[i] = s;
				alpha[i] = MIN( alpha[s], Edges[i][s].f );

				int x = DFS( i, t, n );

				Edges[i][s].f -= x;
				alpha[s] -= x;
				sumAlpha += x;
			}
		}
	}

	flag[s] = -1;

	return sumAlpha;
}

// 第一个参数为源点，第二个为汇点; 
int Ford( int s, int t, int n )
{
	// 进行寻找增广路径;
	while ( BFS( s, n ), level[t] )
	{
		// 对标号进行初始化;
		memset( flag, 0xff, sizeof(flag) );

		// 对分量进行初始化;
		memset( prar, 0xff, sizeof(prar) );
		memset( alpha, 0xff, sizeof(alpha) ); 

		alpha[s] = INF;
		prar[s] = s;
		DFS( s, t, n );
	}

	// 存放最大流; 
	int iMaxFlow = 0;
	for ( int i = 0; i < n; ++i )
	{
		if ( Edges[s][i].f < INF )
			iMaxFlow += Edges[s][i].f;
	}

	return iMaxFlow;
}

int main()
{
	int iSet[MAXN] = {0};
	int Pigs[MAXN] = {0};
	int m;
	int n;
	scanf( "%d%d", &m, &n );

	for ( int i = 0; i < n+2; ++i )
	{
		for ( int j = 0; j < n+2; ++j )
			Edges[i][j].c = Edges[i][j].f = INF;
	}
	for ( int i = 1; i <= m; ++i )
		scanf( "%d", &Pigs[i] );
	for ( int i = 1; i <= n; ++i )
	{
		int t;
		scanf( "%d", &t );
		int num;
		while ( t-- )
		{
			scanf( "%d", &num );
			if ( iSet[num] != 0 )
			{
				Edges[iSet[num]][i].f = 0;
				Edges[iSet[num]][i].c = INF2;
				iSet[num] = i;
			}
			else
			{
				iSet[num] = i;
				if ( Edges[0][i].c != INF )
					Edges[0][i].c += Pigs[num];
				else
				{
					Edges[0][i].c = Pigs[num];
					Edges[0][i].f = 0;
				}
			}
		}

		scanf( "%d", &Edges[i][n+1].c );
		Edges[i][n+1].f = 0;
	}

	cout << Ford( 0, n+1, n+2 ) << endl;

	return 0;
}



                

        

        

    




    

      

        

            

              
                
                  Drecik__
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
PIGS POJ - 1149 最大流（建图神题）

				
			

			

				

					WA是一笔财富
				

				

					04-29
					
					331
					
				

			

		

		

			
				
传送门：POJ1149

正确建模方法：


这题说多了都是泪啊，连暴力建模方法都和大牛想的不一样，还傻X的想为什么连样例都过不了。。
说这题是建图神题是因为他用到了许多建图时的优化方法，建图的基本优化准则：


直到今天才接触到这些方法，实在是太弱了。。都不敢往外说自己是搞图论的。。
代码：
//ISAP int
#include 
#include 
#include

			
		

	



                

              
                



	

		

			

				
					
poj 1149 最大流经典建图

				
			

			

				

					AngelBeats!
				

				

					09-08
					
					437
					
				

			

		

		

			
				
poj 1149
题意：有m个猪圈，n个人去买猪，每个人有ai个猪圈的钥匙最多买bi只猪，每个人买猪时会把猪圈门打开，这时候可以将这几个猪圈里买剩下的猪自由分配到这几个猪圈里，问最多能卖掉多少头猪。
思路：实在是经典的建图方法，这篇博客写的很清晰了，膜拜大牛orzzzzzzzzzzzzzzzzzzz
#include 
#include 
#include 
#include 
#inclu

			
		

	



                


  
              

                


	

		

			

				
					
POJ 1149 迈克卖猪问题（PIGS)  最大流

				
			

			

				

					EnjoyingAC的博客
				

				

					11-27
					
					590
					
				

			

		

		

			
				
#include 
#include 
#include 
#include 
#include 
#define INF 0x3f3f3f3f

using namespace std;

int M,N;
vector que[1010];
int pig[1010];
int cus[110];
const int maxe=1e4+1000;
const int maxv=110;
str

			
		

	





	

		

			

				
					
poj1149【sap最大流】

				
			

			

				

					leijp
				

				

					03-23
					
					300
					
				

			

		

		

			
				
poj1149 模板题#include &lt;cstdio&gt;
#include &lt;cstring&gt;
#include &lt;iostream&gt;
using namespace std;
int n,m;

int p[1010];
int last[1010];
bool con[110][110];
int CON[110];

struct edge {
	int ...

			
		

	



		

			
		



	

		

			

				
					
POJ-1149

				
			

			

				

					ACMSlience的专栏
				

				

					05-01
					
					417
					
				

			

		

		

			
				
#include 
#include 
#include 
#include 
#include
using namespace std;
#define INF 99999999
const int maxn =1110;
const int maxm =220000;
const int oo = 1<<29;
struct Arclist
{
    int cnt, head[maxn],

			
		

	





	

		

			

				
					
poj 1149

				
			

			

				

					[CHN]liurui
				

				

					08-19
					
					297
					
				

			

		

		

			
				
题目概述你在养猪场打工，养猪场M个猪圈，编号1到M，都锁着，你打不开，有N个顾客会依次来买猪，他们有A个猪圈的钥匙，最多要买B只猪，你可以从打开的猪圈里随便挑一些猪卖给他们，并且可以顺手在打开的猪圈之间转移猪以便下次多卖一点，顾客走后猪圈会再锁上，问你最多可以卖掉多少猪 
每个猪圈可以放无穷多头猪时限1000ms/2000ms输入第一行整数M,N，下一行M个整数，描述每个猪圈初始猪数，按编号升序给出

			
		

	





	

		

			

				
					
poj 1149 PIGS.md

				
			

			

				

					11-17
				

			

		

		

			
				
poj 1149 PIGS.md

			
		

	





	

		

			

				
					
POJ3308-Paratroopers 【Dinic算法求最大流】

				
			

			

				

					09-17
				

			

		

		

			
				
【二分图顶点覆盖->最小割->最大流->Dinic算法求解】   解题报告+AC代码  http://hi.csdn.net/!s/WKVPR0    ----> 我的所有POJ解题报告 http://blog.csdn.net/lyy289065406/article/details/6642573

			
		

	





	

		

			

				
					
三分法求最大值

				
			

			

				

					08-05
				

			

		

		

			
				
"三分法求最大值"  三分法是求解凸性函数的极值问题的一种方法。凸性函数是指函数在定义域内的所有点的函数值都是非负的或非正的函数。三分法是一种分治方法，适用于求解凸性函数的极值问题。  三分法的基本思想是将...

			
		

	





	

		

			

				
					
POJ2195-Going Home【费用流】

				
			

			

				

					08-30
				

			

		

		

			
				
4. **Dinic算法**：一种解决最大流问题的高效算法，适用于处理有负权边的情况，可以与费用流问题结合。  5. **增广路径**：在费用流问题中，增广路径是指从源点到汇点的路径，沿路径可以增加流量而不会违反任何边的...

			
		

	





	

		

			

				
					
POJ2516__最小费用最大流

				
			

			

				

					10-23
				

			

		

		

			
				
poj2516代码最小费用最大流

			
		

	





	

		

			

				
					
poj1149 PIGS（建图最大流）

				
			

			

				

					Icefox的博客
				

				

					12-20
					
					331
					
				

			

		

		

			
				
这题真的是好妙啊。首先有一种O(nm)个点的比较直观的建图方法：把每个猪圈拆成n个阶段，第i个人买第i阶段的相应猪圈里的猪。第i阶段的猪可以留到第i+1阶段，第i阶段打开的猪圈可以互相流通到下一阶段。源向所有第一阶段的猪圈连边，容量为猪圈大小，所有人向汇连边，容量为这个人可以购买的数量。然后跑最大流即可，应该也能过。 
还有一种更好的建图方法：源向所有猪圈建边，容量为猪圈大小。所有人向汇连边，容量为

			
		

	





	

		

			

				
					
poj 1149题解

				
			

			

				

					Taylor Wu的专栏
				

				

					08-19
					
					657
					
				

			

		

		

			
				
题目来源：http://poj.org/problem?id=1149
题目大意：
Mirko在猪场工作，有N个猪圈，每个猪圈有pig[i]个猪，但是他不能打开任何猪圈的门，有M个人按顺序来买猪，每个人有K个猪圈的钥匙，有一个最大的可能要买的数量buy[i]，但是Mirko 可以卖给他任意数量的猪（当然不能超过MAX），这个人走后Mikro可以重新分配这K个猪圈里的猪，然后猪圈又会把门锁起来，

			
		

	





	

		

			

				
					
poj 1149 PIGS 题解（网络流，建图）

				
			

			

				

					LightningUZ的博客
				

				

					08-10
					
					225
					
				

			

		

		

			
				
原题链接：
poj
题意简述
有m(&lt;=1000)m(&lt;=1000)m(<=1000)头猪，和n(&lt;=100)n(&lt;=100)n(<=100)个顾客。第iii个顾客有ai(&lt;=m)a_i(&lt;=m)ai​(<=m)个喜欢的猪（给定这些猪的编号），但是最多只会买bi(&lt;=m)b_i(&a...

			
		

	





	

		

			

				
					
POJ 1149

				
			

			

				

					Jaster_wisdom的专栏
				

				

					03-21
					
					525
					
				

			

		

		

			
				
题目：
m个猪圈，n个顾客，每个猪圈里面有一定数量的猪，每个顾客有一定的需求量。求最多可以卖出多少条猪？
这里注意有一个前提条件，就是一个顾客开了一个猪圈之后，后 面的话，可以将这个猪圈里面的猪 拉到其他猪圈里去。
此题关键就是 建立图结构，因为最大流问题，我们可以用 EK 模板来套。
此图里面有三层，第一层就是源点，第二层顾客，第三层是汇点。
总的来说，源点与顾客连，顾客与汇点连。注意

			
		

	





	

		

			

				
					
POJ 1149(构图巨难……）

				
			

			

				

					爱.NET
				

				

					08-16
					
					101
					
				

			

		

		

			
				
EK……


Program P1149;
var
   i,j,k,n,m,p:longint;
   map,f:array[0..500,0..500] of longint;
   visit,e,pre,pighouse:array[0..500] of longint;
   maxflow:longint;
function min(a,b:longint):longint;
b...

			
		

	





	

		

			

				
					
poj-1149(最大流)

				
			

			

				

					weixin_30410999的博客
				

				

					05-03
					
					89
					
				

			

		

		

			
				
题意：有一个养猪场，厂长没有钥匙，这个养猪场一共M个猪圈，N个顾客，每个顾客有一些猪圈的钥匙，每个顾客需要一些猪，问你厂长最多能卖多少猪？这里有个条件是，厂长可以在一个顾客买完后，调整没有锁门的猪圈中猪数量，比如，把几个猪圈中的猪全部转到一个猪圈内（这个条件会影响到后期建图），然后再关门，等下一个顾客；
解题思路：因为这里猪圈猪的数量限制的是顾客能买的数量，所以把顾客当成结点建图：
首先，设立...

			
		

	





	

		

			

				
					
POJ1149 网络流最大流

				
			

			

				

					qq_37804582的博客
				

				

					02-20
					
					120
					
				

			

		

		

			
				
POJ1149 网络流最大流
		
		POJ1149 网络流最大流
#include <queue>
#include <cstring>
#include <cstdio>
using namespace std;
const int N = 1010;
struct node{
    int v, w, nxt;
}edge[N *...

			
		

	





	

		

			

				
					
POJ 1149 PIGS（网络流经典建图题）

				
			

			

				

					llzhh的博客
				

				

					08-23
					
					335
					
				

			

		

		

			
				
题意就是：给出m个猪圈，每个猪圈都有一定数量的猪，然后有n个顾客来买猪，他们每个都有一个最大的买猪数目。每次他们会按照顺序打开某些猪圈买猪，然后离开，此时卖家就在打开的猪圈里面重新分配猪，没有打开的猪圈不参与，然后全部猪圈都会关闭，一直循环。
经典的网络流题目。每个猪圈剩下多少猪是由第一个进入这个猪圈买猪的人决定的，所以每个猪圈和第一个进入这个猪圈的买家连一条流量为无穷的边。后进来的买家则只能从

			
		

	





	

		

			

				
					
POJ2135 Farm Tour —— 最小费用最大流

					
最新发布

				
			

			

				

					05-25
				

			

		

		

			
				
题目描述

农夫约翰在他的农场里建立了一些水沟，以帮助水从一个地方流到另一个地方。他需要为这些水沟安排一些管道，以便水可以通过它们流动。然而，由于约翰的农场是非常大的，因此在不同位置的水沟之间建立管道的成本可能会有所不同。

现在，约翰需要你的帮助来计算从他的农场的某个地方到另一个地方的最小成本路径。路径上必须存在一些管道，以便水可以流动。他希望你能够计算出这样一条路径的最小成本，并且还要确保这条路径上的所有水沟都能够通过管道连接。

输入格式

第一行包含两个整数 N 和 M，分别表示水沟的数量和水沟之间的连通性。

接下来 M 行，每行包含三个整数 a, b, w，表示编号为 a 和 b 的两个水沟之间连接一条成本为 w 的无向管道。

输出格式

输出从 1 到 N 的最小费用最大流，如果无法到达，则输出 -1。

数据范围

1≤N≤1000
1≤M≤10000
1≤a,b≤N
1≤w≤10000

输入样例

4 5
1 2 1
2 3 2
3 4 3
1 3 4
2 4 3

输出样例

6

算法1

(最小费用最大流) $O(N^2M)$

最小费用最大流

时间复杂度

参考文献

C++ 代码

算法2

(暴力枚举) $O(n^3)$

blablabla

时间复杂度

参考文献

C++ 代码

			
		

	



              



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

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值