剑指 Offer 53 - I. 在排序数组中查找数字 I
难度简单145
统计一个数字在排序数组中出现的次数。
示例 1:
输入: nums = [5,7,7,8,8,10], target = 8
输出: 2
示例 2:
输入: nums = [5,7,7,8,8,10], target = 6
输出: 0
限制:
0 <= 数组长度 <= 50000
class Solution {
public int search(int[] nums, int target) {
// 搜索右边界 right
int i = 0, j = nums.length - 1;
while(i <= j) {
int m = (i + j) / 2;
if(nums[m] <= target) i = m + 1;
else j = m - 1;
}
int right = i;
// 若数组中无 target ,则提前返回
if(j >= 0 && nums[j] != target) return 0;
// 搜索左边界 right
i = 0; j = nums.length - 1;
while(i <= j) {
int m = (i + j) / 2;
if(nums[m] < target) i = m + 1;
else j = m - 1;
}
int left = j;
return right - left - 1;
}
}
class Solution {
public int search(int[] nums, int target) {
return helper(nums, target) - helper(nums, target - 1);
}
int helper(int[] nums, int tar) {
int i = 0, j = nums.length - 1;
while(i <= j) {
int m = (i + j) / 2;
if(nums[m] <= tar) i = m + 1;
else j = m - 1;
}
return i;
}
}
剑指 Offer 53 - II. 0~n-1中缺失的数字
难度简单149
一个长度为n-1的递增排序数组中的所有数字都是唯一的,并且每个数字都在范围0~n-1之内。在范围0~n-1内的n个数字中有且只有一个数字不在该数组中,请找出这个数字。
示例 1:
输入: [0,1,3]
输出: 2
示例 2:
输入: [0,1,2,3,4,5,6,7,9]
输出: 8
限制:
1 <= 数组长度 <= 10000
class Solution {
public int missingNumber(int[] nums) {
int i = 0, j = nums.length - 1;
while(i <= j) {
int m = (i + j) / 2;
if(nums[m] == m) i = m + 1;
else j = m - 1;
}
return i;
}
}
剑指 Offer 54. 二叉搜索树的第k大节点
难度简单170
给定一棵二叉搜索树,请找出其中第k大的节点。
示例 1:
输入: root = [3,1,4,null,2], k = 1
3
/ \
1 4
\
2
输出: 4
示例 2:
输入: root = [5,3,6,2,4,null,null,1], k = 3
5
/ \
3 6
/ \
2 4
/
1
输出: 4
限制:
1 ≤ k ≤ 二叉搜索树元素个数
后序遍历
class Solution {
public int kthLargest(TreeNode root, int k) {
if (root==null)
return 0;
dfs(root);
return arrayList.get(k-1);
}
ArrayList<Integer> arrayList=new ArrayList<>();
public void dfs(TreeNode root){
if (root!=null&&root.left==null&&root.right==null){
arrayList.add(root.val);
return;
}
if (root.right!=null)
dfs(root.right);
arrayList.add(root.val);
if (root.left!=null)
dfs(root.left);
}
}
参考别人的代码,优化之后的,遍历到k就return了
int count=0, res=0;//形参k不能随着dfs的迭代而不断变化,为了记录迭代进程和结果,引入类变量count和res。
public int kthLargest(TreeNode root, int k) {
this.count=k;//利用形参值k对类变量count进行初始化
dfs(root);//这里不要引入形参k,dfs中直接使用的是初始值为k的类变量count
return res;
}
public void dfs(TreeNode root){
if(root==null||count==0) return;//当root为空或者已经找到了res时,直接返回
dfs(root.right);
if(--count==0){//先--,再判断
res = root.val;
return;//这里的return可以避免之后的无效迭代dfs(root.left);
}
dfs(root.left);
}
剑指 Offer 55 - I. 二叉树的深度
难度简单124
输入一棵二叉树的根节点,求该树的深度。从根节点到叶节点依次经过的节点(含根、叶节点)形成树的一条路径,最长路径的长度为树的深度。
例如:
给定二叉树 [3,9,20,null,null,15,7]
,
3
/ \
9 20
/ \
15 7
返回它的最大深度 3 。
提示:
节点总数 <= 10000
- 关键点: 此树的深度和其左(右)子树的深度之间的关系。显然,此树的深度 等于 左子树的深度 与 右子树的深度 中的 最大值 +1 。
class Solution {
public int maxDepth(TreeNode root) {
if(root == null) return 0;
return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
}
}
//方法二:层序遍历(BFS)
//树的层序遍历 / 广度优先搜索往往利用 队列 实现。
//关键点: 每遍历一层,则计数器 +1,直到遍历完成,则可得到树的深度。
class Solution {
public int maxDepth(TreeNode root) {
if(root == null) return 0;
List<TreeNode> queue = new LinkedList<>() {{ add(root); }}, tmp;
int res = 0;
while(!queue.isEmpty()) {
tmp = new LinkedList<>();
for(TreeNode node : queue) {
if(node.left != null) tmp.add(node.left);
if(node.right != null) tmp.add(node.right);
}
queue = tmp;
res++;
}
return res;
}
}
剑指 Offer 55 - II. 平衡二叉树
难度简单166
输入一棵二叉树的根节点,判断该树是不是平衡二叉树。如果某二叉树中任意节点的左右子树的深度相差不超过1,那么它就是一棵平衡二叉树。
示例 1:
给定二叉树 [3,9,20,null,null,15,7]
3
/ \
9 20
/ \
15 7
返回 true
。
示例 2:
给定二叉树 [1,2,2,3,3,null,null,4,4]
1
/ \
2 2
/ \
3 3
/ \
4 4
返回 false
。
限制:
0 <= 树的结点个数 <= 10000
方法一:后序遍历 + 剪枝 (从底至顶)
此方法为本题的最优解法,但剪枝的方法不易第一时间想到。
思路是对二叉树做后序遍历,从底至顶返回子树深度,若判定某子树不是平衡树则 “剪枝” ,直接向上返回。
算法流程:
recur(root) 函数:
返回值:
当节点root 左 / 右子树的深度差 ≤1 :则返回当前子树的深度,即节点 root 的左 / 右子树的深度最大值 +1 ( max(left, right) + 1 );
当节点root 左 / 右子树的深度差 >2 :则返回 -1 ,代表 此子树不是平衡树 。
终止条件:
当 root 为空:说明越过叶节点,因此返回高度 0 ;
当左(右)子树深度为 -1 :代表此树的 左(右)子树 不是平衡树,因此剪枝,直接返回 -1 ;
class Solution {
public boolean isBalanced(TreeNode root) {
return recur(root) != -1;
}
private int recur(TreeNode root) {
if (root == null) return 0;
int left = recur(root.left);
if(left == -1) return -1;
int right = recur(root.right);
if(right == -1) return -1;
return Math.abs(left - right) < 2 ? Math.max(left, right) + 1 : -1;
}
}
方法二:先序遍历 + 判断深度 (从顶至底)
此方法容易想到,但会产生大量重复计算,时间复杂度较高。
思路是构造一个获取当前子树的深度的函数 depth(root)
(即 面试题55 - I. 二叉树的深度 ),通过比较某子树的左右子树的深度差 abs(depth(root.left) - depth(root.right)) <= 1
是否成立,来判断某子树是否是二叉平衡树。若所有子树都平衡,则此树平衡。
class Solution {
public boolean isBalanced(TreeNode root) {
if (root == null) return true;
return Math.abs(depth(root.left) - depth(root.right)) <= 1 && isBalanced(root.left) && isBalanced(root.right);
}
private int depth(TreeNode root) {
if (root == null) return 0;
return Math.max(depth(root.left), depth(root.right)) + 1;
}
}
剑指 Offer 56 - I. 数组中数字出现的次数
难度中等412
一个整型数组 nums
里除两个数字之外,其他数字都出现了两次。请写程序找出这两个只出现一次的数字。要求时间复杂度是O(n),空间复杂度是O(1)。
示例 1:
输入:nums = [4,1,4,6]
输出:[1,6] 或 [6,1]
示例 2:
输入:nums = [1,2,10,4,1,4,3,3]
输出:[2,10] 或 [10,2]
题目要求时间复杂度 O(N),空间复杂度 O(1),因此首先排除 暴力法 和 哈希表统计法 。
class Solution {
public int[] singleNumbers(int[] nums) {
int x = 0, y = 0, n = 0, m = 1;
for(int num : nums) // 1. 遍历异或
n ^= num;
while((n & m) == 0) // 2. 循环左移,计算 m
m <<= 1;
for(int num: nums) { // 3. 遍历 nums 分组
if((num & m) != 0) x ^= num; // 4. 当 num & m != 0
else y ^= num; // 4. 当 num & m == 0
}
return new int[] {x, y}; // 5. 返回出现一次的数字
}
}
剑指 Offer 56 - II. 数组中数字出现的次数 II
难度中等193
在一个数组 nums
中除一个数字只出现一次之外,其他数字都出现了三次。请找出那个只出现一次的数字。
示例 1:
输入:nums = [3,4,3,3]
输出:4
示例 2:
输入:nums = [9,1,7,9,7,9,7]
输出:1
限制:
1 <= nums.length <= 10000
1 <= nums[i] < 2^31
如下图所示,考虑数字的二进制形式,对于出现三次的数字,各 二进制位 出现的次数都是 3 的倍数。
因此,统计所有数字的各二进制位中 1 的出现次数,并对 3 求余,结果则为只出现一次的数字。
class Solution {
public int singleNumber(int[] nums) {
int[] counts = new int[32];
for(int num : nums) {
for(int j = 0; j < 32; j++) {
counts[j] += num & 1;
num >>>= 1;
}
}
int res = 0, m = 3;
for(int i = 0; i < 32; i++) {
res <<= 1;
res |= counts[31 - i] % m;
}
return res;
}
}
剑指 Offer 57. 和为s的两个数字
难度简单116
输入一个递增排序的数组和一个数字s,在数组中查找两个数,使得它们的和正好是s。如果有多对数字的和等于s,则输出任意一对即可。
示例 1:
输入:nums = [2,7,11,15], target = 9
输出:[2,7] 或者 [7,2]
示例 2:
输入:nums = [10,26,30,31,47,60], target = 40
输出:[10,30] 或者 [30,10]
限制:
1 <= nums.length <= 10^5
1 <= nums[i] <= 10^6
解题思路:
利用 HashMap 可以通过遍历数组找到数字组合,时间和空间复杂度均为 O(N) ;
注意本题的 nums是 排序数组 ,因此可使用 双指针法 将空间复杂度降低至 O(1) 。
算法流程:
-
初始化: 双指针 i, j 分别指向数组 nums的左右两端 (俗称对撞双指针)。
-
循环搜索:
当双指针相遇时跳出;
- 计算和 s = nums[i] + nums[j];
- 若 s > target,则指针 j 向左移动,即执行 j = j - 1;
- 若 s < target ,则指针 i 向右移动,即执行 i = i + 1;
- 若 s = target ,立即返回数组 [nums[i], nums[j]][num**s[i];
-
返回空数组,代表无和为 target的数字组合。
class Solution {
public int[] twoSum(int[] nums, int target) {
int i = 0, j = nums.length - 1;
while(i < j) {
int s = nums[i] + nums[j];
if(s < target) i++;
else if(s > target) j--;
else return new int[] { nums[i], nums[j] };
}
return new int[0];
}
}
剑指 Offer 57 - II. 和为s的连续正数序列
难度简单282
输入一个正整数 target
,输出所有和为 target
的连续正整数序列(至少含有两个数)。
序列内的数字由小到大排列,不同序列按照首个数字从小到大排列。
示例 1:
输入:target = 9
输出:[[2,3,4],[4,5]]
示例 2:
输入:target = 15
输出:[[1,2,3,4,5],[4,5,6],[7,8]]
限制:
1 <= target <= 10^5
方法二:滑动窗口(双指针)
设连续正整数序列的左边界 i 和右边界 j ,则可构建滑动窗口从左向右滑动。循环中,每轮判断滑动窗口内元素和与目标值 target 的大小关系,若相等则记录结果,若大于 target 则移动左边界 i (以减小窗口内的元素和),若小于 target则移动右边界 j (以增大窗口内的元素和)。
算法流程:
- 初始化: 左边界 i = 1,右边界 j = 2,元素和 s = 3 ,结果列表 res;
- 循环: 当i≥j 时跳出;
- 当 s > target时: 向右移动左边界 i = i + 1,并更新元素和 s ;
- 当 s < target时: 向右移动右边界 j = j + 1,并更新元素和 s ;
- 当 s = target时: 记录连续整数序列,并向右移动左边界 i = i + 1;
- 返回值: 返回结果列表 res;
class Solution {
public int[][] findContinuousSequence(int target) {
int i = 1, j = 2, s = 3;
List<int[]> res = new ArrayList<>();
while(i < j) {
if(s == target) {
int[] ans = new int[j - i + 1];
for(int k = i; k <= j; k++)
ans[k - i] = k;
res.add(ans);
}
if(s >= target) {
s -= i;
i++;
} else {
j++;
s += j;
}
}
return res.toArray(new int[0][]);
}
}
- !!!!!!
- 如果向左扩展窗口:比如 target 为10 ,以 1,2,3,4,5,6 为例,初始窗口[1,2] sum = 3 < target,首先此时窗口左边没有元素,无法扩展。 即使使用条件判断避免首次向左扩展,假设窗口能走到[1,2,3,4],此时sum == 10,满足条件, 然后更新窗口为[2,3,4],计算sum = 9 <target; 如果向左扩展,则又变为[1,2,3,4] 存在以下问题: 1. 该结果已经运算过了,会造成重复运算 2. 死循环,[1.2,3,4]计算过又变为[2,3,4],继续向左扩展会变成死循环。
剑指 Offer 58 - I. 翻转单词顺序
难度简单109
输入一个英文句子,翻转句子中单词的顺序,但单词内字符的顺序不变。为简单起见,标点符号和普通字母一样处理。例如输入字符串"I am a student. “,则输出"student. a am I”。
示例 1:
输入: "the sky is blue"
输出: "blue is sky the"
示例 2:
输入: " hello world! "
输出: "world! hello"
解释: 输入字符串可以在前面或者后面包含多余的空格,但是反转后的字符不能包括。
示例 3:
输入: "a good example"
输出: "example good a"
解释: 如果两个单词间有多余的空格,将反转后单词间的空格减少到只含一个。
说明:
- 无空格字符构成一个单词。
- 输入字符串可以在前面或者后面包含多余的空格,但是反转后的字符不能包括。
- 如果两个单词间有多余的空格,将反转后单词间的空格减少到只含一个。
方法一:双指针
算法解析:
- 倒序遍历字符串 s,记录单词左右索引边界 i, j;
- 每确定一个单词的边界,则将其添加至单词列表 res;
- 最终,将单词列表拼接为字符串,并返回即可。
class Solution {
public String reverseWords(String s) {
s = s.trim(); // 删除首尾空格
int j = s.length() - 1, i = j;
StringBuilder res = new StringBuilder();
while(i >= 0) {
while(i >= 0 && s.charAt(i) != ' ') i--; // 搜索首个空格
res.append(s.substring(i + 1, j + 1) + " "); // 添加单词
while(i >= 0 && s.charAt(i) == ' ') i--; // 跳过单词间空格
j = i; // j 指向下个单词的尾字符
}
return res.toString().trim(); // 转化为字符串并返回
}
}
方法二:分割 + 倒序
利用 “字符串分割”、“列表倒序” 的内置函数 (面试时不建议使用) ,可简便地实现本题的字符串翻转要求。
算法解析:
- Python : 由于 split()方法将单词间的 “多个空格看作一个空格” (参考自 split()和split(’ ')的区别 ),因此不会出现多余的 “空单词” 。因此,直接利用 reverse()方法翻转单词列表 strs** ,拼接为字符串并返回即可。
class Solution {
public String reverseWords(String s) {
String[] strs = s.trim().split(" "); // 删除首尾空格,分割字符串
StringBuilder res = new StringBuilder();
for(int i = strs.length - 1; i >= 0; i--) { // 倒序遍历单词列表
if(strs[i].equals("")) continue; // 遇到空单词则跳过
res.append(strs[i] + " "); // 将单词拼接至 StringBuilder
}
return res.toString().trim(); // 转化为字符串,删除尾部空格,并返回
}
}
方法二:分割 + 倒序
利用 “字符串分割”、“列表倒序” 的内置函数 (面试时不建议使用) ,可简便地实现本题的字符串翻转要求。
算法解析:
- Python : 由于 split()方法将单词间的 “多个空格看作一个空格” (参考自 split()和split(’ ')的区别 ),因此不会出现多余的 “空单词” 。因此,直接利用 reverse()方法翻转单词列表 strs** ,拼接为字符串并返回即可。
class Solution {
public String reverseWords(String s) {
String[] strs = s.trim().split(" "); // 删除首尾空格,分割字符串
StringBuilder res = new StringBuilder();
for(int i = strs.length - 1; i >= 0; i--) { // 倒序遍历单词列表
if(strs[i].equals("")) continue; // 遇到空单词则跳过
res.append(strs[i] + " "); // 将单词拼接至 StringBuilder
}
return res.toString().trim(); // 转化为字符串,删除尾部空格,并返回
}
}
剑指 Offer 58 - II. 左旋转字符串
难度简单129
字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如,输入字符串"abcdefg"和数字2,该函数将返回左旋转两位得到的结果"cdefgab"。
示例 1:
输入: s = "abcdefg", k = 2
输出: "cdefgab"
示例 2:
输入: s = "lrloseumgh", k = 6
输出: "umghlrlose"
限制:
- `1 <= k < s.length <= 10000
方法一:字符串切片
应用字符串切片函数,可方便实现左旋转字符串。
获取字符串 s[n:]切片和 s[:n]切片,使用 “+” 运算符拼接并返回即可。
复杂度分析:
- 时间复杂度 O(N): 其中 N 为字符串 s 的长度,字符串切片函数为线性时间复杂度(参考资料);
- 空间复杂度 O(N) : 两个字符串切片的总长度为 N 。
class Solution {
public String reverseLeftWords(String s, int n) {
return s.substring(n, s.length()) + s.substring(0, n);
}
}
方法二:列表遍历拼接
若面试规定不允许使用 切片函数 ,则使用此方法。
算法流程:
- 新建一个 list(Python)、StringBuilder(Java) ,记为 res;
- 先向 res添加 “第 n + 1位至末位的字符” ;
- 再向 res添加 “首位至第 n位的字符” ;
- 将 res转化为字符串并返回。
复杂度分析:
- 时间复杂度 O(N)\: 线性遍历 s 并添加,使用线性时间;
- 空间复杂度 O(N) : 新建的辅助 res使用 O(N) 大小的额外空间。
class Solution {
public String reverseLeftWords(String s, int n) {
StringBuilder res = new StringBuilder();
for(int i = n; i < s.length(); i++)
res.append(s.charAt(i));
for(int i = 0; i < n; i++)
res.append(s.charAt(i));
return res.toString();
}
}
方法三:字符串遍历拼接
class Solution {
public String reverseLeftWords(String s, int n) {
String res = "";
for(int i = n; i < s.length(); i++)
res += s.charAt(i);
for(int i = 0; i < n; i++)
res += s.charAt(i);
return res;
}
}
方法三测试:
在 Python 和 Java 中,字符串是 “不可变对象” 。因此,每轮遍历拼接字符时,都需要新建一个字符串;因此,系统 需申请 N 次内存 ,数据量较大时效率低下。
剑指 Offer 59 - I. 滑动窗口的最大值
难度困难280
给定一个数组 nums
和滑动窗口的大小 k
,请找出所有滑动窗口里的最大值。
示例:
输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3
输出: [3,3,5,5,6,7]
解释:
滑动窗口的位置 最大值
--------------- -----
[1 3 -1] -3 5 3 6 7 3
1 [3 -1 -3] 5 3 6 7 3
1 3 [-1 -3 5] 3 6 7 5
1 3 -1 [-3 5 3] 6 7 5
1 3 -1 -3 [5 3 6] 7 6
1 3 -1 -3 5 [3 6 7] 7
提示:
你可以假设 k 总是有效的,在输入数组不为空的情况下,1 ≤ k ≤ 输入数组的大小。
提示:
你可以假设 k 总是有效的,在输入数组不为空的情况下,1 ≤ k ≤ 输入数组的大小。
class Solution {
public int[] maxSlidingWindow(int[] nums, int k) {
if(nums.length == 0 || k == 0) return new int[0];
Deque<Integer> deque = new LinkedList<>();
int[] res = new int[nums.length - k + 1];
for(int j = 0, i = 1 - k; j < nums.length; i++, j++) {
// 删除 deque 中对应的 nums[i-1]
if(i > 0 && deque.peekFirst() == nums[i - 1])
deque.removeFirst();
// 保持 deque 递减
while(!deque.isEmpty() && deque.peekLast() < nums[j])
deque.removeLast();
deque.addLast(nums[j]);
// 记录窗口最大值
if(i >= 0)
res[i] = deque.peekFirst();
}
return res;
}
}
可以将 “未形成窗口” 和 “形成窗口后” 两个阶段拆分到两个循环里实现。代码虽变长,但减少了冗余的判断操作。
剑指 Offer 59 - II. 队列的最大值
难度中等253
请定义一个队列并实现函数 max_value
得到队列里的最大值,要求函数max_value
、push_back
和 pop_front
的均摊时间复杂度都是O(1)。
若队列为空,pop_front
和 max_value
需要返回 -1
示例 1:
输入:
["MaxQueue","push_back","push_back","max_value","pop_front","max_value"]
[[],[1],[2],[],[],[]]
输出: [null,null,null,2,1,2]
示例 2:
输入:
["MaxQueue","pop_front","max_value"]
[[],[],[]]
输出: [null,-1,-1]
限制:
1 <= push_back,pop_front,max_value的总操作数 <= 10000
1 <= value <= 10^5
方法二:维护一个单调的双端队列
那么如何高效实现一个始终递减的队列呢?我们只需要在插入每一个元素 value
时,从队列尾部依次取出比当前元素 value
小的元素,直到遇到一个比当前元素大的元素 value'
即可。
class MaxQueue {
Queue<Integer> q;
Deque<Integer> d;
public MaxQueue() {
q = new LinkedList<Integer>();
d = new LinkedList<Integer>();
}
public int max_value() {
if (d.isEmpty()) {
return -1;
}
return d.peekFirst();
}
public void push_back(int value) {
while (!d.isEmpty() && d.peekLast() < value) {
d.pollLast();
}
d.offerLast(value);
q.offer(value);
}
public int pop_front() {
if (q.isEmpty()) {
return -1;
}
int ans = q.poll();
if (ans == d.peekFirst()) {
d.pollFirst();
}
return ans;
}
}
回忆 剑指Offer 30. 包含 min 函数的栈 ,其使用 单调栈 实现了随意入栈、出栈情况下的 O(1)时间获取 “栈内最小值” 。本题同理,不同点在于 “出栈操作” 删除的是 “列表尾部元素” ,而 “窗口滑动” 删除的是 “列表首部元素” 。思考方式不同,细细掂量!!!
class Solution {
public boolean isStraight(int[] nums) {
int joker = 0;
Arrays.sort(nums); // 数组排序
for(int i = 0; i < 4; i++) {
if(nums[i] == 0) joker++; // 统计大小王数量
else if(nums[i] == nums[i + 1]) return false; // 若有重复,提前返回 false
}
return nums[4] - nums[joker] < 5; // 最大牌 - 最小牌 < 5 则可构成顺子
}
}
剑指 Offer 62. 圆圈中最后剩下的数字
难度简单386
0,1,···,n-1这n个数字排成一个圆圈,从数字0开始,每次从这个圆圈里删除第m个数字(删除后从下一个数字开始计数)。求出这个圆圈里剩下的最后一个数字。
例如,0、1、2、3、4这5个数字组成一个圆圈,从数字0开始每次删除第3个数字,则删除的前4个数字依次是2、0、4、1,因此最后剩下的数字是3。
示例 1:
输入: n = 5, m = 3
输出: 3
示例 2:
输入: n = 10, m = 17
输出: 2
限制:
1 <= n <= 10^5
1 <= m <= 10^6
方法:数学 + 递归
思路
题目中的要求可以表述为:给定一个长度为 n
的序列,每次向后数 m
个元素并删除,那么最终留下的是第几个元素?
这个问题很难快速给出答案。但是同时也要看到,这个问题似乎有拆分为较小子问题的潜质:如果我们知道对于一个长度 n - 1
的序列,留下的是第几个元素,那么我们就可以由此计算出长度为 n
的序列的答案。
算法
我们将上述问题建模为函数 f(n, m)
,该函数的返回值为最终留下的元素的序号。
首先,长度为 n
的序列会先删除第 m % n
个元素,然后剩下一个长度为 n - 1
的序列。那么,我们可以递归地求解 f(n - 1, m)
,就可以知道对于剩下的 n - 1
个元素,最终会留下第几个元素,我们设答案为 x = f(n - 1, m)
。
由于我们删除了第 m % n
个元素,将序列的长度变为 n - 1
。当我们知道了 f(n - 1, m)
对应的答案 x
之后,我们也就可以知道,长度为 n
的序列最后一个删除的元素,应当是从 m % n
开始数的第 x
个元素。因此有 f(n, m) = (m % n + x) % n = (m + x) % n
。
我们递归计算 f(n, m), f(n - 1, m), f(n - 2, m), ...
直到递归的终点 f(1, m)
。当序列长度为 1
时,一定会留下唯一的那个元素,它的编号为 0
。
下面的代码实现了上述的递归函数。
class Solution {
public int lastRemaining(int n, int m) {
return f(n, m);
}
public int f(int n, int m) {
if (n == 1) {
return 0;
}
int x = f(n - 1, m);
return (m + x) % n;
}
}
剑指 Offer 63. 股票的最大利润
难度中等130
假设把某股票的价格按照时间先后顺序存储在数组中,请问买卖该股票一次可能获得的最大利润是多少?
示例 1:
输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天(股票价格 = 1)的时候买入,在第 5 天(股票价格 = 6)的时候卖出,最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。
示例 2:
输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
限制:
0 <= 数组长度 <= 10^5
动态规划解析:
- 状态定义: 设动态规划列表 dp,dp[i]代表以 prices[i]为结尾的子数组的最大利润(以下简称为 前 i日的最大利润 )。
- 转移方程: 由于题目限定 “买卖该股票一次” ,因此前 i日最大利润 dp[i]等于前 i - 1 日最大利润 dp[i-1]和第 i 日卖出的最大利润中的最大值。
前 i 日最大利润 =前i日最大利润=max(前(i−1)日最大利润,第i日价格−前i日最低价格)
dp[i] =max(dp[i−1],prices[i]−min(prices[0:i]))
- 初始状态: dp[0] = 0,即首日利润为 0;
- 返回值: dp[n - 1],其中 n为 dp列表长度。
class Solution {
public int maxProfit(int[] prices) {
int cost = Integer.MAX_VALUE, profit = 0;
for(int price : prices) {
cost = Math.min(cost, price);
profit = Math.max(profit, price - cost);
}
return profit;
}
}