1053. 二哥的内存

Description

二哥买了一台内存非常非常大的电脑，以至于二哥写程序直接开了一个 100,000 * 100,000 的数组都跑得很顺畅。这个数组初始被清零，二哥在其中的 n 个位置赋了值，然后他做了 m 次操作，每次操作为以下三个指令之一：

0 x y ：交换数组的 x 行与 y 行

1 x y ：交换数组的 x 列与 y 列

2 x y ：读取数组当期 x 行 y 列的数

现在请你写一个程序，对于每次读取，输出内存中对应位置的数。

Input Format

第 1 行：一个整数 n 表示初始化了 n 个位置。

第 2..n+1 行：每行三个整数： x y z 表示数组中 x 行 y 列的值被赋值为 z。

第 n+2 行：一个整数 m 表示操作的数量

第 n+3..n+m+2 行：每行一条指令 op x y，其中 op 为 0 表示交换行，op 为 1 表示交换列，op 为 2 表示读取操作。

数组中一个位置不会被赋值两次。

Output Format

对于每个读取指令，输出一行一个整数，为内存中对应位置的数。

Hint

对 70% 的数据，数组行列的下标范围为 0..199,0≤n≤1000, 0≤m≤2000.

对 100% 的数据，数组行列的下标范围为 0..99999, 0≤n≤10000, 0≤m≤20000.

Sample Input

3
0 1 1
1 0 2
2 2 3
9
0 0 1
2 0 0
2 1 1
2 2 2
1 0 1
0 0 1
2 0 0
2 1 1
2 2 2

Sample Output

2
1
3
1
2
3

题目不难，就是开个数组记录下标，如果要优化的话可以排个序然后二分查找，不过这题可以直接过。但当我写完以后发现无论如何都有几个点过不了，这个bug隐藏的太深，费了好大功夫才找到。原因就是我交换一个数组的两个位置的值时采用异或的办法，结果就悲剧了，因为这两个位置可能相同，这么一来异或一下本来只改变一个变量的值，现在由于实际上是同一个变量，这么一交换实际上就是变为零了。比如执行a ^= a，就这一步已经把a变为了零。实际上貌似异或的办法并不能提高效率，以后还是别装逼了。代码：

 1 #include <cstdio>
 2 #include <iostream>
 3 #include <algorithm>
 4 using namespace std;
 5
 6 struct arr{
 7     int r;
 8     int c;
 9     int v;
10     bool operator < (const arr &a)const{
11         return r<a.r;
12     }
13 }array[100005];
14
15 int x[100005]; //记录下标
16 int y[100005];
17 int n;
18
19 void Find(int a,int b){
20     int xx = x[a],yy = y[b];
21     bool flag = 0;
22     for (int i = 0;i < n;++i){
23         if (array[i].r == xx && array[i].c == yy) {
24             printf("%d\n",array[i].v);
25             flag = 1;
26             break;
27         }
28     }
29     if (!flag) printf("%d\n",0);
30 }
31 int main(){
32     int m;
33
34     for (int i = 0;i < 100005;++i) x[i] = y[i] = i;
35     scanf("%d",&n);
36     for (int i =0;i < n;++i)
37     {
38         scanf("%d%d%d",&array[i].r,&array[i].c,&array[i].v);
39     }
40     sort(array,array+n);
41     scanf("%d",&m);
42     for (int i = 0;i < m;++i)
43     {
44         int op,a,b;
45         scanf("%d%d%d",&op,&a,&b);
46         switch (op){
47             case 0:{
48                 if (a != b) {
49                     x[a] = x[a]^x[b]; //这就是坑爹的异或交换 ,只有下标不同才能换
50                     x[b] = x[a]^x[b];
51                     x[a] = x[a]^x[b];
52             }
53                 break;
54             }
55             case 1:{
56                 if (a != b) {
57                     y[a] = y[a]^y[b];
58                     y[b] = y[a]^y[b];
59                     y[a] = y[a]^y[b];
60                 }
61
62                 break;
63             }
64             default:{
65                 Find(a,b);
66             }
67         }
68     }
69
70     return 0;
71 }