【英雄算法六月集训】Day01

1464. 数组中两元素的最大乘积

暴力就是两次for循环 一次相乘 取最大

class Solution {
    public int maxProduct(int[] nums) {
       int maxMultNum = 0;
       for(int i=0;i<nums.length;++i){
           for(int j=i+1;j<nums.length;++j){
               maxMultNum = Math.max(maxMultNum,(nums[i]-1) * (nums[j]-1));
           }
       }
       return maxMultNum;
    }
}

1636. 按照频率将数组升序排序

这里调用的Java的API 只不过排序规则需要根据每个数字的出现频次来排序，大的数-小的数，降序，小的数-大的数，升序，那么现在问题就是怎么知道每个数字的出现频次，用一个hashmap统计下就行了。，然后在制定排序规则也就是sort方法里的匿名实现类里的逻辑，详见代码

class Solution {
    public int[] frequencySort(int[] nums) {
        HashMap<Integer, Integer> map = new HashMap<>();
        ArrayList<Integer> arrToList = new ArrayList<>();
        for (int i = 0; i < nums.length; ++i) {
            arrToList.add(nums[i]);
            map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
        }

        arrToList.sort((a, b) -> {
            Integer aCount = map.getOrDefault(a, 0);
            Integer bCount = map.getOrDefault(b, 0);
            if (aCount == bCount) {
                return b - a;
            }
            return aCount-bCount;
        });

        return arrToList.stream().mapToInt(Integer::intValue).toArray();

    }
}

1287. 有序数组中出现次数超过25%的元素

直接map统计，也可别的数据结构统计，统计完就判断下，这个数的次数 是否 大于 数组长度的百分之25

class Solution {
    public int findSpecialInteger(int[] arr) {
        HashMap<Integer, Integer> map = new HashMap<>();
        double total = arr.length * 0.25;
        for (int i = 0; i < arr.length; ++i) {
            map.put(arr[i], map.getOrDefault(arr[i], 0) + 1);
            if(map.getOrDefault(arr[i], 0)> total){
                return arr[i];
            }
        }   
        return -1;
    }
}

436. 寻找右区间

虽然过辣！ 打算这时间复杂度，简直没眼看，但是竟然没垫底

class Solution {
    int maxNum =0;
    public int searchMin(int x,int[][] intervals,Map<Integer,Integer> leftMap){
        int tmp = intervals[x][1];
        int tmpIndex = 0;
        tmpIndex = leftMap.getOrDefault(tmp,-1);
        while(tmp <= maxNum){
            if(tmpIndex != -1){
               return tmpIndex;  
            }
            ++tmp;
            tmpIndex = leftMap.getOrDefault(tmp,-1);    
        }
        return tmpIndex;
    }
    public int[] findRightInterval(int[][] intervals) {
        if(intervals.length ==1 ){
            return  new int[]{-1};
        }
        int[] ret = new int[intervals.length];
        Map<Integer,Integer> leftMap = new HashMap<Integer,Integer>();

        for(int i=0;i<intervals.length;++i){
            leftMap.put(intervals[i][0],i);
            int tmpMax = Math.max(intervals[i][0],intervals[i][1]);
            maxNum = Math.max(maxNum,tmpMax);
        }
        for(int i=0;i<intervals.length;++i){
             ret[i] = searchMin(i,intervals,leftMap);
        }
        return ret;
    }
}