PAT B1008 数组元素循环右移问题

一个数组A中存有N（>0）个整数，在不允许使用另外数组的前提下，将每个整数循环向右移M（≥0）个位置，即将A中的数据由$A_0{A}_1{A}_2^{\dots }{A}_{N-1}$变换为${A_{N-M}}^{\dots }{A}_{N-1}{A}_0{A}_1^{\dots }{A}_{N-M-1}$（最后M个数循环移至最前面的M个位置）。如果需要考虑程序移动数据的次数尽量少，要如何设计移动的方法？

输入格式:
每个输入包含一个测试用例，第1行输入N（1≤N≤100）和M（≥0）；第2行输入N个整数，之间用空格分隔。

输出格式:
在一行中输出循环右移M位以后的整数序列，之间用空格分隔，序列结尾不能有多余空格。

输入样例:
6 2
1 2 3 4 5 6
输出样例:
5 6 1 2 3 4

首先分析这个题目，各个元素的最终位置为(i+M)%N；最简单的方法就是分两部分直接输出，首先输出${A_{N-M}}^{\dots }{A}_{N-1}$，然后输出$A_0{A}_1^{\dots }{A}_{N-M-1}$，简单粗暴，通过率100%。
但是这题我起初并没有想到这个方法，最容易想到的方法就是按照规则遍历M次，用第i个元素替换第(i+M)%N个元素。如下：

#include <iostream>
#include <cmath>
#include <string>
using namespace std;
int main()
{
    int m, n;
    cin >> n >> m;
    int a[100];
    int i,j,k;
    for ( i = 0; i < n; i++)
    {
        cin >> a[i];
    }
    int temp,temp1,flag;
    for (i = 0; i < (m % n); i++)
    {
        j = (i + m) % n;
        temp = a[j];
        a[j] = a[i];
        while (i != j)
        {
            j = (j + m) % n;  
            temp1 = temp;
            temp = a[j];
            a[j] = temp1;

            if (i == j)
            {
                flag = 0;
            }          
        }
    }
    for (i = 0; i < n-1; i++)
    {
        cout << a[i] << " ";
       
    }
    cout << a[n - 1];
    return 0;
}

在此基础上，我们可以发现搜索遍历次数有一个规律，即遍历N和M的最大公约数次就可以将所有元素归位。如下所示：

#include <iostream>
#include<stdio.h>
#include<cmath>
using namespace std;
int gcdRecursion(int a, int b)
{
    if (b == 0) {
        return a;
    }
    else {
        return gcdRecursion(b, a % b);
    }
}

int main()
{
    int m, n, i, j, d, k;
    cin >> n >> m;
    int a[n];
    for (i = 0; i < n; i++)
    {
        cin >> a[i];
    }
    m = m % n;
    d = gcdRecursion(m, n);
    for (i = n - m; i < n - m + d; i++)
    {
        int temp;
        bool flag = 1;
        j = i;
        temp = a[i];
        while (j != i || flag) {
            if (j - m < 0)
            {
                a[j] = a[j - m + n];
                j = j - m + n;
                if (j == i)
                {
                    flag = 0;
                    k = j + m - n;
                }
            }
            else {
                a[j] = a[j - m];
                j -= m;
                if (j == i)
                {
                    flag = 0;
                    k = j + m;
                }
            }
        }
        a[k] = temp;
    }
    for (i = 0; i < n - 1; i++) {
        cout << a[i] << " ";
    }
    cout << a[n - 1];
    return 0;
}

其他人还有另外一个方法，我觉得好聪明，自己是万万想不到的。整体逆置，两部分分别逆置。

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

int main() {
    int N, M;
    cin >> N >> M;
    int a[N];
    for (int i = 0; i < N; i++)
        scanf("%d",&a[i]);
    M %= N;
    if (M != 0) {
        reverse(a, a+N);
        reverse(a, a+M);
        reverse(a+M, a+N);
    }
    for (int i = 0; i < N - 1; i++)
        printf("%d ",a[i]);
    printf("%d",a[N-1]);
    return 0;
}

上述涉及到reverse()函数的用法，头文件为#include <algorithm>。
1.交换vector容器中元素顺序

vector<int> v = {5,4,3,2,1};
reverse(v.begin(),v.end());//v的值为1,2,3,4,5

2.交换string字符串中元素的顺序

string str="www.mathor.top";
reverse(str.begin(),str.end());//str结果为pot.rohtam.wwww

3.交换字符数组char[]中元素的顺序

char a[101] = “hello world”;
reverse(a,a+strlen(a));

4.交换整型数组int[]中元素的顺序

参考 https://blog.csdn.net/qq_39093164/article/details/90107832
和https://www.cnblogs.com/hebust/p/9813279.html