hihoCoder #1240 Image Encryption

Description

A fancy square image encryption algorithm works as follow:

0. consider the image as an N x N matrix

1. choose an integer k∈ {0, 1, 2, 3}

2. rotate the square image k * 90 degree clockwise

3. if N is odd stop the encryption process

4. if N is even split the image into four equal sub-squares whose length is N / 2 and encrypt them recursively starting from step 0

Apparently different choices of the k serie result in different encrypted images. Given two images A and B, your task is to find out whether it is POSSIBLE that B is encrypted from A. B is possibly encrypted from A if there is a choice of k serie that encrypt A into B.

Input

Input may contains multiple testcases.

The first line of the input contains an integer T(1 <= T <= 10) which is the number of testcases.

The first line of each testcase is an integer N, the length of the side of the images A and B.

The following N lines each contain N integers, indicating the image A.

The next following N lines each contain N integers, indicating the image B.

For 20% of the data, 1 <= n <= 15

For 100% of the data, 1 <= n <= 100, 0 <= Aij, Bij <= 100000000

Output

For each testcase output Yes or No according to whether it is possible that B is encrypted from A.

Sample Input

3
2
1 2
3 4
3 1
4 2
2
1 2
4 3
3 1
4 2
4
4 1 2 3
1 2 3 4
2 3 4 1
3 4 1 2
3 4 4 1
2 3 1 2
1 4 4 3
2 1 3 2

Sample Output

Yes
No
Yes

 

 Solution:

#include <cstdlib>
#include <cstdio>
#include <vector>
using namespace std;


void rotateImg(vector<vector<int> > &A) {
    
    int N = A.size();
    int r = N >> 1;
    int c = (N + 1) >> 1;
    for (int i = 0; i < r; ++i) {
        for (int j = 0; j < c; ++j) {
            int tmp = A[i][j];
            A[i][j] = A[N - 1 - j][i];
            A[N - 1 - j][i] = A[N - 1 - i][N - 1 - j];
            A[N - 1 - i][N - 1 - j] = A[j][N - 1 - i];
            A[j][N - 1 - i] = tmp;
        }
    }

}

bool isEqual(vector<vector<int> > A, vector<vector<int> > B) {
    int N = A.size();
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            if (A[i][j] != B[i][j]) return false;
        }
    }
    return true;
}

vector<vector<int> > split(vector<vector<int> > A, int x, int y) {
    int N = A.size() >> 1;
    vector<vector<int> > v(N, vector<int>(N, 0));
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            v[i][j] = A[i + x][j + y];
        }
    }
    return v;
}

bool isEncrypted(vector<vector<int> > A, vector<vector<int> > B) {
    int N = A.size();
    if (N == 1) return A[0][0] == B[0][0];
    if (N & 0x01) {
        vector<vector<int> > AA = A;
        for (int k = 0; k < 4; ++k) {
            if (isEqual(AA, B)) return true;
            rotateImg(AA);
        }
        return false;
    }
    else {
        int N_2 = N >> 1;
        vector<vector<int> > AA = A;
        int x[] = { 0, N_2, 0, N_2 };
        int y[] = { 0, 0, N_2, N_2 };
        for (int k = 0; k < 4; ++k) {
            bool flag = true;
            for (int kk = 0; kk < 4; ++kk) {
                if (!isEncrypted(split(AA, x[kk], y[kk]), split(B, x[kk], y[kk]))) {
                    flag = false;
                    break;
                }
            }
            if (flag) return true;
            rotateImg(AA);
        }
        return false;
    }
}




int main() {
    int T;
    scanf("%d", &T);
    while (T--) {
        int N;
        scanf("%d", &N);
        vector<vector<int> > A(N, vector<int>(N, 0));
        vector<vector<int> > B(N, vector<int>(N, 0));
        for (int i = 0; i < N; ++i) {
            for (int j = 0; j < N; ++j) {
                int v;
                scanf("%d", &v);
                A[i][j] = v;
            }
        }
    
        for (int i = 0; i < N; ++i) {
            for (int j = 0; j < N; ++j) {
                int v;
                scanf("%d", &v);
                B[i][j] = v;
            }
        }

        if (isEncrypted(A, B)) printf("Yes\n");
        else printf("No\n");
    }
}