题解 CF706E 【Working routine】

于 2020-08-19 15:45:47 发布
阅读量186 收藏 1
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pikabi/article/details/108102570
版权

优雅的指针

题意

给出矩阵上各点的权值，并给出 q q q 次左上角坐标 x 1 , y 1 x_1, y_1 x1​,y1​ 、 x 2 , y 2 x_2, y_2 x2​,y2​ 即长宽 h , w h, w h,w，交换这两个矩阵，求最后矩阵的上各点的值。

tips

一开始看到交换一段矩阵，笔者不免想到用 fhq Treap 来维护每一段并交换，可惜复杂度堪忧， “ 猝死 ” 于 #11。有兴趣的小伙伴可以来看一下 − − > --> −−> here。

其实正解是用指针描述每一个点的信息。我维护的是每个点的上（up）下 ( down ) 左 ( l ) 右 ( r )。

先在原先 n ∗ m n * m n∗m 的矩阵周围绕上一圈作为边界 − − > --> −−>

	for(int i = 0; i <= n + 1 ; i++)//这两个是边界上点与矩阵内点的关系
	a[i][0].r = calc(i, 1), a[i][n + 1].l = calc(i, n);
	for(int i = 0; i <= m + 1; i++)
	a[0][i].down = calc(1, i), a[n + 1][i].up = calc(n, i);
	
	for(int i = 0; i <= m; i++)//这些是边界上各点之间的关系
	a[0][i].r = calc(0, i + 1), a[n + 1][i].r = calc(n + 1, i + 1);
	for(int i = 1; i <= m + 1; i++)
	a[0][i].l = calc(0, i - 1), a[n + 1][i].l = calc(n + 1, i - 1);
	for(int i = 0; i <= n; i++)
	a[i][0].down = calc(i + 1, 0), a[i][n + 1].down = calc(i + 1, n + 1);
	for(int i = 1; i <= n + 1; i++)
	a[i][0].up = calc(i - 1, 0), a[i][n + 1].up = calc(i - 1, n + 1);

然后是矩阵内各点的关系 − − > --> −−>

	for(int i = 1; i <= n; i++){
		for(int j = 1; j <= m; j++){
			a[i][j].l = calc(i, j - 1);
			a[i][j].r = calc(i, j + 1);
			a[i][j].up = calc(i - 1, j);
			a[i][j].down = calc(i + 1, j);
		}
	}

接下来是关键：我们交换的矩阵的内部关系是不变的，而只有最外围会改变对应关系，我们可以做一个简单的模拟 − − > --> −−>

初始每个点的上下左右如图所示，周围的 0 是边界，如果把左上角 3 ∗ 3 3 * 3 3∗3 矩阵和右下角 3 ∗ 3 3 * 3 3∗3 矩阵交换，中间的相对位置是不会改变的，如（2， 2）的 1，上还是 1，下还是 4 , 左还是 4，右还是 1。所以我们只需要维护周围一圈的信息好了。但是该如何找到矩阵修改后的左上角端点呢？我们可以从 （0， 0）出发，dfs找到，并逐步 dfs（根据其 r 和 down ） 下去，找到端点，在对调信息即可。我是先一步枚举竖直方向，考虑到可能会改变左右端点，故在枚举水平方向时在 dfs2 中先 dfs 水平方向（其实也没必要，无论水平是否交换矩阵上下交换结果不变 ）。

这是 dfs （dfs2 同理） − − > --> −−>

inline pair<int, int> dfs(int x, int y, int xx, int yy){//xx，yy 为将要走的步数，x、y 为当前坐标。用 pair 传递目标的坐标
	if(xx){
		pair <int, int> now = re_calc(a[x][y].down );
		return dfs(now.first , now.second , xx - 1, yy);
	}
	if(yy){
		pair <int, int > now = re_calc(a[x][y].r );
		return dfs(now.first , now.second , xx, yy - 1);
	}
	return make_pair(x, y);
}
}

由于笔者能力有限，在维护信息时打的又臭又长，但个人感觉还是比较对称美观的 （逃

下面给出矩阵左端的维护代码 − − > --> −−>

	pair <int, int> now1 = dfs(0, 0, x1 - 1, y1);
	pair <int, int> now2 = dfs(0, 0, x2 - 1, y2);
  	for(int j = 0; j < h; j++){
		now1 = dfs(now1.first , now1.second , 1, 0);
		now2 = dfs(now2.first , now2.second , 1, 0);
		pair <int, int> u = re_calc(a[now1.first][now1.second ].l );
		pair <int, int> v = re_calc(a[now2.first][now2.second ].l );
		a[u.first ][u.second ].r = calc(now2.first, now2.second );
		a[v.first ][v.second ].r = calc(now1.first, now1.second );
		a[now1.first][now1.second ].l = calc(v.first , v.second );
		a[now2.first][now2.second ].l = calc(u.first , u.second );
	}

