spoj spoj839 Optimal Marks 网络流 最小割 附数据生成器

最新推荐文章于 2018-07-04 21:47:40 发布
最新推荐文章于 2018-07-04 21:47:40 发布
阅读量514 收藏
点赞数
分类专栏： 网络流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_23081367/article/details/52403163
版权

题目大意：


给定一张图，每个点有一个数字，有的点没有数字。


给所有点涂上数字，使得任意直接相连的2个点的数字，xor值的和最小。



对于xor运算，每一位之间没有关系。所以题目首先拆分成31个小问题。。求最后每个数字的每一位（二进制位）的数字。


然后目前的问题就是，一张图，很多点数字是0，很多点数字是1，还有一些点没有上数字。 找一个方案，使得任何直接相连的点的数字，xor值的和最小。


显然0附近的点都写0比较好，1附近的点都写1比较好。 最后1和0交汇了，希望交汇的点尽量小。 这显然就是一个最小割。


然后新原连1的边，0连新汇，流量都是无穷大。


其他原来图中相连的边，都是正反连上流量为1的边即可。


跑一个最大流，割的位置，就是01交汇的地方。


然后从S出发经过的所有点，都涂上1. 其他点都是0.


然后这题就做完了。。


写完程序过了样例交一发WA了。。就去写对拍器。。结果发现数组没清0，导致多组数据WA……忧伤


数据生成器代码

#include <cstdio>
#include <cstring>
#include <vector>
#include <ctime>
#include <iostream>
#include <cstdlib>
using namespace std;

char get_rand()
{
	int flag= rand()%3;
	if (flag==0)
	{
		return rand()%10 + '0';
	}
	if (flag==1)
	{
		return rand()%26+'a';
	}
	return rand()%26+'A';
}

int rand_from_to(int a, int b)
{
	return rand()%(b-a+1) + a;
}

int f[550][550];
typedef pair<int,int>pii;
#define mp(a,b) make_pair(a,b)

int main()
{
	srand(time(0));

	int T=2;
	cout<<T<<endl;
	while (T--)
	{
		memset(f,0,sizeof(f));
		int n =  5;//n个点,m个边
		int totm = 15;
		int sb=rand()%totm+1;
		for (int i = 1; i <= sb;++i)
		{
			int a = rand()%n+1;
			int b = rand()%n+1;
			if (a>b)swap(a,b);
			f[a][b] = rand()*rand()%10000000+1;
		}

		vector<pii>g;
		for (int i = 1; i <=n;++i)
			for (int j = i+1; j <=n;++j)
			{
				if (i==j)continue;
				if (f[i][j])
				{
					g.push_back(mp(i,j));
					f[j][i]=0;
				}
			}
		cout<<n<<" ";
		cout<<g.size()<<endl;
		for (auto x : g)
		{
			cout<<x.first<<" "<<x.second<<endl;//<<" "<<f[x.first][x.second]<<endl;
		}
		g.clear();
		for (int i = 1; i <= n ; ++ i)
		{
			int flag = rand()%2;
			if (flag)	continue;
			g.push_back(mp(i, rand()%10));
		}

		cout<<g.size()<<endl;
		for (auto x : g)
		{
			cout<<x.first<<" "<<x.second<<endl;//<<" "<<f[x.first][x.second]<<endl;
		}
	}
	return 0;
}

ac code 

