leetCode周赛106解题报告 javascript

比赛地址:

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] 也会被接受。

 

提示:

  1. 2 <= A.length <= 20000
  2. A.length % 2 == 0
  3. 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

 

提示:

  1. S.length <= 1000
  2. 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 种情况。

 

提示:

  1. 3 <= A.length <= 3000
  2. 0 <= A[i] <= 100
  3. 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. 1 < graph.length = graph[0].length <= 300
  2. 0 <= graph[i][j] == graph[j][i] <= 1
  3. graph[i][i] = 1
  4. 1 <= initial.length < graph.length
  5. 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;
};

 

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