UVa 12657：Boxes in a Line

这里我用了head和tail记录链表的头和尾，在进行操作的时候要考虑head和tail，以及swap的时候考虑X，Y是否是相邻的。

#include <iostream>

using namespace std;


struct element
{
    int left;
    int right;
}NODE;


static void movingBoxUVa12657(void); 
static void operateBox(int ind_ins, int X, int Y, struct element* seq, int &reverse_flag, int &head, int &tail, int seq_len);

enum operation_type{START, MOVE_LEFT, MOVE_RIGHT, EXCHANGE_X_Y, REVERSE_X_Y};

int main()
{
    movingBoxUVa12657();

    return 0;
}


static void movingBoxUVa12657()
{
    int num_box;
    int num_ins;
    int head = 0;
    int tail = 0;
    int test_num = 1;

    while(cin >> num_box >> num_ins)
    {
        struct element* seq = new struct element[num_box + 1];
        head = 1;
        tail = num_box;

        for(int i = 1; i <= num_box; i++)
        {
            seq[i].left = i - 1; // header left is 0
            seq[i].right = i + 1;
        }

        int reverse_flag = 0; // in the right order.
        for(int i = 0; i < num_ins; i++)
        {
            int ind_ins;
            int X, Y;
            cin >> ind_ins;
            if (ind_ins != REVERSE_X_Y)
            {
                cin >>  X >> Y;
                operateBox(ind_ins, X, Y, seq, reverse_flag, head, tail, num_box+1);
            }
            else
            {
                reverse_flag = 1 - reverse_flag;
            }   

            /*
            struct element tmp = seq[head];
            cout << head << " ";
            for (int j = 1; j < num_box; j++)
            {
                cout << tmp.right << " ";
                tmp = seq[tmp.right];
            }   
            cout << endl;

            tmp = seq[tail];
            cout << tail << " ";
            for (int k = 1; k < num_box; k++)
            {
                cout << tmp.left << " ";
                tmp = seq[tmp.left];
            }   
            cout << endl;*/
        }   

            long long result = 0;
            struct element tmp = seq[head];
            result = head;

            if (reverse_flag)
            {
                result = tail;
                tmp = seq[tail];
            }

            int add_flag = 0;

            for (int i = 1; i < num_box; i++)
            {
                int add_element = 0;
                if (reverse_flag)
                {
                    add_element = tmp.left;
                    tmp = seq[tmp.left];
                }
                else
                {
                    add_element = tmp.right;
                    tmp = seq[tmp.right];
                }
                if(add_flag)
                    result += add_element;

                add_flag = 1 - add_flag;
            }

            cout << "Case " << test_num << ": " << result << endl;
            test_num++;


        delete[]seq;
    }   

    return;
}


static void operateBox(int ind_ins, int X, int Y, struct element* seq, int &reverse_flag, int &head, int &tail, int seq_len)
{
    int tmp;

    if (ind_ins == EXCHANGE_X_Y)
    {
        // 2 1 3 8 5 6 7 4 9 10 11

        // 2 1 3 8 5 6 7 4 10 10 10
        int X_left = seq[X].left;
        int X_right = seq[X].right;
        int Y_left = seq[Y].left;
        int Y_right = seq[Y].right;
        int flag = 0;

        if(X_left == Y)
        {
            seq[X].left = Y_left;
            seq[Y].left = X;
            seq[X].right = Y;
            seq[Y].right = X_right;

            // Y X -> X Y
            if(X_right != seq_len)
                seq[X_right].left = Y;
            else
                tail = Y;

            if(Y_left)
                seq[Y_left].right = X;
            else
                head = X;
        }   
        // 2 1 3 8 5 6 7 4 9 X 10 Y 11

        // 2 1 3 8 5 6 7 4 10 10 10
        else if(X_right == Y)
        {
            seq[X].left = Y;
            seq[Y].left = X_left;
            seq[X].right = Y_right;
            seq[Y].right = X;
            // X Y -> Y X
            if(Y_right != seq_len)  
                seq[Y_right].left = X;
            else
                tail = X;

            if(X_left)  
                seq[X_left].right = Y;
            else
                head = Y;
        }   
        else
        {   
            seq[X].left = Y_left;
            seq[Y].left = X_left;
            seq[X].right = Y_right;
            seq[Y].right = X_right;

            if(!X_left)
            {
                head = Y;
                seq[X_right].left = Y;
            }   
            else if(X_right == seq_len)
            {
                tail = Y;
                seq[X_left].right = Y;
            }   
            else
            {
                seq[X_left].right = Y;
                seq[X_right].left = Y;
            }   

            if(!Y_left)
            {
                head = X;
                seq[Y_right].left = X;
            }   
            else if(Y_right == seq_len)
            {
                tail = X;
                seq[Y_left].right = X;
            }   
            else
            {
                seq[Y_left].right = X;
                seq[Y_right].left = X;
            }
        }


    }   
    else if((ind_ins == MOVE_RIGHT && !reverse_flag) || (ind_ins == MOVE_LEFT && reverse_flag))
    {
        if(seq[Y].right == X)
            return;

        int X_left = seq[X].left;
        int X_right = seq[X].right;

        // take X out.
        if(X_left == 0)
        {
            head = X_right;
            seq[X_right].left = 0;
        }   
        else if(X_right == seq_len)
        {
            tail = X_left;
            seq[X_left].right = seq_len;
        }   
        else
        {
            seq[X_left].right = X_right;
            seq[X_right].left = X_left;
        }   

        int Y_right = seq[Y].right;
        seq[Y].right = X;

        if(Y_right == seq_len)
        {
            tail = X;
            seq[X].right = seq_len;
            seq[X].left = Y;    
        }   
        else
        {
            seq[X].right = Y_right;
            seq[X].left = Y;
            seq[Y_right].left = X;
        }   
    }   
    else if((ind_ins == MOVE_LEFT && !reverse_flag) || (ind_ins == MOVE_RIGHT && reverse_flag))
    {
        if(seq[Y].left == X)
            return;

        int X_left = seq[X].left;
        int X_right = seq[X].right;

        // take X out.
        if(X_left == 0)
        {
            head = X_right;
            seq[X_right].left = 0;
        }   
        else if(X_right == seq_len)
        {
            tail = X_left;
            seq[X_left].right = seq_len;
        }   
        else
        {
            seq[X_left].right = X_right;
            seq[X_right].left = X_left;
        }   

        int Y_left = seq[Y].left;
        seq[Y].left = X;

        if(Y_left == 0)
        {
            head = X;
            seq[X].right = Y;
            seq[X].left = 0;    
        }   
        else
        {
            seq[X].right = Y;
            seq[X].left = Y_left;
            seq[Y_left].right = X;
        }           
    }   
    else
    {
        return;
    }   
}