约瑟夫环问题

约瑟夫环是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人開始报数，数到m的那个人出列；他的下一个人又从1開始报数，数到m的那个人又出列；依此规律反复下去，直到圆桌周围的人所有出列。

C代码例如以下（joseph.cpp）：

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>

typedef struct _node
{
  struct _node* next;
  int number;
}node,*linklist;

linklist create(int n);
void joseph(linklist head, int k, int m);

int main()
{
  linklist head;
  int m, n, k;
  printf("please input n:");
  scanf("%d",&n);
  printf("please input m:");
  scanf("%d",&m);
  printf("please input k:");
  scanf("%d",&k);
  head = create(n);
  printf("the sequences of leaving the list are:");
  joseph(head,k,m);
  return 0;
}
linklist create(int n)
{
  linklist head = (linklist)malloc(sizeof(node));
  node *tail;
  int i;
  head->next = head;
  head->number = 1;
  tail = head;
  for(i=2;i<=n;i++)
  {
    node *p = (node*)malloc(sizeof(node));
    p->number = i;
    p->next = tail->next;
    tail->next = p;
    tail = p;
  }
  return head;
}

void joseph(linklist head, int k, int m)
{
  int j;
  node *p;
  node *q;
  if(m == 1 && k == 1)
  {
    p = head;
    while(p->next != head)
    {
      printf("%d ",p->number);
      q = p->next;
      free(p);
      p = q;
    }
    printf("%d\n",p->number);
  }
  else if(m == 1 && k != 1)
  {
    p = head;
    for(j=1; j<k-1; j++)
      p = p->next;
    while(head->next != head)
    {
      q = p->next;
      p->next = q->next;
      printf("%d ",q->number);
      if(q == head)
        head = q->next;
      free(q);
    }
    printf("%d\n",head->number);
  }
  else
  {
    p = head;
    for(j=1; j<k; j++)
      p = p->next;
    while(head->next != head)
    {
      for(j=1; j<m-1; j++)
        p = p->next;
      q = p->next;
      p->next = q->next;
      printf("%d ",q->number);
      if(q == head)
        head = q->next;
      free(q);
      p = p->next;
    }
    printf("%d\n",head->number);
  }
}

须要特别注意m和k的值是否等于1。

几组測试用例结果例如以下：

1、m != 1，k != 1

2、m != 1，k == 1

3、m == 1，k != 1

4、m == 1，k == 1

上面程序中，之所以要分别讨论m==1和k==1的情况，是由于在单向循环链表中要想删除某一个结点，必须先找到该结点的前驱结点，然后更改相关指针域，使循环链表不断链，而m=1，k=1时，要想使循环链表不断链，必须先找到链表的尾结点，所以要分不同情况讨论。

鉴于此，想到使用双向循环链表，要想删除某一个结点，不须要找前驱结点，即使是删除第一个结点，也不须要找尾结点。

C代码例如以下所看到的（joseph2.cpp），能够看到代码逻辑简洁了不少：

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>

typedef struct _node
{
  struct _node* prev;
  struct _node* next;
  int number;
}node,*linklist;

linklist create(int n);
void joseph(linklist head, int k, int m);

int main()
{
  linklist head;
  int m, n, k;
  printf("please input n:");
  scanf("%d",&n);
  printf("please input m:");
  scanf("%d",&m);
  printf("please input k:");
  scanf("%d",&k);
  head = create(n);
  printf("the sequences of leaving the list are:");
  joseph(head,k,m);
  return 0;
}
linklist create(int n)
{
  linklist head = (linklist)malloc(sizeof(node));
  node *tail;
  int i;
  head->next = head;
  head->prev = head;
  head->number = 1;
  tail = head;
  for(i=2;i<=n;i++)
  {
    node *p = (node*)malloc(sizeof(node));
    p->number = i;
    p->next = tail->next;
    p->prev = tail;
    tail->next = p;
    tail = p;
    head->prev = tail;
  }
  return head;
}

