环形链表约瑟夫问题（可参考剑指offer面试题62）

题目描述：

0,1,2,...n-1这n个数字排成一个圆圈，从数字0开始，每次从这个圆圈里删除第m个数字。求出这个圆圈里剩下的最后一个数字。

解法1： 采用环形链表模拟圆圈。这是一个经典解法。

采用模板库里的std::list来模拟一个环形链表。因为list本身不是一个环形结构，所以每次迭代器扫描到链表尾部的时候，将其移到链表的头部。

class Solution {
public:
    int LastRemaining_Solution(int n, int m)
    {
        if(n<1 || m<1) return -1;
        int i = 0;
        list<int> numbers;
        for(i = 0; i<n;i++){
            numbers.push_back(i);
        }
        list<int>::iterator cur = numbers.begin();
        while(numbers.size()>1){
            for(int i = 1; i<m;i++){
                cur++;
                if(cur == numbers.end()){
                    cur = numbers.begin();
                }
            }
            list<int>::iterator next = ++cur;
            if(next == numbers.end()){
                next = numbers.begin();
            }
            --cur;
            numbers.erase(cur);
            cur = next;
        }
        return *(cur);
    }
};

该方法没删除一个数字需要m步运算，一共有n个数字，因此总的时间复杂度为O(mn)，需要一个辅助链表，所以空间复杂度为O(n).

解法2： 定义一个关于n和m的方程f(n,m)，表示每次在n个数字0,1,...,n-1中删除第m个数字最后剩下的数字，即在0,1,...n-1的序列中不停的删除第m个数字后最终剩下的那个数字。也就是本题目所求解。

在n个数字中，第一个被删除的数字为(m-1)%n，将该数字记为k。则剩下的序列为0,1,2,...,k-1,k+1,...,n-1。

该序列中继续删除的话，是从k+1开始，即实际上的序列为k+1,...n-1,0,1,...,k-1。序列因为不是从0开始，可以记为 ff(n-1,m)。实际上，f(n,m) = ff(n-1,m)。而在该序列ff(n-1,m)中，相邻的数字相差1，只有 n-1到0的时候有个跳变。可以通过对序列中每个数字x执行 （x-(k+1)）%n 的操作转换为0,1,...,n-k-2,n-k-1,...,n-2.。此时转换得到的序列可根据定义表示为 f(n-1,m).

同理，f(n-1,m)= ff(n-2,m)， 而ff(n-2,m) 可转换为 f(n-2,m).

这里需要求得的其实就是ff(n-2,m)与f(n-2,m)之间的转换关系。

记 p 为映射 f(n-1,m)->ff(n-1,m). 则是（x-(k+1)）%n 的逆操作： （x+(k+1)%n）

f(n,m) = ff(n-1,m) =  p(f(n-1,m)) = (f(n-1,m)+k+1)%n,因为 k = (m-1)%n，将其代入得： (f(n-1,m) + m)%n;

所以最终表达公式为：

f(n,m) =                 0              n=1

                 [f(n-1,m)+m]%n     n>1 

代码实现：

class Solution {
public:
    int LastRemaining_Solution(int n, int m)
    {
        if(n < 1 || m<1){
            return -1;
        }
        int last = 0;
        for(int i = 2; i<=n;i++){
            last = (last + m)%i;
        }
        return last;
    }
};

时间复杂度为O(n)，空间复杂度O(1).