leetcode-215场周赛

5601-设计有序流

题目-5601-设计有序流
最开始没有看明白什么意思，其实，简单来说，就是，维护一个String数组，一次在数组中插入字符串，同时维护一个ptr指针，如果当前插入的位置与ptr指针指向相同，则遍历至数组为空，同时更改ptr指针位置。否则，ptr指针向下指一个。

class OrderedStream {
    String[] str = null;
    int ptr = 1;
    int id = 1;
    public OrderedStream(int n) {
        str = new String[n];
    }
    
    public List<String> insert(int id, String value) {
        List<String> res = new ArrayList<>();
        str[id - 1] = value;
        if (ptr == id && ptr <= str.length){
        	// 遍历，注意防止数组越界
            while(ptr <= str.length && str[ptr - 1] != null ){
                res.add(str[ptr - 1]);
                ptr++;
            }
        }
        return res;
        
    }
}

/**
 * Your OrderedStream object will be instantiated and called as such:
 * OrderedStream obj = new OrderedStream(n);
 * List<String> param_1 = obj.insert(id,value);
 */

5602-将 x 减到 0 的最小操作数

题目-5602. 将 x 减到 0 的最小操作数
对于这个问题，对于左边，如果要移除第i个，必然要移除0~i-1个。同理，如果右边移除第i个，必然要移除i+1 ~ n。
因此，可以构建从左往右的数组和以及从右往左的数组和，当left_sum[i] + right_sum[j] == x && i + j < n 的时候，就存在解.

class Solution {
    int[] left_sum = new int[100005];
    int[] right_sum = new int[100005];
    public int minOperations(int[] nums, int x) {
        int n = nums.length;
        left_sum[0] = 0;
        right_sum[0] = 0;
        for (int i = 1; i <= n; i++){
            left_sum[i] = left_sum[i - 1] + nums[i - 1];
            right_sum[i] = right_sum[i - 1] + nums[n - i];
        }
        
        int minn = Integer.MAX_VALUE;
        int i = 0, j = n;
        
        // 双指针求和问题
        while (i + j <= n && i >=0 && j>=0){
            if (left_sum[i] + right_sum[j] == x){
                minn = Math.min(minn, i + j);
                i++;
                j--;
            }
            else if(left_sum[i] + right_sum[j] > x){
                j--;
            }
            else{
                i++;
            }
        }
        
        if (minn < Integer.MAX_VALUE) return minn;
        return -1;
    }
}

5603-确定两个字符串是否接近

题目-5603. 确定两个字符串是否接近

1. 由于字符串内部可以任意交换顺序，因此不需要考虑字符串内部顺序问题
2. 两个字符串长度不同，必然false
3. 如果一个串中出现另一个串中没有的字符，必然false
4. 此时问题转换成，对于a串中出现的字符，判断b串中是否含有等量的字符可用来转换（是什么字符不重要，反正能转化，比如说我把b串中的c转成a了，后面我需要c，只需要再从别的字符转过来即可）

class Solution {
    public boolean closeStrings(String word1, String word2) {
        if (word1.length() != word2.length())return false;
        int[] w1 = new int[27];
        int[] w2 = new int[27];
        for (int i = 0; i < word1.length(); i++){
            w1[word1.charAt(i) - 'a']++;
            w2[word2.charAt(i) - 'a']++;
        }
        boolean flag = true;
        // 判断是否含有只在一个串中出现的字符
        for (int i = 0; i < 26; i++){
            if (w1[i] == 0 && w2[i] > 0 || w1[i] > 0 && w2[i] == 0){
                return false;
            }
        }
        // 对于a串中出现的字符，判断b中是否含有等量的字符可用来转换
        for (int i = 0; i < 26; i++){
            if (w1[i] > 0){
                int j = 0;
                for (j = 0; j < 26; j++){
                    if (w2[j] == w1[i]){
                        w2[j] = 0;
                        break;
                    }
                }
                if (j == 26){
                    flag = false;
                    break;
                }
            }
        }
        return flag;
    }
}

5604-最大化网格幸福感

题目-5604. 最大化网格幸福感

这题没写出来，留坑待补