LeetCode Biweekly Contest 65

Sun, 14 Nov 2021 00:00:00 +0000

心态崩了，第二题太坑，然后键盘出问题，连删三次代码，哭泣

T1: Check Whether Two Strings are Almost Equivalent

模拟统计即可

T2: Walking Robot Simulation II

模拟操作，然后可以优化多次循环操作，但是至少要留一次循环（因为方向问题）

T3: Most Beautiful item for Each Query

排序后进行统计询问即可

T4: Maximum Number of Tasks You Can Assign

无论怎么样，完成的Tasks一定是前面力量最小的。所以二分答案，然后判断是否能完成：如果直接完成就完成，不能就找个能吃药的完成进行判断即可，通过TreeMap来统计。

LeetCode Weekly Contest 266

Sun, 07 Nov 2021 00:00:00 +0000

由于搬家，所以上周比赛没有参加，今天比赛难度简单，找回状态中（状态偏不行）

T1: Count Vowel SubStrings of a String

直接枚举统计即可，注意是子串有且只有5种字符

T2: Vowels of All Substrings

找到对应的Vowel字符，然后计算出包含这个字符由多少个子串即可，数学统计计算

T3: Minimized Maximum of Products Distributed to Any Store

二分答案，判断答案是否ok

T4: Maximum Path Quality of a Graph

搜索即可，因为maxTime/Time最大是10，所以最多枚举10步即可，而且每个点最多只有4条边，后面可以做个优化就是判断这个点回0的最小时间，因为终点要为0

LeetCode Weekly Contest 264

Sun, 24 Oct 2021 00:00:00 +0000

第一题字符串处理的题又臭又长，真的很讨厌，导致罚时有点可怕

T1: Number of Valid Words in a Sentence

根据题目意思进行字符串处理匹配，注意处理-这个符号的要求

T2: Next Greater Numerically Balanced Number

根据数字直接暴力模拟遍历即可。

T3: Count Nodes With the Highest Score

树遍历统计，注意中间的乘积结果会超过Integer，需要用Long

T4: Parallel Courses III

遍历即可，然后求出每个课程的最大值

LeetCode Weekly Contest 263

Sun, 17 Oct 2021 00:00:00 +0000

今天题目比较偏弱，只不过最后一题被罚时有点可惜，掉出了前100，如果不被罚时，说不定能进前50

T1: Check if Numbers Are Ascending in a Sentence

空格字符串分离，判断是不是数字，再判断是否递增即可

T2: Simple Bank System

简单的加减模拟器，注意不为负和用户操作边界判断

T3: Count Number of Maximum Bitwise-OR subsets

深搜即可

T4: Second Minimum Time to Reach Destination

