【每日三题】2022-4-2 LeetCode 34-36-CSDN博客

本文链接：https://blog.csdn.net/qq_40818336/article/details/123932126

34.在排序数组中查找元素的第一个和最后一个位置

思路：二分查找。需要两次二分查找，分别找出第一个和最后一个位置。首先，通过二分查找找第一个的位置。

判断nums[mid] == target。如果不等于，则说明第一个的位置在mid左侧或者右侧，根据其大小关系移动指针。如果等于，则进行下一步判断。
如果mid = 0 || nums[mid - 1] != target，此时说明mid就是该元素第一次出现的位置。如果不满足条件，则说明当前位置等于目标但不是目标元素第一次出现，因此第一次出现会出现在mid左侧，将右指针移动到mid-1。

如果找到了第一个的位置，则说明数组中出现过目标元素，继续搜索最后一个位置。如果没有找到，则说明数组中没有目标元素，直接返回。查找最后一个位置的步骤：（注意：这时候左指针初始化为第一个的位置）

如果nums[mid] != target，且此时nums[mid]一定大于target，因此最后一次出现的位置位于mid左侧。如果相等，则需进一步判断是否是最后一个位置。
如果mid == nums.length - 1 || nums[mid+1] != target，则说明此时mid就是最后一个目标元素的位置。如果不满足条件，则说明最后一个位置出现在mid右侧。

最后返回结果。

代码：

public int[] searchRange(int[] nums, int target) {
    if (nums.length == 0) {
        return new int[]{-1, -1};
    }
    int start = -1, end = -1, l = 0, r = nums.length - 1;
    while (l <= r) {
        int mid = (l + r) / 2;
        if (nums[mid] == target) {
            if (mid == 0 || nums[mid - 1] != target) {
                start = mid;
                break;
            } else {
                r = mid - 1;
            }
        } else if (nums[mid] > target) {
            r = mid - 1;
        } else {
            l = mid + 1;
        }
    }
    if (start == -1) {
        return new int[]{-1, -1};
    }
    l = start;
    r = nums.length - 1;
    while (l <= r) {
        int mid = (l + r) / 2;
        if (nums[mid] == target) {
            if (mid == nums.length - 1 || nums[mid + 1] != target) {
                end = mid;
                break;
            } else {
                l = mid + 1;
            }
        } else {
            r = mid - 1;
        }
    }
    return new int[]{start, end};
}

时间复杂度：O(logn)

空间复杂度：O(1)

35.搜索插入的位置

思路：二分查找，找到第一个大于等于目标值的元素位置。计算mid，若当前mid指向的元素等于目标值，则直接返回mid。若nums[mid] > target，此时mid有可能是第一个大于目标值的元素，因此判断mid == 0 || nums[mid - 1] < target。若满足条件则说明当前位置是第一个大于目标值的元素，且目标值不存在，则返回mid。如果不满足，则说明所要找的位置在mid左侧。若nums[mid]< target，如果mid已经搜索到了结尾，则说明当前数组中不存在目标值且所有元素都小于目标值，则返回数组的长度，即数组末尾的位置。若还没有到结尾，则说明我们要找的位置在mid右侧。

代码：

public int searchInsert(int[] nums, int target) {
    int l = 0, r = nums.length - 1;
    while (l <= r) {
        int mid = (l + r) / 2;
        if (nums[mid] == target) {
            return mid;
        } else if (nums[mid] > target) {
            if (mid == 0 || nums[mid - 1] < target) {
                return mid;
            } else {
                r = mid - 1;
            }
        } else {
            if (mid == nums.length - 1) {
                return nums.length;
            } else {
                l = mid + 1;
            }
        }
    }
    return 0;
}

时间复杂度：O(logn)

空间复杂度：O(1)

36.有效的数独

思路：有效的数独需要判断三个条件：

同行不能有重复数字
同列不能有重复数字
同个3 x 3格子不能有相同数字

因此，我们使用三个boolean矩阵来追踪同行，同列，同格子中元素出现的情况。如果遇到不合法字符或冲突，则立刻返回false，否则在3个矩阵中更新状态，并继续遍历下一个数字。

代码：

public boolean isValidSudoku(char[][] board) {
    boolean[][] rows = new boolean[9][9], cols = new boolean[9][9];
    boolean[][][] boxes = new boolean[3][3][9];
    for (int i = 0; i < 9; i++) {
        for (int j = 0; j < 9; j++) {
            if (board[i][j] == '.') {
                continue;
            } else if (board[i][j] - '1' < 0 || board[i][j] - '1' >= 9) {
                return false;
            } else {
                if (rows[i][board[i][j] - '1'] || cols[j][board[i][j] - '1'] || boxes[i / 3][j / 3][board[i][j] - '1']) {
                    return false;
                }
                rows[i][board[i][j] - '1'] = true;
                cols[j][board[i][j] - '1'] = true;
                boxes[i / 3][j / 3][board[i][j] - '1'] = true;
            }
        }
    }
    return true;
}