问题描述

约瑟夫问题是一个经典的问题，我们不妨将这个经典问题进行扩展，变成一个双向的约瑟夫问题。

已知 n 个人（不妨分别以编号 1，2，3，…，n 代表）围坐在一张圆桌周围，首先从编号为 k 的人从 1 开始顺时针报数，1, 2, 3, …，记下顺时针数到 m 的那个人，同时从编号为 k 的人开始逆时针报数，1, 2, 3, …，数到 m 后，两个人同时出列。然后从出列的下一个人又从 1 开始继续进行双向报数，数到 m 的那两个人同时出列，…；。依此重复下去，直到圆桌周围的人全部出列。直到圆桌周围只剩一个人为止。

如果双向报数报到 m 时落在同一个人身上，那本次出列的只有一个人。

例如：5,1,2。则总共5个人，从1开始顺时针报数，数到2，定位编号2；同时从1开始报数数到2，定位编号5；2和5同时出列。然后继续开始报数，顺时针报数3,4，定位到4；逆时针报数4,3，定位3；4和3同时出列。最后剩余的为编号1。输出为：2-5,4-3,1,。

如果输入：6,2,3。则输出：4-6,2,1-3,5,。其中第2次只输出一个2，表示第二次双向报数时，恰好都落在编号2上，所以只有一个编号出列。

输入

输入：n, k, m

输出

输出：按照出列的顺序依次输出编号。同时出列编号中间用减号"-”连接。

非法的输入输出

a) 输入：n、k、m任一个小于1

输出：n,m,k must bigger than 0.

b)输入：k>n

输出：k should not bigger than n.

例:

输入：9,3,2

输出：4 6 8 1 3 7 2 9 5

样例

输入（1）

1,0,0

输出（1）

n,m,k must bigger than 0.

输入（2）

1,2,1

输出（2）

k should not bigger than n.

输入（3）

5,1,2

输出（3）

2-5,4-3,1,

输入（4）

6,2,3

输出（4）

4-6,2,1-3,5,

代码

#include<stdio.h>     
#include<stdlib.h>     
int main()     
{     
    int n,k,m;     
    scanf("%d,%d,%d",&n,&k,&m);     
    if (n<1||k<1||m<1)     
    {     
        printf("n,m,k must bigger than 0.\n");     
        return 0;     
    }     
    if (k>n)     
    {     
        printf("k should not bigger than n.\n");     
        return 0;     
    }     
    else     
    {     
        struct node     
        {     
            int id;     
            struct node *front;  
            struct node *back;     
        };     
        struct node *head,*p,*q,*tmp;     
        head=(struct node*)malloc(sizeof(struct node));     
        head->id=-1;     
        head->front=head;  
        head->back=head;     
        for (int i=n;i>=1;i--)     
        {     
            tmp=(struct node*)malloc(sizeof(struct node));     
            tmp->back=head->back;     
            head->back=tmp;     
            tmp->id=i;     
            if (tmp->id==k)     
            {     
              p=tmp;     
            }     
        }        
        while(tmp->back!=head)  
        {  
            q=tmp->back;  
            q->front=tmp;  
            tmp=tmp->back;  
        }  
        tmp->back=head->back;  
        q=head->back;  
        q->front=tmp;  
        struct node *p1,*p2;  
        p1=p;  
        p2=p;     
        for(int i=0;i<=n;)     
        {     
            for(int j=1;j<m;j++)     
            {     
               p1=p1->back;  
               p2=p2->front;   
            }     
            if(p1->id==p2->id)  
            {  
                printf("%d",p1->id);  
                i++;  
                if(i==n)  
                {  
                    printf(",\n");  
                    return 0;  
                }  
                else  
                {  
                    printf(",");  
                }  
                p1->front->back=p1->back;  
                p1->back->front=p1->front;  
                p2->front->back=p2->back;  
                p2->back->front=p2->front;  
                p1=p1->back;  
                p2=p2->front;  
            }  
            else  
            {  
                printf("%d-%d",p1->id,p2->id);  
                i++;  
                i++;                  
                if(i==n)  
                {  
                    printf(",\n");  
                    return 0;  
                }  
                else  
                {  
                    printf(",");  
                }  
                p1->front->back=p1->back;  
                p1->back->front=p1->front;  
                p2->front->back=p2->back;  
                p2->back->front=p2->front;  
                p1=p1->back;  
                p2=p2->front;  
            }  
      }        
    }     
  return 0;     
}