[力扣算法刷题学习]17. 电话号码的字母组合 18. 四数之和-CSDN博客

17. 电话号码的字母组合

问题

在这里插入图片描述

我的答案

8会

官方答案（回溯）

在这里插入图片描述
代码

class Solution {
    public List<String> letterCombinations(String digits) {
    	// 初始化结果列表
        List<String> combinations = new ArrayList<String>();
        // 若为空串则返回空列表
        if (digits.length() == 0) {
            return combinations;
        }
        // 定义电话数字与字母组合的映射关系
        Map<Character, String> phoneMap = new HashMap<Character, String>() {{
            put('2', "abc");
            put('3', "def");
            put('4', "ghi");
            put('5', "jkl");
            put('6', "mno");
            put('7', "pqrs");
            put('8', "tuv");
            put('9', "wxyz");
        }};
        // 调用回溯函数（参数：结果列表，映射map，电话数字串，下标，拼接字符串）
        backtrack(combinations, phoneMap, digits, 0, new StringBuffer());
        // 返回结果
        return combinations;
    }
	// 回溯函数
    public void backtrack(List<String> combinations, Map<Character, String> phoneMap, String digits, int index, StringBuffer combination) {
        if (index == digits.length()) {
    		// 当下标值达到数字串长度时，结果列表添加拼接字符串
            combinations.add(combination.toString());
        } else {
        	// 若没达到则需要继续拼接
        	// 取当前下标的数字字符
            char digit = digits.charAt(index);
            // 获得映射的字母组合
            String letters = phoneMap.get(digit);
            // 计算字母组合长度
            int lettersCount = letters.length();
            // 进行循环拼接
            for (int i = 0; i < lettersCount; i++) {
            	// 先取出第i个字母
                combination.append(letters.charAt(i));
                // 递归调用回溯函数，拼接后续数字对应字母组合
                backtrack(combinations, phoneMap, digits, index + 1, combination);
                // 第i个字母拼接任务完成，删除该字母
                combination.deleteCharAt(index);
            }
        }
    }
}

在这里插入图片描述
作者：力扣官方题解
链接：https://leetcode.cn/problems/letter-combinations-of-a-phone-number/solutions/388738/dian-hua-hao-ma-de-zi-mu-zu-he-by-leetcode-solutio/
来源：力扣（LeetCode）

网友解答（队列）

在这里插入图片描述
代码

public static List<String> letterCombinations(String digits) {
    List<String> combinations = new ArrayList<>();  //使用一个集合来存储所有的字母组合结果
    if (digits == null || digits.length() == 0) return combinations;

    //将号码字母对应关系存储进Map
    HashMap<Character, String[]> map = new HashMap<Character, String[]>() {{    //存储为数组更好操作
        put('2', new String[]{"a", "b", "c"});
        put('3', new String[]{"d", "e", "f"});
        put('4', new String[]{"g", "h", "i"});
        put('5', new String[]{"j", "k", "l"});
        put('6', new String[]{"m", "n", "o"});
        put('7', new String[]{"p", "q", "r", "s"});
        put('8', new String[]{"t", "u", "v"});
        put('9', new String[]{"w", "x", "y", "z"});
    }};

    //定义一个队列来存储所有的组合结果
    Queue<String> queue = new LinkedList<>();
    //遍历Digits，取到对应号码对应的字母数组
    for (int i = 0; i < digits.length(); i++) {
        queue_letterCombinations(queue, map.get(digits.charAt(i)));
    }
    //要求返回List
    for (String s : queue) {
        combinations.add(s);
    }
    return combinations;
}

private static Queue<String> queue_letterCombinations(Queue<String> queue, String[] letters) {
    //初始定义的queue一定是空的，所以这时候把第一个号码的字母放入队列
    if (queue.size() == 0) {
        for (String letter : letters) {
            queue.add(letter);
        }
    } else {
        //对于后面到来字母，把queue出队列然后拼接以后进入队列
        int queueLength = queue.size(); //记录本次需要进行出列组合的元素数量
        for (int i = 0; i < queueLength; i++) {
            String s = queue.poll();    //队列头元素出队列
            for (String letter : letters) {
                queue.add(s + letter);  //将出来的队列元素和电话号码对应的字母依次进行拼接并添加进队列
            }
        }
    }
    return queue;
}

在这里插入图片描述
作者：腐烂的橘子、czheng2019
链接：https://leetcode.cn/problems/letter-combinations-of-a-phone-number/solutions/89041/hui-su-dui-lie-tu-jie-by-ml-zimingmeng/
https://leetcode.cn/problems/letter-combinations-of-a-phone-number/solutions/89041/hui-su-dui-lie-tu-jie-by-ml-zimingmeng/comments/695745
来源：力扣（LeetCode）

18. 四数之和

问题

在这里插入图片描述

我的解答（和三数之和一样，多加一重循环）

