最小费最大流 II

最新推荐文章于 2021-03-17 01:58:43 发布
最新推荐文章于 2021-03-17 01:58:43 发布
阅读量708 收藏
点赞数
分类专栏： 费用流|网络流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/solotzg/article/details/38347385
版权

hdu 3376 Matrix Again

对时间复杂度要求还挺高的 
#include<cstdio>
#include<algorithm>
#include<vector>
#include<cmath>
#include<set>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int MAXN = 360000*2+10, inf = 0x3f3f3f3f;
int n, m;
struct _node
{
	int to, next, cost, val;
	_node(int a, int b, int c, int d): to(a),next(b),cost(c),val(d) {}
	_node() {}
}ee[MAXN*10];
int head[MAXN], cnt, ppre[MAXN], wt[MAXN];
inline void add(int u, int v, int cost, int val)
{
	ee[cnt] = _node(v, head[u], cost, val);
	head[u] = cnt++;
	ee[cnt] = _node(u, head[v], -cost, 0);
	head[v] = cnt++;
}
int q[MAXN*10], vis[MAXN], dis[MAXN], fa[MAXN], pos[MAXN];
int spfa(int s, int t)
{
	int bg = 0, ed = 0;
	for (int i = 0; i<= t+10; ++i)
	{
		vis[i] = 0; fa[i] = -1; dis[i] = inf;
	}
	dis[s] = 0;
	q[ed++] = s;
	while (bg < ed)
	{
		int u = q[bg++];
		vis[u] = 0;
		for (int i = head[u]; ~i; i=ee[i].next)
		{
			int v = ee[i].to;
			if (ee[i].val > 0 && dis[v]>dis[u]+ee[i].cost)
			{
				dis[v]=dis[u]+ee[i].cost;
				fa[v] = u;
				pos[v] = i;
				if (!vis[v])
				{
					vis[v] = 1;
					q[ed++] = v;
				}
			}
		}
	}
	return fa[t] != -1;
}
int minCost_maxFlow(int s, int t)
{
	int res = 0;
	while (spfa(s, t))
	{
		for (int i = t; i!=s; i=fa[i])
		{
			--ee[pos[i]].val;
			++ee[pos[i]^1].val;
		}
		res += dis[t];
	}
	return res;
}
int mmp[605][605];
void minit()
{
	cnt = 0;
	memset(head, -1, sizeof head);
}
int main()
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif
	int s, t, N;
	while (scanf("%d", &n) != EOF)
	{
		N = n*n;
		minit();
		for (int i = 0; i< n; ++i)
		{
			for (int j = 0; j< n; ++j)
			{
				scanf("%d", &mmp[i][j]);
			}
		}
		s = 0 ; t = 2*N-1;
		for (int i = 0, p; i< n; ++i)
		{
			for (int j = 0; j< n; ++j)
			{
				p = i*n+j;
				if (i+1 < n) add(p+N, p+n, 0, 1);
				if (j+1 < n) add(p+N, p+1, 0, 1);
				if (p == 0 || p == N-1) {add(p, p+N, 0, 2);}
				else add(p, p+N, -mmp[i][j], 1);
			}
		}
		printf("%d\n", -minCost_maxFlow(s, t)+mmp[0][0]+mmp[n-1][n-1]);
	}
	return 0;
}


hdu 4411 Arrest