#include <bits/stdc++.h>
#include <ext/pb_ds/priority_queue.hpp>
#include <tr1/unordered_map>
using std::tr1::unordered_map;
//using std::setiosflags;
//using std::setprecision;
using std::sort;
using std::max;
using std::min;
using std::cout;
using std::stack;
using std::cin;
using std::endl;
using std::swap;
using std::pair;
using std::vector;
using std::set;
using std::map;
using std::make_pair;
using std::multiset;
using std::unique;
using std::queue;
using std::greater;
using std::string;
using std::priority_queue;
using std::lower_bound;//返回第一个不小于
using std::upper_bound;//返回第一个大于
using std::max_element;
using std::min_element;
using __gnu_pbds::pairing_heap_tag;
#define x first
#define y second
#define Hash unordered_map
#define clr(x,b) memset((x),(b),sizeof(x))
typedef unsigned long long uLL;
typedef long long LL;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef __gnu_pbds::priority_queue<pii, greater<pii>, pairing_heap_tag> Heap;//小根堆
typedef Heap::point_iterator Hit;
const Hit null;
const double PI = acos(-1);
const LL LINF = 0x3f3f3f3f3f3f3f3fll;//4e18
const int INF = 0x3f3f3f3f;//1e9
const double eps = 1e-8;
const int MOD = 1 << 16;
#define prln(x) cout<<#x<<" = "<<x<<endl
#define pr(x) cout<<#x<<" = "<<x<<" "

//调用方法：
//init(n) 初始化 n 为节点数
//clear_flow() 清空所有边的流量
//add_edge(from, to, cap) 添加边from -> to 容量为cap
//maxflow(s, t) 返回s->t的最大流
//void mincut(vector<int>& ans) // 调用完maxflow后才可以用，ans里面存最小割
//print() 打印整张图，调试用
const int maxn = 600;
struct Edge { int from, to, cap, flow; };
struct ISAP {
	int n, m, s, t;
	vector<Edge> edges;
	vector<int> G[maxn];   // 邻接表，G[i][j]表示结点i的第j条边在e数组中的序号
	bool vis[maxn];        // BFS使用
	int d[maxn];           // 从起点到i的距离
	int cur[maxn];        // 当前弧指针
	int p[maxn];          // 可增广路上的上一条弧
	int num[maxn];        // 距离标号计数
	void add_edge(int from, int to, int cap) {
		edges.push_back((Edge){from, to, cap, 0});
		edges.push_back((Edge){to, from, 0, 0});
		m = edges.size();
		G[from].push_back(m-2);
		G[to].push_back(m-1);
	}
	bool bfs() {
		memset(vis, 0, sizeof(vis));
		queue<int> q;
		q.push(t);
		vis[t] = 1;
		d[t] = 0;
		while(!q.empty()) {
			int x = q.front(); q.pop();
			for(int i = 0; i < G[x].size(); i++) {
				Edge& e = edges[G[x][i]^1];
				if(!vis[e.from] && e.cap > e.flow) {
					vis[e.from] = 1;
					d[e.from] = d[x] + 1;
					q.push(e.from);
				}
			}
		}
		return vis[s];
	}

	void doit(int ans[])
	{
		clr(vis, 0);
		queue<int>q;
		q.push(s);
		vis[s] = 1;
		d[s] = 0;
		while (!q.empty())
		{
			int x = q.front();
			ans[x]+=1;
			q.pop();
			for (int i = 0; i < G[x].size(); i ++ )
			{
				Edge& e = edges[G[x][i]];
				if (!vis[e.to] && e.cap > e.flow)
				{
					vis[e.to] = 1;
					q.push(e.to);
				}
			}
		}
	}




	void init(int n) {
		this->n = n;
		for(int i = 0; i < n; i++) G[i].clear();
		edges.clear();
	}
	void clear_flow() {
		for(int i = 0; i < edges.size(); i++) edges[i].flow = 0;    
	}
	int augment() {
		int x = t, a = INF;
		while(x != s) {
			Edge& e = edges[p[x]];
			a = min(a, e.cap-e.flow);
			x = edges[p[x]].from;
		}
		x = t;
		while(x != s) {
			edges[p[x]].flow += a;
			edges[p[x]^1].flow -= a;
			x = edges[p[x]].from;
		}
		return a;
	}
	int maxflow(int s, int t) {//到的最大流大于need就停止，如果没有限制，删去含有need的地方
		this->s = s; this->t = t;
		int flow = 0;
		bfs();
		memset(num, 0, sizeof(num));
		for(int i = 0; i < n; i++) num[d[i]]++;
		int x = s;
		memset(cur, 0, sizeof(cur));
		while(d[s] < n) {
			if(x == t) {
				flow += augment();
				x = s;
			}
			int ok = 0;
			for(int i = cur[x]; i < G[x].size(); i++) {
				Edge& e = edges[G[x][i]];
				if(e.cap > e.flow && d[x] == d[e.to] + 1) { // Advance
					ok = 1;
					p[e.to] = G[x][i];
					cur[x] = i; // 注意
					x = e.to;
					break;
				}
			}
			if(!ok) { // Retreat
				int m = n-1; // 初值注意
				for(int i = 0; i < G[x].size(); i++) {
					Edge& e = edges[G[x][i]];
					if(e.cap > e.flow) m = min(m, d[e.to]);
				}
				if(--num[d[x]] == 0) break;//gap优化
				num[d[x] = m+1]++;
				cur[x] = 0; // 注意
				if(x != s) x = edges[p[x]].from;
			}
		}
		return flow;
	}

