【leetcode】Weekly Contest 93

　　又是周末，leetcode周赛，菜鸡下定决心要AK一次，然后失败了，周常三题QAQ。

1.Binary Gap

　　第一题给一个数字，让你找数字的二进制中相邻的1最大距离是多少，直接扫描一遍就好啦。

    public int binaryGap(int N) {
        int last = -1;
        int res = 0;
        for(int i = 0;N>0;N/=2,i++){
            if(N%2 == 1){
                if(last!=-1){
                    res = Math.max(res, i-last);
                }
                last = i;
            }
        }
        return res;
    }

2.Binary Gap

　　第二题也不难，找到与所给的数字位数相同的2^n次方数，然后比较所给的数字构成是不是一样，把每一位拆开来扔进一个10位的int数组里比较就行。因为给的数字最大是10^9，因此直接暴力求即可。

    public boolean reorderedPowerOf2(int N) {
        for(int i = 0;;i++){
            int a = (int)Math.pow(2, i);
            int com = compareLength(N, a);
            if(com!=1){
                if(com == 0){//找到位数相同的（后来发现好像不加这个条件也可以，反正范围小）
                    if(compare(N, a)){
                        return true;
                    }
                }
            }else {
                return false;
            }
        }
    }
    
    boolean compare(int N,int a){//比较构成是否相同
        int[] num = new int[10];
        while(N!=0){
            num[N%10]++;
            N/=10;
        }
        while(a!=0){
            num[a%10]--;
            a/=10;
        }
        for(int i = 0;i<10;i++){
            if(num[i] != 0){
                return false;
            }
        }
        return true;
    }
    
    int compareLength(int N,int a){//比较两个数位数是否相同
        while(a!=0&&N!=0){
            N/=10;
            a/=10;
        }
        if(a!=0){
            return 1;
        }else if (N!=0) {
            return -1;
        }
        return 0;
    }

3.Advantage Shuffle

　　第三题用贪心做就好了，先把A数组排序，对B数组中的每个数B[i]，从A数组中找一个最小的并且大于B[i]的数（未被使用过的），如果找不到，就放一个最小的且没被使用过的（有点像田忌赛马的感觉），举个例子A【1，5】，B【2，3】，对于这种数组，5放在第一位和第二位都是一样的，因此无需考虑某个位置放的数是否会对后面放置数字产生影响。

    public int[] advantageCount(int[] A, int[] B) {
        Arrays.sort(A);
         int temp;
        for(int i = 0,j=A.length-1;i<j;i++,j--){//sort从小到大，翻转一下QAQ
            temp = A[i];
            A[i] = A[j];
            A[j] = temp;
        }
        int[] C = new int[A.length];
        Arrays.fill(C, -1);
        boolean[] use = new boolean[A.length];
        for(int i = 0;i<A.length;i++){
            for(int j = A.length-1;j>=0;j--){
                if(!use[j] && A[j]>B[i]){
                    C[i] = A[j];
                    use[j] = true;
                    break;
                }
            }
            if(C[i] == -1){
                for(int j = A.length-1;j>=0;j--){
                    if(!use[j]){
                        C[i] = A[j];
                        use[j] = true;
                        break;
                    }
                }
            }
        }
        return C;
    }

4.Minimum Number of Refueling Stops

　　题目不难理解，一开始用贪心做了，后来发现贪心会出现问题，可能前面的加油站加油是能到达目标点的，但是贪心只考虑当前能到最远的位置，就可能会出现一些傻傻的答案。然后看了一下时间不多啦，就没怎么思考尝试dfs求解了，虽然感觉会超时，不过最终真的超时啦！

　　后来补题的时候呢，发现别人写的好简洁QAQ，自己学着码了一个。

    public int minRefuelStops(int target, int startFuel, int[][] stations) {
        Queue<Integer> queue = new PriorityQueue<>();
        int d = startFuel;
        int last = 0;
        int res = 0;
        while(true){
            for(;last<stations.length&&d>=stations[last][0];last++){//从前往后找到加了res次油后能到达的位置
                queue.offer(-stations[last][1]);//优先队列默认小根堆，加个负号就能少写一个比较器，这他喵的也太聪明了吧
            }
            if(d>=target){
                return res;
            }
            if(queue.isEmpty()){
                return -1;
            }
            d += -queue.poll();
            res++;
        }
    }