约瑟夫环问题

约瑟夫环问题（基本）

n个人围成圈，依次编号为1,2,..,n，现在从1号开始依次报数，当报到m时，报m的人退出，下一个人重新从1报起，循环下去，问最后剩下那个人的编号是多少？

递归法

参见百度百科：Josephus(约瑟夫)问题的数学方法

递推式：

            

将这些人的编号用对总人数取模所得余数代替（即原编号减一），其中 Fn 表示n个人的环，最后剩下的那个人的编号。

由这个递推式不难写出相应代码：

/* 约瑟夫环问题 */# include <stdio.h>int main(){    int m, n, i, s;     while (~scanf("%d%d", &m, &n))    {        s = 0;                               // F1 = 0;        for (i = 2; i <= n; ++i)            s = (s + m) % i;          // 注意这个地方是 %i，因为递推的过程是由1->2->3->...->n，人数n逐渐增大的过程，所以f[i]表示i个人的问题        printf("%d\n", s+1);       // 原问题的编号是从1开始的    }     return 0;}//上述代码的复杂度为O(n)。

模拟法

采用循环链表进行模拟题目描述的过程，退出通过删除节点表示；
使用链表模拟时，维护一个充当报数角色的变量 i ，每当 i 等于 m 时，重置 i 为 1；
循环终止的条件是只剩余一个节点（p->next = p），或者已经删除了 n-1 个节点；
由于每次删除一个节点需要报够 m 次数（遍历 m 个节点），一共要删除 n-1 个数，所以链表模拟的复杂度O(m*n)。

/* 约瑟夫环问题——链表模拟*/# include <stdio.h># include <stdlib.h> typedef struct node{    int id;    struct node* next;} node; int main(){    int m, n, i;    node *p, *q, *head;     while (~scanf("%d%d", &m, &n))    {        // 创建含 n 个节点的循环链表，初始化编号        head = (node *)malloc(sizeof(node));        head->id = 1;        q = head;        for (i = 2; i <= n; ++i)        {            p = (node *)malloc(sizeof(node));            p->id = i;            q->next = p;            q = p;        }        q->next = head;         // 模拟退出过程         i = 1;        p = head;        while (p->next != p)        {            q = p;            p = p->next;            ++i;            if (i == m)         //delete(p); i = 1;   这个算法没有考虑到m可能等于1的情况下面的算法每次寻找待删除节点的前驱，则解决了m为1情况。            {                q->next = p->next;                free(p);                p = q->next;                i = 1;            }        }         // 打印剩余节点的编号        printf("%d\n", p->id);       free(p);    }     return 0;}

扩展
当最先报数的那个人编号不是 1 时，对于递归法，需要对结果进行调整，对于链表只需要将循环起点的 head 改成相应编号的指针；
当报数前去掉一个编号为 k 的人，并从 k+1 开始报数时，可以认为从某个人报起，到编号为 k 时，刚好为 m ，因此去掉了这个人，这样对应上述递归方法的结果为：(s+1) + (m-k)，并将这个结果的范围调整到 [1, n] 内。

从0开始编号的约瑟夫问题(每次寻找待删除节点的前驱)

#include<cstdio>/*N个候选人围成一个圈，依次编号为0..N-1。然后随机抽选一个数K，并0号候选人开始按从1到K的顺序依次报数，N-1号候选人报数之后，又再次从0开始。当有人报到K时，这个人被淘汰，从圈里出去。下一个人从1开始重新报数。也就是说每报K个数字，都会淘汰一人。这样经过N-1轮报数之后，圈内就只剩下1个人了，这个人就作为新的班长。*/struct Node{int sno;Node *next;};int N,K;int main(){int T;scanf("%d",&T);while(T>0){--T;scanf("%d%d",&N,&K);Node *head=NULL;Node *List=new Node;List->sno=0,List->next=NULL;head=List;for(int i=1;i<N-1;++i){Node *p=new Node;p->sno=i,p->next=NULL;List->next=p;List=List->next;}Node *p=new Node;         // 建立循环链表p->sno=N-1,p->next=head;List->next=p;List=List->next;          // List指向循环链表的末尾int cnt=1;/*while(cnt<=N){printf("%d\n",List->sno); cnt++ ; List=List->next;}*/while(cnt<N){for(int t=1;t<K;t++)   // 始终保持 List 指向待删除节点的前一个位置{List=List->next;}Node *cur=List->next;   // cur 是报数到 K 要删除的节点Node *tmp=cur->next;List->next=tmp;         //将List 与被删除节点 cur 后段部分连接起来delete cur;cnt++;}printf("%d\n",List->sno);}return 0;}

