练习题 3.10 -- Josephus问题

这是一个Josephus问题
http://en.wikipedia.org/wiki/Josephus_problem上面有如下的说法。
There are n people standing in a circle waiting to be executed. After the first man is executed, k − 1 people are skipped and the k-th man is executed. Then again, k − 1 people are skipped and the k-th man is executed. The elimination proceeds around the circle (which is becoming smaller and smaller as the executed people are removed), until only the last man remains, who is given freedom.
The task is to choose the place in the initial circle so that you survive (are the last one remaining), given n and k.

翻成中文
http://zh.wikipedia.org/wiki/%E7%BA%A6%E7%91%9F%E5%A4%AB%E6%96%AF%E9%97%AE%E9%A2%98
有n个囚犯站成一个圆圈，准备处决。首先从一个人开始，越过k − 2个人，并杀掉第k个人。接着，再越过k − 1个人，并杀掉第k个人。这个过程沿着圆圈一直进行，直到最终只剩下一个人留下，这个人就可以继续活着。
问题是，给定了n和k，一开始要站在什么地方才能避免被处决？

对于k=2的情况，有下面这样的定理，具体的证明过程，参考wiki
定理： 如果n = 2^m + l 且 ，则f (n ) = 2l + 1 。

我用很笨拙的链表实现的一个

1. void  josephuse(list **p,  int  n,  int  k)
2. {
3.     list    *before, *next, *cur;
4.      int      counter;
6.     assert(NULL != p);
7.     assert(NULL != *p);
9.     before = cur = *p;
10.     k = k % n;
11.     counter = 0;
13.      while (cur) {
14.         counter++;
15.          if ( counter == k) {
16.             n--;
17.             counter = 0;
18.             printf( "deleting pos %d/n" , cur->pos);
19.             before->next = cur->next;
20.             free(cur);
21.             cur = before->next;
22.              if ( 1 == n)  break ;
23.              continue ;
24.         }
25.         before = cur;
26.         cur = cur->next;
27.     }
29.     printf( "last pos is %d/n" , before->pos);
30. }

全部的的程序

1. #include 
2. #include 
3. #include 
4. #include 
6. typedef   struct  list_t list;
7. struct  list_t {
8.      int      pos;
9.     list*   next;
10. };
12. void  josephuse(list **p,  int  n,  int  k)
13. {
14.     list    *before, *next, *cur;
15.      int      counter;
17.     assert(NULL != p);
18.     assert(NULL != *p);
20.     before = cur = *p;
21.     k = k % n;
22.     counter = 0;
24.      while (cur) {
25.         counter++;
26.          if ( counter == k) {
27.             n--;
28.             counter = 0;
29.             printf( "deleting pos %d/n" , cur->pos);
30.             before->next = cur->next;
31.             free(cur);
32.             cur = before->next;
33.              if ( 1 == n)  break ;
34.              continue ;
35.         }
36.         before = cur;
37.         cur = cur->next;
38.     }
40.     printf( "last pos is %d/n" , before->pos);
41. }
43. #define LEN     1000
44. #define KTH     2
45. int  main( void ) 
46. {
47.      int      i;
48.     list    *p,*tmp, *last;
50.      /* malloc head */
51.     p = (list*)malloc( sizeof (list));
52.      if (!p)  return  -1;
53.     p->pos = 0;
54.     p->next = NULL;
55.     last = p;
57.      /* alloc 9 more */
58.      for (i = 1; i < LEN; i++) {
59.         tmp = (list*)malloc( sizeof (list));
60.          /* take care the memory allocated are not freed by hand */
61.          if (!tmp)  return  -1;
62.         last->next = tmp;
63.         tmp->pos = i;
64.         tmp->next = NULL;
65.         last = tmp;
66.     }
68.     last->next = p;
70.     josephuse(&p, LEN, KTH);
72.      return  EXIT_SUCCESS;
73. }

验证
N     K     last
10    2     5 - 1   
1000  2     977 - 1
1000  3     604 - 1

找到了网上更好的算法如下2009/6/2

#include #include int King(int M, int N) { int i, k; for (i = 2; i <= M; i++) k = (k + N) % i; return ++k; } int main(void) { int m,n; printf("Inpurt two numbers: "); scanf("%d %d", &m, &n); printf("out of king is %d /n", King(m, n)); return 0; }