public static List<List<Integer>> fourSum(int[] nums, int target) {
    // 初始化结果数组
    List<List<Integer>> resultLists = new ArrayList<>();
    // 若数组为null或长度小于4，则返回空列表
    if (nums == null || nums.length < 4) {
        return quadruplets;
    }
    // 数组长度
    int length = nums.length;
    // 数组排序
    Arrays.sort(nums);
    // 枚举first
    for (int first = 0; first < length; first++) {
        // 去重，需要和上一次枚举的数字不相同
        if (first > 0 && nums[first] == nums[first - 1]) {
            continue;
        }
        // 枚举second
        for (int second = first + 1; second < length; second++) {
            // 去重，需要和上一次枚举的数字不相同
            if (second > first + 1 && nums[second] == nums[second - 1]) {
                continue;
            }
            // fourth 对应的指针初始指向数组的最右端
            int fourth = length - 1;
            // 枚举third
            for (int third = second + 1; third < length; third++) {
                // 去重，需要和上一次枚举的数字不相同
                if (third > second + 1 && nums[third] == nums[third - 1]) {
                    continue;
                }// 保证third的指针在fourth的指针的左侧

                while (third < fourth && (long)nums[first] + nums[second] + nums[third] + nums[fourth] > target) {
                    --fourth;
                }
                // 如果指针重合，随着third指针后续的增加，也不会有有满足求和为0，
                // 且third < fourth的third指针了，可以退出循环
                if (third == fourth) {
                    break;
                }
                if (nums[first] + nums[second] + nums[third] + nums[fourth] == target) {
                    List<Integer> list = new ArrayList<>();
                    list.add(nums[first]);
                    list.add(nums[second]);
                    list.add(nums[third]);
                    list.add(nums[fourth]);
                    resultLists.add(list);
                }
            }
        }
    }
    return resultLists;
}

针对测试用例做出的改变，java同样适用

官方C++ 解法中，将 int sum = nums[i] + nums[j] + nums[left] + nums[right]; 改为 long sum = (long)nums[i] + nums[j] + nums[left] + nums[right]; 可解决类似 [1000000000, 1000000000, 1000000000, 1000000000] 的数据溢出问题。

作者：OrgFreeFly
链接：https://leetcode.cn/problems/4sum/solutions/436368/si-shu-zhi-he-by-leetcode-solution/comments/1677864
来源：力扣（LeetCode）

官方解答（同样是排序+双指针）

在这里插入图片描述

代码

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> quadruplets = new ArrayList<List<Integer>>();
        if (nums == null || nums.length < 4) {
            return quadruplets;
        }
        Arrays.sort(nums);
        int length = nums.length;
        for (int i = 0; i < length - 3; i++) {
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            if ((long) nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3] > target) {
                break;
            }
            if ((long) nums[i] + nums[length - 3] + nums[length - 2] + nums[length - 1] < target) {
                continue;
            }
            for (int j = i + 1; j < length - 2; j++) {
                if (j > i + 1 && nums[j] == nums[j - 1]) {
                    continue;
                }
                if ((long) nums[i] + nums[j] + nums[j + 1] + nums[j + 2] > target) {
                    break;
                }
                if ((long) nums[i] + nums[j] + nums[length - 2] + nums[length - 1] < target) {
                    continue;
                }
                int left = j + 1, right = length - 1;
                while (left < right) {
                    long sum = (long) nums[i] + nums[j] + nums[left] + nums[right];
                    if (sum == target) {
                        quadruplets.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
                        while (left < right && nums[left] == nums[left + 1]) {
                            left++;
                        }
                        left++;
                        while (left < right && nums[right] == nums[right - 1]) {
                            right--;
                        }
                        right--;
                    } else if (sum < target) {
                        left++;
                    } else {
                        right--;
                    }
                }
            }
        }
        return quadruplets;
    }
}

在这里插入图片描述
作者：力扣官方题解
链接：https://leetcode.cn/problems/4sum/solutions/436368/si-shu-zhi-he-by-leetcode-solution/
来源：力扣（LeetCode）

网友解答（回溯法）

在这里插入图片描述

代码

class Solution {
	// 初始化变量
	// 结果列表
    List<List<Integer>> ans = new ArrayList<>();
    // 临时数据列表
    List<Integer> list = new ArrayList<>();
    // 游标，临时存储数据值之和
    int cur = 0;
    public List<List<Integer>> fourSum(int[] nums, int target) {
    	// 排序
        Arrays.sort(nums);
        // 调用回溯方法（参数列表：数组，目标值，起始下标）
        dfs(nums, target,0);
        // 返回结果
        return ans;
    }
    // 回溯方法
    void dfs(int[] nums, int target, int begin){
    	// 临时数据列表满了
        if(list.size() == 4){
        	// 若游标和值等于目标值
            if(cur == target){
            	// 将临时列表加入结果列表中
                ans.add(new ArrayList<>(list));
            }
            // 返回
            return;
        }
		// 循环
        for(int i = begin; i < nums.length; i++ ){
        	// 若剩余数字无法填充临时列表，则返回
            if(nums.length - i  < 4 - list.size())return;
            // 去重
            if(begin != i && nums[i - 1] == nums[i])continue;
            // 若当前游标和、当前值与预测后续和大于目标值，则已经找不到合适的结果，返回
            if(i < nums.length - 1 && cur + nums[i] + (3 - list.size()) * nums[i + 1] > target)return;
            // 若当前游标和、当前值与预测后续和小于目标值，则寻找下一个后续值
            if(i < nums.length - 1 && cur + nums[i] + (3 - list.size()) * nums[nums.length - 1] < target)continue;
            // 若当前游标和、当前值与预测后续和等于目标值，则游标和增加当前值
            cur += nums[i];
            // 临时列表添加当前值
            list.add(nums[i]);
            // 调用回溯函数，添加后续值
            dfs(nums, target, i + 1);
            // 当前值使用完毕后弹出，以便后续计算
            list.remove(list.size() - 1);
            // 游标和减去当前值
            cur -= nums[i];
        }
    }
}

作者：DahridReam，forwhat
链接：https://leetcode.cn/problems/4sum/solutions/436660/mei-kan-dao-ji-ge-hui-su-de-ti-jie-na-wo-lai-xie-y/
https://leetcode.cn/problems/4sum/solutions/436660/mei-kan-dao-ji-ge-hui-su-de-ti-jie-na-wo-lai-xie-y/comments/616047
来源：力扣（LeetCode）