leetcode16——排序数组的搜索，数独，组合综合一二

最新推荐文章于 2020-12-13 15:53:15 发布

取个程序猿的名字

最新推荐文章于 2020-12-13 15:53:15 发布

阅读量143

点赞数

分类专栏： Leetcode1 文章标签： leetcode

本文链接：https://blog.csdn.net/weixin_45680007/article/details/102582901

版权

Leetcode1 专栏收录该内容

56 篇文章 0 订阅

订阅专栏

本文介绍了LeetCode中涉及排序数组搜索、数独和组合问题的四个经典题目，包括旋转排序数组中查找目标值的位置、找到升序数组中目标值的范围、验证数独的有效性，以及找到给定数组中和为目标数的所有组合。通过示例解析了题目的解题思路和解决方案，重点关注O(log n)时间复杂度的算法设计。

摘要由CSDN通过智能技术生成

leetcode33:
题目一：
假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。
你可以假设数组中不存在重复的元素。
你的算法时间复杂度必须是 O(log n) 级别。

示例 1:
输入: nums = [4,5,6,7,0,1,2], target = 0
输出: 4

示例 2:
输入: nums = [4,5,6,7,0,1,2], target = 3
输出: -1

解析：基于两次比较的二分查找，通过两次比较，将区域分成三个区域

class Solution {
    public int search(int[] nums, int target) {
        if (nums == null || nums.length == 0) {
            return -1;
        }
        int start = 0;
        int end = nums.length - 1;
        int mid;
        while (start <= end) {
            mid = start + (end - start) / 2;
            if (nums[mid] == target) {
                return mid;
            }
            //前半部分有序,注意此处用小于等于
            if (nums[start] <= nums[mid]) {
                //target在前半部分
                if (target >= nums[start] && target < nums[mid]) {
                    end = mid - 1;
                } else {
                    start = mid + 1;
                }
            } else {
                if (target <= nums[end] && target > nums[mid]) {
                    start = mid + 1;
                } else {
                    end = mid - 1;
                }
            }

        }
        return -1;
    }

}

leetcode34:
题目二:
给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
你的算法时间复杂度必须是 O(log n) 级别。
如果数组中不存在目标值，返回 [-1, -1]。

示例 1:
输入: nums = [5,7,7,8,8,10], target = 8
输出: [3,4]

示例 2:
输入: nums = [5,7,7,8,8,10], target = 6
输出: [-1,-1]

解析：查找位置后向两方扩张

class Solution {
    public int[] searchRange(int[] nums, int target) {
        if (nums == null || nums.length == 0) {
            return new int[]{-1,-1};
        }
        int start = 0;
        int end = nums.length - 1;
        int mid;
        while (start <= end) {
            mid=(end+start)/2;
            if(nums[mid]==target){
                int i=mid-1,j=mid+1;
                while(i>=0&&nums[i]==target)i--;
                while(j<nums.length&&nums[j]==target)j++;
                return new int[]{i+1,j-1};
            }
            if(nums[mid]>target){
                end=mid-1;
            }
            else{
                start=mid+1;
            }
        }
         return new int[]{-1,-1};
        
    }
}

leetcode:36
题目三：数独
判断一个 9x9 的数独是否有效。只需要根据以下规则，验证已经填入的数字是否有效即可。
数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。
在这里插入图片描述
上图是一个部分填充的有效的数独。

数独部分空格内已填入了数字，空白格用 ‘.’ 表示。

示例 1:

输入:
[
[“5”,“3”,".",".",“7”,".",".",".","."],
[“6”,".",".",“1”,“9”,“5”,".",".","."],
[".",“9”,“8”,".",".",".",".",“6”,"."],
[“8”,".",".",".",“6”,".",".",".",“3”],
[“4”,".",".",“8”,".",“3”,".",".",“1”],
[“7”,".",".",".",“2”,".",".",".",“6”],
[".",“6”,".",".",".",".",“2”,“8”,"."],
[".",".",".",“4”,“1”,“9”,".",".",“5”],
[".",".",".",".",“8”,".",".",“7”,“9”]
]
输出: true

