约瑟夫问题:经典算法
已知n个人(以编号1,2,3…n分别表示)围坐在一张圆桌周围。从编号为k的人开始报数,数到m的那个人出列;他的下一个人又从1开始报数,数到m的那个人又出列;依此规律重复下去,直到圆桌周围的人全部出列。
例如:n = 9, k = 1, m = 5
【解答】出局人的顺序为5, 1, 7, 4, 3, 6, 9, 2, 8。
/*************************************************
//约瑟夫环,时间复杂度O(n*m)
**************************************************/
# include <iostream>
using namespace std;
int main()
{
int n=10, m=2,k=1;//n是人数(编号1,2,……,x),m是出列号,k是起始人编号,在这里定义为1,因为都是从第一个人开始
int a[10000];
while(cin>>n)
{
if(n==0) break;
cin>>m;
//number是已经出列的人数,j用来是报数值即j=1,2···m
int j=0, number=0;
for (int i=1;i<=n;i++)
{
a[i]=1;
}
while (number<n)
{
for (int i=1;i<=n;i++)
{
if (a[i]==1)
{
j++;
if (j==m) //满足出列号
{
a[i]=0;
//格式输出
if (number<n-1)
{
cout<<i<<",";
}
else
cout<<i<<endl;
j=0;
number++;
}
}
}//end for i
}//end while
}//end while cin
}
代码出自:http://blog.csdn.net/iamyina/article/details/4126054
还有一种使用循环链表模拟执行流程的解法,请参考:http://blog.csdn.net/eagleest/article/details/8091351
约瑟夫问题:数学推理
本文地址:http://hi.baidu.com/anywei/item/294351b5f432f144ba0e12f2
约瑟夫环是一个数学的应用问题:已知n个人(以编号1,2,3…n分别表示)围坐在一张圆桌周围;从编号为k的人开始报数,数到m的那个人出列;他的下一个人又从1开始报数,数到m的那个人又出列;依此规律重复下去,直到圆桌周围的人全部出列。
前几天,在一篇文章中得知了约瑟夫环的问题。然后,就涉及了解决办法。这个问题,在许多计算机或者关于数据结构的书中都有提及,而其中的解决办法便是使用循环链表——无论这个循环链表是使用指针还是数组实现,模拟约瑟夫环的进行,最后得到解决方案。具体方法肯定早有某人披露。但是,令人深感奇妙的还是这个问题的数学解决。在不统计解决过程,即不统计每次都需要出列哪个序号时,就可以应用数学递推公式,直接得出最后剩下的那个人的序号。
使用数学方式,奇妙是很奇妙,也确实让人感受到数学的魅力。可是,在我查找如何推导出这个公式的时候,网上的解决方案都是在我觉得很关键的地方一笔带过。“众所周知”,“显而易见”,“很简单的”……诸如此类。我悲剧的郁闷了。所以在大家都陶醉在“数学真奇妙啊”的飘飘然中时,我惴惴不安。因为我只感受到了数学带给我的困惑。
对着网上的推导思考良久,终于茅塞顿开。所以赶紧写下来,以防以后再次悲剧和郁闷。并且希望以后看到这篇文章的人,能和我一样摆脱困惑。
先总结一下约瑟夫环的递推公式:
f[1]=0; f[i]=(f[i-1]+m)%i; (i>1)
f[1]=1; f[i]=(f[i-1]+m)%i (i>1); if(f[i]==0) f[i]=i;
P(1, m, k)=1 (i = 1); P(i, m, k)=[P(i - 1, m, k ) + m - 1] % i + 1 (i > 1, 此处先减1是为了让模i的值不为0)
那么这三个公式有什么不同?
首先可以肯定的是这三个公式都正确。公式1,得到的是以0~n-1标注的最终序号;公式2,3得到的就是正常的1~n的序号;并且公式2和公式3其实是一个意思。下面我们就分别推导三个公式,并且推导的过程中,你也就能明白这三个公式的共同点和不同点。
公式1的推导:——————————
给出一个序列,从0~n-1编号。其中,k代表出列的序号的下一个,即k-1出列。
a 0, 1, …, k-1, k, k+1, …, n-1
那么,出列的序号是(m-1)%n,k=m%n(这个可真的是显而易见)。出列k-1后,序列变为
b 0, 1, …, k-2, k, k+1, …, n-1
然后,我们继续从n-1后延长这个序列,可以得到
c` 0, 1, …, k-2, k, k+1, …, n-1, n, n+1, …, n+k-2
我们取从k开始直到n+k-2这段序列。其实这段序列可以看作将序列b的0~k-2段移到了b序列的后面。这样,得到一个新的序列
c k, k+1, …, n-1, n, n+1, …, n+k-2
好了,整个序列c都减除一个k,得到
d 0, 1, …, n-2
c序列中的n-1, n, n+1都减除个k是什么?这个不需要关心,反正c序列是连续的,我们知道了头和尾,就能知道d序列是什么样的。
这样你看,从序列a到序列d,就是一个n序列到n-1序列的变化,约瑟夫环可以通过递推来获得最终结果。ok,继续向下。
剩下的就是根据n-1序列递推到n序列。假设在n-1序列中,也就是序列d中,我们知道了最终剩下的一个序号是x,那么如果知道了x转换到序列a中的编号x`,不就是知道了最终的结果了么?
下面我们就开始推导出序列a中x的序号是什么。
d->c,这个变换很容易,就是x+k;
c->b,这个变换是网上大家都一带而过的,也是令我郁闷的一个关键点。从b->c,其实就是0~k-2这段序列转换为n~n+k-2这段序列,那么再翻转回去,简单的就是%n,即(x+k)%n。%n以后,k~n-1这段序列值不会发生变化,而n~n+k-2这段序列则变成了0~k-2;这两段序列合起来,就是序列b。
于是乎,我们就知道了,x=(x+k)%n。并且,k=m%n,所以x
=(x+m%n)%n=(x+m)%n。公式1就出来了:f[i]=(f[i-1]+m)%i。当然,i=1就是特殊情况了,f[1]=0。这里还有一个小问题。也许你会迷惑为什么x`=(x+m%n)%n=(x+m)%n中的%n变成公式中f[i]=(f[i-1]+m)%i中的%i?其实这个稍微想想就能明了。我们%n就是为了从序列c转换到序列b——这是在n-1序列转换成n序列时%n;那么从n-2转换到n-1呢?不是要%(n-1)了吗?所以这个值是变量,不是常量。
好了,这个最后需要注意的就是从一开始,我们将n序列从0~n-1编号,所以依据公式1得出的序号是基于0开始的
这样子就有了约瑟夫环的变形:就是一共n个人,查到m的人出圈,求最后圈里的人是几号。
int fun(int n, int m)
{
int i, r = 0;
for (i = 2; i <= n; i++)
r = (r + m) % i;
return r+1;
}
这个算法的时间复杂度为O(n),相对于模拟算法已经有了很大的提高。算n,m等于一百万,一千万的情况不是问题了。可见,适当地运用数学策略,不仅可以让编程变得简单,而且往往会成倍地提高算法执行效率。
约瑟夫问题:线段树
本段出自:http://blog.csdn.net/acceptedxukai/article/details/6926431,原文解释更加详细,推荐阅读
设计一个算法,时间复杂度要求O(nlogn)时间,使给定的整数n和m,输出(n,m)-Josephus排列。
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <set>
#include <map>
#include <vector>
#include <queue>
#include <ctime>
using namespace std;
#define LL long long
const int N = 10005;
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
int sum[N<<2];
int tree[N<<2][2];
void PushUp(int rt)
{
sum[rt] = sum[rt<<1] + sum[rt<<1|1];
}
void build(int l,int r,int rt)
{
tree[rt][0] = l;
tree[rt][1] = r;
if(l == r)
{
sum[rt] = 1;
return;
}
int m = (l+r)>>1;
build(lson);
build(rson);
PushUp(rt);
}
int update(int p,int rt)
{
sum[rt] --;
if(tree[rt][0] == tree[rt][1])
{
sum[rt] = 0;
return tree[rt][0];//从绝对位置剔除
}
if(p <= sum[rt<<1]) return update(p,rt<<1);
else return update(p-sum[rt<<1],rt<<1|1);
PushUp(rt);
}
int main()
{
int n,m;
while(~scanf("%d %d",&n,&m))
{
build(1,n,1);
for(int i = 1 ; i <= 15 ; i ++) cout<<sum[i]<<" "<<tree[i][0]<<" "<<tree[i][1]<<endl;
int pos = 1;
int seq = 1;
for(int i = 0 ; i < n ; i++)
{
seq = (seq + m - 1) % sum[1];//seq 只是相对位置
if(seq == 0) seq = sum[1];
cout<<"seq = "<<seq<<"; ";
pos = update(seq,1);
cout<<pos<<" ";
}
}
return 0;
}
约瑟夫问题:递归算法
本段地址:http://www.cnblogs.com/yangyh/archive/2011/10/30/2229517.html
假设下标从0开始,0,1,2 .. m-1共m个人,从1开始报数,报到k则此人从环出退出,问最后剩下的一个人的编号是多少?
现在假设m=10
0 1 2 3 4 5 6 7 8 9 k=3
第一个人出列后的序列为:
0 1 3 4 5 6 7 8 9
即:
3 4 5 6 7 8 9 0 1(*)
我们把该式转化为:
0 1 2 3 4 5 6 7 8 (**)
则你会发现: ((*)+3)%10则转化为()式了
也就是说,我们求出9个人中第9次出环的编号,最后进行上面的转换就能得到10个人第10次出环的编号了
设f(m,k,i)为m个人的环,报数为k,第i个人出环的编号,则f(10,3,10)是我们要的结果
当i=1时, f(m,k,i) = (m+k-1)%m
当i!=1时, f(m,k,i)= ( f(m-1,k,i-1)+k )%m
所以程序如下:
int fun(int m,int k,int i){
if(i==1)
return (m+k-1)%m;
else
return (fun(m-1,k,i-1)+k)%m;
}
int main(int argc, char* argv[])
{
for(int i=1;i<=10;i++)
printf("第%2d次出环:%2d\n",i,fun(10,3,i));
return 0;
}
执行结果:
第 1次出环: 2
第 2次出环: 5
第 3次出环: 8
第 4次出环: 1
第 5次出环: 6
第 6次出环: 0
第 7次出环: 7
第 8次出环: 4
第 9次出环: 9
第10次出环: 3