解题笔记（10）——约瑟夫环问题

约瑟夫环问题的原来描述为，设有编号为1，2，……，n的n(n>0)个人围成一个圈，从第1个人开始报数，报到m时停止报数，报m的人出圈，再从他的下一个人起重新报数，报到m时停止报数，报m的出圈，……，如此下去，直到所有人全部出圈为止。当任意给定n和m后，设计算法求n个人出圈的次序。  稍微简化一下。

        问题描述：n个人（编号0~(n-1))，从0开始报数，报到(m-1)的退出，剩下的人继续从0开始报数。求胜利者的编号。 

        思路：容易想到的就是用环链表来做，构建一个环链表，每个结点的编号为0, 1, ...... n-1。每次从当前位置向前移动m-1步，然后删除这个结点。最后剩下的结点就是胜利者。给出两种方法实现，一种是自定义链表操作，另一种用是STL库的单链表。不难发现，用STL库可以提高编写速度。

[cpp]  view plain copy print ?

1. struct ListNode  
2. {  
3.     int num;        //编号  
4.     ListNode *next; //下一个  
5.     ListNode(int n = 0, ListNode *p = NULL)   
6.     { num = n; next = p;}  
7. };  
8.   
9. //自定义链表实现  
10. int JosephusProblem_Solution1(int n, int m)  
11. {  
12.     if(n < 1 || m < 1)  
13.         return -1;  
14.   
15.     ListNode *pHead = new ListNode(); //头结点  
16.     ListNode *pCurrentNode = pHead;   //当前结点  
17.     ListNode *pLastNode = NULL;       //前一个结点  
18.     unsigned i;  
19.   
20.     //构造环链表  
21.     for(i = 1; i < n; i++)  
22.     {  
23.         pCurrentNode->next = new ListNode(i);  
24.         pCurrentNode = pCurrentNode->next;  
25.     }  
26.     pCurrentNode->next = pHead;  
27.   
28.     //循环遍历  
29.     pLastNode = pCurrentNode;  
30.     pCurrentNode = pHead;  
31.   
32.     while(pCurrentNode->next != pCurrentNode)  
33.     {  
34.         //前进m - 1步  
35.         for(i = 0; i < m-1; i++)  
36.         {  
37.             pLastNode = pCurrentNode;  
38.             pCurrentNode = pCurrentNode->next;  
39.         }  
40.         //删除报到m - 1的数  
41.         pLastNode->next = pCurrentNode->next;  
42.         delete pCurrentNode;  
43.         pCurrentNode = pLastNode->next;  
44.     }  
45.     //释放空间  
46.     int result = pCurrentNode->num;  
47.     delete pCurrentNode;  
48.   
49.     return result;  
50. }  

[cpp]  view plain copy print ?

1. //使用标准库  
2. int JosephusProblem_Solution2(int n, int m)  
3. {  
4.     if(n < 1 || m < 1)  
5.         return -1;  
6.   
7.     list<int> listInt;  
8.     unsigned i;  
9.     //初始化链表  
10.     for(i = 0; i < n; i++)  
11.         listInt.push_back(i);  
12.   
13.     list<int>::iterator iterCurrent = listInt.begin();  
14.     while(listInt.size() > 1)  
15.     {  
16.         //前进m - 1步  
17.         for(i = 0; i < m-1; i++)  
18.         {  
19.             if(++iterCurrent == listInt.end())  
20.                 iterCurrent = listInt.begin();  
21.         }  
22.         //临时保存删除的结点  
23.         list<int>::iterator iterDel = iterCurrent;  
24.         if(++iterCurrent == listInt.end())  
25.             iterCurrent = listInt.begin();  
26.         //删除结点  
27.         listInt.erase(iterDel);  
28.     }  
29.   
30.     return *iterCurrent;  
31. }  

       上述方法的效率很低，其时间复杂度为O(mn)。当n和m很大时，很难在短时间内得出结果。不过好处就是可以给出n个人出圈的次序。只要在删除前保存一下即可。

       下面利用数学推导，如果能得出一个通式，就可以利用递归、循环等手段解决。下面给出推导的过程：

        （1）第一个被删除的数为 (m - 1) % n。

        （2）假设第二轮的开始数字为k，那么这n - 1个数构成的约瑟夫环为k, k + 1, k + 2, k +3, .....,k - 3, k - 2。做一个简单的映射。

             k         ----->  0 
             k+1    ------> 1 
             k+2    ------> 2 
               ... 
               ... 

             k-2    ------>  n-2 

        这是一个n -1个人的问题，如果能从n - 1个人问题的解推出 n 个人问题的解，从而得到一个递推公式，那么问题就解决了。假如我们已经知道了n -1个人时，最后胜利者的编号为x，利用映射关系逆推，就可以得出n个人时，胜利者的编号为 (x + k) % n。其中k等于m % n。代入(x + k) % n  <=>  (x + (m % n))%n <=> (x%n + (m%n)%n)%n <=> (x%n+m%n)%n <=> (x+m)%n

        （3）第二个被删除的数为(m - 1) % (n - 1)。

        （4）假设第三轮的开始数字为o，那么这n - 2个数构成的约瑟夫环为o, o + 1, o + 2,......o - 3, o - 2.。继续做映射。

             o         ----->  0 
             o+1    ------> 1 
             o+2    ------> 2 
               ... 
               ... 

             o-2     ------>  n-3 

         这是一个n - 2个人的问题。假设最后的胜利者为y，那么n -1个人时，胜利者为 (y + o) % (n -1 )，其中o等于m % (n -1 )。代入可得 (y+m) % (n-1)

         要得到n - 1个人问题的解，只需得到n - 2个人问题的解，倒推下去。只有一个人时，胜利者就是编号0。下面给出递推式：

          f [1] = 0; 
          f [ i ] = ( f [i -1] + m) % i; (i>1) 

        有了递推公式，实现就非常简单了，给出循环的两种实现方式。再次表明用标准库的便捷性。

[cpp]  view plain copy print ?

1. int JosephusProblem_Solution3(int n, int m)  
2. {  
3.     if(n < 1 || m < 1)  
4.         return -1;  
5.   
6.     int *f = new int[n+1];  
7.     f[0] = f[1] = 0;        //f[0]其实用不到的  
8.   
9.     for(unsigned i = 2; i <= n; i++)  
10.         f[i] = (f[i-1] + m) % i; //按递推公式进行计算  
11.   
12.     int result = f[n];  
13.     delete []f;  
14.   
15.     return result;  
16. }  

[cpp]  view plain copy print ?

1. int JosephusProblem_Solution4(int n, int m)  
2. {  
3.     if(n < 1 || m < 1)  
4.         return -1;  
5.   
6.     vector<int> f(n+1,0);  
7.     for(unsigned i = 2; i <= n; i++)  
8.         f[i] = (f[i-1] + m) % i;