class Solution {
    public boolean isValidSudoku(char[][] board) {
        Map<Integer,LinkedList<Integer>> map1=new HashMap<>();//保存行
        Map<Integer,LinkedList<Integer>> map2=new HashMap<>();//保存列
        Map<Integer,LinkedList<Integer>> map3=new HashMap<>();//保存宫格
        int k=0;
        for(int i=1;i<=9;i++){
            map1.put(i,new LinkedList<Integer>());
            map2.put(i,new LinkedList<Integer>());
            map3.put(i,new LinkedList<Integer>());
        }
        for(int i=0;i<9;i++){
            for(int j=0;j<9;j++){
                 k=i/3*3+1+j/3;
                 if(board[i][j]!='.'){
                 if(map1.get(board[i][j]-'0').contains(new Integer(i)))return false;
                 map1.get(board[i][j]-'0').add(i);
                 if(map2.get(board[i][j]-'0').contains(new Integer(j)))return false;
                 map2.get(board[i][j]-'0').add(j);
                 if(map3.get(board[i][j]-'0').contains(new Integer(k)))return false;
                 map3.get(board[i][j]-'0').add(k);
                 }
                 }        
        }
        return true;
    }
}

leetcode39:
题目四:
给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的数字可以无限制重复被选取。
说明：
所有数字（包括 target）都是正整数。
解集不能包含重复的组合。
示例 1:

输入: candidates = [2,3,6,7], target = 7,
所求解集为:
[
[7],
[2,2,3]
]
示例 2:

输入: candidates = [2,3,5], target = 8,
所求解集为:
[
[2,2,2,2],
[2,3,3],
[3,5]
]

class Solution {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(candidates);
        backtrack(candidates, target, res, 0, new ArrayList<Integer>());
        return res;
    }

    private void backtrack(int[] candidates, int target, List<List<Integer>> res, int i, ArrayList<Integer> tmp_list) {
        if (target < 0) return;
        if (target == 0) {
            res.add(new ArrayList<>(tmp_list));
            return;
        }
        for (int start = i; start < candidates.length; start++) {
            if (target < candidates[start]) break;
            tmp_list.add(candidates[start]);
            backtrack(candidates, target - candidates[start], res, start, tmp_list);
            tmp_list.remove(tmp_list.size() - 1);
        }
    }
}

leetcode40:
题目五:
给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的每个数字在每个组合中只能使用一次。
说明：
所有数字（包括目标数）都是正整数。
解集不能包含重复的组合。
示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,
所求解集为:
[
[1, 7],
[1, 2, 5],
[2, 6],
[1, 1, 6]
]
示例 2:

输入: candidates = [2,5,2,1,2], target = 5,
所求解集为:
[
[1,2,2],
[5]
]

class Solution {
   public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        Arrays.sort(candidates);
        List<List<Integer>> res = new ArrayList<>();
        backtrack(res, candidates, target, 0, 0, new ArrayList<Integer>());
        return res;

    }

    private void backtrack(List<List<Integer>> res, int[] candidates, int target, int i, int tmp_sum, ArrayList<Integer> tmp_list) {
        if (tmp_sum == target) {
            res.add(new ArrayList<>(tmp_list));
            return;
        }
        for (int start = i; start < candidates.length; start++) {
            if (tmp_sum + candidates[start] > target) break;
            if (start > i && candidates[start] == candidates[start - 1]) continue;
            tmp_list.add(candidates[start]);
            backtrack(res, candidates, target, start + 1, tmp_sum + candidates[start], tmp_list);
            tmp_list.remove(tmp_list.size() - 1);
        }
    }
}

解析：这里注意，回溯递归有两种情况：
1：根据index有无进行回溯
2：在Index处根据数字大小进行回溯
对于有重复的数组，只能用第二种方法，利用if (start > i && candidates[start] == candidates[start - 1]) continue;可以进行重复排除

取个程序猿的名字

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
leetcode16——排序数组的搜索，数独，组合综合一二

假设按照升序排序的数组在预先未知的某个点上进行了旋转。( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。你可以假设数组中不存在重复的元素。你的算法时间复杂度必须是 O(log n) 级别。示例 1:输入: nums = [4,5,6,7,0,1,2], targ...
复制链接

扫一扫

专栏目录