	void mincut(vector<int>& ans) { // 调用完maxflow后才可以用，ans里面存最小割
		bfs();
		for(int i = 0; i < edges.size(); i++) {
			Edge& e = edges[i];
			if(!vis[e.from] && vis[e.to] && e.cap > 0) ans.push_back(i);
		}
	}
	void print() {
		printf("Graph:\n");
		for(int i = 0; i < edges.size(); i++)
			printf("%d->%d, %d, %d\n", edges[i].from, edges[i].to , edges[i].cap, edges[i].flow);
	}
} isap;

int n, m;


struct xxx
{
	int u,v;
}eee[3000*2];
int known_num;
int isbiao[600];//是否初始有标号
int biao[600];//如果被标了，标的是什么
int marks[600];
int ans[600];
int mp[600][600];

void init()
{
	scanf("%d%d", &n, &m);
	clr(mp,0);
	for (int i = 0; i != m; ++ i)
	{
		scanf("%d%d", &eee[i].u, &eee[i].v);
		mp[eee[i].u][eee[i].v]=1;
		mp[eee[i].v][eee[i].u]=1;
	}
	scanf("%d", &known_num);
	clr(isbiao, 0);
	clr(ans, 0);
	for (int i = 1; i <= known_num; ++ i)
	{
		int a,b;
		scanf("%d%d", &a, &b);
		isbiao[a]=1;
		biao[a]=b;
	}
}


void cal()
{
	isap.init(n + 5);
	for (int i = 0; i <=n; ++ i)
		for (int j = i+1; j <=n;++j)
		{
			if (mp[i][j])
			{
				isap.add_edge(i, j, 1);
				isap.add_edge(j, i, 1);
			}
		}
	for (int i = 1; i <= n; ++ i)
	{
		if (!isbiao[i])	continue;
		if (marks[i])
		{
			isap.add_edge(0, i, INF);
		}else
		{
			isap.add_edge(i, n + 1, INF);
		}
	}
	isap.maxflow(0, n + 1);

}

void doit()
{
	clr(ans, 0);	//初始化标号为0
	for (int i = 1; i <= 31; ++ i)
	{
		for (int j = 1; j <= n; ++ j)
		{
			ans[j]<<=1;
			if (!isbiao[j])	continue;
			marks[j] = (biao[j]>>(31-i))&1;
		}
		cal();
		isap.doit(ans);
	}
	for (int i = 1; i <= n; ++ i)
		printf("%d\n", ans[i]);
}


int main()
{
	int T;
	scanf("%d", &T);
	while (T--)
	{
		init();
		doit();
	}
	return 0;
}


