leetCode周赛98解题报告 javascript

比赛地址：

https://leetcode-cn.com/contest/weekly-contest-98

 

888. 公平的糖果交换

888. Fair Candy Swap

爱丽丝和鲍勃有不同大小的糖果棒：A[i] 是爱丽丝拥有的第 i 块糖的大小，B[j] 是鲍勃拥有的第 j 块糖的大小。

因为他们是朋友，所以他们想交换一个糖果棒，这样交换后，他们都有相同的糖果总量。（一个人拥有的糖果总量是他们拥有的糖果棒大小的总和。）

返回一个整数数组 ans，其中 ans[0] 是爱丽丝必须交换的糖果棒的大小，ans[1] 是 Bob 必须交换的糖果棒的大小。

如果有多个答案，你可以返回其中任何一个。保证答案存在。

 

示例 1：

输入：A = [1,1], B = [2,2]
输出：[1,2]

示例 2：

输入：A = [1,2], B = [2,3]
输出：[1,2]

示例 3：

输入：A = [2], B = [1,3]
输出：[2,3]

示例 4：

输入：A = [1,2,5], B = [2,4]
输出：[5,4]

 

提示：

• 1 <= A.length <= 10000
• 1 <= B.length <= 10000
• 1 <= A[i] <= 100000
• 1 <= B[i] <= 100000
• 保证爱丽丝与鲍勃的糖果总量不同。
• 答案肯定存在。

题解：预先计算出两个人的糖果总量，

需要交换之后总量相等，总量差值的一半即是交换需要改变的量，

用集合加速查找（集合的查找速度为常量时间）。

 

/**
 * @param {number[]} A
 * @param {number[]} B
 * @return {number[]}
 */
var fairCandySwap = function(A, B) {
    var aSum = A.reduce((a,b)=>a+b, 0);
    var bSum = B.reduce((a,b)=>a+b, 0);
    var need = (bSum - aSum) / 2;
    var bSet = new Set(B);
    for (var i = 0; i < A.length; i++) {
        if (bSet.has(A[i] + need)) {
            return [A[i], A[i] + need];
        }
    }
};

 

 

 

 

 

890. 查找和替换模式

890. Find and Replace Pattern

• 用户通过次数163
• 用户尝试次数186
• 通过次数166
• 提交次数269
• 题目难度Medium

 

你有一个单词列表 words 和一个模式  pattern，你想知道 words 中的哪些单词与模式匹配。

如果存在字母的排列 p ，使得将模式中的每个字母 x 替换为 p(x) 之后，我们就得到了所需的单词，那么单词与模式是匹配的。

（回想一下，字母的排列是从字母到字母的双射：每个字母映射到另一个字母，没有两个字母映射到同一个字母。）

返回 words 中与给定模式匹配的单词列表。

你可以按任何顺序返回答案。

 

示例：

输入：words = ["abc","deq","mee","aqq","dkd","ccc"], pattern = "abb"
输出：["mee","aqq"]
解释：
"mee" 与模式匹配，因为存在排列 {a -> m, b -> e, ...}。
"ccc" 与模式不匹配，因为 {a -> c, b -> c, ...} 不是排列。
因为 a 和 b 映射到同一个字母。

 

提示：

• 1 <= words.length <= 50
• 1 <= pattern.length = words[i].length <= 20

题解：对于每个单词，新建一个字母映射关系w2p和反向映射关系p2w，

然后依次遍历单词所有字母生成字母映射关系：

如果已经存在正确的映射关系则跳过，

如果存在矛盾的映射关系则终止计算，

存在完整的映射关系即为题目所求的单词。

 

/**
 * @param {string[]} words
 * @param {string} pattern
 * @return {string[]}
 */
var findAndReplacePattern = function(words, pattern) {
    var ans = [];
    for (var i = 0; i < words.length; i++) {
        var w2p = {};
        var p2w = {};
        var w = words[i];
        for (var j = 0; j < pattern.length; j++) {
            var a = w[j];
            var b = pattern[j];
            // 已经存在正确的映射关系则跳过
            if (w2p[a] == b) { 
                continue;
            }
            // 存在矛盾的映射关系则终止计算
            if (w2p[a] || p2w[b]) { 
                break;
            }
            // 生成新的字母映射关系
            w2p[a] = b;
            p2w[b] = a;
        }
        // 存在完整的映射关系
        if (j == pattern.length) {
            ans.push(w);
        }
    }
    return ans;
};

 

 

 

889. 根据前序和后序遍历构造二叉树

889. Construct Binary Tree from Preorder and Postorder Traversal

返回与给定的前序和后序遍历匹配的任何二叉树。

 pre 和 post 遍历中的值是不同的正整数。

 

示例：

输入：pre = [1,2,4,5,3,6,7], post = [4,5,2,6,7,3,1]
输出：[1,2,3,4,5,6,7]

 

提示：

• 1 <= pre.length == post.length <= 30
• pre[] 和 post[] 都是 1, 2, ..., pre.length 的排列
• 每个输入保证至少有一个答案。如果有多个答案，可以返回其中一个。

题解：根据样例分析，1为根结点，2为左子树根结点，

在后续遍历中查找2的位置即可得出:

1的左子树的前序遍历和后续遍历分别为245和452、

1的右子树的前序遍历和后续遍历分别为367和673，

将问题转换为更小的规模，故可以递归求解。

 

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {number[]} pre
 * @param {number[]} post
 * @return {TreeNode}
 */
var constructFromPrePost = function(pre, post) {
    var build = function(af, ar, bf, br) {
        if (af > ar) {
            return null;
        }
        var r = pre[af];
        var node = new TreeNode(r);
        for (var i = bf; i < br; i++) {
            if (post[i] == pre[af + 1]) {
                node.left = build(af + 1, af + i - bf + 1, bf, i);
                node.right = build(af + i - bf + 2, ar, i + 1, br - 1);
            }
        }
        return node;
    }
    return build(0, pre.length - 1, 0, post.length - 1);
};