描述

这是一篇针对初学者的题解，共用三种方法解决。
知识点：数组，链表，递归
难度：二星

题解

题目抽象：给定一个由[0...n-1]构成的数组，第一次从0开始数m个数，然后删除，以后每次都从删除的数下一个位置开始数m个数，然后删除，直到剩余一个数字，找出那个数字。
比如：arr = [0 1 2 3 4]， m = 3
第一次：删除2 ，变成 arr = [0 1 3 4]
第二次，删除0，变成 arr = [1 3 4]
第三次，删除4，变成 arr = [1 3]
第四次，删除1，变成 arr = [3]

方法一：模拟

最开始长度为n，每次删除一个数，长度变为n-1，如果用数组模拟操作的话，删除一个数据，涉及大量的数据搬移操作，所以我们可以使用链表来模拟操作。
代码如下：

class Solution {
public:
    int LastRemaining_Solution(int n, int m)
    {
        if (n <= 0) return -1; 
        list<int> lt;
        for (int i=0; i<n; ++i) 
            lt.push_back(i);
        int index = 0;
        while (n > 1) {
            index = (index + m - 1) % n;
            auto it = lt.begin();
            std::advance(it, index); // 让it向后移动index个位置
            lt.erase(it);
            --n;
        }
        return lt.back();
    }
};

时间复杂度：O(N^2), 每次删除一个节点，需要先找到那个节点，然后再删除，查找的时间复杂度为O(N)
空间复杂度：O(N)

方法二：递归

假设f(n, m) 表示最终留下元素的序号。比如上例子中表示为:f(5,3) = 3

首先，长度为 n 的序列会先删除第 m % n 个元素，然后剩下一个长度为 n - 1 的序列。那么，我们可以递归地求解 f(n - 1, m)，就可以知道对于剩下的 n - 1 个元素，最终会留下第几个元素，我们设答案为 x = f(n - 1, m)。

由于我们删除了第 m % n 个元素，将序列的长度变为 n - 1。当我们知道了 f(n - 1, m) 对应的答案 x 之后，我们也就可以知道，长度为 n 的序列最后一个删除的元素，应当是从 m % n 开始数的第 x 个元素。因此有 f(n, m) = (m % n + x) % n = (m + x) % n。

当n等于1时，f(1,m) = 0
代码为：

class Solution {
public:
    int f(int n, int m) {
        if (n == 1) return 0;
        int x = f(n-1, m);
        return (x+m) % n;
    }
    int LastRemaining_Solution(int n, int m)
    {
        if (n <= 0) return -1; 
        return f(n,m);
    }
};

时间复杂度：O(N)
空间复杂度: O(N)

方法三：迭代法

根据方法二可知，
f[1] = 0
f[2] = (f{1] + m) % 2
f[3] = (f[2] + m) % 3
...
f[n] = (f[n-1] + m) % n
所以代码如下：

class Solution {
public:

    int LastRemaining_Solution(int n, int m)
    {
        if (n <= 0) return -1; 
        int index = 0;
        for (int i=2; i<=n; ++i) {
            index = (index + m) % i;
        }
        return index;
    }
};

时间复杂度：O(N)
空间复杂度: O(1)