leetCode周赛106解题报告 javascript

最新推荐文章于 2024-05-04 00:15:00 发布

最新推荐文章于 2024-05-04 00:15:00 发布 · 274 阅读

文章标签：

#算法思路 leetcode javascript

算法思路专栏收录该内容

14 篇文章

订阅专栏

本文解析LeetCode周赛106四道题目，包括按奇偶排序数组II、使括号有效的最少添加、三数之和的多种可能及尽量减少恶意软件的传播。提供详细的解题思路与代码实现。

比赛地址：

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

922. 按奇偶排序数组 II

922. Sort Array By Parity II

给定一个非负整数数组 A， A 中一半整数是奇数，一半整数是偶数。

对数组进行排序，以便当 A[i] 为奇数时，i 也是奇数；当 A[i] 为偶数时， i 也是偶数。

你可以返回任何满足上述条件的数组作为答案。

示例：

输入：[4,2,5,7]
输出：[4,5,2,7]
解释：[4,7,2,5]，[2,5,4,7]，[2,7,4,5] 也会被接受。

提示：

2 <= A.length <= 20000
A.length % 2 == 0
0 <= A[i] <= 1000

题解：先将偶数排在前半部分，然后挨个交换到中间，例如数组共8个数字，位置14、35分别交换。

/**
 * @param {number[]} A
 * @return {number[]}
 */
var sortArrayByParityII = function(A) {
    A.sort((a,b)=>a%2-b%2);
    for (var i = A.length / 2, j = 1; j < i; i++, j += 2) {
        var temp = A[i];
        A[i] = A[j];
        A[j] = temp;
    }
    return A;
};

921. 使括号有效的最少添加

921. Minimum Add to Make Parentheses Valid

给定一个由 '(' 和 ')' 括号组成的字符串 S，我们需要添加最少的括号（ '(' 或是 ')'，可以在任何位置），以使得到的括号字符串有效。

从形式上讲，只有满足下面几点之一，括号字符串才是有效的：

它是一个空字符串，或者
它可以被写成 AB （A 与 B 连接）, 其中 A 和 B 都是有效字符串，或者
它可以被写作 (A)，其中 A 是有效字符串。

给定一个括号字符串，返回为使结果字符串有效而必须添加的最少括号数。

示例 1：

输入："())"
输出：1

示例 2：

输入："((("
输出：3

示例 3：

输入："()"
输出：0

示例 4：

输入："()))(("
输出：4

提示：

S.length <= 1000
S 只包含 '(' 和 ')' 字符。

题解：只需用一变量记录当前左括号的数量，之后匹配了右括号就减一。

/**
 * @param {string} S
 * @return {number}
 */
var minAddToMakeValid = function(S) {
    var leftCount = 0;
    var ans = 0;
    for (var i = 0; i < S.length; i++) {
        if (S[i] === ")") {
            if (leftCount === 0) {
                ans++;
            }
            else {
                leftCount--;
            }
        }
        else {
            leftCount++;
        }
    }
    ans += leftCount;
    return ans;
};

923. 三数之和的多种可能

923. 3Sum With Multiplicity

给定一个整数数组 A，以及一个整数 target 作为目标值，返回满足 i < j < k 且 A[i] + A[j] + A[k] == target 的元组 i, j, k 的数量。

由于结果会非常大，请返回 结果除以 10^9 + 7 的余数。

示例 1：

输入：A = [1,1,2,2,3,3,4,4,5,5], target = 8
输出：20
解释：
按值枚举（A[i]，A[j]，A[k]）：
(1, 2, 5) 出现 8 次；
(1, 3, 4) 出现 8 次；
(2, 2, 4) 出现 2 次；
(2, 3, 3) 出现 2 次。

示例 2：

输入：A = [1,1,2,2,2,2], target = 5
输出：12
解释：
A[i] = 1，A[j] = A[k] = 2 出现 12 次：
我们从 [1,1] 中选择一个 1，有 2 种情况，
从 [2,2,2,2] 中选出两个 2，有 6 种情况。

提示：