最后 dfs 并输出即可。

下面给出总代码 − − > --> −−>

#include <cstdio>
#include <cctype>
#include <algorithm>
#define ll long long
#define inf 0x3f3f3f3f

using namespace std;

inline int read(){
	int x=0,w=0;char ch=getchar();
	while (!isdigit(ch))w|=ch=='-',ch=getchar();
	while (isdigit(ch))x=(x<<1)+(x<<3)+ch-'0',ch=getchar();
	return w?-x:x;
}

struct node{
	int l, r, up, down;
	int val;
}a[1005][1005];

int n, m, q, b[1005][1005], cnt; 

inline int calc(int x, int y){
	return x * (m + 3) + y;
}

inline pair<int, int> re_calc(int p){
	return make_pair(p / (m + 3), p % (m + 3));
}

inline pair<int, int> dfs(int x, int y, int xx, int yy){
	if(xx){
		pair <int, int> now = re_calc(a[x][y].down );
		return dfs(now.first , now.second , xx - 1, yy);
	}
	if(yy){
		pair <int, int > now = re_calc(a[x][y].r );
		return dfs(now.first , now.second , xx, yy - 1);
	}
	return make_pair(x, y);
}

inline pair<int, int> dfs2(int x, int y, int xx, int yy){
	if(yy){
		pair <int, int> now = re_calc(a[x][y].r );
		return dfs2(now.first , now.second , xx, yy - 1);
	}
	if(xx){
		pair <int, int > now = re_calc(a[x][y].down );
		return dfs2(now.first , now.second , xx - 1, yy);
	}
	return make_pair(x, y);
}

int main(){
	n = read();
	m = read();
	q = read();
	for(int i = 1; i <= n; i++){
		for(int j = 1; j <= m; j++){
			a[i][j].val = read();
		}
	}
	for(int i = 0; i <= n + 1 ; i++)
	a[i][0].r = calc(i, 1), a[i][n + 1].l = calc(i, n);
	
	for(int i = 0; i <= m + 1; i++)
	a[0][i].down = calc(1, i), a[n + 1][i].up = calc(n, i);
	
	for(int i = 0; i <= m; i++)
	a[0][i].r = calc(0, i + 1), a[n + 1][i].r = calc(n + 1, i + 1);
	
	for(int i = 1; i <= m + 1; i++)
	a[0][i].l = calc(0, i - 1), a[n + 1][i].l = calc(n + 1, i - 1);
	
	for(int i = 0; i <= n; i++)
	a[i][0].down = calc(i + 1, 0), a[i][n + 1].down = calc(i + 1, n + 1);
	
	for(int i = 1; i <= n + 1; i++)
	a[i][0].up = calc(i - 1, 0), a[i][n + 1].up = calc(i - 1, n + 1);
	
	for(int i = 1; i <= n; i++){
		for(int j = 1; j <= m; j++){
			a[i][j].l = calc(i, j - 1);
			a[i][j].r = calc(i, j + 1);
			a[i][j].up = calc(i - 1, j);
			a[i][j].down = calc(i + 1, j);
		}
	}
	for(int i = 1; i <= q; i++){
		int x1 = read(), y1 = read(), x2 = read(), y2 = read(), h = read(), w = read();
		pair <int, int> now1 = dfs(0, 0, x1 - 1, y1);
		pair <int, int> now2 = dfs(0, 0, x2 - 1, y2);
		pair <int, int> now3 = dfs(0, 0, x1 - 1, y1 + w - 1);
		pair <int, int> now4 = dfs(0, 0, x2 - 1, y2 + w - 1);
		for(int j = 0; j < h; j++){
			now1 = dfs(now1.first , now1.second , 1, 0);
			now2 = dfs(now2.first , now2.second , 1, 0);
			now3 = dfs(now3.first , now3.second , 1, 0);
			now4 = dfs(now4.first , now4.second , 1, 0);
			pair <int, int> u = re_calc(a[now1.first][now1.second ].l );
			pair <int, int> v = re_calc(a[now2.first][now2.second ].l );
			a[u.first ][u.second ].r = calc(now2.first, now2.second );
			a[v.first ][v.second ].r = calc(now1.first, now1.second );
			a[now1.first][now1.second ].l = calc(v.first , v.second );
			a[now2.first][now2.second ].l = calc(u.first , u.second );
			u = re_calc(a[now3.first][now3.second ].r );
			v = re_calc(a[now4.first][now4.second ].r );
			a[u.first ][u.second ].l = calc(now4.first, now4.second);
			a[v.first ][v.second ].l = calc(now3.first, now3.second);
			a[now3.first][now3.second].r = calc(v.first , v.second );
			a[now4.first][now4.second].r = calc(u.first , u.second );
		}
		now1 = dfs2(0, 0, x1, y1 - 1);
		now2 = dfs2(0, 0, x2, y2 - 1);
		now3 = dfs2(0, 0, x1 + h - 1, y1 - 1);
		now4 = dfs2(0, 0, x2 + h - 1, y2 - 1);
		for(int j = 0; j < w; j++){
			now1 = dfs(now1.first , now1.second , 0, 1);
			now2 = dfs(now2.first , now2.second , 0, 1);
			now3 = dfs(now3.first , now3.second , 0, 1);
			now4 = dfs(now4.first , now4.second , 0, 1);
			pair <int, int> u = re_calc(a[now1.first ][now1.second ].up );
			pair <int, int> v = re_calc(a[now2.first ][now2.second ].up );
			a[u.first ][u.second ].down = calc(now2.first , now2.second );
			a[v.first ][v.second ].down = calc(now1.first , now1.second );
			a[now1.first ][now1.second ].up = calc(v.first , v.second );
			a[now2.first ][now2.second ].up = calc(u.first , u.second );
			u = re_calc(a[now3.first ][now3.second ].down );
			v = re_calc(a[now4.first ][now4.second ].down );
			a[u.first ][u.second ].up = calc(now4.first , now4.second );
			a[v.first ][v.second ].up = calc(now3.first , now3.second );
			a[now3.first ][now3.second ].down = calc(v.first , v.second );
			a[now4.first ][now4.second ].down = calc(u.first , u.second );
		}
	}
	for(int i = 1; i <= n; i++){
		pair <int, int> now = dfs(0, 0, i, 0);
		for(int j = 1; j <= m; j++){
			now = dfs(now.first , now.second , 0, 1);
			printf("%d ",a[now.first ][now.second ].val );
		}
		printf("\n");
	}
    return 0;
}

