跳到主要内容

131 篇博文 含有标签「数组」

查看所有标签

· 阅读需 4 分钟

1、题干

根据 逆波兰表示法,求该后缀表达式的计算结果。

有效的算符包括 +-*/ 。每个运算对象可以是整数,也可以是另一个逆波兰表达式。

 

说明:

  • 整数除法只保留整数部分。
  • 给定逆波兰表达式总是有效的。换句话说,表达式总会得出有效数值且不存在除数为 0 的情况。

 

示例 1:

输入:tokens = ["2","1","+","3","*"]
输出:9
解释:该算式转化为常见的中缀算术表达式为:((2 + 1) * 3) = 9

示例 2:

输入:tokens = ["4","13","5","/","+"]
输出:6
解释:该算式转化为常见的中缀算术表达式为:(4 + (13 / 5)) = 6

示例 3:

输入:tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
输出:22
解释:
该算式转化为常见的中缀算术表达式为:
((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22

 

提示:

  • 1 <= tokens.length <= 104
  • tokens[i] 要么是一个算符("+""-""*""/"),要么是一个在范围 [-200, 200] 内的整数

 

逆波兰表达式:

逆波兰表达式是一种后缀表达式,所谓后缀就是指算符写在后面。

  • 平常使用的算式则是一种中缀表达式,如 ( 1 + 2 ) * ( 3 + 4 )
  • 该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * )

逆波兰表达式主要有以下两个优点:

  • 去掉括号后表达式无歧义,上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。
  • 适合用栈操作运算:遇到数字则入栈;遇到算符则取出栈顶两个数字进行计算,并将结果压入栈中。

 

注意:本题与主站 150 题相同: https://leetcode-cn.com/problems/evaluate-reverse-polish-notation/

执行结果

1.png

解题思路

  • 遍历tokens中的所有元素
  • 遇到数字则入栈
  • 遇到运算符,则取栈顶两个元素计算,结果入栈
  • 遍历结束,栈中只剩运算结果

代码

const evalRPN = tokens => {
return tokens.reduce((acc, cur) => {
if ('0' <= cur[cur.length - 1] && cur[cur.length - 1] <= '9') return acc.push(+cur), acc;
const n2 = acc.pop(), n1 = acc.pop();
if (cur === '+') return acc.push(n1 + n2), acc;
if (cur === '-') return acc.push(n1 - n2), acc;
if (cur === '*') return acc.push(n1 * n2), acc;
if (cur === '/') return acc.push(Math.trunc(n1 / n2)), acc;
}, [])[0];
};

· 阅读需 4 分钟

1、题干

给定一个整数数组 asteroids,表示在同一行的小行星。

对于数组中的每一个元素,其绝对值表示小行星的大小,正负表示小行星的移动方向(正表示向右移动,负表示向左移动)。每一颗小行星以相同的速度移动。

找出碰撞后剩下的所有小行星。碰撞规则:两个行星相互碰撞,较小的行星会爆炸。如果两颗行星大小相同,则两颗行星都会爆炸。两颗移动方向相同的行星,永远不会发生碰撞。

 

示例 1:

输入:asteroids = [5,10,-5]
输出:[5,10]
解释:10 和 -5 碰撞后只剩下 10 。 5 和 10 永远不会发生碰撞。

示例 2:

输入:asteroids = [8,-8]
输出:[]
解释:8 和 -8 碰撞后,两者都发生爆炸。

示例 3:

输入:asteroids = [10,2,-5]
输出:[10]
解释:2 和 -5 发生碰撞后剩下 -5 。10 和 -5 发生碰撞后剩下 10 。

示例 4:

输入:asteroids = [-2,-1,1,2]
输出:[-2,-1,1,2]
解释-2 和 -1 向左移动,而 1 和 2 向右移动。 由于移动方向相同的行星不会发生碰撞,所以最终没有行星发生碰撞。

 

提示:

  • 2 <= asteroids.length <= 104
  • -1000 <= asteroids[i] <= 1000
  • asteroids[i] != 0

 

注意:本题与主站 735 题相同: https://leetcode-cn.com/problems/asteroid-collision/

2、解题思路

总体思路 :遍历asteroids中的所有行星,判断栈顶行星与当前遍历到的行星是否可以碰撞,并按碰撞规则加以处理。

大体步骤

  • 创建栈用于存储行星
  • 遍历asteroids中的所有行星,检测栈顶行星与当前行星asteroids[i]是否可以碰撞
    • 栈为空或者栈顶行星与当前行星无法碰撞,当前行星入栈
    • 栈不为空,栈顶行星与当前行星可以碰撞
      • 如果栈顶行星比当前行星更小则循环出栈,直到栈顶行星不小于当前行星
      • 如果栈为空或者栈顶行星与当前行星无法碰撞,当前行星入栈
      • 如果栈顶行星与当前行星大小相同,栈顶行星出栈
      • 其他情况不做处理,进入下一轮遍历
  • 返回栈内所有行星

本题的解题思路不难,难的是边界情况的处理

3、代码

var asteroidCollision = function (asteroids) {
return asteroids.reduce((acc, cur) => {
if (!(acc[acc.length - 1] > 0 && cur < 0)) return acc.push(cur), acc;
while (0 < acc[acc.length - 1] && acc[acc.length - 1] < -cur) acc.pop();
if (!acc.length || acc[acc.length - 1] < 0) acc.push(cur);
else if (acc[acc.length - 1] === -cur) acc.pop();
return acc;
}, []);
};

4、执行结果

1.png

· 阅读需 4 分钟

1、题干

根据 逆波兰表示法,求该后缀表达式的计算结果。

有效的算符包括 +-*/ 。每个运算对象可以是整数,也可以是另一个逆波兰表达式。

 

说明:

  • 整数除法只保留整数部分。
  • 给定逆波兰表达式总是有效的。换句话说,表达式总会得出有效数值且不存在除数为 0 的情况。

 

示例 1:

输入:tokens = ["2","1","+","3","*"]
输出:9
解释:该算式转化为常见的中缀算术表达式为:((2 + 1) * 3) = 9

示例 2:

输入:tokens = ["4","13","5","/","+"]
输出:6
解释:该算式转化为常见的中缀算术表达式为:(4 + (13 / 5)) = 6

示例 3:

输入:tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
输出:22
解释:
该算式转化为常见的中缀算术表达式为:
((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22

 

提示:

  • 1 <= tokens.length <= 104
  • tokens[i] 要么是一个算符("+""-""*""/"),要么是一个在范围 [-200, 200] 内的整数

 

逆波兰表达式:

逆波兰表达式是一种后缀表达式,所谓后缀就是指算符写在后面。

  • 平常使用的算式则是一种中缀表达式,如 ( 1 + 2 ) * ( 3 + 4 )
  • 该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * )

逆波兰表达式主要有以下两个优点:

  • 去掉括号后表达式无歧义,上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。
  • 适合用栈操作运算:遇到数字则入栈;遇到算符则取出栈顶两个数字进行计算,并将结果压入栈中。

 

注意:本题与主站 150 题相同: https://leetcode-cn.com/problems/evaluate-reverse-polish-notation/

执行结果

1.png

解题思路

  • 遍历tokens中的所有元素
  • 遇到数字则入栈
  • 遇到运算符,则取栈顶两个元素计算,结果入栈
  • 遍历结束,栈中只剩运算结果

代码

const evalRPN = tokens => {
return tokens.reduce((acc, cur) => {
if ('0' <= cur[cur.length - 1] && cur[cur.length - 1] <= '9') return acc.push(+cur), acc;
const n2 = acc.pop(), n1 = acc.pop();
if (cur === '+') return acc.push(n1 + n2), acc;
if (cur === '-') return acc.push(n1 - n2), acc;
if (cur === '*') return acc.push(n1 * n2), acc;
if (cur === '/') return acc.push(Math.trunc(n1 / n2)), acc;
}, [])[0];
};

· 阅读需 4 分钟

1、题干

给定一个整数数组 asteroids,表示在同一行的小行星。

对于数组中的每一个元素,其绝对值表示小行星的大小,正负表示小行星的移动方向(正表示向右移动,负表示向左移动)。每一颗小行星以相同的速度移动。

找出碰撞后剩下的所有小行星。碰撞规则:两个行星相互碰撞,较小的行星会爆炸。如果两颗行星大小相同,则两颗行星都会爆炸。两颗移动方向相同的行星,永远不会发生碰撞。

 

示例 1:

输入:asteroids = [5,10,-5]
输出:[5,10]
解释:10 和 -5 碰撞后只剩下 10 。 5 和 10 永远不会发生碰撞。

示例 2:

输入:asteroids = [8,-8]
输出:[]
解释:8 和 -8 碰撞后,两者都发生爆炸。

示例 3:

输入:asteroids = [10,2,-5]
输出:[10]
解释:2 和 -5 发生碰撞后剩下 -5 。10 和 -5 发生碰撞后剩下 10 。

示例 4:

输入:asteroids = [-2,-1,1,2]
输出:[-2,-1,1,2]
解释-2 和 -1 向左移动,而 1 和 2 向右移动。 由于移动方向相同的行星不会发生碰撞,所以最终没有行星发生碰撞。

 

提示:

  • 2 <= asteroids.length <= 104
  • -1000 <= asteroids[i] <= 1000
  • asteroids[i] != 0

 

注意:本题与主站 735 题相同: https://leetcode-cn.com/problems/asteroid-collision/

2、解题思路

总体思路 :遍历asteroids中的所有行星,判断栈顶行星与当前遍历到的行星是否可以碰撞,并按碰撞规则加以处理。

大体步骤

  • 创建栈用于存储行星
  • 遍历asteroids中的所有行星,检测栈顶行星与当前行星asteroids[i]是否可以碰撞
    • 栈为空或者栈顶行星与当前行星无法碰撞,当前行星入栈
    • 栈不为空,栈顶行星与当前行星可以碰撞
      • 如果栈顶行星比当前行星更小则循环出栈,直到栈顶行星不小于当前行星
      • 如果栈为空或者栈顶行星与当前行星无法碰撞,当前行星入栈
      • 如果栈顶行星与当前行星大小相同,栈顶行星出栈
      • 其他情况不做处理,进入下一轮遍历
  • 返回栈内所有行星

本题的解题思路不难,难的是边界情况的处理

3、代码

var asteroidCollision = function (asteroids) {
return asteroids.reduce((acc, cur) => {
if (!(acc[acc.length - 1] > 0 && cur < 0)) return acc.push(cur), acc;
while (0 < acc[acc.length - 1] && acc[acc.length - 1] < -cur) acc.pop();
if (!acc.length || acc[acc.length - 1] < 0) acc.push(cur);
else if (acc[acc.length - 1] === -cur) acc.pop();
return acc;
}, []);
};

4、执行结果

1.png

· 阅读需 5 分钟

1、题干

给定一个 24 小时制(小时:分钟 "HH:MM")的时间列表,找出列表中任意两个时间的最小时间差并以分钟数表示。

 

示例 1:

输入:timePoints = ["23:59","00:00"]
输出:1

示例 2:

输入:timePoints = ["00:00","23:59","00:00"]
输出:0

 

提示:

  • 2 <= timePoints.length <= 2 * 104
  • timePoints[i] 格式为 "HH:MM"

2、解法1-API排序

前置处理:先排除3种特殊情况

  • 鸽巢原理:timePoints.length > 1440,最小差值为0。因为分钟数最多1440种情况,如果分钟数量超过1440,则必定有重复值。
  • 哈希去重:new Set(timePoints).size < timePoints.length,表示有重复值,最小差值为0。可以只用哈希去重而不用鸽巢原理,这里两个都用一是为省空间,二是为下一个限制条件提前去重。
  • 相邻原理(瞎扯的):timePoints.length > 720最小差值为1。因为分钟数最多1440种情况,如果分钟数超过一半而没有重复值,则必定有分钟数相邻。

后续步骤:把时间字符串转为分钟数,直接API排序并计算最小差值

  • timePoints中的时间字符串HH:MM转成分钟数(0-1400),构建出新的分钟数数组times
  • times进行升序排序
  • times数组末尾推入1440+times[0](最小分钟数),使得最小时间和最大时间的差值计算常规化
  • 对相邻分钟数求差值,最后返回最小差值

3、复杂度

  • 时间复杂度:O(C)O(C),其中2<=C<=720log7202<=C<=720*log720
  • 空间复杂度:O(C)O(C)

4、代码

var findMinDifference = function (timePoints) {
if (timePoints.length > 1440 || new Set(timePoints).size < timePoints.length) return 0;
if (timePoints.length > 720) return 1;

const times = timePoints.map(p => 60 * (p[0] + p[1]) + 1 * (p[3] + p[4]));
times.sort((a, b) => a - b).push(1440 + times[0]);

return times.reduce((a, c, i) => i ? Math.min(a, c - times[i - 1]) : a, 1440);
};

5、执行结果

0.png


6、解法2-计数排序

前置处理:先排除3种特殊情况(同解法1)

  • 鸽巢原理:timePoints.length > 1440,最小差值为0。因为分钟数最多1440种情况,如果分钟数量超过1440,则必定有重复值。
  • 哈希去重:new Set(timePoints).size < timePoints.length,表示有重复值,最小差值为0。可以只用哈希去重而不用鸽巢原理,这里两个都用一是为省空间,二是为下一个限制条件提前去重。
  • 相邻原理(瞎扯的):timePoints.length > 720最小差值为1。因为分钟数最多1440种情况,如果分钟数超过一半而没有重复值,则必定有分钟数相邻。

后续步骤:把时间字符串转为分钟数,使用计数排序并计算最小差值

  • 创建以分钟数为下标的数组 times,将 timePoints 中的时间字符串HH:MM转成分钟数,对 times 中的分钟数进行计数
  • 对相邻分钟数求差值,计算出最小差值 minDiff
  • 计算最小时间和最大时间的差值,并与上一步的最小值比较,最终结果是:Math.min(minDiff, 1440 + minTime - maxTime);

7、复杂度

  • 时间复杂度:O(C)O(C),其中C=1440C=1440
  • 空间复杂度:O(C)O(C)

8、代码

var findMinDifference = function (timePoints) {
if (timePoints.length > 1440 || new Set(timePoints).size < timePoints.length) return 0;
if (timePoints.length > 720) return 1;

const times = new Array(1440).fill(0);
for (const p of timePoints) {
times[60 * (p[0] + p[1]) + 1 * (p[3] + p[4])] += 1;
}

let minDiff = 1440, prev = -1440, minTime;
for (let i = 0; i < times.length; i++) {
if (minTime === undefined && times[i]) minTime = i;
if (times[i]) minDiff = Math.min(minDiff, i - prev), prev = i;
}

return Math.min(minDiff, 1440 + minTime - prev);
};

9、执行结果

1.png

· 阅读需 4 分钟

1、题干

某种外星语也使用英文小写字母,但可能顺序 order 不同。字母表的顺序(order)是一些小写字母的排列。

给定一组用外星语书写的单词 words,以及其字母表的顺序 order,只有当给定的单词在这种外星语中按字典序排列时,返回 true;否则,返回 false

 

示例 1:

输入:words = ["hello","leetcode"], order = "hlabcdefgijkmnopqrstuvwxyz"
输出:true
解释:在该语言的字母表中,'h' 位于 'l' 之前,所以单词序列是按字典序排列的。

示例 2:

输入:words = ["word","world","row"], order = "worldabcefghijkmnpqstuvxyz"
输出:false
解释:在该语言的字母表中,'d' 位于 'l' 之后,那么 words[0] > words[1],因此单词序列不是按字典序排列的。

示例 3:

输入:words = ["apple","app"], order = "abcdefghijklmnopqrstuvwxyz"
输出:false
解释:当前三个字符 "app" 匹配时,第二个字符串相对短一些,然后根据词典编纂规则 "apple" > "app",因为 'l' > '∅',其中 '∅' 是空白字符,定义为比任何其他字符都小(更多信息)。

 

提示:

  • 1 <= words.length <= 100
  • 1 <= words[i].length <= 20
  • order.length == 26
  • 在 words[i] 和 order 中的所有字符都是英文小写字母。

解题思路

思路 将words中的所有字符替换为正常字典序的字符,然后使用比较运算符(大于号、小于号等)去比较所有words即可。

例子 words = ["hl","la"], order = "hlabcdefgijkmnopqrstuvwxyz"

  • words中的字符替换为正常字典序的字符,结果为:words = ["ab","bc"]
  • 使用比较运算符比较所有words"ab"<"bc"结果为true,最终返回true

步骤

  • 创建哈希映射map,遍历order,获得外星字典序(键)与正常字典序(值)的映射
  • 遍历words中的所有字符串
    • words[i]中的字符替换为正常字典序的字符
    • 使用比较运算符比较words[i]words[i - 1]的大小
    • 如果i && words[i] < words[i - 1]则不符合外星字典序直接返回false
  • 函数运行到结尾,则说明符合外星字典序,返回true

代码

var isAlienSorted = function (words, order) {
const map = new Map();
for (let i = 0; i < order.length; i++) map.set(order[i], String.fromCharCode(97 + i));

for (let i = 0; i < words.length; i++) {
words[i] = [...words[i]].reduce((a, c) => a + map.get(c), '');
if (i && words[i] < words[i - 1]) return false;
}

return true;
};

· 阅读需 4 分钟

1、题干

某种外星语也使用英文小写字母,但可能顺序 order 不同。字母表的顺序(order)是一些小写字母的排列。

给定一组用外星语书写的单词 words,以及其字母表的顺序 order,只有当给定的单词在这种外星语中按字典序排列时,返回 true;否则,返回 false

 

示例 1:

输入:words = ["hello","leetcode"], order = "hlabcdefgijkmnopqrstuvwxyz"
输出:true
解释:在该语言的字母表中,'h' 位于 'l' 之前,所以单词序列是按字典序排列的。

示例 2:

输入:words = ["word","world","row"], order = "worldabcefghijkmnpqstuvxyz"
输出:false
解释:在该语言的字母表中,'d' 位于 'l' 之后,那么 words[0] > words[1],因此单词序列不是按字典序排列的。

示例 3:

输入:words = ["apple","app"], order = "abcdefghijklmnopqrstuvwxyz"
输出:false
解释:当前三个字符 "app" 匹配时,第二个字符串相对短一些,然后根据词典编纂规则 "apple" > "app",因为 'l' > '∅',其中 '∅' 是空白字符,定义为比任何其他字符都小(更多信息)。

 

提示:

  • 1 <= words.length <= 100
  • 1 <= words[i].length <= 20
  • order.length == 26
  • 在 words[i] 和 order 中的所有字符都是英文小写字母。

 

注意:本题与主站 953 题相同: https://leetcode-cn.com/problems/verifying-an-alien-dictionary/

解题思路

思路 将words中的所有字符替换为正常字典序的字符,然后使用比较运算符(大于号、小于号等)去比较所有words即可。

例子 words = ["hl","la"], order = "hlabcdefgijkmnopqrstuvwxyz"

  • words中的字符替换为正常字典序的字符,结果为:words = ["ab","bc"]
  • 使用比较运算符比较所有words"ab"<"bc"结果为true,最终返回true

步骤

  • 创建哈希映射map,遍历order,获得外星字典序(键)与正常字典序(值)的映射
  • 遍历words中的所有字符串
    • words[i]中的字符替换为正常字典序的字符
    • 使用比较运算符比较words[i]words[i - 1]的大小
    • 如果i && words[i] < words[i - 1]则不符合外星字典序直接返回false
  • 函数运行到结尾,则说明符合外星字典序,返回true

代码

var isAlienSorted = function (words, order) {
const map = new Map();
for (let i = 0; i < order.length; i++) map.set(order[i], String.fromCharCode(97 + i));

for (let i = 0; i < words.length; i++) {
words[i] = [...words[i]].reduce((a, c) => a + map.get(c), '');
if (i && words[i] < words[i - 1]) return false;
}

return true;
};

· 阅读需 4 分钟

1、题干

给定一个 24 小时制(小时:分钟 "HH:MM")的时间列表,找出列表中任意两个时间的最小时间差并以分钟数表示。

 

示例 1:

输入:timePoints = ["23:59","00:00"]
输出:1

示例 2:

输入:timePoints = ["00:00","23:59","00:00"]
输出:0

 

提示:

  • 2 <= timePoints.length <= 2 * 104
  • timePoints[i] 格式为 "HH:MM"

 

注意:本题与主站 539 题相同: https://leetcode-cn.com/problems/minimum-time-difference/

解法1

执行结果

0.png

解题思路

前置处理:先排除几种特殊情况:timePoints.length > 1440timePoints.length > 720new Set(timePoints).size < timePoints.length

  • timePoints.length > 1440new Set(timePoints).size < timePoints.length,则必定有重复值,最小差值为0
  • timePoints.length > 720最小差值为1。因为分钟数最多1440种情况,如果分钟数量超过一半,则必定有分钟数相邻

后续步骤:把时间字符串转为分钟数,直接排序并计算最小差值

  • timePoints中的时间字符串HH:MM转成分钟数(0-1400),构建出新的分钟数数组times
  • times进行升序排序
  • times数组末尾推入1440+times[0](最小分钟数),使得最小时间和最大时间的差值计算常规化
  • 对相邻分钟数求差值,最后返回最小差值

整体时间复杂度为O(C)O(C),其中2<=C<=720log7202<=C<=720*log720

代码

var findMinDifference = function (timePoints) {
if (timePoints.length > 1440 || new Set(timePoints).size < timePoints.length) return 0;
if (timePoints.length > 720) return 1;

const times = timePoints.map(p => p.split(':').reduce((a, c, i) => a + (+c) * (i ? 1 : 60), 0));
times.sort((a, b) => a - b).push(1440 + times[0]);

return times.reduce((a, c, i) => i ? Math.min(a, c - times[i - 1]) : a, 1440);
};

2、解法2

执行结果

1.png

解题思路

前置处理:先排除几种特殊情况:timePoints.length > 1440timePoints.length > 720new Set(timePoints).size < timePoints.length

  • timePoints.length > 1440new Set(timePoints).size < timePoints.length,则必定有重复值,最小差值为0
  • timePoints.length > 720最小差值为1。因为分钟数最多1440种情况,如果分钟数量超过一半,则必定有分钟数相邻

后续步骤:把时间字符串转为分钟数,使用计数排序并计算最小差值

  • 创建以分钟数为下标的数组times,将timePoints中的时间字符串HH:MM转成分钟数,对times中的分钟数进行计数
  • 对相邻分钟数求差值,计算出最小差值
  • 计算最小时间和最大时间的差值,并与上一步的最小值比较,最终结果是:Math.min(min, 1440 + minTime - maxTime);

整体时间复杂度为O(C)O(C),其中2<=C<=14402<=C<=1440

代码

var findMinDifference = function (timePoints) {
if (timePoints.length > 1440 || new Set(timePoints).size < timePoints.length) return 0;
if (timePoints.length > 720) return 1;

const times = new Array(1440).fill(0);
for (let p of timePoints) {
times[p.split(':').reduce((a, c, i) => a + (+c) * (i ? 1 : 60), 0)] += 1;
}

let min = 1440, prev = -1440, minTime;
for (let i = 0; i < times.length; i++) {
if (minTime === undefined && times[i]) minTime = i;
if (times[i]) min = Math.min(min, i - prev), prev = i;
}

return Math.min(min, 1440 + minTime - prev);
};

· 阅读需 4 分钟

1、题干

某种外星语也使用英文小写字母,但可能顺序 order 不同。字母表的顺序(order)是一些小写字母的排列。

给定一组用外星语书写的单词 words,以及其字母表的顺序 order,只有当给定的单词在这种外星语中按字典序排列时,返回 true;否则,返回 false

 

示例 1:

输入:words = ["hello","leetcode"], order = "hlabcdefgijkmnopqrstuvwxyz"
输出:true
解释:在该语言的字母表中,'h' 位于 'l' 之前,所以单词序列是按字典序排列的。

示例 2:

输入:words = ["word","world","row"], order = "worldabcefghijkmnpqstuvxyz"
输出:false
解释:在该语言的字母表中,'d' 位于 'l' 之后,那么 words[0] > words[1],因此单词序列不是按字典序排列的。

示例 3:

输入:words = ["apple","app"], order = "abcdefghijklmnopqrstuvwxyz"
输出:false
解释:当前三个字符 "app" 匹配时,第二个字符串相对短一些,然后根据词典编纂规则 "apple" > "app",因为 'l' > '∅',其中 '∅' 是空白字符,定义为比任何其他字符都小(更多信息)。

 

提示:

  • 1 <= words.length <= 100
  • 1 <= words[i].length <= 20
  • order.length == 26
  • 在 words[i] 和 order 中的所有字符都是英文小写字母。

 

注意:本题与主站 953 题相同: https://leetcode-cn.com/problems/verifying-an-alien-dictionary/

解题思路

思路 将words中的所有字符替换为正常字典序的字符,然后使用比较运算符(大于号、小于号等)去比较所有words即可。

例子 words = ["hl","la"], order = "hlabcdefgijkmnopqrstuvwxyz"

  • words中的字符替换为正常字典序的字符,结果为:words = ["ab","bc"]
  • 使用比较运算符比较所有words"ab"<"bc"结果为true,最终返回true

步骤

  • 创建哈希映射map,遍历order,获得外星字典序(键)与正常字典序(值)的映射
  • 遍历words中的所有字符串
    • words[i]中的字符替换为正常字典序的字符
    • 使用比较运算符比较words[i]words[i - 1]的大小
    • 如果i && words[i] < words[i - 1]则不符合外星字典序直接返回false
  • 函数运行到结尾,则说明符合外星字典序,返回true

代码

var isAlienSorted = function (words, order) {
const map = new Map();
for (let i = 0; i < order.length; i++) map.set(order[i], String.fromCharCode(97 + i));

for (let i = 0; i < words.length; i++) {
words[i] = [...words[i]].reduce((a, c) => a + map.get(c), '');
if (i && words[i] < words[i - 1]) return false;
}

return true;
};

· 阅读需 4 分钟

1、题干

给定一个 24 小时制(小时:分钟 "HH:MM")的时间列表,找出列表中任意两个时间的最小时间差并以分钟数表示。

 

示例 1:

输入:timePoints = ["23:59","00:00"]
输出:1

示例 2:

输入:timePoints = ["00:00","23:59","00:00"]
输出:0

 

提示:

  • 2 <= timePoints <= 2 * 104
  • timePoints[i] 格式为 "HH:MM"

 

注意:本题与主站 539 题相同: https://leetcode-cn.com/problems/minimum-time-difference/

解法1

执行结果

0.png

解题思路

前置处理:先排除几种特殊情况:timePoints.length > 1440timePoints.length > 720new Set(timePoints).size < timePoints.length

  • timePoints.length > 1440new Set(timePoints).size < timePoints.length,则必定有重复值,最小差值为0
  • timePoints.length > 720最小差值为1。因为分钟数最多1440种情况,如果分钟数量超过一半,则必定有分钟数相邻

后续步骤:把时间字符串转为分钟数,直接排序并计算最小差值

  • timePoints中的时间字符串HH:MM转成分钟数(0-1400),构建出新的分钟数数组times
  • times进行升序排序
  • times数组末尾推入1440+times[0](最小分钟数),使得最小时间和最大时间的差值计算常规化
  • 对相邻分钟数求差值,最后返回最小差值

整体时间复杂度为O(C)O(C),其中2<=C<=720log7202<=C<=720*log720

代码

var findMinDifference = function (timePoints) {
if (timePoints.length > 1440 || new Set(timePoints).size < timePoints.length) return 0;
if (timePoints.length > 720) return 1;

const times = timePoints.map(p => p.split(':').reduce((a, c, i) => a + (+c) * (i ? 1 : 60), 0));
times.sort((a, b) => a - b).push(1440 + times[0]);

return times.reduce((a, c, i) => i ? Math.min(a, c - times[i - 1]) : a, 1440);
};

2、解法2

执行结果

1.png

解题思路

前置处理:先排除几种特殊情况:timePoints.length > 1440timePoints.length > 720new Set(timePoints).size < timePoints.length

  • timePoints.length > 1440new Set(timePoints).size < timePoints.length,则必定有重复值,最小差值为0
  • timePoints.length > 720最小差值为1。因为分钟数最多1440种情况,如果分钟数量超过一半,则必定有分钟数相邻

后续步骤:把时间字符串转为分钟数,使用计数排序并计算最小差值

  • 创建以分钟数为下标的数组times,将timePoints中的时间字符串HH:MM转成分钟数,对times中的分钟数进行计数
  • 对相邻分钟数求差值,计算出最小差值
  • 计算最小时间和最大时间的差值,并与上一步的最小值比较,最终结果是:Math.min(min, 1440 + minTime - maxTime);

整体时间复杂度为O(C)O(C),其中2<=C<=14402<=C<=1440

代码

var findMinDifference = function (timePoints) {
if (timePoints.length > 1440 || new Set(timePoints).size < timePoints.length) return 0;
if (timePoints.length > 720) return 1;

const times = new Array(1440).fill(0);
for (let p of timePoints) {
times[p.split(':').reduce((a, c, i) => a + (+c) * (i ? 1 : 60), 0)] += 1;
}

let min = 1440, prev = -1440, minTime;
for (let i = 0; i < times.length; i++) {
if (minTime === undefined && times[i]) minTime = i;
if (times[i]) min = Math.min(min, i - prev), prev = i;
}

return Math.min(min, 1440 + minTime - prev);
};