3 <= A.length <= 3000
0 <= A[i] <= 100
0 <= target <= 300

题解：观察数据量A[i]为不大于100的整数，所以有这样的思路：遍历每个位置的数假设为n，再看0~100每个数字m在前面出现的次数，乘以 target-m-n 在后面出现的次数，累加起来即为答案；需要两个数组记录当前位置前后0~100所有数字的出现次数，详见代码；

/**
 * @param {number[]} A
 * @param {number} target
 * @return {number}
 */
var threeSumMulti = function(A, target) {
    var maxNum = 100;
    var pre = new Array(maxNum + 1).fill(0);
    pre[A[0]]++;
    var ps = new Array(maxNum + 1).fill(0);
    for (var i = 1; i < A.length; i++) {
        ps[A[i]]++;
    }
    var m = 1e9 + 7;
    var ans = 0;
    for (var i = 1; i < A.length - 1; i++) {
        ps[A[i]]--;
        for (var j = Math.max(0, target - A[i] - maxNum); j <= maxNum && j <= target - A[i]; j++) {
            ans = (ans + pre[j] * ps[target - A[i] - j]) % m;
        }
        pre[A[i]]++;
    }
    return ans;
};

924. 尽量减少恶意软件的传播

924. Minimize Malware Spread

在节点网络中，只有当 graph[i][j] = 1 时，每个节点 i 能够直接连接到另一个节点 j。

一些节点 initial 最初被恶意软件感染。只要两个节点直接连接，且其中至少一个节点受到恶意软件的感染，那么两个节点都将被恶意软件感染。这种恶意软件的传播将继续，直到没有更多的节点可以被这种方式感染。

假设 M(initial) 是在恶意软件停止传播之后，整个网络中感染恶意软件的最终节点数。

我们可以从初始列表中删除一个节点。如果移除这一节点将最小化 M(initial)，则返回该节点。如果有多个节点满足条件，就返回索引最小的节点。

请注意，如果某个节点已从受感染节点的列表 initial 中删除，它以后可能仍然因恶意软件传播而受到感染。

示例 1：

输入：graph = [[1,1,0],[1,1,0],[0,0,1]], initial = [0,1]
输出：0

示例 2：

输入：graph = [[1,0,0],[0,1,0],[0,0,1]], initial = [0,2]
输出：0

示例 3：

输入：graph = [[1,1,1],[1,1,1],[1,1,1]], initial = [1,2]
输出：1

提示：

1 < graph.length = graph[0].length <= 300
0 <= graph[i][j] == graph[j][i] <= 1
graph[i][i] = 1
1 <= initial.length < graph.length
0 <= initial[i] < graph.length

题解：用一个数组记录每个节点被感染的次数，首先visit将每个初始感染点蔓延，依次去掉每个被感染的节点，calCount计算被感染过的节点数量，最小值的节点即为答案；

/**
 * @param {number[][]} graph
 * @param {number[]} initial
 * @return {number}
 */
var minMalwareSpread = function(graph, initial) {
    initial.sort((a,b)=>a-b)
    var n = graph.length;
    var gCount = new Array(n).fill(0);
    var calCount = function() {
        var count = 0;
        for (var i = 0; i < gCount.length; i++) {
            if (gCount[i] > 0) {
                count++;
            }
        }
        return count;
    }
    var visit = function(index, added, flags) {
        flags[index] = 1;
        gCount[index] += added;
        for (var j = 0; j < n; j++) {
            if (graph[index][j] === 1 && flags[j] === 0) {
                visit(j, added, flags);
            }
        }
    }
    for (var i = 0; i < initial.length; i++) {
        visit(initial[i], 1, new Array(n).fill(0));
    }
    var ans = initial[0];
    var minm = n + 1;
    for (var i = 0; i < initial.length; i++) {
        visit(initial[i], -1, new Array(n).fill(0));
        var m = calCount();
        if (minm > m) {
            minm = m;
            ans = initial[i];
        }
        visit(initial[i], 1, new Array(n).fill(0));
    }
    return ans;
};