可以理解为双层图的路径，第一层是最快的到达时间，第二层是第二快的时间(两者不能相等），然后直接用优先队列解决即可，注意剪枝。

LeetCode Biweekly Contest 63

Sat, 16 Oct 2021 00:00:00 +0000

第四题稍微有点难度，前三题偏弱，但是第四题自己想了比较久

T1: Minimum Number of Moves to Seat Everyone

排序后依次求绝对值之和

T2: Remove Colored Pieces if Both Neighbors are the Same Color

分别计算Alice和Bob可以移除颜色的数量，返回Alice >= Bob即可

T3: The Time When the Network Becomes Idle

计算每个结点到0的时间为N，计算在2N的时间内最后一次发送的时间为T，取T+2N+1的最大值即可

T4: Kth Smallest Product of Two Sorted Arrays

对于两个数组先计算负数，0和正数的数量，求出最终数字是正数还是负数（或者是0）。切换成两组递增（递减）的数组，通过二分来计算目标数值即可。

LeetCode Weekly Contest 262

Sun, 10 Oct 2021 00:00:00 +0000

整个人傻乎乎的，虽然全部做完了，但是时间整个人都是懵逼的，前三题耗时太长了。

T1: Two out of Three

用二进制表示3个数组的位置，找出1出现2次以上的即可

T2: Minimum Operations to Make a Uni-Value Grid

映射到线性空间上，然后O（n）计算求解，求解前先判断是否正常

T3: Stock Price Fluctuation

使用TreeSet即可，可以直接使用Long（当时傻掉了）来组合Timestamp和Price

T4: Partition Array Into Two Arrays to Minimize Sum Difference

假设数组总和为sum，那么找一个a,满足sum-2a最小，且2a小于等于sum（如果sum为负数，可以转换成正数）假设数组长度是2*n，拆成两个n长度的数组，进行计算求和。转换成 2个数组集合，第一个集合找出k个数，第二个集合找出n-k个数，且满足这两个数相加的和符合前面的条件，可以排序线性扫描计算

LeetCode Weekly Contest 261

Sun, 03 Oct 2021 00:00:00 +0000

最后一题尴尬卡住（不会做）

T1: Minimum Moves to Convert String

枚举，暴力计算即可

T2: Find Missing Observations

先判断是否合理，然后优先填充1和6

T3: Stone Game IX

对三取余进行统计，也就是余为0，1，2的数字集合，然后进行判断：

如果余1，2都为0，那么bob赢
如果余1，2相等，那么看0是奇数还是偶数，如果是偶数，那么alice赢
取余1，2最小的，如果大于0且是偶数，那么alice赢
去余1，2的差值，如果小于3那么bob赢
最后看余0如果为奇数alice赢

T4: Smallest K-Length Subsequence With Occurences of a Letter

利用栈的方法解决，这题我不会，详细看代码

    public String smallestSubsequence(String s, int k, char letter, int repetition) {
        int nLetter = 0;
        for(char ch : s.toCharArray()) {
            if (ch == letter) nLetter++;
        }
        Stack<Character> stack = new Stack<>();
        for(int i=0;i<s.length();i++) {
            char ch = s.charAt(i);
            while(!stack.isEmpty() && stack.peek() > ch && (s.length() - i + stack.size()>k) && (stack.peek()!=letter || nLetter>repetition)) {
                if (stack.pop() == letter) repetition++;
            }
            if (stack.size() < k) {
                if (ch == letter) {
                    stack.push(ch);
                    repetition--;
                } else if (k - stack.size() > repetition) {
                    stack.push(ch);
                }
            }
            if (ch == letter) nLetter--;
        }
        StringBuilder ans = new StringBuilder(stack.size());
        for(Character ch : stack) ans.append(ch);
        return ans.toString();
    }

LeetCode Biweekly Contest 62

Sat, 02 Oct 2021 00:00:00 +0000

上周比赛没打（折腾人），今天比赛比较简单，最后一题比较迟钝

T1: Convert 1D Array Into 2D Array

先判断是否可行再暴力模拟即可

T2: Number of Pairs of Strings With Concatenation Equal to Target

枚举暴力即可

T3: Maximize the Confusion of an Exam

分别计算转成T或者转成F，求两者最大值。可以直接用线性扫描O（N）复杂度解决。

T4: Maximum Number of Ways to Parition an Array

假设等式替换为Left-Right，枚举某个数进行变动，那么如果这个数在等式左侧，那么左侧Left为变动为k-num，那么只需要知道左侧这部分差值为k-num，同理右侧也是，两者求和即可

public int waysToPartition(int[] nums, int k) {
    HashMap<Long, Integer> rmap = new HashMap<>();
    HashMap<Long, Integer> lmap = new HashMap<>();
    long cnt = 0;
    long now = 0;
    for(int num : nums) {
        cnt += num;
    }
    long left = 0;
    long right = cnt;
    for(int i=0;i<nums.length-1;i++) {
        left += nums[i];
        right -= nums[i];
        long v = left - right;
        rmap.put(v, rmap.getOrDefault(v, 0) + 1);
    }
    int ans = rmap.getOrDefault(0l,0);
    for(int i=0;i<nums.length;i++) {
        now += nums[i];
        cnt -= nums[i];
        long v = now - cnt;
        long diff = k - nums[i];
        ans = Math.max(ans, lmap.getOrDefault(diff, 0) + rmap.getOrDefault(-diff,0));
        if (i != nums.length-1) {
            rmap.put(v, rmap.get(v) - 1);
            lmap.put(v, lmap.getOrDefault(v, 0) + 1);
        }
    }
    return ans;
}

LeetCode Weekly Contest 259

Sun, 19 Sep 2021 00:00:00 +0000

最后一题有点大失所望，好像直接莽过去就行了

T1: Find Value of Variable After Performing Operations

枚举4个操作判断即可

T2: Sum of Beauty in the Array

O(n)复杂度，记录左边最大值，右边最小值判断即可

T3: Detect Squares

枚举正方形长度，判断3个角有没有point

T4: Longest Subsequence Repeated k Times

暴力莽就行，如果某个子串至少出现k次，那么这个子串前面的也至少出现k次。做好判重查询即可，注意不是出现K次，是至少k次

LeetCode Biweekly Contest 61

Sat, 18 Sep 2021 00:00:00 +0000

第一次30min解决战斗，奈何罚时太狠了，自己失误率过高

T1: Count Number of Pairs With Absolute Difference K

模拟即可

T2: Find Original Array From Doubled Array

罚时题*1，基数排序，然后模拟判断是否拆分两个数组，第一个是第二个的double即可。

T3: Maximum Earnings From Taxi

DP题，按时间模拟即可，对Rides进行排序即可

T4: Minimum Number of Operations to Make Array Continuous

注意重复，首选去重，去重的个数都是需要修改的。枚举开始的x，记录[x,x+n)这个区间内有多少个去重后的数，答案就是n-这个值即可。