0047:约瑟夫问题
总时间限制:
1000ms
内存限制:
65536kB
描述
约瑟夫问题：有ｎ只猴子，按顺时针方向围成一圈选大王（编号从１到ｎ），从第１号开始报数，一直数到ｍ，数到ｍ的猴子退出圈外，剩下的猴子再接着从1开始报数。就这样，直到圈内只剩下一只猴子时，这个猴子就是猴王，编程求输入ｎ，ｍ后，输出最后猴王的编号。
输入
每行是用空格分开的两个整数，第一个是 n, 第二个是 m ( 0 < m,n <=300)。最后一行是：
0 0
输出
对于每行输入数据（最后一行除外)，输出数据也是一行，即最后猴王的编号
样例输入
6 2
12 4
8 3
0 0样例输出
5
1
7全局题号
1748
添加于
2018-07-09
提交次数
10
尝试人数
6
通过人数
6
Other language verions
//普通数组实现链表
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner cin=new Scanner(System.in);
while(true)
{
int n=cin.nextInt();
int m=cin.nextInt();
if(n==0&&m==0)break;
int [] a=new int[n+1];
int p=0,ans=1,j;//p记录总共选出来来了多少数，ans记录是否到m
for(int i=1;i<n;i++)
a[i]=i+1;//建立链表
a[n]=1;
j=n;//现在a[n]=1
while(p<n)
{
while(ans<m)
{
j=a[j];
ans++;
}
if(p==n-1)
System.out.println(a[j]);
p++;
a[j]=a[a[j]];
ans=1;//计数器置1
}
}
}
}
//模拟
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner cin=new Scanner(System.in);
while(true)
{
LinkedList<Integer> l= new LinkedList<>();
int n=cin.nextInt();
int m=cin.nextInt();
if(n==0&&m==0)break;
for(int i=1;i<=n;i++)
{
l.add(i);
}
int pos=0;
m--; //当前人也要报名
while(l.size()>0)
{
if(l.size()==1)
{
System.out.println(l.getFirst());
break;
}
pos+=m;
pos=pos%l.size();
l.remove(l.get(pos));
}
}
}
}//list实现链表
import java.util.Arrays;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main {
private static int lastone2(int n,int k) {
List<Integer> list=new ArrayList<Integer>(n);
for(int i=0;i<n;i++)
list.add(i+1);
while(list.size()>1)
{
for(int i=0;i<k-1;i++)
{
list.add(list.remove(0));//头元素挪动到结尾处
}
list.remove(0);
}
return list.get(0);
}
public static void main(String[] args) {
Scanner oin=new Scanner(System.in);
while(oin.hasNext())
{
int n=oin.nextInt();
int k=oin.nextInt();
if(n==0&&k==0) break;
System.out.println(lastone2(n, k));
}
}
}https://cn.vjudge.net/problem/HihoCoder-1296
提示：约瑟夫问题
小Hi：这个问题其实还蛮有名的，它被称为约瑟夫的问题。
最直观的解法是用循环链表模拟报数、淘汰的过程，复杂度是O(NM)。
今天我们来学习两种更高效的算法，一种是递推，另一种也是递推。第一种递推的公式为：
令f[n]表示当有n个候选人时，最后当选者的编号。
f[1] = 0
f[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] = 0
For i = 2 .. N
f[i] = (f[i - 1] + K) mod i
End For
Return f[N]
同时由于计算f[i]时，只会用到f[i-1]，因此我们还可以将f[]的空间节约，改进后的代码为：
Josephus(N, K):
ret = 0
For i = 2 .. N
ret = (ret + K) mod i
End For
Return 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 + N
2) 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) Then
Return 0
End If
If (N < K) Then
ret = 0
For i = 2 .. N
ret = (ret + K) mod i
End For
Return ret
End If
ret = Josephus(N - N / K, K);
If (ret < N mod K) Then
ret = ret - N mod K + N
Else
ret = ret - N mod K + (ret - N mod K) / (K - 1)
End If
Return ret
改进后的算法可以很快将N的规模减小到K，对于K不是很大的问题能够快速求解。