算法学习有些时候是枯燥的，每天学习一点点

算法题目

• 一. 单词接龙 II 题目描述
• • java 解答参考
• 二. 合并区间 题目描述
• • java 解答参考
• 三. 二叉搜索树的最近公共祖先 题目要求
• • java实现方案
• 四 寻找旋转排序数组中的最小值

一. 单词接龙 II 题目描述

按字典 wordList 完成从单词 beginWord 到单词 endWord 转化，一个表示此过程的 转换序列 是形式上像 beginWord -> s1 -> s2 -> … -> sk 这样的单词序列，并满足：

每对相邻的单词之间仅有单个字母不同。
转换过程中的每个单词 si（1 <= i <= k）必须是字典 wordList 中的单词。注意，beginWord 不必是字典 wordList 中的单词。 sk == endWord
给你两个单词 beginWord 和 endWord ，以及一个字典 wordList 。请你找出并返回所有从 beginWord 到 endWord 的 最短转换序列 ，如果不存在这样的转换序列，返回一个空列表。每个序列都应该以单词列表 [beginWord, s1, s2, …, sk] 的形式返回。

示例 1：

输入：beginWord = “hit”, endWord = “cog”, wordList = [“hot”,“dot”,“dog”,“lot”,“log”,“cog”]
输出：[[“hit”,“hot”,“dot”,“dog”,“cog”],[“hit”,“hot”,“lot”,“log”,“cog”]]
解释：存在 2 种最短的转换序列：
“hit” -> “hot” -> “dot” -> “dog” -> “cog”
“hit” -> “hot” -> “lot” -> “log” -> “cog”

示例 2：

输入：beginWord = “hit”, endWord = “cog”, wordList = [“hot”,“dot”,“dog”,“lot”,“log”]
输出：[]
解释：endWord “cog” 不在字典 wordList 中，所以不存在符合要求的转换序列。

提示：

1 <= beginWord.length <= 7
endWord.length == beginWord.length
1 <= wordList.length <= 5000
wordList[i].length == beginWord.length
beginWord、endWord 和 wordList[i] 由小写英文字母组成
beginWord != endWord
wordList 中的所有单词 互不相同

java 解答参考

class Solution {public List> findLadders(String beginWord, String endWord, List wordList) {List> res = new ArrayList<>();if (wordList == null)return res;Set dicts = new HashSet<>(wordList);if (!dicts.contains(endWord))return res;if (dicts.contains(beginWord))dicts.remove(beginWord);Set endList = new HashSet<>(),beginList = new HashSet<>();Map> map = new HashMap<>();beginList.add(beginWord);endList.add(endWord);bfs(map, beginList, endList, beginWord, endWord, dicts, false);List subList = new ArrayList<>();subList.add(beginWord);dfs(map, res, subList, beginWord, endWord);return res;}void dfs(Map> map,List> result, List subList,String beginWord, String endWord) {if (beginWord.equals(endWord)) {result.add(new ArrayList<>(subList));return;}if (!map.containsKey(beginWord)) {return;}for (String word : map.get(beginWord)) {subList.add(word);dfs(map, result, subList, word, endWord);subList.remove(subList.size() - 1);}}void bfs(Map> map, Set beginList, Set endList, String beginWord,String endWord, Set wordList, boolean reverse) {if (beginList.size() == 0)return;wordList.removeAll(beginList);boolean finish = false;Set temp = new HashSet<>();for (String str : beginList) {char[] charr = str.toCharArray();for (int chI = 0; chI < charr.length; chI++) {char old = charr[chI];for (char ch = 'a'; ch <= 'z'; ch++) {if (ch == old)continue;charr[chI] = ch;String newstr = new String(charr);if (!wordList.contains(newstr)) {continue;}if (endList.contains(newstr)) {finish = true;} else {temp.add(newstr);}String key = reverse ? newstr : str;String value = reverse ? str : newstr;if (!map.containsKey(key)) {map.put(key, new ArrayList<>());}map.get(key).add(value);}charr[chI] = old;}}if (!finish) {if (temp.size() > endList.size()) {bfs(map, endList, temp, beginWord, endWord, wordList, !reverse);} else {bfs(map, temp, endList, beginWord, endWord, wordList, reverse);}}}
}

二. 合并区间 题目描述

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。
示例 1：

输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

示例 2：

输入：intervals = [[1,4],[4,5]]
输出：[[1,5]]
解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。

提示：

1 <= intervals.length <= 104
intervals[i].length == 2
0 <= starti <= endi <= 104

java 解答参考

class Solution {public int[][] merge(int[][] intervals) {List res = new ArrayList<>();if (intervals == null) {return res.toArray(new int[0][]);}Arrays.sort(intervals, (a, b) -> a[0] - b[0]);int i = 0;int left = 0;int right = 0;while (i < intervals.length) {left = intervals[i][0];right = intervals[i][1];while (i < intervals.length - 1 && right >= intervals[i + 1][0]) {i++;right = Math.max(right, intervals[i][1]);}res.add(new int[] { left, right });i++;}return res.toArray(new int[0][]);}
}

三. 二叉搜索树的最近公共祖先 题目要求

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。
什么是最近公共祖先呢？百度百科解释 中将最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

例如，给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]

示例 1:
输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
输出: 6
解释: 节点

2

和节点

8

的最近公共祖先是

6

示例 2:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
输出: 2
解释: 节点

2

和节点

4

的最近公共祖先是

2

因为根据定义最近公共祖先节点可以为节点本身。
说明:
所有节点的值都是唯一的。
p、q 为不同节点且均存在于给定的二叉搜索树中。

java实现方案

所以用代码实现方式是:

public class TreeNode {int val;TreeNode left;TreeNode right;TreeNode(int x) {val = x;}
}
class Solution {public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {if (p.val >= root.val && q.val >= root.val)return lowestCommonAncestor(root.left, p, q);else if (p.val > root.val && q.val > root.val)return lowestCommonAncestor(root.right, p, q);elsereturn root;}
}

四 寻找旋转排序数组中的最小值

已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：

若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]
若旋转 7 次，则可以得到 [0,1,2,4,5,6,7]

注意，数组 [a[0], a[1], a[2], …, a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], …, a[n-2]] 。

给你一个元素值 互不相同 的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。

示例 1：

输入：nums = [3,4,5,1,2]
输出：1
解释：原数组为 [1,2,3,4,5] ，旋转 3 次得到输入数组。

示例 2：

输入：nums = [4,5,6,7,0,1,2]
输出：0
解释：原数组为 [0,1,2,4,5,6,7] ，旋转 4 次得到输入数组。

示例 3：

输入：nums = [11,13,15,17]
输出：11
解释：原数组为 [11,13,15,17] ，旋转 4 次得到输入数组。

提示：

n == nums.length
1 <= n <= 5000
-5000 <= nums[i] <= 5000
nums 中的所有整数 互不相同
nums 原来是一个升序排序的数组，并进行了 1 至 n 次旋转

class Solution {public int findMin(int[] nums) {int low = 0, high = nums.length - 1, mid = 0;while (low <= high) {mid = (low + high) / 2;if (nums[mid] > nums[high])low = mid + 1;else if (nums[mid] < nums[high])high = mid;elsehigh--;}return nums[low];}
}