【上海交大oj】1053 二哥的内存

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变为了零。
实际上貌似异或的办法并不能提高效率，以后还是别装逼了。
代码：

#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;

struct arr{
    int r;
    int c;
    int v;
    bool operator < (const arr &a)const{
        return r<a.r;
    }
}array[100005];

int x[100005]; //记录下标 
int y[100005];
int n;

void Find(int a,int b){
    int xx = x[a],yy = y[b];
    bool flag = 0;
    for (int i = 0;i < n;++i){
        if (array[i].r == xx && array[i].c == yy) {
            printf("%d
",array[i].v);
            flag = 1;
            break;
        }
    } 
    if (!flag) printf("%d
",0);
}
int main(){
    int m;

    for (int i = 0;i < 100005;++i) x[i] = y[i] = i;
    scanf("%d",&n);
    for (int i =0;i < n;++i)
    {
        scanf("%d%d%d",&array[i].r,&array[i].c,&array[i].v);
    }
    sort(array,array+n); 
    scanf("%d",&m);
    for (int i = 0;i < m;++i)
    {
        int op,a,b;
        scanf("%d%d%d",&op,&a,&b);
        switch (op){
            case 0:{
                if (a != b) {  
                    x[a] = x[a]^x[b]; //这就是坑爹的异或交换 ,只有下标不同才能换 
                    x[b] = x[a]^x[b];
                    x[a] = x[a]^x[b];
            }
                break;
            }
            case 1:{
                if (a != b) {
                    y[a] = y[a]^y[b];
                    y[b] = y[a]^y[b];
                    y[a] = y[a]^y[b];
                }
                
                break;
            }
            default:{
                Find(a,b);
            }
        }
    }

    return 0;
}