leetcode1093-1096、1103-1106

最新推荐文章于 2023-03-07 20:00:03 发布

原创最新推荐文章于 2023-03-07 20:00:03 发布 · 244 阅读

0 ·

CC 4.0 BY-SA版权

leetcode周赛同时被 2 个专栏收录

12 篇文章

订阅专栏

每日一题leetcode

11 篇文章

订阅专栏

本文深入解析了周赛142和143中的多个算法问题，包括大样本统计、拼车问题、山脉数组查找、花括号展开、分糖果II、二叉树寻路、填充书架及解析布尔表达式等，提供了详细的代码实现和思路说明。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

周赛142

大样本统计

public double[] sampleStats(int[] count) {
    double min = 256,max = 0,avg,mode = 0,mid = 0,mmaxnum = 0,sum = 0,c = 0;

    for(int i = 0;i < 256;i++) {
        if(count[i] != 0){
            if(min > i){
                min = i;
            }
            if(max < i){
                max = i;
            }
            if(mmaxnum < count[i]){
                mmaxnum = count[i];
                mode = i;
            }
            sum += count[i] * i;
            c += count[i];
        }
    }

    avg = sum / c;
    
    int half = (int)(c / 2);
    for(int i = 0;i < 256;i++){
        if(count[i] != 0) {
            if(half > count[i]){
                half -= count[i];
            }else if(half == count[i]){
                if(c % 2 != 0){
                    half -= count[i];
                } else {
                    for(int j = i + 1;j < 256;j++){
                        if (count[j] != 0){
                            mid = (i + j) / 2.0;
                            break;
                        }
                    }
                    break;
                }
            }else {
                mid = i;
                break;
            }
        }
    }
    return new double[]{min,max,avg,mid,mode};
}

拼车

public boolean carPooling(int[][] trips, int capacity) {
    int[] road = new int[1001];
    for(int i = 0;i < trips.length;i++){
        road[trips[i][1]] += trips[i][0];
        road[trips[i][2]] -= trips[i][0];
    }

    for(int i = 0;i < 1000;i++){
        road[i + 1] += road[i];
        if(capacity < road[i])
            return false;
    }
    return true;
}

山脉数组中查找目标值

public int findInMountainArray(int target, MountainArray mountainArr) {
    int size = mountainArr.length();
    int top = findTop(mountainArr,0,size - 1);
    int res = findFromLeft(mountainArr,0,top,target);
    return (res != -1)?res:findFromRight(mountainArr,top + 1,size - 1,target);
}

public int findTop(MountainArray mountainArr,int l,int r){
    while (l < r){
        int mid = (l + r) / 2;
        if(mountainArr.get(mid) < mountainArr.get(mid+1)){
            l = mid + 1;
        } else {
            r = mid;
        }
    }
    return l;
}

public int findFromLeft(MountainArray mountainArr,int l,int r,int target){
    while (l < r){
        int mid = (l + r) / 2;
        if(mountainArr.get(mid) < target){
            l = mid + 1;
        } else {
            r = mid;
        }
    }
    return (mountainArr.get(l) == target)?l:-1;
}

public int findFromRight(MountainArray mountainArr,int l,int r,int target){
    while (l < r){
        int mid = (l + r) / 2;
        if(mountainArr.get(mid) > target){
            l = mid + 1;
        } else {
            r = mid;
        }
    }
    return (mountainArr.get(l) == target)?l:-1;
}

花括号展开 II

class Pair{
	public HashSet<String> set;
	public int index;
	public Pair(HashSet<String> set,int index){
   	 this.set = set;
    	this.index = index;
	}
}

public List<String> braceExpansionII(String expression) {
    Pair temp = helper(expression,0);
    String[] unorder = new String[temp.set.size()];
    List<String> res = new ArrayList<>();
    int i = 0;
    for(String s:temp.set){
        unorder[i++] = s;
    }
    Arrays.sort(unorder);
    for(String s:unorder){
        res.add(s);
    }
    return res;
}

