力扣周赛371复盘（总结与进步）

比赛结果

 第一题

2932. 找出强数对的最大异或值 I - 力扣（LeetCode）

这个由于是简单题，暴力for循环即可

通过结果如下：

 

class Solution {
    public int maximumStrongPairXor(int[] nums) {
        int ans=0;
        for(int i =0;i<nums.length;i++){
            for(int j =i+1;j<nums.length;j++){
                if(Math.abs(nums[i]-nums[j])<=Math.min(nums[i],nums[j]))
                ans=Math.max(ans,nums[i]^nums[j]);
            }
        }
        return ans;
    }
}

第二题

2933. 高访问员工 - 力扣（LeetCode）

业务实现题，要逻辑处理对，错了跟多次，被罚了很多时间

 

代码通过目前效果

 贴代码

class Solution {
    public List<String> findHighAccessEmployees(List<List<String>> access_times) {
  Map<String, List<String>> map = new HashMap<>();
        for (int i = 0; i < access_times.size(); i++) {
            String name = access_times.get(i).get(0);
            String time = access_times.get(i).get(1);
            map.putIfAbsent(name, new ArrayList<>());
            map.get(name).add(time);
        }
        List<String> ans = new ArrayList<>();
        for (Map.Entry<String, List<String>> entry : map.entrySet()) {
            if (entry.getValue().size() <= 2) continue;
            List<String> times = entry.getValue();
            Collections.sort(times);
            int cnt = 0;
            for (int i = 0; i < times.size() - 2; i++) {
                int hour = Integer.parseInt(times.get(i).substring(0, 2));
                int minute = Integer.parseInt(times.get(i).substring(2, 4));
                // System.out.println("hourse:"+hour);
                // System.out.println("minute:"+minute);
                cnt=0;
                for (int j = i + 1; j < times.size(); j++) {
                    int newhour = Integer.parseInt(times.get(j).substring(0, 2));
                    int newminute = Integer.parseInt(times.get(j).substring(2, 4));
                    // System.out.println("newhour:"+newhour);
                    // System.out.println("newminute:"+newminute);
                    if (newhour == hour || (newhour - hour == 1 && newminute < minute)) {
                        cnt++;
                        // System.out.println("cnt:"+cnt);
                        if (cnt >= 2) {
                            break;
                        }
                    } else {
                        break;
                    }
                }

                if (cnt >= 2&& ans.indexOf(entry.getKey())==-1) {
                    ans.add(entry.getKey());
                    break;
                }
            }

        }
        return ans;
    }
}

解释步骤，首先，我先以名字作为键值，时间作为value值，这样子就可以通过遍历value值进行判断了，我先对时间进行排序。即一个人的时间，从小到大排序。然后遍历这个时间，因为要求在同一个小时里面要超过三次以上，所以我只要判断2次即可，为什么是俩次了，因为你的第一次就是在这个基础成立的情况下做的。如果有不符合条件的，直接跳出循环，重新假设下一个开始时间。如果cnt>=2&&我list里面不存在有这个人，我就可以放入。依次类推

第三题

2934. 最大化数组末位元素的最少操作次数 - 力扣（LeetCode）

 代码交的太着急了，心态有点崩，实在不应该编译出错。虽然是第三题，但是比第二题更简单。

提交性能

 代码

class Solution {
    public int minOperations(int[] nums1, int[] nums2) {
   int[] copy1 = Arrays.copyOf(nums1, nums1.length);
        int []copy2=Arrays.copyOf(nums2, nums2.length);
       int n=0;
        boolean flag=false;
       int ans =Integer.MAX_VALUE;
       int n1=nums1.length;
       int n2=nums2.length;
       int last1=nums1[n1-1];
       int last2=nums2[n2-1];
        int max1 = Arrays.stream(nums1).max().getAsInt();
        int max2 = Arrays.stream(nums2).max().getAsInt();
        if(last1==max1&&last2==max2)return 0;
       for(int i=0;i<n1;i++){
           if(nums1[i]<=last1&&nums2[i]<=last2)continue;
           int t=nums1[i];
           nums1[i]=nums2[i];
           nums2[i]=t;
           if(nums1[i]<=last1&&nums2[i]<=last2){
               n++;
               continue;
           };
           flag=true;
           break;
       }
       if(n!=0&&!flag){
           ans=n;
       }

       flag=false;
       n=0;
        copy1[n1-1]=last2;
        copy2[n2-1]=last1;
         last1=copy1[n1-1];
         last2=copy2[n2-1];
         max1 = Arrays.stream(copy1).max().getAsInt();
         max2 = Arrays.stream(copy2).max().getAsInt();
        if(last1==max1&&last2==max2)return 1;
        n=1;


        for(int i=0;i<n1;i++){
            if(copy1[i]<=last1&&copy2[i]<=last2)continue;
            int t=copy1[i];
            copy1[i]=copy2[i];
            copy2[i]=t;
            if(copy1[i]<=last1&&copy2[i]<=last2){
                n++;
                continue;
            };
            flag=true;
            break;
        }
        if(n!=1&&!flag)
            ans=Math.min(ans,n);
//        System.out.println(ans);
       if(ans==Integer.MAX_VALUE)return -1;
       return ans;
    }
}

首先我们要理解一个事情，这个n最大大概不超过n-1（可能实际上更小）。我们先假设，我们不进行交换最后一个尾数的情况下，将其他进行交换，保证尾数最大即可。然后再交换尾数的情况下，再交换其他的数。保证尾数最小。如果我存在无论无何我怎么交换这个数，我无法保证尾数最大，那么则无解，否则比最小就好了。实际情况可以看代码

第四题

做梦都没有想到这个是一个原题

考察的是字典树，但是茶神，直接转成哈希理解了。

贴一下茶神的题解，然后补充我的理解

 茶神题解，你值得拥有

 贴代码

class Solution {
    public int maximumStrongPairXor(int[] nums) {
  Arrays.sort(nums);
        //    java的整型长度为32位。那么这个方法返回的就是28
        int highBit=31-Integer.numberOfLeadingZeros(nums[nums.length-1]);
        int ans =0,mask=0;
        Map<Integer,Integer>mp=new HashMap<>();
        for(int i=highBit;i>=0;i--){
            mp.clear();
            mask=mask|(1<<i);
            int newAns=ans | (1<<i);
            for(int y:nums){
                int maskY=y&mask;//低于i的比特位置为0
                if(mp.containsKey(newAns ^ maskY)){
                    int x=mp.get(newAns^maskY);
                    
                    if(Math.abs(x-y)<=Math.min(x,y))
                    {
                        ans=newAns;
                        break;
                    }
                }
                mp.put(maskY,y);
            }
        }
        return ans;
    }
}

这个和三数之和一样，前面做的结果，会被我用来计算了。先了解一下异或的特性

1^2=3   3^2=1  3^1=2

她们有可以互相转换的，如果我哈希表里面有存在 value ^ newY =newAns,那么就存在这个值，然后从高位推到最后位，接着就是要符合

if(Math.abs(x-y)<=Math.min(x,y))的条件

总结

这次比赛打的很烂，掉了30分，这次双周赛白打了，我什么时候才可以拿k牌啊！！！。

比赛前面错了很多法，导致心态不好，第二题，我在第二次错，就发现问题了，结果越debug，越有问题，也是心态不好，第四题我是完全没有看（不过看了我也不会做就是了）