约瑟夫环问题【剑指offer-45】

最新推荐文章于 2024-05-04 03:26:02 发布

weixin_33941350

最新推荐文章于 2024-05-04 03:26:02 发布

阅读量75

点赞数

文章标签：数据结构与算法 python

原文链接：https://my.oschina.net/u/347414/blog/150416

版权

2019独角兽企业重金招聘Python工程师标准>>>

约瑟夫环问题的原来描述为，设有编号为1，2，……，n的n(n>0)个人围成一个圈，从第1个人开始报数，报到m时停止报数，报m的人出圈，再从他的下一个人起重新报数，报到m时停止报数，报m的出圈，……，如此下去，直到所有人全部出圈为止。当任意给定n和m后，设计算法求n个人出圈的次序。稍微简化一下。

问题描述：n个人（编号0~(n-1))，从0开始报数，报到(m-1)的退出，剩下的人继续从0开始报数。求胜利者的编号。

思路：容易想到的就是用环链表来做，构建一个环链表，每个结点的编号为0, 1, ...... n-1。每次从当前位置向前移动m-1步，然后删除这个结点。最后剩下的结点就是胜利者。给出两种方法实现，一种是自定义链表操作，另一种用是STL库的单链表。不难发现，用STL库可以提高编写速度。

struct ListNode
{
int num;//编号
ListNode *next;
};
//自定义链表实现
int JosephusProblem_Solution1(int n, int m)
{
if(n < 1 || m <1)return -1;
ListNode *pHead = new ListNode();//头结点
ListNode *pCurrentNode = pHead;//当前结点
ListNode *pLastNode = NULL;//前一个结点
unsigned i;
//构造环链表
for(i = 1; i<n ; i++)
{ 
pCurrentNode->next = new ListNode(i);
pCurrentNode = pCurrentNode->next;
}
pCurrentNode->next = pHead;

//循环遍历
pLastNode = pCurrentNode;
pCurrentNode = pHead;

while(pCurrentNode->next != pCurrentNode)
{
//前进m-1步
for(i = 0; i < m-1; i++)
{
pLastNode = pCurrentNode;
pCurrentNode->next = pLastNode;
}
//删除报m-1的数
pLastNode->next = pCurrentNode->next;
delete pCurrentNode;
pCurrentNode = pLastNode->next;
}
//释放空间
int result = pCurrentNode->num;
delete pCurrentNode;

return result;
}

//使用标准库STL
int JosephusProblem_Solution2(int n,int m)
{
if(n<1||m<1)return -1;
list<int> listInt;
unsigned i;
for(i=0;i<n;i++)
listInt.push_back(i);
list<int>::iterator iterCurrent = listInt.begin();
while(listInt.size()>1)
{
//前进m-1步
for(i=0;i<m-1;i++)
{
if(++iterCurrent == listInt.end())
iterCurrent = listInt.begin();
}
//临时保存删除的结点
list<int>::iterator iterDel = iterCurrent;
if(++iterCurrent == listInt.end())
   iterCurrent = listInt.begin();
   //删除结点
   listInt.erase(iterDel);
}
return *iterCurrent;
}

上述方法的效率很低，其时间复杂度为O(mn)。当m和n很大时，很难在短时间内得出结果。不过好处就是可以给出n个人出圈的次序。

下面利用数学推导，如果能得出一个通式，就可以利用递归、循环等手段解决。下面给出推导的过程：

(1)第一个被删除的数为（m-1）%n;

(2)第二论的开始数字为k，那么这n-1个数构成的约瑟夫环为k,k+1,k+2,...k-3,k-2做一个简单映射。

（p(x)=(x-k)%n）

k--->0

k+1--->1

k+2--->2

---

k-2--->n-2

这是一个n-1个人的问题，如果能从n-1个人的问题的解退出n个人问题的解，从而得到一个递推公式，那么问题就解决了。假如我们已经知道了n-1个人时，最后胜利者的编号为x，利用映射关系逆推，就可以得出n个人时，胜利者的编号为(x+k)%n。其中k=m%n。代入（x+k）%n<=>(x+(m%n))%n<=>(x%n + (m%n)%n)%n<=> (x%n+m%n)%n <=> (x+m)%n

(3)第二个被删除的数为（m-1）%n-1

(4)假设第三轮的开始数字为o，那这n-2个数构成的约瑟夫环为o,o+1,o+2,...,o-3,o-2。继续做映射

p(x)=(y-o)%(n-2)

o--->0

o+1--->1

o+2--->2

---

o-2--->n-3

这是一个n-2个人的问题。假设最后胜利者为y，那么n-1个人时，胜利者为(y+o)%(n-1)，其中o等于m%(n-1)。代入可得(y+m)%(n-1)

要得到n-1个人问题的解，只需要得到n-2个人问题的解，倒退下去。只有一个人时，胜利者就是编号0.小面给出递推式：

f(1)=0;

f(i)=(f[i-1]+m)%i;(i>1)

有了递推公式，实现就非常简单了，给出循环的两种实现。再次表明使用标准库的便捷性。

int JosephusProblem_Solution3(int n, int m)
{
  if(n<1||m<1)return -1;
  int *f = new int[n+1];
  f[0]=f[1]=0;
  for(unsigned i=2;i<n;i++)
    f[i]=(f[i-1]+m)%i;//按递推公式进行计算

  int return = f[n];
  delete []f;
  return result;
}

int JosephusProblem_Solution4(int n, int m)
{
  if(n<1||m<1)return -1;
  vector<int> f(n+1,0);
  for(unsigned i = 2;i<=n;i++)
     f[i]=(f[i-1]+m)%i;
  return f[n];
}

转载于:https://my.oschina.net/u/347414/blog/150416