目录

79. 单词搜索 Word Search  🌟🌟

80. 删除有序数组中的重复项 II Remove-duplicates-from-sorted-array-II  🌟🌟

81. 搜索旋转排序数组 II Search-in-rotated-sorted-array-II  🌟🌟

🌟 每日一练刷题专栏 🌟

Golang每日一练 专栏

Python每日一练 专栏

C/C++每日一练 专栏

Java每日一练 专栏

---

79. 单词搜索 Word Search

给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。

单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

示例 1：

输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
输出：true

示例 2：

输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "SEE"
输出：true

示例 3：

输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCB"
输出：false

提示：

• m == board.length
• n = board[i].length
• 1 <= m, n <= 6
• 1 <= word.length <= 15
• board 和 word 仅由大小写英文字母组成

进阶：你可以使用搜索剪枝的技术来优化解决方案，使其在 board 更大的情况下可以更快解决问题？

代码：

fn exist(board: Vec<Vec<char>>, word: String) -> bool {
    let mut board = board;
    let m = board.len();
    let n = board[0].len();

    for i in 0..m {
        for j in 0..n {
            if search(&mut board, &word, i, j, 0) {
                return true;
            }
        }
    }

    false
}

fn search(board: &mut Vec<Vec<char>>, word: &String, i: usize, j: usize, k: usize) -> bool {
    if k == word.len() {
        return true;
    }
    if i >= board.len() || j >= board[i].len() || board[i][j] != word.chars().nth(k).unwrap() {
        return false;
    }
    let c = board[i][j];
    board[i][j] = '#'; // 标记已访问

    if search(board, word, i + 1, j, k + 1)
        || search(board, word, i, j + 1, k + 1)
        || search(board, word, i - 1, j, k + 1)
        || search(board, word, i, j - 1, k + 1)
    {
        return true;
    }
    board[i][j] = c; // 还原
    false
}

fn main() {
    let board = vec![
        vec!['A', 'B', 'C', 'E'],
        vec!['S', 'F', 'C', 'S'],
        vec!['A', 'D', 'E', 'E'],
    ];
    println!("{}", exist(board, String::from("ABCCED")));
}

输出：

true
true
false

---

80. 删除有序数组中的重复项 II Remove-duplicates-from-sorted-array-II

给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 最多出现两次 ，返回删除后数组的新长度。

不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

说明：

为什么返回数值是整数，但输出的答案是数组呢？

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
int len = removeDuplicates(nums);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

示例 1：

输入：nums = [1,1,1,2,2,3]
输出：5, nums = [1,1,2,2,3]
解释：函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3 。 不需要考虑数组中超出新长度后面的元素。

示例 2：

输入：nums = [0,0,1,1,1,1,2,3,3]
输出：7, nums = [0,0,1,1,2,3,3]
解释：函数应返回新长度 length = 7, 并且原数组的前五个元素被修改为 0, 0, 1, 1, 2, 3, 3 。 不需要考虑数组中超出新长度后面的元素。

提示：

• 1 <= nums.length <= 3 * 10^4
• -10^4 <= nums[i] <= 10^4
• nums 已按升序排列

相关题目： 26. 删除有序数组中的重复项

代码：

fn remove_duplicates(nums: &mut Vec<i32>) -> i32 {
    if nums.len() <= 2 {
        return nums.len() as i32;
    }
    let mut i = 1;
    for j in 2..nums.len() {
        if nums[j] != nums[i - 1] {
            i += 1;
            nums[i] = nums[j];
        }
    }
    (i + 1) as i32
}

fn main() {
    let mut nums = vec![1, 1, 1, 2, 2, 3];
    println!("{}", remove_duplicates(&mut nums));

    let mut nums = vec![0, 0, 1, 1, 1, 1, 2, 3, 3];
    println!("{}", remove_duplicates(&mut nums));
}

输出：

5
7

---

81. 搜索旋转排序数组 II Search-in-rotated-sorted-array-II

已知存在一个按非降序排列的整数数组 nums ，数组中的值不必互不相同。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转 ，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,4,4,5,6,6,7] 在下标 5 处经旋转后可能变为 [4,5,6,6,7,0,1,2,4,4] 。

给你 旋转后 的数组 nums 和一个整数 target ，请你编写一个函数来判断给定的目标值是否存在于数组中。如果 nums 中存在这个目标值 target ，则返回 true ，否则返回 false 。

你必须尽可能减少整个操作步骤。

示例 1：

输入：nums = [2,5,6,0,0,1,2], target = 0
输出：true

示例 2：

输入：nums = [2,5,6,0,0,1,2], target = 3
输出：false

提示：

• 1 <= nums.length <= 5000
• -10^4 <= nums[i] <= 10^4
• 题目数据保证 nums 在预先未知的某个下标上进行了旋转
• -10^4 <= target <= 10^4

进阶：

• 这是​搜索旋转排序数组​(题号33)的延伸题目，本题中的 nums  可能包含重复元素。
• 这会影响到程序的时间复杂度吗？会有怎样的影响，为什么？

代码：

fn search(nums: &Vec<i32>, target: i32) -> bool {
    let (mut left, mut right) = (0, nums.len() - 1);
    while left <= right {
        let mid = left + (right - left) / 2;
        if nums[mid] == target {
            return true;
        }
        // 无法确定左右区间是否有序，只能缩小范围
        if nums[left] == nums[mid] && nums[mid] == nums[right] {
            left += 1;
            if right > left {
                right -= 1;
            }
        } else if nums[left] <= nums[mid] { // 左区间有序
            if nums[left] <= target && target < nums[mid] {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        } else { // 右区间有序
            if nums[mid] < target && target <= nums[right] {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
    }
    false
}

fn main() {
    let nums = vec![2, 5, 6, 0, 0, 1, 2];
    println!("{}", search(&nums, 0));
    println!("{}", search(&nums, 3));
}

输出：

true
false

---

🌟 每日一练刷题专栏 🌟

✨ 持续，努力奋斗做强刷题搬运工！

👍 点赞，你的认可是我坚持的动力！ 

🌟 收藏，你的青睐是我努力的方向！ 

✎ 评论，你的意见是我进步的财富！  

☸ 主页：https://hannyang.blog.csdn.net/

	Rust每日一练 专栏 （2023.5.16~）更新中...
	Golang每日一练 专栏 （2023.3.11~）更新中...
	Python每日一练 专栏 （2023.2.18~2023.5.18）暂停更
	C/C++每日一练 专栏 （2023.2.18~2023.5.18）暂停更
	Java每日一练 专栏 （2023.3.11~2023.5.18）暂停更