题目描述

输入一个N阶方阵(0<N<10)，输出此方阵顺时针旋转M(0<=M<=10000)次后的方阵

旋转举例：如下四个三阶方阵从左到右为数字围绕中心顺时针旋转
1 2 3
4 5 6
7 8 9

7 4 1
8 5 2
9 6 3

9 8 7
6 5 4
3 2 1

3 6 9
2 5 8
1 4 7

输入描述

第一行输入一个正整数N(0<N<10)

接下来的N行，每行N个整数，用空格分开，为方阵的数据

最后一行输入一个正整数M(0<=M<=10000)

说明：不用考虑异常输入，所有输入都是正常的，严格遵从取值范围

输出描述

输出N行，每行N个整数，用空格分开，为旋转后的数据

示例

输入：
1
1 2 3
4 5 6
7 8 9
2

输出：
9 8 7
6 5 4
3 2 1

实现思路

以如下方阵为例：
1 2 3
4 5 6
7 8 9

从最外圈开始，可以视为一个正方形，依次让正方形的边按照顺时针方向向后赋值：
原本123的位置就变成了741
原本369的位置就变成了123
原本987的位置就变成了369
原本741的位置就变成了987

从最外圈往里每一圈都按照上述操作执行向后赋值；

上述为旋转一次的步骤，按照M的次数递归调用即可。

代码实现

#include <iostream>
#include <vector>

using namespace std;

vector<vector<int>> getRotate(vector<vector<int>> values)
{
    vector<vector<int>> res = values;
    int size = values.size();
    int count = size / 2;
	for (int i = 0; i < count; i++)
	{
		for (int j = i; j < size - i; j++)
		{
			res[i][j] = values[size - 1 - j][i];
			res[j][size - 1-i] = values[i][j];
			res[size - 1-i][size - 1 - j] = values[j][size - 1-i];
			res[size - 1 - j][i] = values[size - 1-i][size - 1 - j];
		}
	}
    return res;
}

int main()
{
    // input
    int n = 0;
    int m = 0;
    vector<vector<int>> values_ori;
    vector<vector<int>> values_res;
    cin >> n;
    int temp = 0;
    vector<int> temps = {};
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)
		{
			cin >> temp;
            temps.push_back(temp);
		}
        values_ori.push_back(temps);
        temps.clear();
	}
    cin >> m;

    // rotate
    values_res = values_ori;
    m = m % 4;
    for (int i = 0; i < m; i++)
    {
        values_res = getRotate(values_res);
    }

    // output
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            cout << values_res[i][j];
            if (j != n - 1)
            {
                cout << " ";
            }
        }
        cout << endl;
    }
}