题目要求：
0, 1, … , n-1 这 n 个数字排成一个圈，从数字 0 开始每次从这个圈里删除第 m 个数字。求这个圈剩下的最后一个数字。

本题是约瑟夫环问题。
除了以下给出的2中解法，更高级的算法：约瑟夫问题的两个O(log n)解法

1. 环形链表

由于要不断地从圈里删除一个数字，容易想到用链表实现。用链表将这 n 个数字存储，头尾相连，每隔 m 个删除一个，最后剩下的即为结果。
由于数字从 0 开始，待删除的数字： k = (m-1) % n;
每删除 1 个都要遍历 m 个节点，需要删除 n-1 个，时间复杂度O(m*n), 空间复杂度 O(n)

#include <iostream>
#include <list>
using namespace std;
// 环形链表
// 时间复杂度O(m*n)，空间复杂度O(n)
int LastRemain(int n, int m) {
    if (n < 1 || m < 1)
        return -1;
    list<int> circle;
    for (int i = 0; i < n; i++)
        circle.push_back(i);
    list<int>::iterator iter = circle.begin(), delete_iter;
    while (circle.size() > 1) {
        int k = (m-1) % circle.size(); // 如 k = 1, 则删除第0个
        while (k > 0 ) {
            k--;
            iter++;
            if (iter == circle.end())   
                iter = circle.begin();
        }
        delete_iter = iter;
        ++iter;
        if (iter == circle.end())        
            iter = circle.begin();
        circle.erase(delete_iter);
    }
    return *iter;
}
int main() {
    int n = 4;
    int m = 3;
    cout << LastRemain(n, m) << endl;
    cout << LastRemain(2, 1) << endl;
}

2. 直接计算最后一个数字

以下分析来源：《剑指offer》p231

能否不重复遍历数字，而直接计算出最后一个数字是什么呢？

待删除的数字 k = (m-1)%n
删除后：0, 1, …, k-1, k+1, …, n-2, n-1 , 而下一次开始计数是从 k+1 开始，在剩下的序列中，
数组为：k+1, k+2, …, n-1, 0, …, k-1
剩下的序列最后剩下的数字，也应该是 n 和 m 的函数，而且最后剩下的数字，一定和原始序列最后剩下的数字是相同的。
由于剩下的序列是从 k+1 开始，设为$f‘(n-1,m)$，而原始序列设为$f(n, m)$

然后将剩下的 n-1 个数字，做如下映射：

    x                        p(x) 

    k+1            ->           0
    k+2            ->           1
    ...
    n-1            ->         n-k-2
    0              ->         n-k-1
    1              ->          n-k
    ...           
    k-1            ->          n-2

x->p(x)的映射关系 $p(x) = [x - (k+1)]\%n$,
p(x)->x的映射关系则为 $p^{-1}(x) = [x + (k+1)]\%n$,
这个映射，使得映射队列和初始队列的形式相同：
$f‘(n-1,m) =p^{-1}[f(n-1,m)]$ 相当于从p(x)映射到x (从变形序列：0开始 映射回之前的 ： k+1 开始)
$f‘(n-1,m) =p^{-1}[f(n-1,m)]=[f(n-1,m)+(k+1)]\%n$,带入 k = (m-1)%n

得到最终递推式：$f(n,m) =f‘(n-1,m)=[f(n-1,m)+m]\%n$
当 n = 1时，即为最后一个数字。
算法时间复杂度O(n)，空间O(1)

// 算法时间复杂度O(n)，空间O(1)
int ComputeLastRemain(int n, int m) {
    if (n < 1 || m < 1)
        return -1;
    int last;
    for (int i = 2; i <= n; i++) {
        last = (last+m)%i;
    }
    return last;
}