C语言用数组1. 简单约瑟夫环问题： N个人，编号从1~N围成一圈，输入一个数T，从1号开始报数，报到T的人出圈；下一人又从1开始报数，下一个报到T的人出圈，输出出圈顺序。 考虑问实现约瑟夫环问题

1. 简单约瑟夫环问题：

N个人，编号从1~N围成一圈，输入一个数T，从1号开始报数，报到T的人出圈；下一人又从1开始报数，下一个报到T的人出圈，输出出圈顺序。

考虑问题：

报到T的人出圈，怎么表示出圈？要么删除对应的标号，其他的标号前移（如果是数组结构，要依次移动元素，效率低；如果是链表，删除结点也比较麻烦）；要么设定状态标志位（声明一个状态数组status[N]，status[i] ==0时表示未出圈，出圈时将对应第i号人的status置为出圈的次数；即status[i]=count）

解决了表示出圈的问题，那如何出圈？如果报数T大于总人数N时，需要取余才能将报号的范围限制在标号为0~N-1中。

流程呢？

while（出圈人数<总人数)

{

        从start下标依次查找status为0的下标（需要保存start下标）

                     计数

                判断计数是否等于T

              若计数等于T

                         出圈，更新对应下标的status，出圈人数加1

}

[cpp]  view plain  copy

1. void joseph()  
2. {  
3.     int T,N;  
4.     scanf("%d%d",&T,&N);  
5.     //T为出列周期，N为N个人，即环的元素个数  
6.     int status[1000];  
7.     memset(status,0,sizeof(status));  
8.     int start,end;  
9.     start = -1;  
10.     int count = 0;  
11.       
12.     while(count<N)  
13.     {  
14.         int i=0;  
15.         while(1)  
16.         {  
17.               
18.             start = (start+1) % N;  
19.             if(status[start] == 0)  
20.             {  
21.                 i++;  
22.             }  
23.             if(i == T)  
24.             {  
25.                   
26.                 ++count;  
27.                 status[start]=count;  
28.                   
29.                 break;  
30.             }  
31.         }  
32.           
33.     }  
34.       
35.     for(int k=0;k<N;k++)  
36.         printf("%d",status[k]);  
37.       
38. }  

2. 复杂约瑟夫环

1~N个人构成一圈，每个人手中有个号码，读入一个数T，从第一个人开始报数，报到T的人出圈；下一个人接着从1报数，报到出圈人手里的号码的人出圈，依次进行。

与简单约瑟夫环不同的是T变了；每出圈一个，要更新对应的T；

[cpp]  view plain  copy

1. void rand_joseph()  
2. {  
3.     //如果约瑟夫环中的数是用户输入的数据时  
4.     int N,data[1000],status[1000];  
5.     memset(data,0,sizeof(data));  
6.     memset(status,0,sizeof(status));  
7.     int i=0;  
8.     scanf("%d",&N);  
9.     while(i<N)  
10.     {  
11.         scanf("%d",&data[i]);  
12.         i++;  
13.     }  
14.     int T;  
15.     scanf("%d",&T);//第一个周期由用户输入，其他的是出队用户对应的值  
16.     int count = 0;  
17.     int index = -1;  
18.     while(count<N)  
19.     {  
20.         int i=0;  
21.         while(1)  
22.         {  
23.             index = (index+1)%N;  
24.             if(status[index] == 0 )  
25.             {  
26.                 i++;  
27.             }  
28.             if(i == T)  
29.             {  
30.                 ++count;  
31.                 status[index] = count;  
32.                 T = data[index];  
33.                 break;  
34.             }  
35.         }  
36.     }  
37.     for(int i=1;i<=N;i++)  
38.     {  
39.         for(int j=0;j<N;j++)  
40.         if(status[j] == i)  
41.             printf("第%d个出列的是第%d人\n",i,j+1);  
42.     }  
43.   
44. }  

3. 如果要求最后出圈的人的编号，还有简单的方法：

引用：http://www.cnblogs.com/EricYang/archive/2009/09/04/1560478.html

无论是用链表实现还是用数组实现都有一个共同点：要模拟整个游戏过程，不仅程序写起来比较烦，而且时间复杂度高达O(nm)，当n，m非常大(例如上百万，上千万)的时候，几乎是没有办法在短时间内出结果的。我们注意到原问题仅仅是要求出最后的胜利者的序号，而不是要读者模拟整个过程。因此如果要追求效率，就要打破常规，实施一点数学策略。

为了讨论方便，先把问题稍微改变一下，并不影响原意：
问题描述：n个人（编号0~(n-1))，从0开始报数，报到(m-1)的退出，剩下的人继续从0开始报数。求胜利者的编号。

我们知道第一个人(编号一定是m%n-1) 出列之后，剩下的n-1个人组成了一个新的约瑟夫环（以编号为k=m%n的人开始）:
  k  k+1  k+2  ... n-2, n-1, 0, 1, 2, ... k-2并且从k开始报0。
现在我们把他们的编号做一下转换：

k     --> 0
k+1   --> 1
k+2   --> 2
...
...
k-2   --> n-2
k-1   --> n-1
变换后就完完全全成为了(n-1)个人报数的子问题，假如我们知道这个子问题的解：例如x是最终的胜利者，那么根据上面这个表把这个x变回去不刚好就是n个人情况的解吗？！！变回去的公式很简单，相信大家都可以推出来：x'=(x+k)%n

如何知道(n-1)个人报数的问题的解？对，只要知道(n-2)个人的解就行了。(n-2)个人的解呢？当然是先求(n-3)的情况 ---- 这显然就是一个倒推问题！好了，思路出来了，下面写递推公式：

令f[i]表示i个人玩游戏报m退出最后胜利者的编号，最后的结果自然是f[n]

递推公式
f[1]=0;
f[i]=(f[i-1]+m)%i;  (i>1)

有了这个公式，我们要做的就是从1-n顺序算出f[i]的数值，最后结果是f[n]。因为实际生活中编号总是从1开始，我们输出f[n]+1
由于是逐级递推，不需要保存每个f[i]，程序也是异常简单：

[cpp]  view plain  copy

1. #include <stdio.h>  
2. int main()  
3. {  
4.     int n, m, i, s = 0;  
5.     printf ("N M = ");  
6.     scanf("%d%d", &n, &m);  
7.     for (i = 2; i <= n; i++)  
8.     {  
9.         s = (s + m) % i;  
10.     }  
11.     printf ("\nThe winner is %d\n", s+1);  
12. }