为了保障每个点必被访问一次，需要将一个点拆分后连一条费用极小的边 
#include<cstdio>
#include<algorithm>
#include<vector>
#include<cmath>
#include<set>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int MAXN = 105*2, inf = 0x3f3f3f3f;
int n, m, k;
struct _node
{
    int to, next, cost, val;
    _node(int a, int b, int c, int d): to(a),next(b),cost(c),val(d) {}
    _node() {}
}ee[MAXN*MAXN];
int head[MAXN], cnt;
void add(int u, int v, int cost, int val)
{
    ee[cnt] = _node(v, head[u], cost, val);
    head[u] = cnt++;
    ee[cnt] = _node(u, head[v], -cost, 0);
    head[v] = cnt++;
}
int q[MAXN*MAXN], vis[MAXN], dis[MAXN], fa[MAXN], pos[MAXN];
int spfa(int s, int t)
{
    int bg = 0, ed = 0;
    memset(vis, 0, sizeof vis);
    memset(fa, -1, sizeof fa);
    memset(dis, 0x3f, sizeof dis);
    dis[s] = 0;
    q[ed++] = s;
    while (bg < ed)
    {
        int u = q[bg++];
        vis[u] = 0;
        for (int i = head[u]; ~i; i=ee[i].next)
        {
            int v = ee[i].to;
            if (ee[i].val > 0 && dis[v]>dis[u]+ee[i].cost)
            {
                dis[v]=dis[u]+ee[i].cost;
                fa[v] = u;
                pos[v] = i;
                if (!vis[v])
                {
                    vis[v] = 1;
                    q[ed++] = v;
                }
            }
        }
    }
    return fa[t] != -1;
}
int minCost_maxFlow(int s, int t)
{
    int flow = 0;
    int res = 0;
    while (spfa(s, t))
    {
        int mn = inf;
        for (int i = t; i!= s; i = fa[i])
        {
            if (mn > ee[pos[i]].val)
                mn = ee[pos[i]].val;
        }
        for (int i = t; i!=s; i=fa[i])
        {
            ee[pos[i]].val -= mn;
            ee[pos[i]^1].val += mn;
        }
        flow += mn;
        res += dis[t]*mn;
    }
    return res;
}
void init()
{
    cnt = 0;
    memset(head, -1, sizeof head);
}
int gg[MAXN/2][MAXN/2];
int main()
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif
    while (scanf("%d%d%d", &n, &m, &k) && (n+m+k))
    {
        int u, v, w;
        memset(gg, inf, sizeof gg);
        for (int i = 0; i<= n; ++i) gg[i][i] = 0;
        for (int i = 0; i< m; ++i) 
        {
            scanf("%d%d%d", &u, &v, &w);
            if (gg[u][v] > w)
                gg[u][v] = gg[v][u] = w;
        }
        for (int kk = 0; kk<= n; ++kk)
        for (int i = 0; i<= n; ++i)
        for (int j = 0; j<= n; ++j)
        if (gg[i][j] > gg[i][kk] + gg[kk][j])
            gg[i][j] = gg[i][kk] + gg[kk][j];
        init();
        int res = 0, s = 2*n+1, t = 2*n+2;
        add(s, 0, 0, k);
        add(0, t, 0, k);
        for (int i = 1; i<= n; ++i)
            add(0, i, gg[0][i], 1), add(i, i+n, -1000000, 1), add(i+n, t, gg[i][0], 1);
        for (int i = 1; i<= n; ++i)
        for (int j = i+1; j<= n; ++j)
        add(i+n, j, gg[i][j], 1);
        printf("%d\n", minCost_maxFlow(s,t)+1000000*n);
    }
    return 0;
}


hdu 3667 Transportation

将每条边拆分成val = 1 & cost = a, 3a, 5a, 7a ... a(2c-1) 的边 
#include<stdio.h>
#include<queue>
using namespace std;
const int MAXN = 110, inf = 0x3f3f3f3f;
struct _edge
{
    int v, next, val, cost;
    _edge(){}
}e[500010];
int head[MAXN], cnt, fa[MAXN], dis[MAXN], vis[MAXN], pos[MAXN];
int n, m;
inline void add(int u, int v, int val, int c)
{
    e[cnt].v = v; e[cnt].val = val, e[cnt].cost = c; e[cnt].next = head[u];
    head[u] = cnt++;
    e[cnt].v = u; e[cnt].val = 0; e[cnt].cost = -c; e[cnt].next = head[v];
    head[v] = cnt++;
}
bool spfa(int s, int t)
{
    for(int i = 0; i<= t; ++i) fa[i]=-1,dis[i]=inf,vis[i]=0;
    int bg = 0, ed = 0, p;
    queue<int> q;
    q.push(s);
    dis[s] = 0; vis[s] = 1;
    while (!q.empty())
    {
        int u = q.front(); q.pop();
        vis[u] = 0;
        for (int i = head[u]; ~i; i=e[i].next)
        {
            int v = e[i].v;
            if (e[i].val > 0 && dis[v] > (p = dis[u]+e[i].cost))
            {
                dis[v] = p;
                fa[v] = u;
                pos[v] = i;
                if (!vis[v])
                {
                    vis[v] = 1;
                    q.push(v);
                }
            }
        }
    }
    return fa[t] != -1;
}
void minCost_maxFlow(int s, int t, int all)
{
    int f = 0;
    __int64 cost = 0;
    while (spfa(s,t))
    {
    	int mn = 1;
        for (int i=t; i!=s; i=fa[i])
            e[pos[i]].val-=mn, e[pos[i]^1].val+=mn;
        f += mn;
        cost += dis[t];
    }
    if (f != all) {printf("-1\n"); return ;}
    printf("%d\n", cost);
}
int main()
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif
    int k, u, v, a, c;
    while(~scanf("%d%d%d", &n, &m, &k))
    {
    	cnt = 0;
    	memset(head, -1, sizeof head);
        for (int i = 0; i< m; ++i)
        {
			scanf("%d%d%d%d", &u, &v, &a, &c);
			for (int j = 1; j<= c; ++j)
			{
				add(u, v, 1, a*(2*j-1));
			}
        }
       	add(0, 1, k, 0);
       	minCost_maxFlow(0, n, k);
    }
    return 0;
}


