169竞赛
和为零的N个唯一整数
给你一个整数 n，请你返回 任意 一个由 n 个 各不相同 的整数组成的数组，并且这 n 个数相加和为 0 。
示例 1：
输入：n = 5
输出：[-7,-1,1,3,4]
解释：这些数组也是正确的 [-5,-1,1,2,3]，[-3,-1,2,-2,4]。
示例 2：
输入：n = 3
输出：[-1,0,1]
示例 3：
输入：n = 1
输出：[0]
提示：
1 <= n <= 1000
/** * @param {number} n * @return {number[]} */ var sumZero = function(n) { let res = []; let start = 0; let p=0; while(n>1){ start+=1; res.push(start, -start); n-=2; } if(n===1){ res.push(0); } return res; };
/** * @param {number} n * @return {number[]} */ var sumZero = function(n) { const result = []; if (n % 2 === 1) result.push(0); for (let i = 1; result.length < n; i++) { result.push(i); result.push(-i); } return result; };
这个写是写了，但是上面第一个是我写的，就是有点搞怪，明明循环一下就可以，我估计是当时并没有想到循环跳出的判断条件 result.length < n ,所以整了个while 循环，还行吧。
两棵二叉搜索树中的所有元素
给你 root1 和 root2 这两棵二叉搜索树。
请你返回一个列表，其中包含 两棵树 中的所有整数并按 升序 排序。.
示例 1：
输入：root1 = [2,1,4], root2 = [1,0,3]
输出：[0,1,1,2,3,4]
示例 2：
输入：root1 = [0,-10,10], root2 = [5,1,7,0,2]
输出：[-10,0,0,1,2,5,7,10]
示例 3：
输入：root1 = [], root2 = [5,1,7,0,2]
输出：[0,1,2,5,7]
示例 4：
输入：root1 = [0,-10,10], root2 = []
输出：[-10,0,10]
示例 5：
输入：root1 = [1,null,8], root2 = [8,1]
输出：[1,1,8,8]
提示：
每棵树最多有 5000 个节点。
每个节点的值在 [-10^5, 10^5] 之间。
/** * Definition for a binary tree node. * function TreeNode(val) { * this.val = val; * this.left = this.right = null; * } */ /** * @param {TreeNode} root1 * @param {TreeNode} root2 * @return {number[]} */ const dfs = (root, arr)=>{ if(!root) return; arr.push(root.val) if(root.left){ dfs(root.left, arr) } if(root.right){ dfs(root.right, arr) } } const toList = (arr)=>{ // let s = null; // let p = null; // s = p; // arr.forEach(a=>{ // let newObj = { // val: a, // next: null // } // p = newObj; // p = p.next // }) // return s; let s = null; let p = null; arr.forEach((a, i)=>{ let newObj = { val: a, next: null } // p = newObj; if(i===0){ p = newObj; s=p } p.next = newObj; p = p.next }) return s; } var getAllElements = function(root1, root2) { let arr = []; dfs(root1, arr); dfs(root2, arr); // arr.sort() 默认排序有 0 还不对 arr.sort((a, b)=> a-b) return arr; };
解释： 这个题描述的有问题，说什么列表，我以为链表。转了层链表，开始还没转对，翻了了以前代码才转对。导致花费一些时间。还有这个sort函数，我用了默认sort(),这样是不行的，元素中出现2位以上数字是不行的，它会按照相同位的大小排序。
跳跃游戏 III
这里有一个非负整数数组 arr，你最开始位于该数组的起始下标 start 处。当你位于下标 i 处时，你可以跳到 i + arr[i] 或者 i - arr[i]。
请你判断自己是否能够跳到对应元素值为 0 的 任意 下标处。
注意，不管是什么情况下，你都无法跳到数组之外。
示例 1：
输入：arr = [4,2,3,0,3,1,2], start = 5
输出：true
解释：
到达值为 0 的下标 3 有以下可能方案：
下标 5 -> 下标 4 -> 下标 1 -> 下标 3
下标 5 -> 下标 6 -> 下标 4 -> 下标 1 -> 下标 3
示例 2：
输入：arr = [4,2,3,0,3,1,2], start = 0
输出：true
解释：
到达值为 0 的下标 3 有以下可能方案：
下标 0 -> 下标 4 -> 下标 1 -> 下标 3
示例 3：
输入：arr = [3,0,2,1,2], start = 2
输出：false
解释：无法到达值为 0 的下标 1 处。
提示：
1 <= arr.length <= 5 * 10^4
0 <= arr[i] < arr.length
0 <= start < arr.length
/** * @param {number[]} arr * @param {number} start * @return {boolean} */ var canReach = function(arr, start) { let flag = false; let getZero = (arr, start, map=new Map())=>{ if(arr[start] === 0){ flag = true; return; } if(map.has(start)) return; map.set(start, 1); let plus = start+arr[start]; let minus = start-arr[start]; let len = arr.length; if(plus>=0 && plus <len ){ // map.set(plus, 1); getZero(arr, plus, map) // map.set(plus, 1); } if( minus >= 0 && minus < len) { // map.set(minus, 1) getZero(arr, minus, map); // map.set(minus, 1) } } getZero(arr, start); return flag };
这个在判断出现重复索引start 时，整错几个地方，就上面注释的地方，要么就是 栈溢出，要么就是 只递归一次就退出了。最后灵机一动放到了正确位置。
/** * @param {number[]} arr * @param {number} start * @return {boolean} */ var canReach = function(arr, start) { let l = 0; const r = [ start ]; const a = new Array(arr.length).fill(0); a[start] = 1; while (l < r.length) { if (!arr[r[l]]) return true; if (r[l] - arr[r[l]] >= 0 && !a[r[l] - arr[r[l]]]) { r.push(r[l] - arr[r[l]]); a[r[l] - arr[r[l]]] = 1; } if (r[l] + arr[r[l]] < arr.length && !a[r[l] + arr[r[l]]]) { r.push(r[l] + arr[r[l]]); a[r[l] + arr[r[l]]] = 1; } l++; } return false; };
/** * @param {number[]} arr * @param {number} start * @return {boolean} */ var canReach = function(arr, start) { if (arr[start] === 0) { return true } const n = arr.length let a = [start] let s = new Set() let i = 0 while (i < a.length) { const x = a[i++] const w = x - arr[x] if (w >= 0 && !s.has(w)) { if (arr[w] === 0) { return true } s.add(w) a.push(w) } const y = x + arr[x] if (y < n && !s.has(y)) { if (arr[y] === 0) { return true } s.add(y) a.push(y) } } return false };
口算难题
给你一个方程，左边用 words 表示，右边用 result 表示。
你需要根据以下规则检查方程是否可解：
- 每个字符都会被解码成一位数字（0 - 9）。
- 每对不同的字符必须映射到不同的数字。
- 每个
words[i]和result都会被解码成一个没有前导零的数字。 - 左侧数字之和（
words）等于右侧数字（result）。
如果方程可解，返回 True，否则返回 False。
示例 1：
输入：words = ["SEND","MORE"], result = "MONEY" 输出：true 解释：映射 'S'-> 9, 'E'->5, 'N'->6, 'D'->7, 'M'->1, 'O'->0, 'R'->8, 'Y'->'2' 所以 "SEND" + "MORE" = "MONEY" , 9567 + 1085 = 10652
示例 2：
输入：words = ["SIX","SEVEN","SEVEN"], result = "TWENTY" 输出：true 解释：映射 'S'-> 6, 'I'->5, 'X'->0, 'E'->8, 'V'->7, 'N'->2, 'T'->1, 'W'->'3', 'Y'->4 所以 "SIX" + "SEVEN" + "SEVEN" = "TWENTY" , 650 + 68782 + 68782 = 138214
示例 3：
输入：words = ["THIS","IS","TOO"], result = "FUNNY" 输出：true
示例 4：
输入：words = ["LEET","CODE"], result = "POINT" 输出：false
提示：
2 <= words.length <= 51 <= words[i].length, results.length <= 7words[i], result只含有大写英文字母- 表达式中使用的不同字符数最大为 10
/** * @param {string[]} words * @param {string} result * @return {boolean} */ var isSolvable = function(words, result) { let map = new Map(); let arr = [0,1,2,3,4,5,6,7,8,9]; let arr1 = [1,2,3,4,5,6,7,8,9]; words.forEach((a)=>{ let arr = a.split(''); arr.forEach((b, i)=>{ if(i===0){ if(!map.has(b)){ map.set(b, arr1) } } else { if(!map.has(b)){ map.set(b, arr) } } }) }) result.split('').forEach((b, i)=>{ if(i===0){ if(!map.has(b)){ map.set(b, arr1) } } else { if(!map.has(b)){ map.set(b, arr) } } }) words.forEach((a)=>{ let arr = a.split(''); arr.forEach((b, i)=>{ map.get(b).forEach(c=>{ // 下面只能就是不定嵌套层级的循环，无解，要么拼字符串 }) }) }) };
/** * @param {string[]} words * @param {string} result * @return {boolean} */ var isSolvable = function(words, result) { const a = {}; const l = []; const min = []; for (let i = 0; i < words.length; i++) { for (let j = 0; j < words[i].length; j++) { if (!a[words[i][j]]) { l.push(words[i][j]); min.push(0); a[words[i][j]] = l.length; } if (!j) min[a[words[i][j]] - 1] = 1; } } for (let i = 0; i < result.length; i++) { if (!a[result[i]]) { l.push(result[i]); min.push(0); a[result[i]] = l.length; } if (!i) min[a[result[i]] - 1] = 1; } const getL = new Array(10).fill(0); const v = new Array(l.length).fill(0); var dfs = function(d) { if (d === l.length) { let sum1 = 0; for (let i = 0; i < words.length; i++) { let sum = 0; for (let j = 0; j < words[i].length; j++) { const ttt = v[a[words[i][j]] - 1]; if (!j && !ttt) return false; sum = sum * 10 + ttt; } sum1 += sum; } let sum2 = 0; for (let i = 0; i < result.length; i++) { const ttt = v[a[result[i]] - 1]; if (!i && !ttt) return false; sum2 = sum2 * 10 + ttt; } if (sum1 === sum2) return true; } for (let i = min[d]; i < 10; i++) { if (!getL[i]) { getL[i] = true; v[d] = i; if (dfs(d + 1)) return true; getL[i] = false; } } return false; } return dfs(0); };
/** * @param {string[]} words * @param {string} result * @return {boolean} */ var isSolvable = function (words, result) { let letters = new Set() let leading = new Set() let left = {} let right = {} let p = [1, 10, 100, 1000, 10000, 100000, 1000000, 10000000] for (let word of words) { let n = word.length for (let i = 0; i < n; i++) { const c = word[n - 1 - i] letters.add(c) if (c in left) { left[c] += p[i] } else { left[c] = p[i] } } leading.add(word[0]) } let n = result.length for (let i = 0; i < n; i++) { const c = result[n - 1 - i] letters.add(c) if (c in right) { right[c] += p[i] } else { right[c] = p[i] } } leading.add(result[0]) let a = Array.from(letters) let b = new Array(10) let d = {} b.fill(true) return dfs(a, a.length - 1, d, b, leading, left, right) }; const dfs = (a, i, d, b, leading, left, right) => { if (i >= 0) { for (let x = leading.has(a[i]) ? 1 : 0; x < 10; x++) { if (b[x]) { b[x] = false d[a[i]] = x if (dfs(a, i - 1, d, b, leading, left, right)) { return true } b[x] = true } } return false } else { let diff = 0 for (c in left) { diff += d[c] * left[c] } for (c in right) { diff -= d[c] * right[c] } return diff === 0 } }
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/all-elements-in-two-binary-search-trees
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