public HashSet<String> mulSet(HashSet<String> h1,HashSet<String> h2){
    HashSet<String> mul = new HashSet<>();
    if(h1.isEmpty()){
        return h2;
    }else {
        for (String s1 : h1) {
            for (String s2 : h2) {
                mul.add(s1 + s2);
            }
        }
    }
    return mul;
}

public Pair helper(String expression,int index){
    HashSet<String> res = new HashSet<>();
    HashSet<String> cur = new HashSet<>();
    while (index < expression.length()){
        if(expression.charAt(index) == '{') {
            Pair temp = helper(expression,index + 1);
            if(cur.isEmpty()){
                cur = temp.set;
            }else {
                cur = mulSet(cur,temp.set);
            }
            index = temp.index;
        }else if(expression.charAt(index) == ','){
            for (String s : cur){
                res.add(s);
            }
            cur.clear();
            index++;
        }else if(expression.charAt(index) == '}'){
            for (String s : cur){
                res.add(s);
            }
            return new Pair(res,index + 1);
        }else{
            String s = "";
            while (index < expression.length()
                    && expression.charAt(index) >= 'a'
                    && expression.charAt(index) <= 'z'){
                s += expression.charAt(index);
                index++;
            }
            if(cur.isEmpty()){
                cur.add(s);
            }else {
                HashSet<String> tmp = new HashSet<>();
                tmp.add(s);
                cur = mulSet(cur,tmp);
            }
        }
    }
    for (String s : cur){
        res.add(s);
    }
    return new Pair(res,index);
}

周赛143

分糖果 II

public int[] distributeCandies(int candies, int num_people) {
    int[] res = new int[num_people];
    int i = 0,count = 0;
    while (candies > 0){
        if(candies >= num_people * count + i + 1) {
            res[i] += (num_people * count + i + 1);
            candies -= (num_people * count + i + 1);
        } else {
            res[i] += candies;
            candies = 0;
        }
        i++;
        if(i == num_people){
            i = 0;
            count++;
        }
    }
    return res;
}

二叉树寻路

public List<Integer> pathInZigZagTree(int label) {
    List<Integer> res = new LinkedList<>();
    int level = 0;
    int var = label;
    while (var >= 1) {
        var = var >> 1;
        level++;
    }
    while (label != 1) {
        ((LinkedList<Integer>) res).addFirst(label);
        level--;
        label = label >> 1;
        label = (int)(Math.pow(2,level-1) + Math.pow(2,level) - label - 1);
    }
    ((LinkedList<Integer>) res).addFirst(1);
    return res;
}

填充书架

public int minHeightShelves(int[][] books, int shelf_width) {
    int[] dp = new int[books.length + 1];
    Arrays.fill(dp,Integer.MAX_VALUE);
    dp[0] = 0;
    for(int i = 0;i < books.length;i++){
        int height = 0;
        int width = 0;
        for(int j = i;j >= 0;j--){
            width += books[j][0];
            height = Math.max(height,books[j][1]);
            if(width <= shelf_width){
                dp[i + 1] = Math.min(dp[i + 1],height + dp[j]);
            }
            else {
                break;
            }
        }
    }
    return dp[books.length];
}

解析布尔表达式

public boolean parseBoolExpr(String expression) {
    Stack<Character> expr = new Stack<>();
    for(int i = 0; i < expression.length();i++){
        char c = expression.charAt(i);
        if(c == ','){
            continue;
        }else if(c == ')'){
            if(operator(expr)){
                expr.push('t');
            }else {
                expr.push('f');
            }
        }else{
            expr.push(c);
        }
    }
    return (expr.pop() == 't')?true:false;
}

public boolean operator(Stack<Character> source){
    int countTrue = 0, countFalse = 0;
    char c;
    while (!source.isEmpty()){
        c = source.pop();
        if(c == 't'){
            countTrue++;
        }else if(c == 'f'){
            countFalse++;
        }else if(c == '('){
            break;
        }
    }
    c = source.pop();
    if(c == '|'){
        return (countTrue != 0)?true:false;
    }else if(c == '&'){
        return (countFalse != 0)?false:true;
    }else if(c == '!'){
        return (countTrue != 0)?false:true;
    }
    return true;
}