deprecated_tzg
关注
专栏目录
最小费用最大流
E_ROAD_BY_U的博客
04-11 1942
深度优先搜索 这个就用到了递归。此路不通就返回到父节点，换另一个子节点。用数组保存下路径即可。   图如果是地图的模型的话，在算出最短路径长度后，我们总要说明“怎么走”才算真正解决了问题。如何在计算过程中记录下来最短路径是怎么走的，并在最后将它输出呢？     我们定义一个path[]数组，path[i]表示源点s到i的最短路程中，结点i之前的结点的编号(父结点)，我们在借助结
牛客多校第一场 Minimum-cost Flow（最小费最大流）
qq_43734635的博客
07-14 375
题目链接 题意：给你一张有n个点m条边组组成的无向图，每条边的容量未知，但是给你每条边通过1流量所需要的花费，现在给你q个询问，每次询问的给你u，v表示将每条边的容量改为u/v，问你从1-n流过流量为1的最小花费是多少。 思路：很快就能想到这是个最小费最大流问题，但是询问为1e5每次重新跑费用流一定是会超时的，但是我们知道每次询问我们需要的最大的流量和当前流量下的最小花费即可，因此我们可以跑一次就把所有的需要的流量和最小花费全部存在来，然后处理一下前缀就可以了，在询问中乱搞一下就可以把答案搞出来了。 #in
[网络流] 最大流 最小费 回顾
weixin_34253126的博客
08-05 140
1/最大流 容量网络作为问题的有向图. 要有反向弧用于回流, 且反向弧容量为0. 残量网络, 残量=容量-当前流.(容量/当前流/残量都有反向弧) 残量>0,代表可达, 所以要不断在残量网络中找 s 到 t 的可达路. 称为增广路. 什么叫增广路? 就是当你把这条路加进来后, 会使你的结果更优. (在最大匹配中交错轨就是它的增广路). 找到增广路怎么更新当前流? 我们只需要...
最小费最大流，拆点法（海军上将 uva 1658）
xl2015190026的博客
07-14 790
有向加权图，从1到v找两条不相交路径，使权值和最小。 通过拆点法使得两条路径没有公共点（不相交）。 把2到v-1的每个节点拆成i和i’两个节点，中间连一条容量为1，费用为0的边。 如下图，图1为拆点前，图2为拆点后，每条边的容量为1。显然图1可能成为两条路径相交处。图2两点间边的容量为1，使得最多只能有一条路径穿过此点。 附上渣代码 #include #inc
poj 2195 Going Home（最小费最大流）
总有那么一群人喜欢盯着我的博客看，估计这是他们见过最长的博客名，我必须得告诉他们博客名最长可以写多长
07-27 824
poj 2195 Going HomeDescription On a grid map there are n little men and n houses. In each unit time, every little man can move one unit step, either horizontally, or vertically, to an adjacent point.
网络流模板（最大流，最小费）
ACTerminate的博客
07-21 530
网络流模板
最小费最大流，最小权最大匹配，拆点法（最优巴士路线设计 uva 1349）
xl2015190026的博客
07-13 2137
紫书网络流上的题目，上面的题目简述与分析挺清楚。 给n各点（n 每个点恰好属于一个圈，意味着每个点都有一个唯一的后继。反过来，只要每个点都有唯一的后继，每个点一定恰好属于一个圈。“每个东西恰好有唯一的……”让我们想到了二分图匹配。把每个点i拆成Xi和Yi，原图中的有向边u->v对应二分图中的边Xu->Yv，则题目转化为了这个二分图上的最小权完美匹配问题。 Xi就像每个点的尾巴，Yi就
matlab最小费用最大流函数,使用matlab求解最小费用最大流算问题
weixin_42509396的博客
03-17 1761
《使用matlab求解最小费用最大流算问题》由会员分享，可在线阅读，更多相关《使用matlab求解最小费用最大流算问题(8页珍藏版)》请在人人文库网上搜索。1、北京联合大学实验报告项目名称： 运筹学专题实验报告 学 院： 自动化 专 业： 物流工程 班 级： 1201B 学 号：81 姓 名： 管水城 成 绩： 2015 年5月6日实验三：使用matlab求解最小费用最大流算问题一、实验目的：(1...
最小费用最大流问题求解
12-16
基于matlab2016的最小费用最大流问题求解，内含增广链路函数[path,value] = AugmentingPath(G,s,t)和一个demo函数。 寻找增广链路时，使用了matlab自带的最短路径shortestpath函数，demo中使用了matlab自带的...
一句话网络流（EK，Dinic，最小费最大流，（最大/最小）可行流，最小费用可行流）
积极的防守者的博客
05-09 1875
EK算法求最大流： BFS找增广路增广直到无法增广 复杂度：O(V*E^2) 核心代码（邻接表存图）：（一开始学最大流的时候写的代码，非常丑） int pre[maxn]; int vis[maxn]={0}; bool bfs(){//bfs求路径 for(int i = 0;i <= n+1;++i) vis[i] = 0; queue<int> q;q.push(0);...
最大流，最大流最小费用算法
12-17
最大流，最大流最小费用算法，包括代码，测试数据，结果，已测试，完全正确。
最小费用最大流matlab代码
09-25
基于matlab的最大流最小费用代码 适于学习、修改、借鉴
uva 10806 Dijkstra, Dijkstra. （最小费最大流）
总有那么一群人喜欢盯着我的博客看，估计这是他们见过最长的博客名，我必须得告诉他们博客名最长可以写多长
07-22 940
uva 10806 Dijkstra, Dijkstra.题目大意：你和你的伙伴想要越狱。你的伙伴先去探路，等你的伙伴到火车站后，他会打电话给你（电话是藏在蛋糕里带进来的），然后你就可以跑去火车站了，那里有人接应你。但是，因为你的伙伴跑去火车站的时候穿的是囚服，所以，他经过的街道都被戒严了，你必须从其他街道跑过去。如果你可以到达火车站，请输出你和你的伙伴在路上花费的最短时间，如果不能请“Back t
【洛谷 P3381】最小费用最大流（SPFA+EK）
duanghaha的博客
10-10 392
在最大流的基础上把BFS换成SPFA即可。 #include&amp;lt;bits/stdc++.h&amp;gt; using namespace std; const int maxn = 100050; const int INF = 0x3f3f3f3f; int head[maxn]; bool vis[maxn]; int dis[maxn]; int flow[maxn]; int n,m,s,t...
洛谷 p3381 最小费最大流 模板题 spfa算法
junerbaci的博客
06-25 274
大体思路是 spfa找能从起点流到终点的最短路，找到不能找了，就找到了最大流，而此时的费用一定是最小费用； 以下给出ac代码： h[],e[],ne[] 存图， w[],f[],存每条边的流量和单位费用 pre[],last[] 存修改增广路径的点和边 dis[],flow [] 存到点的花费和流量 ``` #include <stdio.h> #include &...
最小费用最大流问题
gyh_420的博客
08-03 2999
基于网络最大流问题，进一步提出的最小费用问题，费用权值和最大流问题的容量限制是两个概念，实质上这个问题就是求图的加权最短路，只是要在最大流的前提下实现。所以要用Bellman-Ford算法找增广路的同时计算最小费。 下面是紫书中求最小费最大流的模板`const int maxn = 2000 + 10; const int INF = 1000000000;struct Edge { int
uva 10594 Data Flow （最小费最大流+题目给的数据有错）
总有那么一群人喜欢盯着我的博客看，估计这是他们见过最长的博客名，我必须得告诉他们博客名最长可以写多长
07-24 755
uva 10594 Data Flow题目大意：给出一张图，以及D， K，D代表所要传送的数据量，K代表每条边可以传送的数据量（就是容量），问在可以传送所有数据的前提下，最小耗费时间。解题思路：建一个超级源点连向源点1，容量为D，然后求该图的最小费最大流。最后将求出的最大流与D比较，比D小输出inpossible，否则输出最小费。#include <cstdio> #include <cstring
POJ2195 Going Home （最小费最大流||二分图最大权匹配）
Jelly_acm的博客
02-12 1116
Going Home Description On a grid map there are n little men and n houses. In each unit time, every little man can move one unit step, either horizontally, or vertically, to an adjacent point. For each little man, you need to pay a $1 travel fee for every
java 小费马定理
最新发布
11-25
根据提供的引用内容，我无法确定“小费马定理”是什么。但是，如果您想了解如何使用Java编写小费计算器，我可以为您提供以下信息： 您可以使用Java编写小费计算器，以下是一个简单的示例： ```java import java....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值