第一题 找出不同元素数目差数组

 public int[] distinctDifferenceArray(int[] nums) {
        int[] res = new int[nums.length];
      
        for(int i=0;i<nums.length;i++){
            res[i]= getfrontValue(nums,i) - getbackValue(nums,i);
        }
        return res;
    }
    public int getfrontValue(int nums[], int n){
          Set<Integer> frontSet = new HashSet<>();
         for(int i=0;i<n+1;i++){
            frontSet.add(nums[i]);
        }
        return frontSet.size();
    }
        public int getbackValue(int nums[], int n){
          Set<Integer> frontSet = new HashSet<>();
         for(int i=n+1;i<nums.length;i++){
            frontSet.add(nums[i]);
        }
        return frontSet.size();
    }

第二题 频率跟踪器

class FrequencyTracker {
    List<Integer> num ;
    Map<Integer,Integer> map = new HashMap<>();
     Set<Integer> set = new HashSet<>();

    public FrequencyTracker() {
        num = new ArrayList<>();
    }
    
    public void add(int number) {
        if(null == map.get(number)) {
            map.put(number, 1);
            set.add(1);
        } else{
            int res = map.get(number);
             int end = res+1;

            map.put(number, end);
              if(!map.containsValue(res)) {
                set.remove(res);
            }
            set.add(end);
         
        }
    }
    
    public void deleteOne(int number) {
        if(map.containsKey(number) && map.get(number) !=0){
            int res = map.get(number);
            int end = res-1;
            map.put(number, end);
              if(!map.containsValue(res)) {
                set.remove(res);
            }
             set.add(end);
      
        }
        
    }
    
    public boolean hasFrequency(int frequency) {
        return set.contains(frequency);
    }
}

/**
 * Your FrequencyTracker object will be instantiated and called as such:
 * FrequencyTracker obj = new FrequencyTracker();
 * obj.add(number);
 * obj.deleteOne(number);
 * boolean param_3 = obj.hasFrequency(frequency);
 */

第三题 有相同颜色的相邻元素数目

public int[] colorTheArray(int n, int[][] queries) {
    int[] nums = new int[n];
    Arrays.fill(nums, 0);
    int[] answer = new int[queries.length];
    for (int i = 0; i < queries.length; i++) {
        int[] query = queries[i];

        int index = query[0];
        int color = query[1];

        int oldColor = nums[index];
        nums[index] = color;

        if (i == 0) {
            answer[i] = 0;
            continue;
        }

        int left = 0, right = 0;
        if (index > 0) {
            left = nums[index - 1];
        }
        if (index < nums.length - 1) {
            right = nums[index + 1];
        }

        int before = 0;
        if (left != 0 && left == oldColor) {
            before++;
        }
        if (right != 0 && right == oldColor) {
            before++;
        }
        int after = 0;
        if (left != 0 && left == color) {
            after++;
        }
        if (right != 0 && right == color) {
            after++;
        }

        int delta = after - before;
        answer[i] = answer[i - 1] + delta;
    }

    return answer;
}

第四题 使二叉树所有路径值相等的最小代价

public int minIncrements(int n, int[] cost) {
    int count = 0;
    for (int i = cost.length - 1; i > 0; i-=2) {
        int j = i - 1;
        int delta = Math.abs(cost[i] - cost[j]);
        count += delta;
        int value = Math.max(cost[i], cost[j]);
        if (j / 2 > 0) {
            cost[j/2] += value;
        }
    }

    return count;
}