圆圈中最后剩下的数字（约瑟夫环问题）

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

例如，0、1、2、3、4这5个数字组成一个圆圈，从数字0开始每次删除第3个数字，则删除的前4个数字依次是2、0、4、1，因此最后剩下的数字是3。

示例 1：
输入: n = 5, m = 3
输出: 3

示例 2：
输入: n = 10, m = 17
输出: 2

---

模拟链表，O(n^2))
如果单纯用链表模拟的话，时间复杂度是 O(nm)O(nm) 的，可以看下题目的数据范围，肯定是不能这么做的。关于运行时间的预估，经验是如果 n<10^5，那么 O(n^2) 的解法耗时大概是几秒左右（当然时间复杂度会忽略常数，而且也有可能由于执行程序的机器性能的不同，O(n^2) 的实际耗时也有可能一秒多，也有可能十几秒）。本题由于 1 <= m <= 10^6 ，所以 O(nm) 肯定是超时的。

可以分析下纯暴力的做法，每次找到删除的那个数字，需要 O(m) 的时间复杂度，然后删除了 n-1n−1 次。但实际上我们可以直接找到下一个要删除的位置的！

假设当前删除的位置是 idx，下一个删除的数字的位置是 idx + m 。但是，由于把当前位置的数字删除了，后面的数字会前移一位，所以实际的下一个位置是 idx + m - 1。由于数到末尾会从头继续数，所以最后取模一下，就是 (idx + m - 1) mod n。

至于这种思路的代码实现，我尝试了下 LinkedList 会超时，我猜是因为 LinkedList 虽然删除指定节点的时间复杂度是 O(1) 的，但是在 remove 时间复杂度仍然是 O(n) 的，因为需要从头遍历到需要删除的位置。那 ArrayList 呢？索引到需要删除的位置，时间复杂度是 O(1)，删除元素时间复杂度是 O(n)（因为后续元素需要向前移位）， remove 整体时间复杂度是 O(n) 的。看起来LinkedList 和 ArrayList 单次删除操作的时间复杂度是一样的 ？ArrayList 的 remove 操作在后续移位的时候，其实是内存连续空间的拷贝的！所以相比于LinkedList大量非连续性地址访问，ArrayList的性能是很 OK 的！

这是 ArrayList 的 remove 源码：

class Solution {
    public int lastRemaining(int n, int m) {
        //ArrayList增删快，所以用ArrayList
        List<Integer> list = new ArrayList<Integer>();
        for(int i = 0; i < n; i++){
            list.add(i);
        }

        int index = 0;
        while(n > 1){
            index = (index + m - 1) % n;
            list.remove(index);
            n--;
        }
        return list.get(0);
    }
}

数学解法，O(n)
最后剩下的 3 的下标是 0。

第四轮反推，补上 mm 个位置，然后模上当时的数组大小 22，位置是(0 + 3) % 2 = 1。

第三轮反推，补上 mm 个位置，然后模上当时的数组大小 33，位置是(1 + 3) % 3 = 1。

第二轮反推，补上 mm 个位置，然后模上当时的数组大小 44，位置是(1 + 3) % 4 = 0。

第一轮反推，补上 mm 个位置，然后模上当时的数组大小 55，位置是(0 + 3) % 5 = 3。

所以最终剩下的数字的下标就是3。因为数组是从0开始的，所以最终的答案就是3。

总结一下反推的过程，就是 (当前index + m) % 上一轮剩余数字的个数。

class Solution {
    public int lastRemaining(int n, int m) {
        int ans = 0;
        // 最后一轮剩下2个人，所以从2开始反推
        for (int i = 2; i <= n; i++) {
            ans = (ans + m) % i;
        }
        return ans;
    }
}