【LOJ2321】「清华集训 2017」无限之环

最新推荐文章于 2019-07-19 22:48:00 发布
最新推荐文章于 2019-07-19 22:48:00 发布
阅读量438 收藏
点赞数
分类专栏： 【OJ】LOJ 【类型】做题记录 【算法】线性规划与网络流 【算法】费用流 【算法】基于连通性的动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39972971/article/details/80820977
版权

【题目链接】

【思路要点】

  • 先说这道题的正解：
  • 将棋盘看做一张二分图，每一条边拆成两个点，分别属于二分图的一边。
  • 我们需要做一件类似于匹配的事情，同一条边的两侧或是都没有管道，或是都有管道。
  • 通过合适的建边我们能够用最小费用最大流来解决本题。
  • 时间复杂度 O ( M i n C o s t F l o w ( N ∗ M , N ∗ M ) ) O(MinCostFlow(N*M,N*M)) O(MinCostFlow(N∗M,N∗M)) 。
  • 但自从笔者从考场回来就一直在思考本题的插头DP做法的复杂度是不是能够被证明更优，因为我们发现实际上合法的插头数少之又少。
  • 遗憾的是笔者并不能证明其更优的复杂度，但笔者将考场上的插头DP代码的状态开成了64位整型，就通过了本题，而且似乎比大部分费用流的做法要快。
  • 因此笔者相信在本题中插头DP有着低于理论时间复杂度上界（ O ( N M ∗ 2 N M ) O(NM*2^{\sqrt{NM}}) O(NM∗2NM ​) ）的复杂度。
  • 以下代码实现的是插头DP。
  • 时间复杂度 O ( S ) O(S) O(S) ，其中 S S S 为合法的状态数。
  • U p d : Upd: Upd: 更新了网络流做法。

【代码】

