UVA 12657 Boxes in a Line 【双向链表】

链接：VJudge【click here】

题意：

给定N个盒子，分别标号为1~N；有下面4种操作：

“1 X Y” 表示将X移到Y的左边；

“2 X Y” 表示将Y移到Y的右边；

“3 X Y” 表示交换X与Y的位置；

“4”   表示将1~N所有的盒子反序。

要你求经过M次操作之后，所有奇数位置的盒子标号之和。

分析:

前三种操作都是对单个盒子进行操作，第四种操作是对所有盒子进行操作，那么我们首先来考虑第四种情况。

由于只要求所有奇数位置的盒子标号之和，那么可以发现，当N为奇数的时候，将所有盒子逆序，是不会改变此时的所有奇数位置的盒子标号之和的，当N是偶数的时候，不逆序的情况下，求所有偶数位置的盒子标号之和，即所有位置的盒子标号之和 - 所有奇数位置的盒子标号之和，因此，我们对于操作4不进行反序处理，而只是将这种操作标记下来，如果有偶数倍操作4，那么这个时候我再清除标记即可。

那么还有一个问题就是，如果前面出现了奇数倍的操作4，接下来，进行操作1,2的时候，我只需要将操作1变为操作2，操作2变为操作1。比如：

输入如下：

6  4   <<====对应的状态====>> 1 2 3 4 5 6

4  <<====对应的状态====>> 6 5 4 3 2 1

1  1  4  <<====对应的状态====>> 6 5 1 4 3 2

其实可以发现，上面的情况中求得的答案等价于下面这种情况

6  4  <<====对应的状态====>>  1 2 3 4 5 6

2  1  4     <<====对应的状态====>>  2 3 4 1 5 6

，操作2的处理也是同理。。

最后，这个题目还有一个坑： 那就是对于操作3，如果操作3的X，Y相邻的时候最好还是进行一下特判，比如：

输入如下：

2  1

3  1  2

自己试一下就知道了。

实现代码

#include <cstdio>
#include <string>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define FIN             freopen("input.txt","r",stdin)
typedef long long       LL;
const int maxn = 100000 + 5;
int N, M, Op, X, Y;
struct Node
{
    int Left, Right;
    Node() : Left(0), Right(0) {}
} nodes[maxn];
void init()
{
    nodes[0].Left = nodes[0].Right = nodes[N+1].Left = nodes[N+1].Right = 0;
    nodes[1].Left = 0, nodes[1].Right = 2;
    for(int i = 2; i < N; i++)
    {
        nodes[i].Left = i - 1, nodes[i].Right = i + 1;
    }
    nodes[N].Left = N - 1, nodes[N].Right = 0;
}
int main()
{
//    FIN;
    int cas = 0;
    while(~scanf("%d %d", &N, &M))
    {
        init();
        bool bRev = false;
        for(int i = 0; i < M; i++)
        {
            scanf("%d", &Op);
            if(Op == 4)
            {
                bRev = !bRev;
                continue;
            }
            scanf("%d %d", &X, &Y);
            if(bRev) Op = 3 - Op;
            if(Op == 1)
            {
                int xl = nodes[X].Left, xr = nodes[X].Right;
                nodes[xl].Right = xr, nodes[xr].Left = xl;
                int yl = nodes[Y].Left;
                nodes[yl].Right = X, nodes[X].Left = yl;
                nodes[Y].Left = X, nodes[X].Right = Y;
            }
            else if(Op == 2)
            {
                int xl = nodes[X].Left, xr = nodes[X].Right;
                nodes[xl].Right = xr, nodes[xr].Left = xl;
                int yr = nodes[Y].Right;
                nodes[yr].Left = X, nodes[X].Right = yr;
                nodes[Y].Right = X, nodes[X].Left = Y;
            }
            else
            {
                int xl = nodes[X].Left, xr = nodes[X].Right;
                int yl = nodes[Y].Left, yr = nodes[Y].Right;
                if(xr == Y)
                {
                    nodes[xl].Right = Y;
                    nodes[Y].Left = xl;
                    nodes[X].Right = yr;
                    nodes[yr].Left = X;
                    nodes[X].Left = Y;
                    nodes[Y].Right = X;
                }
                else if(xl == Y)
                {
                    nodes[yl].Right = X;
                    nodes[X].Left = yl;
                    nodes[Y].Right = xr;
                    nodes[xr].Left = Y;
                    nodes[Y].Left = X;
                    nodes[X].Right = Y;
                }
                else
                {
                    nodes[X].Left = yl, nodes[X].Right = yr, nodes[yl].Right = X, nodes[yr].Left = X;
                    nodes[Y].Left = xl, nodes[Y].Right = xr, nodes[xl].Right = Y, nodes[xr].Left = Y;
                }
            }
        }
        int pos = -1;
        for(int i = 1; i <= N; i++)
        {
            if(nodes[i].Left == 0)
            {
                pos = i;
                break;
            }
        }
        LL ans = 0;
        for(int i = 1; i <= N; i++)
        {
            if(i & 1) ans += pos;
            pos = nodes[pos].Right;
        }
        LL t = N;
        if(bRev && !(N & 1)) ans = t * (t + 1) / 2 - ans;
        printf("Case %d: %lld\n", ++cas, ans);
    }
    return 0;
}