移动所有球到每个盒子所需的最小操作数

class Solution {
    public int[] minOperations(String boxes) {
        int n = boxes.length();
        char[] chars = boxes.toCharArray();
        int[] left = new int[n];
        int[] ans = new int[n];
        int preSum = 0;
        for (int i = 1; i < n; i++) {
            int num = (chars[i - 1] - '0');
            preSum += num;
            left[i] = left[i - 1] + preSum;
        }

        preSum = 0;

        for (int i = n - 2; i >= 0; --i) {
            int num = (chars[i + 1] - '0');
            preSum += num;
            ans[i] = ans[i + 1] + preSum;
        }
        for (int i = n - 1; i >= 0; --i) {
            ans[i] += left[i];
        }
        
        return ans;
    }
}

积压订单中的订单总数

class Solution {
    public int getNumberOfBacklogOrders(int[][] orders) {
        int mod = 1_000_000_000 + 7;
        PriorityQueue<int[]> sell = new PriorityQueue<>(new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o1[0] - o2[0];
            }
        });
        PriorityQueue<int[]> buy = new PriorityQueue<>(new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o2[0] - o1[0];
            }
        });
        for (int[] order : orders) {
            int type = order[2];
            if (type == 0) {
                // 0表示采购订单
                while (!sell.isEmpty() && sell.peek()[0] <= order[0] && order[1] > 0) {
                    int[] s = sell.poll();
                    if (order[1] >= s[1]) {
                        order[1] = order[1] - s[1];
                    } else {
                        s[1] = s[1] - order[1];
                        order[1] = 0;
                        sell.add(s);
                    }
                }
                if (order[1] > 0){
                    buy.add(order);
                }
            } else {
                // 1 表示销售订单
                while (!buy.isEmpty() && buy.peek()[0] >= order[0] && order[1] > 0) {
                    int[] s = buy.poll();
                    if (order[1] >= s[1]) {
                        order[1] = order[1] - s[1];
                    } else {
                        s[1] = s[1] - order[1];
                        order[1] = 0;
                        buy.add(s);
                    }
                }
                if (order[1] > 0){
                    sell.add(order);
                }
            }
        }
        long ans = 0;
        while (!sell.isEmpty()) {
            ans = (ans + sell.poll()[1]) % mod;
        }

        while (!buy.isEmpty()) {
            ans = (ans + buy.poll()[1]) % mod;
        }

        return (int) ans;
    }
}

替换字符串中的括号内容

class Solution {
    public String evaluate(String s, List<List<String>> knowledge) {
        Map<String, String> map = new HashMap<>();
        for (List<String> list : knowledge) {
            map.put(list.get(0), list.get(1));
        }
        StringBuilder sb = new StringBuilder();
        char[] chars = s.toCharArray();
        int left = -1;
        for (int i = 0; i < chars.length; i++) {
            if (chars[i] == '(') {
                left = i;
            } else if (chars[i] == ')'){
                sb.append(map.getOrDefault(s.substring(left + 1, i), "?"));
                left = -1;
            } else {
                if (left == -1) {
                    sb.append(chars[i]);
                }
            }
            
        }
        if (left != -1) {
            sb.append(s.substring(left));
        }
        return sb.toString();
    }
}

句子相似性 III

class Solution {
    public boolean areSentencesSimilar(String sentence1, String sentence2) {
        if (sentence1.equals(sentence2)) {
            return true;
        }
        if (sentence1.length() > sentence2.length()) {
            String temp = sentence2;
            sentence2 = sentence1;
            sentence1 = temp;
        }
        String[] s1 = sentence1.split(" ");
        String[] s2 = sentence2.split(" ");
        int len1 = s1.length;
        int len2 = s2.length;
        // System.out.println(s1[0] + " " + s2[0] + " " + s2[len2 - 1]);
        if (len1 == 1) {
            

            return s1[0].equals(s2[0]) || s1[0].equals(s2[len2 - 1]);
        }
        int left = 0;
        int right = 0;
        while (left + right < len1) {
            if (s1[left].equals(s2[left])) {
                ++left;
            } else {
                if (s1[len1 - right - 1].equals(s2[len2 - right - 1])) {
                    ++right;
                } else {
                    break;
                }
            }
        }
        // System.out.println(left + "  " + right);
        return left + right == len1;
    }
}