两类递推思想解决约瑟夫环的问题

小Hi和小Ho的班级正在进行班长的选举，他们决定通过一种特殊的方式来选择班长。

首先N个候选人围成一个圈，依次编号为0..N-1。然后随机抽选一个数K，并0号候选人开始按从1到K的顺序依次报数，N-1号候选人报数之后，又再次从0开始。当有人报到K时，这个人被淘汰，从圈里出去。下一个人从1开始重新报数。

也就是说每报K个数字，都会淘汰一人。这样经过N-1轮报数之后，圈内就只剩下1个人了，这个人就作为新的班长。

举个例子，假如有5个候选人，K=3，最后当选的人编号是3：

小Hi：这个问题其实还蛮有名的，它被称为约瑟夫的问题。

最直观的解法是用循环链表模拟报数、淘汰的过程，复杂度是O(NM)。

今天我们来学习两种更高效的算法，一种是递推，另一种也是递推。第一种递推的公式为：

令f[n]表示当有n个候选人时，最后当选者的编号。f[1] = 0f[n] = (f[n - 1] + K) mod n

接下来我们用数学归纳法来证明这个递推公式的正确性：

(1) f[1] = 0

显然当只有1个候选人时，该候选人就是当选者，并且他的编号为0。

(2) f[n] = (f[n - 1] + K) mod n

假设我们已经求解出了f[n - 1]，并且保证f[n - 1]的值是正确的。

现在先将n个人按照编号进行排序：

0 1 2 3 ... n-1

那么第一次被淘汰的人编号一定是K-1(假设K < n，若K > n则为(K-1) mod n)。将被选中的人标记为"#"：

0 1 2 3 ... K-2 # K K+1 K+2 ... n-1

第二轮报数时，起点为K这个候选人。并且只剩下n-1个选手。假如此时把k+1看作0'，k+2看作1'...

则对应有：

 0   1 2 3 ... K-2  # K  K+1 K+2 ... n-1 n-K'          n-2'   0'  1'  2' ... n-K-1'

此时在0',1',...,n-2'上再进行一次K报数的选择。而f[n-1]的值已经求得，因此我们可以直接求得当选者的编号s'。

但是，该编号s'是在n-1个候选人报数时的编号，并不等于n个人时的编号，所以我们还需要将s'转换为对应的s。

通过观察，s和s'编号相对偏移了K，又因为是在环中，因此得到s = (s'+K) mod n。

即f[n] = (f[n-1] + k) mod n。

至此递推公式的两个式子我们均证明了其正确性，则对于任意给定的n，我们可以使用该递推式求得f[n]，写成伪代码为：

Josephus(N, K):f[1] = 0For i = 2 .. Nf[i] = (f[i - 1] + K) mod iEnd ForReturn f[N]

同时由于计算f[i]时，只会用到f[i-1]，因此我们还可以将f[]的空间节约，改进后的代码为：

Josephus(N, K):ret = 0For i = 2 .. Nret = (ret + K) mod iEnd ForReturn ret

该算法的时间复杂度为O(N)，空间复杂度为O(1)。对于N不是很大的数据来说，可以解决。

小Ho：要是N特别大呢？

小Hi：那么我们就可以用第二种递推，解决的思路仍然和上面相同，而区别在于我们每次减少的N的规模不再是1。