void joseph(linklist head, int k, int m)
{
  int i;
  node *p;
  node *q;
  p = head;
  for(i=1; i<k; i++)//获取開始计数的结点
      p = p->next;
  while(head->next != head)
  {
    for(i=1; i<m; i++)
      p = p->next;//获取每轮计数的第m个结点，即待删除结点
    q = p->next;
    q->prev = p->prev;
    p->prev->next = q;
    printf("%d ",p->number);
    if(p == head)//假设删除的是第一个结点，则须要又一次设置head指针
      head = q;
    free(p);
    p = q;//删除一个结点之后，从该结点的下一个结点又一次開始计数
  }
  printf("%d\n",head->number);
}

能够得到与第一种代码同样的结果：

假设能使用C++标准库中的list来模拟循环链表，那么逻辑更清晰，代码更简洁。

C++代码例如以下（joseph3.cpp）：

#include<iostream>
#include<list>
using namespace std;

void joseph(int n, int m, int k);

int main()
{
  int n,m,k;
  cout<<"please input n:";
  cin>>n;
  cout<<"please input m:";
  cin>>m;
  cout<<"please inpur k:";
  cin>>k;
  cout<<"the sequences of leaving the list are:";
  joseph(n,m,k);
  return 0;
}

void joseph(int n, int m, int k)
{
  list<int> numbers;
  int i,j;
  for(i=1; i<=n; i++)
    numbers.push_back(i);
  list<int>::iterator current = numbers.begin();
  list<int>::iterator next;
  for(i=1; i<k; i++)
  {
    ++current;
    if(current == numbers.end())
      current = numbers.begin();
  }
  while(numbers.size()>1)
  {
    for(i=1; i<m; i++)
    {
      ++current;
      if(current == numbers.end())
        current = numbers.begin();
      /*
      因为list本身并非一个循环链表，所以每当到达
      最后一个元素的下一个位置时，须要改动迭代器指向第一个元素
      */
    }
    next = ++current;
    if(next == numbers.end())
      next = numbers.begin();
    --current;
    cout<<*current<<" ";
    numbers.erase(current);
    current = next;
  }
  cout<<*current<<endl;
}

能够得到与上面两种代码同样的结果。

上面编写的解约瑟夫环的程序模拟了整个报数的过程，程序执行时间还能够接受，非常快就能够出计算结果。但是，当參与的总人数n及出列值m非常大时，其运算速度就慢下来。比如，当n的值有上百万，m的值为几万时，到最后尽管仅仅剩2个人，也须要循环几万次（m的数量）才干确定2个人中下一个出列的序号。显然，在这个程序的执行过程中，非常多步骤都是进行反复没用的循环。那么，能不能设计出更有效率的程序呢？

在约瑟夫环中，假设仅仅是须要求出最后的一个出列者最初的序号，就没有必要去模拟整个报数的过程。因此，为了追求效率，能够考虑从数学角度进行推算，找出规律然后再编敲代码就可以。

为了讨论方便，先依据原意将问题用数学语言进行描写叙述。

问题：将编号为1～n这n个人进行圆形排列，按顺时针从1開始报数，报到m的人退出圆形队列，剩下的人继续从1開始报数，不断反复。求最后出列者最初在圆形队列中的编号。

以下首先列出0～n这n个人的原始编号例如以下：

1、2、3、……、m-2、m-1、m、m+1、m+2、……、n-2、n-1、n

第一个出列人的编号一定是m%n。比如，在41个人中，若报到3的人出列，则第一个出列人的编号一定是3%41=3，1人出列后的列表例如以下：

1、2、3、……、m-2、m-1、m+1、m+2、……、n-2、n-1、n

依据规则，当有人出列之后，下一个位置的人又从1開始报数，则以上列表可调整为下面形式（即以m+1位置開始，n之后再接上0、1、2……，形成环状）：

