移动小球

移动小球

时间限制(普通/Java) : 1000 MS/ 3000 MS          运行内存限制 : 65536 KByte
总提交 : 995            测试通过 : 131 

题目描述

你有一些小球，从左到右依次编号为1，2，3，…，n，如下图所示：



你可以执行两种指令。其中A X Y表示把小球X移动到小球Y左边，B X Y表示把小球X移动到小球Y右边。指令保证合法，即X不等于Y。

例如，在初始状态下执行A 1 4后，小球1被移动到小球4的左边，如下图所示：



如果再执行B 3 5，结点3将会移到5的右边，如下图所示：



输入

输入小球个数n。指令条数m和m条指令，注意，1≤n≤500000，0≤m≤100000。

输出

从左到右输出最后的小球序列。

样例输入

6 2

A 1 4

B 3 5

样例输出

2 1 4 5 3 6

在多数情况下，线性表都用它的顺序存储结构——数组很轻松实现，但对有些问题有时用它的链式存储结构——链表更好。

移动小球。

你有一些小球，从左到右依次编号为1,2,3,…,n，

可以执行两种指令。其中，AX Y表法把小球X移动到小球Y左边，B X Y表示把小球X移动到小球Y右边。指令保证合法，即X不等于Y。

例如，在初始状态下执行A1 4后，小球被移动小球4的左边。

如果再执行B 3 5，结点3将会移到5的右边。

输入小球个数n，指令条数m和n条指令，从左到右输出最后的序列。注意，n可能高达500000，而m可能高达100000。

样例输入：

6     2

A  1  4

B  3  5

样例输出：

2 1 4 5 3 6

【分析】

各个小球在逻辑上是相邻的，因此可考虑把它们放在一个数组A中，所以完整的程序如下：

[cpp] view
plaincopyprint?

#include <stdio.h>  

const int MAXN = 1000;  

int n, A[MAXN];  

int find(int X)  

{  

    for(int i = 1; i <= n; i++)  

        if(A[i] == X) return i;  

    return 0;  

}  

void shift_circular_left(int a, int b)  

{  

    int t = A[a];  

    for(int i = a; i < b; i++)  

    {  

        A[i] = A[i+1];  

    }  

    A = t;  

}  

void shift_circular_right(int a, int b)  

{  

    int t = A[b];  

    for(int i = b; i > a; i--)  

    {  

        A[i] = A[i-1];  

    }  

    A[a] = t;  

}  

int main()  

{  

    int m, X, Y, p, q;  

    char type[9];  

    scanf("%d%d", &n, &m);  

    for(int i = 1; i <= n; i++)   //初始化数组  

        A[i] = i;  

    for(int i = 0; i < m; i++)  

    {  

        scanf("%s%d%d", type, &X, &Y);  

        p = find(X);                //查找X和Y在数组中的位置  

        q = find(Y);  

        if(type[0] == 'A')  

        {  

            if(q > p)  

                shift_circular_left(p, q-1);  //A[p]到A[q-1]往左循环移动  

            else shift_circular_right(q, p);        //A[q]到A[p]往右循环移动  

        }  

        else  

        {  

            if(q > p)  

                shift_circular_left(p, q);   //A[p]到A[q]往左循环移动  

            else shift_circular_right(q+1, p);     //A[q+1]到A[p]往右循环移动  

        }  

    }  

    for(int i = 1; i <= n; i++)  

        printf("%d ", A[i]);  

    printf("\n");  

    return 0;  

}  

 

[b]对于上面的程序，当数据量很大时，代码是否会超时。一般来说，可以用两种方法判断：测试和分析。

计时测试的方法在前面已讲过，它的优点是原理简单、可操作性强，缺点在于必须事先程序写好——包括主程序和测试数据生成器。如果算法非常复杂，这是相当花时间的。

另一种方法是写程序之前进行算法分析，估算时间效率，这种方法在第8章会详细分析。不过现在可以直观分析一下：如果反复执行B 1 n和A 1 2，每次都移动几乎所有元素。元素个数和指令条数都那么大，移动总次数将是相当可观的。

2、链式结构

[cpp] view
plaincopyprint?

#include <stdio.h>  

#include<string.h>  

const int MAXN = 1000;  

int n, left[MAXN], right[MAXN];  

/*利用left数组和right数组*/  

/*分别代表元素X的左右数字*/  

void link(int X, int Y)  

{  

    right[X] = Y;  

    left[Y] = X;  

}  

//link函数实现了两元素的衔接  

int main()  

{  

    int m, X, Y;  

    char type[9];  

    scanf("%d%d", &n, &m);  

    memset(left,0,sizeof(left));  

    memset(right,0,sizeof(right));  

    for(int i = 0; i <= n; i++)  

    {  

        left[i] = i-1;  

        right[i] = i+1;  

    }  

    /*初始化：用left和right数组标记好元素X左右元素*/  

    for(int i = 0; i < m; i++)  

    {  

        scanf("%s%d%d",type, &X, &Y);  

        link(left[X], right[X]);//第一步：将X取出来  

        if(type[0] == 'A')  

        {  

            link(left[Y], X); //这一行和下一行不能搞反  

            link(X, Y);  

        }  

        else  

        {  

            link(X, right[Y]);   //这一行和下一行不能搞反  

            link(Y, X);  

        }  

    }  

    for(int w = right[0]; w != n+1; w = right[w])//right[w]：w后面的元素  

        //int a = right[0];  

        printf("%d ", w);  

    printf("\n");  

    return 0;  

}