[LeetCode] 390. Elimination Game 淘汰游戏

There is a list of sorted integers from 1 to n. Starting from left to right, remove the first number and every other number afterward until you reach the end of the list.

Repeat the previous step again, but this time from right to left, remove the right most number and every other number from the remaining numbers.

We keep repeating the steps again, alternating left to right and right to left, until a single number remains.

Find the last number that remains starting with a list of length n.

Example:

Input:
n = 9,
1 2 3 4 5 6 7 8 9
2 4 6 8
2 6
6

Output:
6

这道题是 LeetCode 第二次编程比赛的题，然而博主并没有做出来，博主用的方法是那种最笨的方法，用一个数组把n个数组都存起来，然后根据循环的奇偶来决定是从左还是从右删除，结果不幸超时 TLE 了。后来通过想大神请教和上网搜索，发现这道题用递归来做很简单，用一个 bool 型变量 left2right，为 true 表示从左往右，为 false 表示从右往左遍历。当n为1时，不论从左往右还是从右往左都返回1。如果n大于1，且是从左往右的话，返回2倍的对 n/2 的从右往左的遍历；如果是从右往左的话，稍稍麻烦一些，肯定还是要对 n/2 调用递归函数的，但是要分奇偶情况，如果n为奇数，返回2倍的对 n/2 的从左往右的遍历的值；如果n为偶数，2倍的对 n/2 的从左往右的遍历的值，再减去1。具体这样的原因，博主还在研究中，也不是太清楚：

解法一：

class Solution {
public:
    int lastRemaining(int n) {
        return help(n, true);    
    }
    int help(int n, bool left2right) {
        if (n == 1) return 1;
        if (left2right) {
            return 2 * help(n / 2, false);
        } else {
            return 2 * help(n / 2, true) - 1 + n % 2;
        }
    }
};

下面这种方法相当的叼，一行就搞定了简直丧心病狂啊。第一次从左往右删除的时候，奇数都被删掉了，剩下的都是偶数。如果对所有数都除以2，那么得到一个1到 n/2 的新数列。下一次从右往左删出，那么返回的结果应该是调用递归的结果 lastRemaining(n / 2) 在数组1到 n/2 之间的镜像。何为镜像，比如 1, 2, 3, 4 这个数字，2的镜像就是3, 1的镜像是4，参见代码如下：

解法二：

class Solution {
public:
    int lastRemaining(int n) {
        return n == 1 ? 1 : 2 * (1 + n / 2 - lastRemaining(n / 2));    
    }
};

下面这种迭代的解法是博主请教另一位大神的方法，个人感觉也非常叼，膜拜大神中，先来看两个简单的例子：

n = 8
1 2 3 4 5 6 7 8
   2    4    6   8
   2          6
               6

n = 7
1 2 3 4 5 6 7
2 4    6
4

如果仔细观察，可以发现从左往右删的时候，每次都是删掉第一个数字，而从右往左删的时候，则有可能删掉第一个或者第二个数字，而且每删一次，数字之间的距离会变为之前的两倍。这里要做的是每次记录当前数组的第一个数字，而且再通过观察可以看出，从右往左删时，如果剩下的数字个数是偶数个时，删掉的是第二个数字；如果是奇数个的时候，删掉的是第一个数字。总结出了上述规律，就可以写出代码如下：

解法三：

class Solution {
public:
    int lastRemaining(int n) {
        int step = 1, res = 1;
        while (step * 2 <= n) {
            res += step;
            step *= 2;
            if (step * 2 > n) break;
            if ((n / step) % 2 == 1) res += step;
            step *= 2;
        }
        return res;
    }
};

再来看一种论坛上的高分解法，其实这种解法的本质跟上面那种解法一样的，这里多使用了两个变量，一个是布尔型变量 left2right，表示当前的方向，为 true 表示是从左往右删；另一个是整型变量 remain，表示当前还剩下的数字个数。当 remain 大于1的时候进行循环，res 表示的是当前剩下的左数第一个数字。根据之前的分析，当从左往右删除的时候，左边第一个数字一定会被删掉；而从右往左删时，如果剩下的数字个数是偶数个时，删掉的是第二个数字；如果是奇数个的时候，删掉的是第一个数字。这样只要判断 left2right 为 true，或者 remain 是奇数的时候，res 要加上 step，也就是当前数字之间的间隔数，每删除一次，step 都要自乘以2，同时 remain 要除以2，left2right 也要变成其相反的状态，参见代码如下：

解法四：

class Solution {
public:
    int lastRemaining(int n) {
        bool left2right = true;
        int res = 1, step = 1, remain = n;
        while (remain > 1) {
            if (left2right || remain % 2 == 1) res += step;
            remain /= 2;
            step *= 2;
            left2right = !left2right;
        }
        return res;
    }
};