其他分享
首页 > 其他分享> > [Leetcode Weekly Contest]271

[Leetcode Weekly Contest]271

作者:互联网

链接:LeetCode

[Leetcode]2103. 环和杆

总计有 n 个环,环的颜色可以是红、绿、蓝中的一种。这些环分布穿在 10 根编号为 0 到 9 的杆上。

给你一个长度为 2n 的字符串 rings ,表示这 n 个环在杆上的分布。rings 中每两个字符形成一个 颜色位置对 ,用于描述每个环:

第 i 对中的 第一个 字符表示第 i 个环的 颜色('R'、'G'、'B')。
第 i 对中的 第二个 字符表示第 i 个环的 位置,也就是位于哪根杆上('0' 到 '9')。
例如,"R3G2B1" 表示:共有 n == 3 个环,红色的环在编号为 3 的杆上,绿色的环在编号为 2 的杆上,蓝色的环在编号为 1 的杆上。

找出所有集齐 全部三种颜色 环的杆,并返回这种杆的数量。

遍历即可。

class Solution {
    public int countPoints(String rings) {
        int res = 0;
        var ringMap = new HashMap<Integer, HashSet<Character>>();
        for(int i=0;i<rings.length();++i)
        {
            if((i&1)!=0)
            {
                int ring = rings.charAt(i) - '0'; // (int) rings.charAt(i)
                var set = ringMap.getOrDefault(ring, new HashSet<Character>());
                set.add(rings.charAt(i-1));
                ringMap.put(ring, set);
            }
        }
        for (HashSet<Character> set:ringMap.values()) {
            if(set.size() == 3) res ++;
        }
        return res;
    }
}

[Leetcode]2104. 子数组范围和

给你一个整数数组 nums 。nums 中,子数组的 范围 是子数组中最大元素和最小元素的差值。
返回 nums 中 所有 子数组范围的 和 。
子数组是数组中一个连续 非空 的元素序列。

暴力算法,即记录子数组最大元素和最小元素,循环即可,时间复杂度\(O(N^2)\)。

class Solution {
    public long subArrayRanges(int[] nums) {
        int n = nums.length;
        long res = 0;
        for(int i=0;i<n;++i){
            int mn = nums[i], mx = nums[i];
            for (int j=i+1;j<n;++j) {
                mn = Math.min(mn, nums[j]);
                mx = Math.max(mx, nums[j]);
                res += mx - mn;
            }
        }
        return res;
    }
}

另外, 我们可以考虑每个元素作为最大值出现在了多少子数组中,以及作为最小值出现在了多少子数组中,即分别计算每个元素对于最大值和最小值的贡献。令left[i] 为左侧严格大于 num[i] 的最近元素位置(不存在时为 -1),right[i] 为右侧大于等于 num[i] 的最近元素位置(不存在时为 n),那么为了包含索引i,该子数组的区间起始点有(i−left[i])种情况,终止点有(right[i]−i)种情况,两者的乘积就是子区间的个数。
这里求left以及right数组就需要用到单调栈了。

class Solution {
    public long subArrayRanges(int[] nums) {
        int n = nums.length;
        long res = 0;
        int[] leftLarger = new int[n], leftSmaller = new int[n];
        int[] rightLarger = new int[n], rightSmaller = new int[n];
        Arrays.fill(leftLarger, -1);
        Arrays.fill(leftSmaller, -1);
        Arrays.fill(rightLarger, n);
        Arrays.fill(rightSmaller, n);
        arrayLeft(nums,leftLarger,leftSmaller);
        arrayRight(nums,rightLarger,rightSmaller);
        for(int i=0;i<n;i++)
        {
            res += 1L * nums[i] *  ((rightLarger[i]-i)*(i-leftLarger[i]) - (rightSmaller[i]-i)*(i-leftSmaller[i]));
        }
        return res;
    }

    //   get first right index > nums[i] with first right index < nums[i]
    public void arrayRight(int[] nums, int[] rightLarger, int[] rightSmaller) {
        int n = nums.length;
        Deque<Integer> increasedStack = new ArrayDeque<>();
        Deque<Integer> decreasedStack = new ArrayDeque<>();
        for(int i=0;i<n;++i) {
            while(!increasedStack.isEmpty() && nums[increasedStack.peek()] > nums[i]){
                rightSmaller[increasedStack.pop()] = i;
            }
            while(!decreasedStack.isEmpty() && nums[decreasedStack.peek()] < nums[i]){
                rightLarger[decreasedStack.pop()] = i;
            }
            increasedStack.push(i);
            decreasedStack.push(i);
        }
    }
    //   get first left index >= nums[i] with first left index <= nums[i]
    public void arrayLeft(int[] nums, int[] leftLarger, int[] leftSmaller) {
        int n = nums.length;
        Deque<Integer> increasedStack = new ArrayDeque<>();
        Deque<Integer> decreasedStack = new ArrayDeque<>();
        for(int i=n-1;i>=0;--i) {
            while(!increasedStack.isEmpty() && nums[increasedStack.peek()] >= nums[i]){
                leftSmaller[increasedStack.pop()] = i;
            }
            while(!decreasedStack.isEmpty() && nums[decreasedStack.peek()] <= nums[i]){
                leftLarger[decreasedStack.pop()] = i;
            }
            increasedStack.push(i);
            decreasedStack.push(i);
        }
    }
}

[Leetcode]2105. 给植物浇水 II

Alice 和 Bob 打算给花园里的 n 株植物浇水。植物排成一行,从左到右进行标记,编号从 0 到 n - 1 。其中,第 i 株植物的位置是 x = i 。

