uva 133 - The Dole Queue

The Dole Queue

In a serious attempt to downsize (reduce) the dole queue, The New National Green Labour Rhinoceros Party has decided on the following strategy. Every day all dole applicants will be placed in a large circle, facing inwards. Someone is arbitrarily chosen as number 1, and the rest are numbered counter-clockwise up to N (who will be standing on 1's left). Starting from 1 and moving counter-clockwise, one labour official counts off k applicants, while another official starts from N and moves clockwise, counting m applicants. The two who are chosen are then sent off for retraining; if both officials pick the same person she (he) is sent off to become a politician. Each official then starts counting again at the next available person and the process continues until no-one is left. Note that the two victims (sorry, trainees) leave the ring simultaneously, so it is possible for one official to count a person already selected by the other official.

Input

Write a program that will successively read in (in that order) the three numbers (N, k and m; k, m > 0, 0 < N < 20) and determine the order in which the applicants are sent off for retraining. Each set of three numbers will be on a separate line and the end of data will be signalled by three zeroes (0 0 0).

Output

For each triplet, output a single line of numbers specifying the order in which people are chosen. Each number should be in a field of 3 characters. For pairs of numbers list the person chosen by the counter-clockwise official first. Separate successive pairs (or singletons) by commas (but there should not be a trailing comma).

Sample input

10 4 3
0 0 0

Sample output

 4  8,  9  5,  3  1,  2  6,  10,  7

where  represents a space.

分析 ：

简单 模拟。要双向遍历，所以采用循环双向链表。

一点要注意的地方：当要删除的元素相邻时（且接下来要向相向运动），注意下一次运动起始点的确定。

代码 ：

#include 
typedef struct person person;
struct person{
    int num;
    int next;
    int prev;
};
person que[20];  // 声明数组，避免动态分配内存
int c, cs;      //  顺时针和逆时针遍历指针
void build_cycle(int n)      //创建循环链表
{
    int i;
    for(i = 0; i < n; i++){
        que[i].num = i+1;
        que[i].next = i+1;
        que[i].prev = i-1;
    }
    que[n-1].next = 0;
    que[0].prev = n-1;
}
int main()
{
    int n, k, m, i, t;
    while(scanf("%d %d %d", &n, &k, &m) != EOF &&
        (n != 0 || k != 0 || m != 0)){
        c  = n-1;
        cs = 0;
        build_cycle(n);
        t = n;        // 保存链表大小，即cycle中剩余人数
        while(t > 0){
            for(i = 0; i < k-1; i++)
                cs = que[cs].next;       //逆时针遍历
            for(i = 0; i < m-1; i++)
                c = que[c].prev;         //顺时针遍历
            printf("%3d", que[cs].num);
            if(c != cs)
                printf("%3d", que[c].num);    //如果一次运动后c和cs指示不同位置，输出另一个位置的数据。
            que[que[cs].prev].next = que[cs].next;  //删
            que[que[cs].next].prev = que[cs].prev;  //除
            que[que[c].prev].next = que[c].next;    //元
            que[que[c].next].prev = que[c].prev;    //素，如果c和cs相同，则这两个删除效果一样
            t--;                                    //元素个数减1
            if(c != cs)                             //如果c和cs指向的不是同一个元素，还要再减1个元素个数。
                t--;
            cs = que[cs].next;                      //cs移动到下一个位置
            if(c == cs){
                cs = que[cs].next;                  //如果c和cs相邻的话，cs要继续向后移动一个位置，才到达下一次遍历的起始位置。
            }
            c = que[c].prev;                        //c运动到下一次遍历的起始位置
            if(t != 0)
                printf(",");
        }
        printf("\n");
    }
    return 0;
}