//Flow Version
#include<bits/stdc++.h>
using namespace std;
const int MAXQ = 1e7 + 5;
const int MAXP = 1e5 + 5;
const int MAXN = 2e3 + 5;
const int INF = 2e9;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
struct edge {int dest, flow, pos, cost; };
vector <edge> a[MAXP];
int n, m, s, t, tot, flow, cost, goal;
int dist[MAXP], path[MAXP], home[MAXP];
int point[MAXN][MAXN][4], cnt[2];
void FlowPath() {
	int p = t, ans = INF;
	while (p != s) {
		ans = min(ans, a[path[p]][home[p]].flow);
		p = path[p];
	}
	flow += ans;
	cost += ans * dist[t];
	p = t;
	while (p != s) {
		a[path[p]][home[p]].flow -= ans;
		a[p][a[path[p]][home[p]].pos].flow += ans;
		p = path[p];
	}
}
bool spfa() {
	static int q[MAXQ];
	static bool inq[MAXP];
	static int l = 0, r = 0;
	for (int i = 0; i <= r; i++)
		dist[q[i]] = INF;
	q[l = r = 0] = s, dist[s] = 0, inq[s] = true;
	while (l <= r) {
		int tmp = q[l];
		for (unsigned i = 0; i < a[tmp].size(); i++)
			if (a[tmp][i].flow != 0 && dist[tmp] + a[tmp][i].cost < dist[a[tmp][i].dest]) {
				dist[a[tmp][i].dest] = dist[tmp] + a[tmp][i].cost;
				path[a[tmp][i].dest] = tmp;
				home[a[tmp][i].dest] = i;
				if (!inq[a[tmp][i].dest]) {
					q[++r] = a[tmp][i].dest;
					inq[q[r]] = true;
				}
			}
		l++, inq[tmp] = false;
	}
	return dist[t] != INF;
}
void addedge(int x, int y, int z, int c) {
	a[x].push_back((edge) {y, z, a[y].size(), c});
	a[y].push_back((edge) {x, 0, a[x].size() - 1, -c});
}
int main() {
	read(n), read(m);
	s = 0, t = tot = 1;
	for (int i = 1; i <= n; i++)
	for (int j = 1; j <= m; j++) {
		point[i][j][0] = ++tot;
		point[i][j][1] = ++tot;
		point[i][j][2] = ++tot;
		point[i][j][3] = ++tot;
	}
	//0 : up, 1 : right, 2 : down, 3 : left.
	for (int i = 1; i <= n; i++)
	for (int j = 1; j <= m; j++) {
		int x; read(x);
		int tmp = ++tot, Cnt = 0, tnp = x;
		int up = point[i][j][0];
		int Right = point[i][j][1];
		int down = point[i][j][2];
		int Left = point[i][j][3];
		while (tnp) {Cnt += tnp & 1, tnp >>= 1; }
		if ((i + j) & 1) {
			addedge(s, tmp, Cnt, 0);
			if (x & 1) addedge(tmp, up, 1, 0), cnt[0]++;
			if (x & 2) addedge(tmp, Right, 1, 0), cnt[0]++;
			if (x & 4) addedge(tmp, down, 1, 0), cnt[0]++;
			if (x & 8) addedge(tmp, Left, 1, 0), cnt[0]++;
			if (x == 1) {
				addedge(tmp, Right, 1, 1);
				addedge(tmp, down, 1, 2);
				addedge(tmp, Left, 1, 1);
			}
			if (x == 2) {
				addedge(tmp, up, 1, 1);
				addedge(tmp, down, 1, 1);
				addedge(tmp, Left, 1, 2);
			}
			if (x == 4) {
				addedge(tmp, up, 1, 2);
				addedge(tmp, Right, 1, 1);
				addedge(tmp, Left, 1, 1);
			}
			if (x == 8) {
				addedge(tmp, up, 1, 1);
				addedge(tmp, Right, 1, 2);
				addedge(tmp, down, 1, 1);
			}
			if (x == 14) {
				addedge(Right, up, 1, 1);
				addedge(down, up, 1, 2);
				addedge(Left, up, 1, 1);
			}
			if (x == 13) {
				addedge(up, Right, 1, 1);
				addedge(down, Right, 1, 1);
				addedge(Left, Right, 1, 2);
			}
			if (x == 11) {
				addedge(up, down, 1, 2);
				addedge(Right, down, 1, 1);
				addedge(Left, down, 1, 1);
			}
			if (x == 7) {
				addedge(up, Left, 1, 1);
				addedge(Right, Left, 1, 2);
				addedge(down, Left, 1, 1);
			}
			if (x == 3) {
				addedge(up, down, 1, 1);
				addedge(Right, Left, 1, 1);
			}
			if (x == 6) {
				addedge(down, up, 1, 1);
				addedge(Right, Left, 1, 1);
			}
			if (x == 12) {
				addedge(down, up, 1, 1);
				addedge(Left, Right, 1, 1);
			}
			if (x == 9) {
				addedge(up, down, 1, 1);
				addedge(Left, Right, 1, 1);
			}
		} else {
			addedge(tmp, t, Cnt, 0);
			if (x & 1) addedge(up, tmp, 1, 0), cnt[1]++;
			if (x & 2) addedge(Right, tmp, 1, 0), cnt[1]++;
			if (x & 4) addedge(down, tmp, 1, 0), cnt[1]++;
			if (x & 8) addedge(Left, tmp, 1, 0), cnt[1]++;
			if (x == 1) {
				addedge(Right, tmp, 1, 1);
				addedge(down, tmp, 1, 2);
				addedge(Left, tmp, 1, 1);
			}
			if (x == 2) {
				addedge(up, tmp, 1, 1);
				addedge(down, tmp, 1, 1);
				addedge(Left, tmp, 1, 2);
			}
			if (x == 4) {
				addedge(up, tmp, 1, 2);
				addedge(Right, tmp, 1, 1);
				addedge(Left, tmp, 1, 1);
			}
			if (x == 8) {
				addedge(up, tmp, 1, 1);
				addedge(Right, tmp, 1, 2);
				addedge(down, tmp, 1, 1);
			}
			if (x == 14) {
				addedge(up, Right, 1, 1);
				addedge(up, down, 1, 2);
				addedge(up, Left, 1, 1);
			}
			if (x == 13) {
				addedge(Right, up, 1, 1);
				addedge(Right, down, 1, 1);
				addedge(Right, Left, 1, 2);
			}
			if (x == 11) {
				addedge(down, up, 1, 2);
				addedge(down, Right, 1, 1);
				addedge(down, Left, 1, 1);
			}
			if (x == 7) {
				addedge(Left, up, 1, 1);
				addedge(Left, Right, 1, 2);
				addedge(Left, down, 1, 1);
			}
			if (x == 3) {
				addedge(down, up, 1, 1);
				addedge(Left, Right, 1, 1);
			}
			if (x == 6) {
				addedge(up, down, 1, 1);
				addedge(Left, Right, 1, 1);
			}
			if (x == 12) {
				addedge(up, down, 1, 1);
				addedge(Right, Left, 1, 1);
			}
			if (x == 9) {
				addedge(down, up, 1, 1);
				addedge(Right, Left, 1, 1);
			}
		}
	}
	for (int i = 1; i <= n; i++)
	for (int j = 1; j <= m; j++) {
		if ((i + j) & 1) {
			if (j != m) addedge(point[i][j][1], point[i][j + 1][3], 1, 0);
			if (i != n) addedge(point[i][j][2], point[i + 1][j][0], 1, 0);
		} else {
			if (j != m) addedge(point[i][j + 1][3], point[i][j][1], 1, 0);
			if (i != n) addedge(point[i + 1][j][0], point[i][j][2], 1, 0);
		}
	}
	goal = max(cnt[0], cnt[1]);
	for (int i = 0; i <= tot; i++)
		dist[i] = INF;
	while (spfa()) FlowPath();
	if (flow != goal) printf("-1\n");
	else printf("%d\n", cost);
	return 0;
}
//DP Version
#include<bits/stdc++.h>
using namespace std;
const int MAXS = 1e7 + 5;
const int MAXN = 2e3 + 5;
const int P = 1e5 + 3;
template <typename T> void read(T &x) {
	int f = 1; x = 0;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
struct Hash_Table {
	int val[MAXS], nxt[MAXS];
	long long num[MAXS];
	int size, head[P];
	void init() {
		for (int i = 1; i <= size; i++) {
			int tmp = num[i] % P;
			head[tmp] = 0;
		}
		size = 0;
	}
	void insert(long long Num, int Val) {
		int tmp = Num % P;
		for (int p = head[tmp]; p; p = nxt[p])
			if (num[p] == Num) {
				val[p] = min(val[p], Val);
				return;
			}
		size++;
		num[size] = Num;
		val[size] = Val;
		nxt[size] = head[tmp];
		head[tmp] = size;
	}
	int query(long long Num) {
		int tmp = Num % P;
		for (int p = head[tmp]; p; p = nxt[p])
			if (num[p] == Num) return val[p];
		return -1;
	}
} HT[2];
int cost[4] = {0, 1, 2, 1};
int ans, n, m, a[MAXN][MAXN];
void Extend(int x, int y, long long s, int v, int dest) {
	long long lft = s & (1ll << y - 1);
	long long upp = s & (1ll << y);
	long long ts = s ^ lft ^ upp;
	if (lft && upp) {
		int tmp = a[x][y];
		for (int i = 0; i < 4; i++) {
			if ((tmp & 9) == 9) {
				long long ds = ts;
				if (tmp & 2) ds ^= 1ll << y;
				if (tmp & 4) ds ^= 1ll << y - 1;
				HT[dest].insert(ds, v + cost[i]);
			}
			if (tmp != 5 && tmp != 10) tmp = (tmp >> 1) + ((tmp & 1) << 3);
		}
	}
	if (lft && !upp) {
		int tmp = a[x][y];
		for (int i = 0; i < 4; i++) {
			if ((tmp & 9) == 8) {
				long long ds = ts;
				if (tmp & 2) ds ^= 1ll << y;
				if (tmp & 4) ds ^= 1ll << y - 1;
				HT[dest].insert(ds, v + cost[i]);
			}
			if (tmp != 5 && tmp != 10) tmp = (tmp >> 1) + ((tmp & 1) << 3);
		}
	}
	if (!lft && upp) {
		int tmp = a[x][y];
		for (int i = 0; i < 4; i++) {
			if ((tmp & 9) == 1) {
				long long ds = ts;
				if (tmp & 2) ds ^= 1ll << y;
				if (tmp & 4) ds ^= 1ll << y - 1;
				HT[dest].insert(ds, v + cost[i]);
			}
			if (tmp != 5 && tmp != 10) tmp = (tmp >> 1) + ((tmp & 1) << 3);
		}
	}
	if (!lft && !upp) {
		int tmp = a[x][y];
		for (int i = 0; i < 4; i++) {
			if ((tmp & 9) == 0) {
				long long ds = ts;
				if (tmp & 2) ds ^= 1ll << y;
				if (tmp & 4) ds ^= 1ll << y - 1;
				HT[dest].insert(ds, v + cost[i]);
			}
			if (tmp != 5 && tmp != 10) tmp = (tmp >> 1) + ((tmp & 1) << 3);
		}
	}
}
void work(int x, int y, int now, int dest) {
	int tx = x, ty = y + 1;
	if (ty > m) ty = 1, tx++;
	HT[dest].init();
	for (int i = 1; i <= HT[now].size; i++)
		if (y == 1) {
			long long tmp = HT[now].num[i];
			if (tmp & (1ll << m)) continue;
			Extend(x, y, tmp << 1, HT[now].val[i], dest);
		} else Extend(x, y, HT[now].num[i], HT[now].val[i], dest);
	if (tx <= n) work(tx, ty, dest, now);
}
int main() {
	read(n), read(m);
	for (int i = 1; i <= n; i++)
	for (int j = 1; j <= m; j++)
		read(a[i][j]);
	if (n < m) {
		swap(n, m);
		for (int i = 1; i <= n; i++)
		for (int j = i + 1; j <= n; j++)
			swap(a[i][j], a[j][i]);
		for (int i = 1; i <= n; i++)
		for (int j = 1; j <= m; j++) {
			int tmp = a[i][j];
			a[i][j] = ((tmp & 1) << 3) + ((tmp & 8) >> 3) + ((tmp & 2) << 1) + ((tmp & 4) >> 1);
		}
	}
	HT[0].insert(0, 0);
	work(1, 1, 0, 1);
	ans = HT[n * m % 2].query(0);
	printf("%d\n", ans);
	return 0;
}
cz_xuyixuan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
清华集训2017游记
weixin_34111819的博客
12-03 123
Day0 报到日 火车上膜了一发附中大佬 试机时感觉机房很热，头脑很不清醒 晚上和cjl,xjt一起吃火锅，等了半天，感觉有毒 Day1 水落在酒店餐厅了，幸好赛场发水 赛前松爷在群里发了一句GL & HF，非常慌 开场看了三题，T1数学题，自己不会数学，T2看上去是个挺好玩的题目，T3是个数据结构题，先放一边，先开T2 读懂了题面后发现40分就是个裸的插头dp，码完之后一直wa，发现有个...
「清华集训 2017」小Y和地铁
luoyuef的博客
12-25 703
霍格沃茨圣诞节传送门这道题还是很妙的啊qwq，拿到题以后观察了下数据，发现。 显然： 1.如果只出现一次的数字对答案没有贡献。 2.相邻的数字对答案没有贡献。这样的话，数据范围最坏情况下就只有n<=22了。然后开始思考，画了几个图发现，对于一条线路，从上面走和从下面走结果是不同的。 如果写搜索 最坏情况下时间复杂度O（2^（n/2））加最优化剪枝也许可以过（记住剪枝呀！）发现线路右边那个站对
loj#2326. 「清华集训 2017」简单数据结构【动态规划+set】
cdsszjj的博客
05-31 869
传送门 解题思路： 感觉复杂度是证不来的……不过跑得挺快…… 注意序列长度不超过20，所以也比较暴力，就是记录每个值的位置，以每个点开头的最长长度和每个长度对应的最小结尾位置，用set维护以每个点为结尾的最长序列开头位置，用桶维护答案……向左加就枚举倍数更新，向右加就枚举约数更新…… #include&amp;lt;bits/stdc++.h&amp;gt; using namespace std; in...
【JZOJ5295】【清华集训2017模拟】Create
dance in th dark的博客
08-23 442
DescriptionData ConstraintSolution这道题很经典。 我们发现一次操作最多使序列多出1段新的连续序列。所以我们考虑维护这个序列。我们将询问按x大小排序后建一棵主席树，那么对于一个修改(l,r,v)，我们可以算出修改后(l,r)对答案的贡献。现在问题是怎样取消修改前的贡献。我们用线段树维护每一段连续的颜色的起点和终点。每一次修改暴力跳一下每个颜色段，查询他们原来的贡献。
Luogu P1654 OSU! | 期望
weixin_30819163的博客
07-19 99
题目链接 很妙的一道题。 题目要求$X^3$的期望值。 直接求不好求。 考虑先求出$X$和$X^2$的期望值，然后再求$X^3$的期望值。 迎.刃.而.解. #include<iostream> #include<cstdio> using namespace std; double p[100005],x1[100005],...
Loj X:创建逻辑电路-开源
07-04
Loj X 使创建真正的计算单元甚至小型完整处理器成为可能。 除了逻辑门，存储盒和程序阅读器可以集成到电路中。
log4j配置，jar包
06-01
log4j配置文档，jar包
mybaits 架包
01-30
包含 mybatis-3.3.0；log4j-1.2.17；junit-4.12；javassist-3.4.GA；hamcrest-all-1.3
up_717085_google-api-php-client_71loj.rar
12-22
使用php做的，google的API客户端的连接程序的例子代码，主要是调用google的API的连接程序，简单全面供给各类学习参考
scicloj.github.com：Scicloj网站
02-08
scicloj.github.com：Scicloj网站
2013国家集训队清华集训
07-30
2013国家集训队清华集训资料。
LibreOJ #2321.「清华集训 2017」无限之环 费用流
beginend
06-21 273
题意 有一个n*m的矩阵，每个格子有些方向上会有接口。设把格子顺时针或逆时针旋转90度的代价为1，且所有格子恰好在相反两端的格子不能旋转，现在要求所有的接口一一配对，问最小代价。 n∗m≤2000n∗m≤2000n*m\le2000 分析 挺妙的建图。 首先把矩阵黑白染色，然后每个点拆成四个点，分别表示四个位置，源点向所有白点的接口连边，所有黑点的接口向汇点连边。所有相邻格子的对应位...
【清华集训】2017 无限之环
晚来天欲雪
08-11 371
无限之环 无限之环 题目 链接 描述 输入格式 输出格式 子任务 解题法 评价：神奇的网络流神题 Round 1: 黑白染色 题目 链接 洛谷 描述 曾经有一款流行的游戏，叫做 Infinity Loop，先来简单的介绍一下这个游戏： 游戏在一个 n ∗ m 的网格状棋盘上进行，其中有些小方格中会有水管，水管可能在 格某些方向的边界的中点有接口，所有...
Loj #2321. 「清华集训 2017」无限之环
weixin_34007886的博客
04-18 108
Loj #2321. 「清华集训 2017」无限之环 曾经有一款流行的游戏，叫做 *Infinity Loop***，先来简单的介绍一下这个游戏: 游戏在一个 \(n \times m\) 的网格状棋盘上进行，其中有些小方格中会有水管，水管可能在方格某些方向的边界的中点有接口，所有水管的粗细都相同，所以如果两个相邻方格的公共边界的中点都有接头，那么可以看作这两个接头互相连接。水管有以下 \(15\...
【uoj336】【清华集训2017】无限之环
weixin_33810006的博客
04-09 87
题目 描述 ​ 给出一个\(n*m\)的网格，每个格子里的水管可能向四个方向都有接口； ​ 游戏的目的是不能让水管漏水，即所有接口都有另一个接口与之相接； ​ 你一步可以将一个格子中的水管旋转\(90^ {\circ}\),规定直线型的接口不能旋转； ​ 求最小的步数； 范围 ​ \(nm \le 2000\)； 题解 对每个点拆成上右下左四个接口(令标号为0123)，将格子黑白染色并将接口分别...
JZOJ5498. 【清华集训2017模拟12.10】大佬的难题
lijf2001的博客
12-14 461
大佬的难题
[FFT][离散对数][原根] LOJ #6156. A * B Problem
Vectorxj的博客
01-18 670
SolutionSolutionSolution 刚开始看错题了。。。其实就是一个FFT裸题 如果p∤a,p∤bp∤a,p∤bp\nmid a,p\nmid bab≡k(modp)ab≡k(modp)ab\equiv k\pmod p是与logGa+logGb≡logGk(modφ(p))logG⁡a+logG⁡b≡logG⁡k(modφ(p))\log_Ga+\log_Gb\equiv \l...
loj #2322. 「清华集训 2017」Hello world!
yzyyylx的博客
09-02 641
题面 题意 给出一棵树，要求支持两种操作： 1.给出u，v，从u开始每次向v条k条边（如果到v的距离小于k则直接到达v），对所有经过的点的权值开根。 2.给出u，v，从u开始每次向v条k条边（如果到v的距离小于k则直接到达v），求所有经过的点的权值和。 做法 根据每次跳的长度k进行分块，令块大小为S。 然后对于1~S中的每一个数i建一个森林，每个点的父亲是这个点在原树上与它深...
[清华集训2017]无限之环(infinityloop)
weixin_30484247的博客
08-10 116
description 题面 solution 一开始的思路是插头\(DP\),然而复杂度太高 考虑将网格图黑白染色后跑费用流 流量为接口数，费用为操作次数 把一个方格拆成五个点，如何连边请自行脑补 打个表感觉还是挺好写的 code #include<bits/stdc++.h> #include<algorithm> #include<iostream> #i...
有源汇有上下界的最小流（LOJ117）
最新发布
06-11
这是一个IT类问题。该问题可以使用网络流算法解决。首先用 Dinic 或 ISAP 算法求出最大流，然后根据最大流的值和边的上下界，构造一个新图，使得原图中的每条边都对应着新图中的一些流量限制。具体地，对于一条容量...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值