完结撒花✿✿ヽ(°▽°)ノ✿

pikabi
关注
洛谷题库-题解 CF171C 【A Piece of Cake】
wangzijun_的博客
04-01 949
CF的愚人节赛题 这题很简单，累加每个元素和其下标的乘积即可。剩下的解释在代码里了。以下是python3代码： a=input().split() # 读入数组。注意此时a是str类型 ans=0 # 累加器 for i in range(int(a[0])): # 循环。注意需要强制转换，而且i是从0到a[0]-1哦 ans+=(i+1)*(int(a[i+1])) # 累加 print...
CF 706E Working routine
dance in th dark的博客
08-19 788
description 题意就是一开始给出一个n*m的矩阵，然后有Q操作，每次把这个矩阵中的两个子矩阵的所有值交换，这两个子矩阵不能相交。输出最后矩阵的形态。 Solution 一开始本来想用splay来处理的，对于每一行的处理，直接弄一下就好，所以复杂度为O(NQloglogN),由于时限为2.5s，所以勉强卡过。 但后来才发现有更简单的解法。。。 对于一次操作，会对一个位置的上下左右
CF706E.Working routine(十字链表）
Buyi的博客
06-16 275
题目链接：https://vjudge.net/problem/CodeForces-706E 题意：给出一个n*m的矩阵，q个任务，每个任务要求将两个相同大小的子矩阵块交换位置。输出最后形成的新矩阵 解题思路： 暴力一个个元素交换肯定会超时 可以发现一个子矩阵内部都是相联系的（不会改变的），交换两个矩阵，只需要将两个矩阵的上下左右边界交换一下就可以了。 所以每次交换，更新交换一下两个子矩阵上下左右边界对应即可 #include<iostream> #include<cstdio>
【CF 706E】Working routine
Facico的博客
08-18 1206
Description题意就是一开始给出一个n*m的矩阵，然后每次把这个矩阵中的两个子矩阵的所有值交换，这两个子矩阵不能相交。输出最后矩阵的形态。Solution先考虑交换两个序列先考虑交换两个序列[l,r]，[l1,r1]的所有值，就算交换了[l,r]里面的数还是相邻的，所以我们考虑维护每个点的右边那个节点是什么，每次交换的时候只用改4个值（l左边，r，l1左边，r1）他们的右边都要修改一下。
Codeforces 706E Working routine (模拟链表)
闲停
08-12 1120
题目链接：Codeforces 706E Working routine (模拟链表)题意分析：给出一个矩阵和q个操作，每次操作需要交换矩阵的两个子矩形，问：经过q次操作后，最终矩阵长什么样子。解题思路：1000×10001000 \times 1000 的矩阵啊，n2n^{2} 操作肯定是要T的。考虑链表将整个矩阵串在一起，如下图：发现对于任意需要我们交换的矩阵，其实我们只需要改变这两个矩阵的周围
Codeforces 706E Working routine
Akakii的博客
08-18 798
题目大意 给定一个N∗M的矩阵和Q个操作。每个操作将矩阵中的两个子矩阵交换，保证这两个子矩阵没有重叠部分。 输出Q次操作后的矩阵。 Data Constraint N,M≤1000,Q≤10000
洛谷CF1458B题解
02-05
有关CF1458B的题解。
python-leetcode题解之第706题设计哈希映射
07-09
python python_leetcode题解之第706题设计哈希映射
题解：ABC276E - Round Trip
08-12
代码
CF题解DIV2
07-09
Oops! Google Chrome could not connect to codeforces.com Try reloading: codeforces.­com Additional suggestions: Access a cached copy of codeforces.­com Search on Google:
CF367 E - Working routine
basasuya的博客
08-31 460
十字链表模拟#include using namespace std; int n,m,q; struct Node{ int v; int d,r; }ma[1005*1005]; int C(int x,int y){ return x*(m+1)+y; } int main(){ while(~scanf("%d %d %d",&n,&m,&q)) { for(int i =
Codeforces Round #367 (Div. 2) E. Working routine （十字链表）
LzyRapX
08-13 879
E. Working routine time limit per test 2.5 seconds memory limit per test 256 megabytes input standard input output standard output Vasiliy finally got to work, where the
Working routine【Codeforces 706 E】【二维链表】
既然弱小，就只顾变强就是了
12-17 204
Codeforces Round #367 (Div. 2) E 可以说是一道模拟题了，写了有些时候，可能是太菜了吧…… 题意：给出一个原始矩阵，之后有Q次操作，我们将两个矩阵交换位置，题目中保证两个矩阵不相交，给出的是两个矩阵的左上方的端点，以及它们对应的高和宽。 思路：很明显，题目中只有最多1e4次操作，矩阵的边最大也才不过是1e3，所以很明显的，我们可以O(1e4 * 1...
CF刷题总结---CF706E链表
lovewangtaotao的专栏
08-21 992
这题目应该要秒做出来的。 首先看到二维，又没什么思路就直接降维 考虑一维的情况，就是一段连续的和另一端连续的交换，最快的当然是链表模拟了。所以考虑到二维中也不应该用数组存储，而是链表表示。‘ 但是由于二维的话，不可能是简单的链表。所以考虑每一个矩形和旁边的关系。肯定就是四周的，但是只考虑单向，那就是2个方向。就是用一个十字交叉链表表示整个数组，这样的话，如果要交换，就是周围一圈的互相交换就可
cf 709D Recover the String(构造题)
fouzhe的博客
08-26 652
题目链接 D. Recover the String time limit per test 1 second memory limit per test 256 megabytes input standard input output standard output For each string s consisting o
CF贪心刷题记录
ItakEjgo的博客
04-14 1419
codeforces贪心刷题记录
Codeforces 706E Working routine十字链表
c_czl的博客
09-06 199
题目大意 给定一个N∗MNM的矩阵和QQ个操作。每个操作将矩阵中的两个子矩阵交换，保证这两个子矩阵没有重叠部分。  输出QQ次操作后的矩阵。 Data Constraint  N,M≤1000,Q≤10000NM1000Q10000 题解 矩阵的每个位置维护一个向右和向下的类似链表指针的东西，然后交换两个子矩阵的时候实际上就是交换边界上的指针。 时间复杂度：O(NQ)   // 十...
基于微信小程序的新生报到系统设计与实现.docx
09-13
基于微信小程序的新生报到系统设计与实现.docx
基于java的电商平台的设计与实现.docx
最新发布
09-13
基于java的电商平台的设计与实现.docx
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值