同样用一个例子来说明，初始N=10,K=4:

初始序列：

0 1 2 3 4 5 6 7 8 9

当7号进行过报数之后：

0 1 2 - 4 5 6 - 8 9

在这里一轮报数当中，有两名候选人退出了。而对于任意一个N,K来说，退出的候选人数量为N/K("/"运算表示整除，即带余除法取商)

由于此时起点为8，则等价于：

2 3 4 - 5 6 7 - 0 1

因此我们仍然可以从f[8]的结果来推导出f[10]的结果。

但需要注意的是，此时f[10]的结果并不一定直接等于(f[8] + 8) mod 10。

若f[8]=2，对于原来的序列来说对应了0，(2+8) mod 10 = 0，是对应的；若f[8]=6，则有(6+8) mod 10 = 4，然而实际

上应该对应的编号为5。

这是因为在序列(2 3 4 - 5 6 7 - 0 1)中，数字并不是连续的。

因此我们需要根据f[8]的值进行分类讨论。假设f[8]=s，则根据s和N mod K的大小关系有两种情况：

1) s < N mod K : s' = s - N mod K + N2) s ≥ N mod K : s' = s - N mod K + (s - N mod K) / (K - 1)

此外还有一个问题，由于我们不断的在减小N的规模，最后一定会将N减少到小于K，此时N/K=0。

因此当N小于K时，就只能采用第一种递推的算法来计算了。

最后优化方法的伪代码为：

Josephus(N, K):If (N == 1) ThenReturn 0End IfIf (N < K) Thenret = 0For i = 2 .. Nret = (ret + K) mod iEnd ForReturn retEnd If ret = Josephus(N - N / K, K);If (ret < N mod K) Then ret = ret - N mod K + NElseret = ret - N mod K + (ret - N mod K) / (K - 1)End IfReturn ret

改进后的算法可以很快将N的规模减小到K，对于K不是很大的问题能够快速求解。

#include<iostream>using namespace std;/*用一个例子来说明，初始N=10,K=4:初始序列：0 1 2 3 4 5 6 7 8 9当7号进行过报数之后：0 1 2 - 4 5 6 - 8 9    在一轮报数当中，而对于任意一个N,K来说，退出的候选人数量为N/K("/"运算表示整除，即带余除法取商）    因此我们仍然可以从f[8]的结果来推导出f[10]的结果。但需要注意的是，此时f[10]的结果并不一定直接等于(f[8] + 8) mod 10。若f[8]=2，对于原来的序列来说对应了0，(2+8) mod 10 = 0，是对应的；若f[8]=6，则有(6+8) mod 10 = 4，然而实际上应该对应的编号为5。这是因为在序列(2 3 4 - 5 6 7 - 0 1)中，数字并不是连续的。因此我们需要根据f[8]的值进行分类讨论。假设f[8]=s，则根据s和N mod K的大小关系有两种情况：1) s < N mod K : s' = s - N mod K + N2) s ≥ N mod K : s' = s - N mod K + (s - N mod K) / (K - 1)此外还有一个问题，由于我们不断的在减小N的规模，最后一定会将N减少到小于K，此时N/K=0。因此当N小于K时，就只能采用第一种递推的算法来计算了。*///改进后的算法可以很快将N的规模减小到K，对于K不是很大的问题能够快速求解。int Josephu(int n,int k){if(n<=1){return 0;}if(n<k){int ret=0;for(int i=2;i<=n;++i){// 注意这个地方是 %i，因为递推的过程是由1->2->3->...->n，人数n逐渐增大的过程，f[i]表示i个人的问题ret=(ret+k)%i;}return ret;}int ret=Josephu(n-n/k,k);if(ret<(n%k)) ret=ret-n%k+n;else          ret=ret-n%k+(ret-n%k)/(k-1);return ret;}int main(){int T;cin>>T;while(T>0){T--;int N,K;cin>>N>>K;cout<<Josephu(N,K)<<endl;}return 0;}