CMTM4
关注
专栏目录
图像分割经典算法--《最小割最大流》（Minimum Cut——Max Flow）
mmm_jsw的博客
11-06 3万+
1.算法介绍 最小割算法（Minimum Cut）是图像分割的经典算法之一，同时也在"Graph Cut"、"Grab Cut"等算法中都有被使用过。最小割最大流算法是指在一个有向的图中，能够从源点（source）到达汇点（terminal）的最大流量等于如果从图中剪除就能够导致网络流中断的边的集合的最小容量和。即在任何网络中，最大流的值等于最小割的容量。 提出该分割算法的论文： Interact...
SPOJ-Solutions：解决了我解决的http://www.spoj.com问题的解决方案
02-05
SPOJ解决方案 我已解决的SPOJ问题的解决方案。 仅当您自己尝试过该问题并且无法提出任何解决方案，也可以随意报告任何错误并为该存储库提供解决方案时，才请参考这些解决方案。 我的个人资料链接 会费 分叉仓库并为...
网络流量生成器
09-21
CICFlowMeter是一个网络流量生成器，它使用Java编写，在选择要计算的功能，添加新功能以及更好地控制流超时的持续时间方面提供了更大的灵活性。它生成双向流（Biflow），其中第一个数据包确定前向（源到目的地）和后向（目标到源）方向，因此有83个统计特征，如持续时间，数据包数，字节数，数据包长度，也可以在正向和反向分别计算。 应用程序的输出采用CSV文件格式，每个流标记有六列，即FlowID，SourceIP，DestinationIP，SourcePort，DestinationPort和具有80多个网络流量功能的协议。通常，TCP流在连接拆除时（通过FIN数据包）终止，而UDP流由流超时终止。流量超时值可以由各个方案任意分配，例如， TCP和UDP均为600秒。 CICFlowMeter-V3可以提取80多个功能。 该实验室用此生成器获取了IDS数据集，2012和2017的都有，2017版的数据集我会作为新资源上传。同样的，采用该数据集做实验的，请私信我，应数据方要求，需要在论文中声明数据出处。
spoj839(Optimal Marks)
ysjjovo的专栏
09-22 801
省赛比完了，进了工作室学做项目，闲来无聊看看网络流建模，这题想半天没想出硬是想不出和网络流有关系，看了07年胡伯涛的论文才有的思路，觉得这题很经典，所以就写了一下。   第一次用VS写的题，小小的纪念一下，呵呵。 发现VS的调试功能真强大！ 代码：本来定义N是550M是15
SPOJ 839 Optimal Marks 最小割 经典 按位建图
08-03 1293
胡伯涛论文中的一题，经典建模，由于二进制每一位异或不会相互影响，所以我们把问题转换模型，按位处理。 即已知一些点的标号0/1（还有些可以自己任意改），和一些边，边权定义为两端点标号的异或，要求边权和最小的标号方案。 我们联想到最小割求的是从源到汇容量最小的边权和。 建图： 标号为1的和源点相连，容量INF，标号为0的和汇点相连，容量INF，这些边是不能割掉的（这些点标号已经明确） 原图相
Spoj 839 Optimal Marks（网络流最小割）
lvmaooi的博客
07-04 204
2400：Spoj 839 Optimal Marks 时间限制: 1000 ms 内存限制: 131072 KB 题目描述 定义无向图中的一条边的值为：这条边连接的两个点的值的异或值。 定义一个无向图的值为：这个无向图所有边的值的和。 给你一个有nnn个结点mmm条边的无向图。其中的一些点的值是给定的，而其余的点的值由你决定（但要求均为非负数），使得这个无向图的值最小。在无向图的值最...
【bzoj2400】Spoj 839 Optimal Marks 网络流最小割
weixin_30634661的博客
08-09 74
题目描述 定义无向图中的一条边的值为：这条边连接的两个点的值的异或值。 定义一个无向图的值为：这个无向图所有边的值的和。 给你一个有n个结点m条边的无向图。其中的一些点的值是给定的，而其余的点的值由你决定（但要求均为非负数），使得这个无向图的值最小。在无向图的值最小的前提下，使得无向图中所有点的值的和最小。 输入 第一行，两个数n，m，表示图的点数和边数。 接下来n行，每行一...
BZOJ 2400: Spoj 839 Optimal Marks|最小割
ws_yzy的博客
02-17 570
bzoj评测姬已经被群攻了.. 可以发现每一位都是独立的 然后枚举每一位，每一个点要么是1要么是0 然后可以划分为两个集合，0集合和1集合，只有连接两个集合的边才会对答案有贡献，然后跑最小割就可以了 建图： 枚举每一位 S连这一位上是1的点，流量inf 这一位上是0的点连T，流量inf 再加上原图中的边，流量为1 这样跑出来的最小割就是这一位对答案1的贡献 然后再看属于S集的点的个数就是
bzoj2400[Spoj 839] Optimal Marks（网络流）
Coco_T的博客
03-18 195
题目链接 题面描述： 定义无向图中的一条边的值为：这条边连接的两个点的值的异或值。 定义一个无向图的值为：这个无向图所有边的值的和。 给你一个有n个结点m条边的无向图。其中的一些点的值是给定的，而其余的点的值由你决定（但要求均为非负数），使得这个无向图的值最小。在无向图的值最小的前提下，使得无向图中所有点的值的和最小。 分析： 看到异或，当然先想到了线性积，但是由于有不确定元素，就想到...
SPOJ.rar_SPOJ
09-19
《SPOJ在线判题平台：越南版解题攻略》 SPOJ，全称Sphere Online Judge，是一个全球知名的在线编程竞赛平台，旨在提供一个环境让程序员可以测试、提交并评估他们的算法解决方案。这个名为"SPOJ.rar_SPOJ"的压缩包...
SPOJ-2.zip_SPOJ_SPOJ-TRIKA.cpp_online judge_sPOJ-Solution_spoj2
09-24
《SPOJ在线判题平台的解题策略与实例解析》 SPOJ（Sphere Online Judge）是一个全球知名的在线编程竞赛平台，它为程序员提供了一个检验自己算法能力的场所。这个名为"SPOJ-2.zip"的压缩包包含了在SPOJ上解决不同...
SPOJ.zip_SPOJ_sgu_them
09-24
1. SPOJ-MINVEST.cpp：这可能是一个关于投资最小化成本的问题，动态规划可以用于找出最优化的投资策略，比如最小化交易费用或者最大化投资回报。 2. SPOJ-MAXSUMSQ.cpp：此代码可能解决的是在一个数组中找到最大平...
SPOJ:我对 SPOJ 问题的解决方案 (www.spoj.com)
05-29
5. **输入输出流**：`std::cin`和`std::cout`用于从标准输入读取数据和向标准输出打印结果，这是在SPOJ中交互处理输入和输出的常用方式。 6. **算法**：SPOJ上的问题通常需要应用各种算法，如排序（快速排序、归并...
spoj839 Optimal Marks（最小割，dinic）
y_immortal的博客 QwQ(qdez_ymh)
07-01 155
题目大意： 给你一个无向图G(V,E)G(V,E)G(V,E)。 每个顶点都有一个int范围内的整数的标记。 不同的顶点可能有相同的标记。 对于边(u,v)(u,v)(u,v)，我们定义Cost(u,v)=mark[u]&nbsp;&nbsp;xor&nbsp;&nbsp;mark[v]Cost(u,v)=mark[u]&nbsp;&nbsp;xor&nbsp;&nbsp;mark[v]Cos...
数据生成器
BlackJack
08-14 2220
数据生成器决定要做数据生成器大集合树生成器prufer编码做生成树http://blog.csdn.net/nikelong0/article/details/50853122mengbi_er友情赞助了一个树的数据生成器#include&lt;iostream&gt; #include&lt;cstdio&gt; #include&lt;cstring&gt; #include&lt;algor...
飞翔的小鸟 scratch
最新发布
10-06
飞翔的小鸟 scratch
ANALOG DESIGN ESSENTIALS
10-06
ANALOG DESIGN ESSENTIALS
网络流模型详解：最大流、最小割与应用实例
本资源汇集了多个经典问题，涵盖了网络流理论的核心知识点，包括最大流、最小割、最小费用最大流以及有上下界流。 1. **最大流**：从《POJ1149 PIGS》开始，该题展示了如何运用最大流原理来确定在有限资源条件下，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值