390. 消除游戏题解

给定一个从1 到 n 排序的整数列表。
首先，从左到右，从第一个数字开始，每隔一个数字进行删除，直到列表的末尾。
第二步，在剩下的数字中，从右到左，从倒数第一个数字开始，每隔一个数字进行删除，直到列表开头。
我们不断重复这两步，从左到右和从右到左交替进行，直到只剩下一个数字。
返回长度为 n 的列表中，最后剩下的数字。

示例：

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

输出:
6

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/elimination-game
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

作为一个渣渣看到这道题的第一反应是正常求解,根据题目的描述将整个流程以java语言来表达如下:

class Solution {
    public int lastRemaining(int n) {
        List<Integer> list = new ArrayList();
        for(int i = 1;i<=n;i++){
            list.add(i);
        }
        return help(1,list);
    }
    public int help(int n,List<Integer> l){
        if(l.size()==1)return l.get(0);
        if(n%2==1){
            for(int i = 0;i<l.size();i+=2){
                l.remove(i);
                i--;
            }
        }else{
            for(int i = l.size()-1;i>=0;i-=2){
                l.remove(i);
            }
        }
        return help(++n,l);
    }
}

这样做答案肯定是对的,但是超时了.怎么办呢?想想办法!这原始的方法不行啊!仔细分析了一下题目可以找到一点小的规律;

1.如果这个数是奇数那么求得的结果一定等于它前面偶数的结果

2.那么如果这个数是偶数,这里就稍微复杂了一点,比如这个数是12,那么就有
              1 2 3 4 5 6 7 8 9 10 11 12
        第一步从左到右删除得到;
                2 4 6 8 10 12

这时候可以看到这个数组似乎和 1 2 3 4 5 6有点类似,那么如果我们找到f(12) 和 f(6)之间的关系,是不是就找到f(n)和f(n/2)(n为偶数)的关系,这样就能用DP的思想来解这道题.

仔细分析,将2 4 6 8 10 12 除以2 得到1 2 3 4 5 6,

但是这时候我们必须从右边开始减少,因为第一步我们从左边开始的,所以我们可以换个思维,这时候还是从左边开始减少,数组变成了下面:

6 5 4 3 2 1
对比

1 2 3 4 5 6

如果我们已知f(6)=4 , 而且我们肯定两个数组经过减少后剩下的最后一个数的角标一定相等.即1 2 3 4 5 6剩下最后4的角标如果是4(我们从1开始数),那么6 5 4 3 2 1减少后剩下的数的角标也一定是4,而这个位置上的数就是3.而这两个位置上的数的和为7,正好是两个数组对应角标上数字之和.

现在我们找到了f(n)和f(n/2)之间的关系:

f(n) = 2*(n/2+1-f(n/2));

所以我们有如下关系:

f(n) = f(n-1); n为奇数

       = 2*(n/2+1-f(n/2)); n为偶数
用java语言来描述

class Solution {
    public int lastRemaining(int n) {
        if(n<=2)return n;
    	int[] arr = new int[n+1];
    	arr[1] = 1;
    	arr[2] = 2;
    	for(int i = 3;i<=n;i++){
    		if(i%2==1){
    			arr[i]=arr[i-1];
    		}else{
    			arr[i]=(i/2+1-arr[i/2])*2;

    		}
    	}
    	
        return arr[n];
    }
}

这样答案也是对的,但是内存溢出了!!!!!

再想想?那肯定不能再用DP了,就只计算一个单独的数吧!

规律和上面我们的思考一样,这次我们通过递归来计算一个很大的数,大数化小,小数化了.

class Solution {
    public int lastRemaining(int n) {
        return help(n);
    }
    
        public static int help(int n){
    	if(n==2)return 2;
    	if(n==1)return 1;
    	if(n%2==1){
    		return help(n-1);
    	}else{
    		return 2*(n/2+1-help(n/2));
    	}
    }
}