每一株植物都需要浇特定量的水。Alice 和 Bob 每人有一个水罐,最初是满的 。他们按下面描述的方式完成浇水:

Alice 按 从左到右 的顺序给植物浇水,从植物 0 开始。Bob 按 从右到左 的顺序给植物浇水,从植物 n - 1 开始。他们 同时 给植物浇水。
如果没有足够的水 完全 浇灌下一株植物,他 / 她会立即重新灌满浇水罐。
不管植物需要多少水,浇水所耗费的时间都是一样的。
不能 提前重新灌满水罐。
每株植物都可以由 Alice 或者 Bob 来浇水。
如果 Alice 和 Bob 到达同一株植物,那么当前水罐中水更多的人会给这株植物浇水。如果他俩水量相同,那么 Alice 会给这株植物浇水。
给你一个下标从 0 开始的整数数组 plants ,数组由 n 个整数组成。其中,plants[i] 为第 i 株植物需要的水量。另有两个整数 capacityA 和 capacityB 分别表示 Alice 和 Bob 水罐的容量。返回两人浇灌所有植物过程中重新灌满水罐的 次数 。

双指针。根据题意遍历即可。

class Solution {
    public int minimumRefill(int[] plants, int capacityA, int capacityB) {
        int left = 0, right = plants.length - 1;
        int res = 0, left_capacity = capacityA, right_capacity = capacityB;
        while(left <= right) {
            if (left == right) {
                if(Math.max(left_capacity,right_capacity) < plants[left]) res ++;
            }
            else {
                if(left_capacity < plants[left]) {
                    left_capacity = capacityA;
                    res ++;
                }
                if(right_capacity < plants[right]) {
                    right_capacity = capacityB;
                    res ++;
                }
                left_capacity -= plants[left];
                right_capacity -= plants[right];
            }
            left ++;
            right --;
        }
        return res;
    }
}

[Leetcode]2106. 摘水果

在一个无限的 x 坐标轴上,有许多水果分布在其中某些位置。给你一个二维整数数组 fruits ,其中 fruits[i] = [positioni, amounti] 表示共有 amounti 个水果放置在 positioni 上。fruits 已经按 positioni 升序排列 ,每个 positioni 互不相同 。

另给你两个整数 startPos 和 k 。最初,你位于 startPos 。从任何位置,你可以选择 向左或者向右 走。在 x 轴上每移动 一个单位 ,就记作 一步 。你总共可以走 最多 k 步。你每达到一个位置,都会摘掉全部的水果,水果也将从该位置消失(不会再生)。

返回你可以摘到水果的 最大总数 。

显然在最优的方案中,最多掉头一次。那么就有两种情况:

针对这两种情况,我们无非是需要计算线段 [l, r] 覆盖了多少水果。
线段有多少种可能呢?假设人向左走 \(y\) 步,然后回到原点,再向右走 \(x\) 步,那么区间长度就是:\(x + 2y\) ,其中 \(x + 2y \le k\) ,区间表示为 [startPos - y, startPos + x] 。
同理,如果向右走 \(y\) 步,然后回到原点,再向左走 \(x\) 步,那么区间表示为 [startPos - x, startPos + y] 。
所以我们枚举 \(y\) 长度就可以把所有最长线段都枚举出来。下面我们计算线段 [l, r]水果个数的时候,就可以用前缀和的知识,由于并不是在每一个点都有水果,我们就优化到线段[l, r]所覆盖的有水果区间[l_hi, r_lo]上, 其中l_hi是指l右侧第一个有水果的索引,同理,r_lo指r左侧第一个有水果的索引。这里就需要二分法来进行优化。
最终解决方案即遍历+前缀和+二分

class Solution {
    public int maxTotalFruits(int[][] fruits, int startPos, int k) {
        int res = 0, n = fruits.length, cur = 0;
        int[] preSum = new int[n];
        for(int i=0;i<n; ++i) {
            cur += fruits[i][1];
            preSum[i] = cur;
        }
        for(int x=Math.min(startPos,fruits[0][0]); x<=startPos; ++x) {
            if(startPos-x > k) continue;
            int xi = GetSmaller(fruits, x);
            int y = Math.max(k - 2*(startPos-x) + startPos, startPos + (int) ((k-(startPos-x)) / 2));
            int yi = GetSmallerOrEqualIndex(fruits, y);
            if(yi == -1) continue;
            else if(xi == -1)  res = Math.max(res, preSum[yi]);
            else res = Math.max(res, preSum[yi]- preSum[xi]);
        }
        return res;
    }

    public int GetSmallerOrEqualIndex(int[][] fruits, int target) {
        int lo = 0, hi = fruits.length-1;
        while(lo <= hi) {
            int mid = lo + ((hi - lo) >> 1);
            int pos = fruits[mid][0];
            if (pos == target) return mid;
            if (pos > target) hi = mid - 1;
            else lo = mid + 1;
        }
        return hi;
    }

    public int GetSmaller(int[][] fruits, int target) {
        int lo = 0, hi = fruits.length-1;
        while(lo <= hi) {
            int mid = lo + ((hi - lo) >> 1);
            int pos = fruits[mid][0];
            if (pos >= target) hi = mid - 1;
            else lo = mid + 1;
        }
        return hi;
    }
}

Leetcode

标签:nums,int,res,Contest,271,数组,fruits,startPos,Leetcode
来源: https://www.cnblogs.com/hellojamest/p/15978130.html