约瑟夫环

题目描述

n个人排成一圈，按顺时针方向依次编号1，2，3…n。从编号为1的人开始顺时针"一二三...."报数，报到m的人退出圈子。这样不断循环下去，圈子里的人将不断减少。最终一定会剩下一个人。试问最后剩下的人的编号。

本题的数据规模更具有挑战性，尝试更通用且高效的算法。

输入

 超过1000组数据。

每组数据一行，每行两个正整数，代表人数n (1 <= n < 2³¹)和m(1<=m<=100)。

输出

每组输入数据输出一行, 仅包含一个整数，代表最后剩下的人的编号。

样例输入

7 2
2 2

样例输出

7
1

这里就不进行模拟了，时间复杂度为O(mn)，用数组与链表都可以，但麻烦。

第一种递归
原理
 
 

  
  
令f[n]表示当有n个候选人时，最后当选者的编号。则：
f[1] = 0
f[n] = (f[n - 1] + K) mod n
 
 
方法证明
上述公式可以用数据归纳法简单证明其正确性：
 
 

  
  
f[1] = 0
当只有一个候选人的时候，显然结果应该是0
 
 
 
 

  
  
f[n] = (f[n - 1] + K) mod n
f[n - 1]为第n - 1次数到的id序列，则第n次就是再往下数k个，最后进行取模运算即可得到结果序列
 
 
这种算法的时间复杂度为O(N)，空间复杂度为O(1)，效率有所提高
#include <iostream>
using namespace std;
int main()
{
    int num, n, k;

        int ret = 0;
        while(cin >> n >> k){
        for(int i = 2; i <= n; ++i)
        {
            ret = (ret + k) % i;//ret记录每一次数到的序列号
        }
        cout << ret +1<< endl;//输出最终序列结果
        }

    return 0;
}
第二种递归
原理
 
 

  
  
在每一轮报数过程中，都有N/K个人退出了队伍，比如N = 10， K = 3，第一轮有N / K = 3三个人退出；
上述第一种方法每次递归的步长为1，这里我们利用上述关系，建立一个步长为N / K的递归过程；
需要注意的是，当N减少到N = K的时候就需要使用第一种递归进行计算；
N > K时的递归公式为：
ret < N mod K: ret = ret - (N mod K) + N
ret >= N mod K: ret = ret - (N mod K) + (ret - N mod K) / (K - 1)
 
 
#include <iostream>
#include <cstdio>
using namespace std;
typedef long long ll;
ll josephus(ll n, ll k)
{
    ll ret;
    if(n == 1)
        return 0;
    //n < k的时候使用第一种递归算法
    if(n < k)
    {
        ll ret = 0;
        for(ll i = 2; i <= n; ++i)
            ret = (ret + k) % i;
        return ret;
    }
    //执行递归过程
    ret = josephus(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()
{



        ll n, m;
        while(cin>>n>>m){
        if(m==1)
        cout<<n<<endl;  //特殊处理
        else
        cout << josephus(n, m)+1 << endl;
        }

    return 0;
}