m+1、m+2、……、n-2、n-1、n、1、2、3、……、m-2、m-1

按上面排列的顺序又一次进行编号，可得到以下的相应关系：

1、       2、        3、   ……、n-2、n-1

m+1、m+2、m+3、……、m-2、m-1

即，将出列1人后的数据又一次组织成了1～n-1的列表，继续求n–1个參与人员，按报数到m即出列，求解最后一个出列者最初在圆形队列中的编号。

通过一次处理，将问题的规模缩小了。即，对于n个人报数的问题，能够分解为先求解（n–1）个人报数的子问题；而对于（n–1）个人报数的子问题，又可分解为先求[（n–1）–1]人个报数的子问题，……。

问题中的规模最小时是什么情况？就是仅仅有1个人时（n=1），报数到m的人出列，这时最后出列的是谁？当然仅仅有编号为1这个人。因此，可设有下面函数：

F（1）= 1

那么，当n=2，报数到m的人出列，最后出列的人是谁？应该是仅仅有一个人报数时得到的最后出列的序号加上m+1（由于已经有1个人出了队列，求F（n）时由于已经有n-1个人出了队列，所以须要加上n-1），可用公式表示为下面形式：

F（2）= F（1）+ m + 1

通过上面的算式计算时，F(2)的结果可能会超过n值（人数的总数）。比如，设n=2，m=3（即2个人，报数到3时就出列），则按上式计算得到的值是：

F（2）= F（1）+ 3 + 1 = 1 + 3 + 1 = 5

一共仅仅有2人參与，编号为5的人显然没有。怎么办？由于是环状报数，因此当两个人报完数之后，又从编号为1的人開始接着报数。依据这个原理，就可以对求得的值与总人数n进行模运算，然后再加上1，由于不是从0開始计数的，即：

F（2）= [F（1）+ m + 1] % n + 1 = [1 + 3 + 1]%2 + 1 = 2

即，n=2，m=3（即有2个人，报数到3的人出列）时，循环报数最后一个出列的人的编号为2（编号从1開始）。

依据上面的推导过程，能够非常easy推导出，当n=3时的公式：

F（3）= [F（2）+ m + 2]%3 + 1

同理，也能够推导出參与人数为N时，最后出列人员编号的公式：

F（n）= [F（n-1）+ m + n - 1]%n + 1

事实上，这就是一个递推公式，公式包括下面两个式子：

F（1）= 1；                                                     n=1

F（n）= [F（n-1）+ m + n - 1]%n + 1；     n>1 

有了这个递推公式，再来设计程序就非常easy了。

使用递归方式的代码例如以下（joseph4.cpp）：

#include<stdio.h>
#include<stdlib.h>

int joseph(int n, int m);

int main()
{
  int n,m;
  printf("please input n:");
  scanf("%d",&n);
  printf("please input m:");
  scanf("%d",&m);
  printf("the last number is: %d\n", joseph(n,m));
  return 0;
}

int joseph(int n, int m)
{
  if(n == 1)
    return 1;
  else
    return (joseph(n-1,m)+m+n-1)%n + 1;
}

几组測试用例结果例如以下：

使用递归函数会占用计算机较多的内存，当递归层次太深时可能导致程序不能运行，因此，也能够将程序直接编写为下面的迭代形式。

joseph5.cpp：

#include<stdio.h>
#include<stdlib.h>

int joseph(int n, int m);

int main()
{
  int n,m;
  printf("please input n:");
  scanf("%d",&n);
  printf("please input m:");
  scanf("%d",&m);
  printf("the last number is: %d\n", joseph(n,m));
  return 0;
}

int joseph(int n, int m)
{
  int last = 1;//相当于F（1）
  int i;
  for(i=2; i<=n; i++)//一步一步求F（2）到F（n）
    last = (last + m + i - 1)%i + 1;
  return last;
}

也能够得到与上面同样的结果。