输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出：2
解释：
两个元组如下：
1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0

示例 2：

输入：nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]
输出：1

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        Map<Integer,Integer> map = new HashMap<>();
        for(int i : nums1) {
            for(int j : nums2) {
                int k = i + j;
//getOrDefault 是 Map 接口提供的一个方法，它接收两个参数，第一个参数是要查找的键（这里是 t），第二个参数是默认值（这里是 0）。
                map.put(k,map.getOrDefault(k,0)+1);
            }
        } 
        int num = 0;
        for(int i : nums3) {
            for(int j : nums4) {
                int temp = -i-j;
                if(map.containsKey(temp)) {
                    num += map.get(temp);
                }
            }
        }
        return num;
    }
}

算法部分——三数之和

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

示例 1：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。

示例 2：

输入：nums = [0,1,1]
输出：[]
解释：唯一可能的三元组和不为 0 。

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        Arrays.sort(nums);
        List<List<Integer>> list = new ArrayList<>();
        for(int k = 0; k < nums.length-2; k++ ) {
            if(nums[k] > 0) break;
            if(k >0 && nums[k] == nums[k-1]) continue;
            int i = k + 1, j = nums.length - 1;
            while(i < j) {
                int sum = nums[k] + nums[i] + nums[j];
                if(sum < 0) {
                    i++;
                }else if(sum > 0) {
                    j--;
                }else {
                //Arrays.asList用于将一组元素快速转换为一个固定大小的列表
                list.add(new ArrayList<Integer>(Arrays.asList(nums[k], nums[i], nums[j])));
                //去重操作，持续删除重复的组合，缩小范围
                while(i < j && nums[i] == nums[++i]);
                while(i < j && nums[j] == nums[--j]);
                }
            }
        }
        return list;
    }
}

昨日八股答案

不同的线程之间如何通信？

共享内存：利用多个线程访问同一块内存区域，通过读写这块内存区域来实现线程之间的通信。为了保证线程安全，通常需要使用 synchronized 关键字或 volatile 关键字。

消息传递：线程通过发送、接收消息通信，避免直接共享内存，达到解耦线程的效果。

信号量：用于控制共享资源访问的同步机制

如何停止一个线程？

设置共享标志位：由主线程控制变量的值，工作的线程循环检测该变量

线程中断机制：通过 Thread.interrupt() 触发线程中断状态

Future取消任务：使用线程池提交任务，并用Future.cancel停止线程

今日八股

如何保证多线程安全
常用的锁，使用的场景
Java并发工具

标签

#java #开发语言 #算法 #学习