D. Little Artem and Dance（带环模拟 + 规律）

D. Little Artem and Dance

Little Artem is fond of dancing. Most of all dances Artem likes rueda
— Cuban dance that is danced by pairs of boys and girls forming a
circle and dancing together.

More detailed, there are n pairs of boys and girls standing in a
circle. Initially, boy number 1 dances with a girl number 1, boy
number 2dances with a girl number 2 and so on. Girls are numbered in
the clockwise order. During the dance different moves are announced
and all pairs perform this moves. While performing moves boys move
along the circle, while girls always stay at their initial position.
For the purpose of this problem we consider two different types of
moves:

Value x and some direction are announced, and all boys move x
positions in the corresponding direction. Boys dancing with
even-indexed girls swap positions with boys who are dancing with
odd-indexed girls. That is the one who was dancing with the girl 1
swaps with the one who was dancing with the girl number 2, while the
one who was dancing with girl number3 swaps with the one who was
dancing with the girl number 4 and so one. It’s guaranteed that n is
even. Your task is to determine the final position of each boy.

Input The first line of the input contains two integers n and q
(2 ≤ n ≤ 1 000 000, 1 ≤ q ≤ 2 000 000) — the number of couples in the
rueda and the number of commands to perform, respectively. It’s
guaranteed that n is even.

Next q lines contain the descriptions of the commands. Each command
has type as the integer 1 or 2 first. Command of the first type is
given as x ( - n ≤ x ≤ n), where 0 ≤ x ≤ n means all boys moves x
girls in clockwise direction, while  - x means all boys move x
positions in counter-clockwise direction. There is no other input for
commands of the second type.

Output Output n integers, the i-th of them should be equal to the
index of boy the i-th girl is dancing with after performing all q
moves.

Examples

input
6 3
1 2
2
1 2
output
4 3 6 5 2 1
input
2 3
1 1
2
1 -2
output
1 2
input
4 2
2
1 3
output
1 4 3 2

思路如下

• 题意：经过题目上的两种操作后，输出 从 第一个 女孩 到 最后一个 女孩 所对应的 男孩的编号。
• 思路： 这一题我开始想的是 直接用 “环形双向链表”（应该是叫这个名字吧）进行模拟，但是由于链表访问中间某个位置的元素浪费时间太长了，造成时间超时了。。。。。 然后又决定 将一开始的模拟思路用 数组来实现模拟 环形双向链表 功能，这样可以快速的 解决 对中间元素的开素访问，但是遗憾的是还是 超时。。。。。
  然后就决定 去看看题解怎么写的，在别人的题解中得到了 方法：
  规律如下：

1. 在奇数位置排列的相对位置是不会变的：XX 1 XX 3 XX 5 XX 7XX;
   在偶数位置排列的相对位置也是不变的：XX 2 XX 4 XX 6 XX 8 XX.
2. 所有的 奇数位置 总是 在所有的偶数位置 前边 或 后边，而且 相邻的奇数与偶数之间的位置 总是相邻的（如果把位置形成一个环）
   原因：经过操作 1 之后显然 奇数之间的相对的位置是不会改变的，偶数也同理，而且 相邻的奇数与偶数之间的位置 总是相邻的（如果把位置形成一个环）
   经过操作 2 之后，所有相邻的奇、偶数位置进行交换,因此也不会破坏 规律1 ：奇数之间、偶数之间的相对位置不改变 ；但是会 改变奇偶数位置之间的 相对位置（例如：之前所有相邻的的 偶数位置在 奇数位置的前边：2 、1、4、3、6 、5，现在则变成相反的情况：1、2、3、4、5、6 ）。
3. 在有了这些规律之后，我们在模拟的时候只需要模拟 奇数位置的第一个 b = 1 和 偶数位置的第一个数 a = 0 的变化情况，则最终得到的 a 、b 位置的值 为 1、2 其它的 位置 则只需要根据 规律1 ：奇数之间、偶数之间的相对位置是不变的 、规律2: 相邻两个奇偶数位置之间总是 相邻的。就能把 数组中剩余位置的值 填补出来！

---

虽然前两个题解都超时了，但是还是可以从里面学到很多的知识的，尤其是练习了 对 链表 的使用

超时题解一

#include
#include
using namespace std;

struct Node
{
     
    char girl_data;
    int data;
    Node * last;
    Node * next;
} * head;

