【解题报告】 洛谷 P3492 [POI2009]TAB-Arrays

【解题报告】 洛谷 P3492 [POI2009]TAB-Arrays

这题是我随机跳题的时候跳到的。写完这道题之后，顺便看了一下题解，发现只有一篇题解，所以就在这里顺便写一个解题报告了。

首先当然是题目链接

顺便贴一下csdn的网址

题目描述

给出两个n*m的矩阵，保证每个矩阵内元素互不相同且权值均在[-10^6,106]之间，请能否把其中一个矩阵通过若干次交换两行或者交换两列的操作变成另外一个矩阵。

输入输出格式

输入格式

第一行是一个整数T，表示有T组数据。

每一组数据的第一行是两个整数n和m，表示两个矩阵的大小是n行m列。接下来2*n行里面，每一行有m个数，前n行是第一个矩阵，后n行是第二个矩阵。话说有一点很奇怪，不知道为什么，题目没有给出数据范围，我还是根据内存空间限制算出我能用多少空间的。

输出格式

对于每一组数据，输出一行。若两个矩阵能够通过变换得到对方，则输出TAK，否则，输出NIE

输入输出样例

输入

2

4 3

1 2 3

4 5 6

7 8 9

10 11 12

11 10 12

8 7 9

5 4 6

2 1 3

2 2

1 2

3 4

5 6

7 8

输出

TAK

NIE

解题思路

我们先想一下另外一个问题：现在给你两个数组，问你：是否能把其中一个数组通过若干次交换两个元素的位置变成另外一个数组。

这个问题有一个简单粗暴的做法。对两个数组各自排序，看排序之后的两个数组是否完全相等即可。如，数组[1,4,3,5,6,7]和数组[4,3,6,1,7,5],他们排序过后都是同样的数组[1,3,4,5,6,7]，所以这两个数组就可以通过若干次交换两个元素变成另外一个数组。（因为排序的过程就是不断地交换两个元素的位置，如果两个数组A,B都可以通过交换两个元素的位置变成同一个数组C（也就是这个排序之后的数组），那么其中一个数组A也必然可以变成排序之后的数组C，然后数组C再变成另外一个数组B）

上面那个方法可行的原因就在于：他们都可以变成一个排好序的数组，只要比较两个排好序的数组是否相等就可以了。而矩阵看起来不能这么干的原因就在于：你好像不能给他排序。

那么，我们回来我们现在这道题。我们通过仔细地思考，不难发现一个有趣的事实：无论是交换两行，还是交换两列，交换前后，本来在同一列的元素依然在同一列，本来在同一行的元素依然在同一行。只不过，经过交换之后，同一行或则同一列的元素的相对位置会改变而已。

所以，我们有这么一个想法：首先，把最小的一个元素放在左上角，然后分别以第一行为关键字和第一列为关键字对它进行排序。然后比较两个排好序之后的矩阵是否相等。

具体做法如下：

具体做法

1. 把矩阵中最小的一个数通过变换放到矩阵的最左上角。（对两个矩阵都进行同样的操作，下面也是一样）
2. 以矩阵的第一行为关键字，利用变换，使得第一行的数字有序（从大到小，或者从小到大）
3. 以矩阵的第一列为关键字，利用变换，使得第一列的数字有序（从大到小，或者从小到大）
4. 比较两个矩阵经过上述两个变换之后是否完全相等。

下面就是我的代码。

AC代码

#include<cstdio>
#include<algorithm>
using namespace std;
const int N=2500;
const int INF=100000000;
struct ary
{
    int n[N];
    bool operator<(const ary &b)const
    {
        return n[1]<b.n[1];
    }
};
ary a[N],b[N],c[N],d[N];
int main()
{
    int test_num;
    scanf("%d",&test_num);
    while(test_num--)
    {
        int n,m;
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++)
                scanf("%d",&a[i].n[j]);
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++)
                scanf("%d",&b[i].n[j]);
        int x=0,ma=INF;
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                if(a[i].n[j]<ma)
                {
                    x=j;
                    ma=a[i].n[j];
                }
            }
        }
        for(int i=1;i<=n;i++)
        {
            int temp=a[i].n[1];
            a[i].n[1]=a[i].n[x];
            a[i].n[x]=temp;
        }
        sort(a+1,a+1+n);
        ma=INF;
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                if(b[i].n[j]<ma)
                {
                    x=j;
                    ma=b[i].n[j];
                }
            }
        }
        for(int i=1;i<=n;i++)
        {
            int temp=b[i].n[1];
            b[i].n[1]=b[i].n[x];
            b[i].n[x]=temp;
        }
        sort(b+1,b+1+n);
        for(int i=1;i<=m;i++)
        {
            for(int j=1;j<=n;j++)
            {
                c[i].n[j]=a[j].n[i];
                d[i].n[j]=b[j].n[i];
            }
        }
        sort(c+1,c+1+m);
        sort(d+1,d+1+m);
        int flag=0;
        for(int i=1;i<=m;i++)
        {
            if(flag) break;
            for(int j=1;j<=n;j++)
            {
                if(c[i].n[j]!=d[i].n[j])
                {
                    flag=1;
                    break;
                }
            }
        }
        if(flag)
        {
            printf("NIE\n");
        }
        else printf("TAK\n");
    }
    return 0;
}