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);
};
 

 

 

你可能感兴趣的:(算法,思路,算法,思路,leetcode,javascript)