leetcode周赛个人题解目录

LeetCode-159周赛

题目传送门

• 缀点成线
• 删除子文件夹
• 替换子串得到平衡字符串
• 规划兼职工作

题解

1. 缀点成线

 题目：
在一个 XY 坐标系中有一些点，我们用数组 coordinates 来分别记录它们的坐标，其中 coordinates[i] = [x, y] 表示横坐标为 x、纵坐标为 y 的点。

请你来判断，这些点是否在该坐标系中属于同一条直线上，是则返回 <font color="#c7254e" face="Menlo, Monaco, Consolas, Courier New, monospace">true</font>，否则请返回 <font color="#c7254e" face="Menlo, Monaco, Consolas, Courier New, monospace">false</font>。

思路：通过第一个点和第二个点求出直线的斜率，k=(y1-y0)/(x1-x0);然后遍历第一个点和第i个点的斜率是否都为k。是就返回true，否则返回false。

demo

/**
 * @param {number[][]} coord
 * @return {boolean}
 */
var checkStraightLine = function(coord) {
        if (coord[1][1] - coord[0][1] === 0) {
        for (let i = 2; i < coord.length; i++) {
            if (coord[i][1] !== coord[0][1])
                return false;
        }
    }
    let k = (coord[1][1] - coord[0][1]) / (coord[1][0] - coord[0][0]);

    for (let i = 1; i < coord.length; i++) {
        if (k !== (coord[i][1] - coord[0][1]) / (coord[i][0] - coord[0][0])){
            return false;
        }
    }
    return true;
};

---

2. 删除子文件夹

题目：你是一位系统管理员，手里有一份文件夹列表 folder，你的任务是要删除该列表中的所有 子文件夹，并以 任意顺序 返回剩下的文件夹。

我们这样定义「子文件夹」：

如果文件夹 folder[i] 位于另一个文件夹 folder[j] 下，那么 folder[i] 就是 folder[j] 的子文件夹。

文件夹的「路径」是由一个或多个按以下格式串联形成的字符串：

/ 后跟一个或者多个小写英文字母。

例如，/leetcode 和 /leetcode/problems 都是有效的路径，而空字符串和 / 不是。

题解：首先按字典序对字符串组排序，然后判断后面一个字符串是否是前面一个字符串的子串。

demo：

/**
 * @param {string[]} folder
 * @return {string[]}
 */
var removeSubfolders = function(folder) {
	    let res=[];
	    folder.sort();//字典序
	    for (let i = 0 , j=1; i < folder.length;) {
        if(i===folder.length-1){
            res.push(folder[i]);
            break;
        }
        let arr1=folder[i].split("/");
        let arr2=folder[j].split("/");
        //let flag=0;//判断是否有子串
        while(arr1.length<arr2.length && arr1.toString()===arr2.slice(0,arr1.length).toString()){
            //flag=1;
            j++;
            if(j<folder.length)
                arr2=folder[j].split('/');
            else break;
        }
        res.push(folder[i]);
        i=j;j=i+1;
    }
    return res;
};

3.替换子串得到平衡字符串

题目：有一个只含有 ‘Q’, ‘W’, ‘E’, ‘R’ 四种字符，且长度为 n 的字符串。

假如在该字符串中，这四个字符都恰好出现 n/4 次，那么它就是一个「平衡字符串」。

给你一个这样的字符串 s，请通过「替换子串」的方式，使原字符串 s 变成一个「平衡字符串」。

你可以用和「待替换子串」长度相同的 任何 其他字符串来完成替换。

请返回待替换子串的最小可能长度。

如果原字符串自身就是一个平衡字符串，则返回 0。

demo

/**
 * @param {string} s
 * @return {number}
 */
var balancedString = function (s) {
    let ex = s.length / 4;
    let count = {Q: -ex, W: -ex, E: -ex, R: -ex};
    for (let char of s) {
        count[char]++;
    }
    let cands = [];
    if (count.Q > 0) cands.push("Q");
    if (count.W > 0) cands.push("W");
    if (count.E > 0) cands.push("E");
    if (count.R > 0) cands.push("R");
    let j=0;
    let ans=s.length;
    l1: for(let i = 0; i < s.length; count[s[i++]]++) {
        j = Math.max(j, i)
        for(let cand of cands) {
            while(count[cand] > 0) {
                if (j >= s.length) break l1;
                // console.log('decreasing', s[j])
                count[s[j++]]--
            }
        }
        // console.log(i, j, count)
        ans = Math.min(ans, j - i)
    }
    return ans
};

4.规划兼职工作

题目：
你打算利用空闲时间来做兼职工作赚些零花钱。

这里有 n 份兼职工作，每份工作预计从 startTime[i] 开始到 endTime[i] 结束，报酬为 profit[i]。

给你一份兼职工作表，包含开始时间 startTime，结束时间 endTime 和预计报酬 profit 三个数组，请你计算并返回可以获得的最大报酬。

注意，时间上出现重叠的 2 份工作不能同时进行。

如果你选择的工作在时间 X 结束，那么你可以立刻进行在时间 X 开始的下一份工作。

示例 1：

输入：startTime = [1,2,3,3], endTime = [3,4,5,6], profit = [50,10,40,70]
输出：120
解释：
我们选出第 1 份和第 4 份工作， 
时间范围是 [1-3]+[3-6]，共获得报酬 120 = 50 + 70。

demo：

/**
 * @param {number[]} startTime
 * @param {number[]} endTime
 * @param {number[]} profit
 * @return {number}
 */
var jobScheduling = function(startTime, endTime, profit) {
    class OrderedSet {
        constructor(){
            this.data = []
        }
        set(key, val) {
            if (this.data.length) {
                let [k, v] = this.data[this.data.length - 1]
                if (val <= v) return
            }
            this.data.push([key, val])
        }
        upperBound(target) {
            let lo = 0
            let hi = this.data.length - 1
            while(lo <= hi) {
                let mi = lo + Math.floor((hi - lo) / 2)
                let [k, v] = this.data[mi]
                if (k <= target) {
                    lo = mi + 1
                }
                else {
                    hi = mi - 1
                }
            }
            let idx = lo - 1
            if (idx < 0) return 0
            return this.data[idx][1]
        }
    }
    let st = new OrderedSet()
    let jobs = startTime.map((t, i) => [startTime[i], endTime[i], profit[i]]).sort((lhs, rhs) => lhs[1] - rhs[1])   
    let ans = 0
    for(let [startTime, endTime, profit] of jobs) {
        let total = st.upperBound(startTime) + profit
        ans = Math.max(ans, total)
        st.set(endTime, total)
    }
    return ans
};