int main()
{
     
    //freopen("test.txt","r",stdin);
    head = (Node *)malloc(sizeof(Node));
    head -> data = 1;
    int n,q;
    scanf("%d %d",&n,&q);
    Node * normal;
    Node * last_pos = head;
    for(int i = 2; i <= n; i ++)
    {
     
        normal = (Node *)malloc(sizeof(Node));
        normal -> data = i;
        normal -> last = last_pos;
        last_pos -> next = normal;
        last_pos = normal;
    }
    head -> last = last_pos;
    last_pos -> next = head;

    while(q --)
    {
     
        int type;
        scanf("%d", &type);

        if(type == 1)
        {
     
            int step;
            scanf("%d", &step);
            if(step > 0)
            {
     
                Node * st_pos = head;
                for(int i = 0; i < step; i ++)
                {
     
                    st_pos = st_pos -> last;
                }
                head = st_pos;
            }
            else
            {
     
                Node * st_pos = head;
                for(int i = 0; i < -step; i ++)
                {
     
                    st_pos = st_pos -> next;
                }
                head = st_pos;
            }
        }
        else
        {
     
            Node * pos = head;
            for(int i = 1; i <= n; i ++)
            {
     
                pos = pos -> next;
                if(i % 2 != 0)
                {
     
                    int tem = pos -> data;
                    pos -> data = pos -> last -> data;
                    pos -> last -> data = tem;
                }
            }
        }
    }

    Node * pos = head;
    for(int i = 1; i <= n; i ++)
    {
     
        printf("%d ",pos ->data);
        pos = pos -> next;
    }

    return 0;
}

超时题解二

#include
using namespace std;
const int Len = 1000005;
int node[Len];

int main()
{
     
    //freopen("T.txt","r",stdin);
    int n,q;
    scanf("%d %d",&n,&q);

    int  head = 0;
    for(int i = 0; i < n; i ++)
        node[i] = i + 1;

    while(q --)
    {
     
        int type;
        scanf("%d", &type);
        if(type == 1)
        {
     
            int step;
            scanf("%d",&step);
            if(step >= 0)
            {
     
                head -= step;
                if(head < 0)
                    head += n;
            }
            else
            {
     
                head -= step;
                head %= n;
            }
        }
        else
        {
     
            int st_pos = head;
            for(int i = 1; i <= n/2; i ++)
            {
     
                int tem = node[st_pos];
                node[st_pos] = node[(st_pos + 1) % n];
                node[(st_pos + 1) % n] = tem;
                st_pos += 2;
                st_pos %= n;
            }
        }
    }
    for(int i = 1; i <= n; i ++)
    {
     
        printf("%d ",node[head]);
        head ++;
        head %= n;
    }


    return 0;
}

正解

#include
using namespace std;
const int Len = 1000005;
int node[Len];

int main()
{
     
//    freopen("test.txt","r",stdin);
    int a = 0,b = 1;        //只对 “奇、偶前开头前两个位置” 进行模拟操作（⚠️ 注意：这里的 下标是从 0 位置开始的）
    int n,q;
    scanf("%d %d",&n,&q);
    int type,step;
    while(q --)
    {
     
        scanf("%d",&type);
        if(type == 1)
        {
     
            scanf("%d",&step);
            a += step;		//根据 step 的正、负 进行 模拟顺时针、逆时针 移动
            (a+=n) %= n;	//处理以防止越界

            b += step;
            (b+=n) %= n;
        }
        else	//相邻奇偶位置进行位置交换（奇数位置 变成 偶数位置 ；偶数位置 变成 奇数位置）
        {
     
            if(a % 2 == 0)	//如果是 偶数 位置 +1 变成 奇数位置
            {
     
                a ++;
                a %= n;		//防止 越界
            }
            else			//如果是 奇数 - 1 变 偶数位置
            {
     
                a --;		
                if(a < 0)
                    a += n;
            }

            if(b % 2 == 0)	//同理
            {
     
                b ++;
                b %= n;
            }
            else
            {
     
                b --;
                if(b < 0)
                    b += n;
            }
        }
    }

    int zhi = 1;
    //往数组里填充数字 （注意为什么这样填数是可行的？ 因为 位置 a、b要么是相邻的的 要么是 一个在开头位置，一个在结尾位置，这样在通过取余数 就可以保证 填上连续的数字了）
    for(int i = 0;i < n; i += 2)
    {
     
        node[(a + i) % n] = zhi;
        node[(b + i) % n] = zhi + 1;
        zhi += 2;
    }
    
    for(int i = 0; i < n; i ++)
        printf("%d ",node[i]);

    return 0;
}