数论中的Josehus环问题

                                                          数论中的Josehus环问题

   这个问题吧，其实从我一开始接触到算法的时候，就开始纠结了。但是至今也没真正懂得其本质含义（冏）。所以，只能转一些别人的博客，记录一下，慢慢研究。不过坑爹的是居然很多人的博客的程序是有BUG的，而且是一个BUG的程序被一堆人转载着。其实，我也是其中转载BUG程序的一个。后来，做题的时候才发现了漏洞的。现在就给出一个正确的程序和解释吧。

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

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

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

             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.。继续做映射。

             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_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];
}

还有一个高深的链表法：

struct ListNode
{
	int num;        //编号
	ListNode *next; //下一个
	ListNode(int n = 0, ListNode *p = NULL) 
	{ num = n; next = p;}
};

//自定义链表实现
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 = pCurrentNode->next;
		}
		//删除报到m - 1的数
		pLastNode->next = pCurrentNode->next;
		delete pCurrentNode;
		pCurrentNode = pLastNode->next;
	}
	//释放空间
	int result = pCurrentNode->num;
	delete pCurrentNode;

	return result;
}

标准库法：

//使用标准库
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;
}

  再次声明，此文代码和解释非原创。

给出一题说是模板题的题吧，纠结了好久，最后才知道。

题目链接：Click Here~

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

int Josehus(int n,int m)
{
    int s = 0;                    //第一个人的编号
    for(int i = 2;i <= n;++i)    //遍历的是总人数，与编号没有任何关系！！！
      s = (s+m)%i;
    return s;                   //返回最后一个人的编号
}
int main()
{
    int n;
    while(scanf("%d",&n),n)
    {
        int m = 2;
        /*假设编号为1的已经出列，则此时从2开始重新编号为1。
        所以，此时总人数应该是N-1.而且，我们知道我们在求解的时候
        是假设第一个人的编号为0的。所以，现在如果要2是最后出列的则
        需要在Josehus的函数中返回第一个值，即0*/
        while(Josehus(n-1,m)!=0)m++;
        printf("%d\n",m);
    }
    return 0;
}