UVaOJ133---The Dole Queue

133 - The Dole Queue

Time limit: 3.000 seconds

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 
#include 
using namespace std;
struct Node
{
   Node *pred;
   int num;
   Node *rear;
};
int n, k, m;
int num_people;
Node *head;
Node *tail;
Node *official_1;
Node *official_2;
void MakeList()
{
   Node *p = new Node;
   head = p;
   for (int i = 0; i < n - 1; i ++)
   {
      p->num = i + 1;
      p->rear = new Node;
      p->rear->pred = p;
      p = p->rear;
   }
   tail = p;
   tail->num = n;
   tail->rear = head;
   head->pred = tail;
}
void Countoff(Node *&p, int num, bool is_reverse)
{
   while (num --)
   {
      p = is_reverse ? p->pred : p->rear;
   }
}
void Delete(Node *&p, bool is_reverse)
{
   p->pred->rear = p->rear;
   p->rear->pred = p->pred;

   if (is_reverse && official_2 == official_1)
   {
      official_1 = official_1->rear;
   }
   Node *temp = is_reverse ? p->pred : p->rear;
   delete p;
   p = temp;
}
int main()
{
    while(cin>>n>>k>>m)
    {
       if (!n && !k && !m)
       {
          break;
       }
       MakeList();
       official_1 = head;
       official_2 = tail;
       num_people = n;
       while (num_people)
       {
          Countoff(official_1, k - 1, false);
          Countoff(official_2, m - 1, true);
          if (official_1 != official_2)
          {
             printf("%3d%3d", official_1->num, official_2->num);
             if (num_people != 2)
             {
                cout<<",";
             }
             else
             {
                cout<num);
             if (num_people != 1)
             {
                cout<<",";
             }
             else
             {
                cout<pred;
             Delete(official_1, false);
             num_people --;
          }
       }
    }
    return 0;
}