LeetCode 第 151 场周赛 【查询无效交易】【最大层内元素和】【从链表中删去总和值为零的连续节点】

1169. 查询无效交易

如果出现下述两种情况，交易 可能无效：

• 交易金额超过 ¥1000
• 或者，它和另一个城市中同名的另一笔交易相隔不超过 60 分钟（包含 60 分钟整）
  每个交易字符串 transactions[i] 由一些用逗号分隔的值组成，这些值分别表示交易的名称，时间（以分钟计），金额以及城市。

给你一份交易清单 transactions，返回可能无效的交易列表。你可以按任何顺序返回答案。
示例 1：

输入：transactions = ["alice,20,800,mtv","alice,50,100,beijing"]
输出：["alice,20,800,mtv","alice,50,100,beijing"]
解释：第一笔交易是无效的，因为第二笔交易和它间隔不超过 60 分钟、名称相同且发生在不同的城市。同样，第二笔交易也是无效的。

示例 2：

输入：transactions = ["alice,20,800,mtv","alice,50,1200,mtv"]
输出：["alice,50,1200,mtv"]

示例 3：

输入：transactions = ["alice,20,800,mtv","bob,50,1200,mtv"]
输出：["bob,50,1200,mtv"]

提示：

transactions.length <= 1000
每笔交易 transactions[i] 按 "{name},{time},{amount},{city}" 的格式进行记录
每个交易名称 {name} 和城市 {city} 都由小写英文字母组成，长度在 1 到 10 之间
每个交易时间 {time} 由一些数字组成，表示一个 0 到 1000 之间的整数
每笔交易金额 {amount} 由一些数字组成，表示一个 0 到 2000 之间的整数

代码：

	public List<String> invalidTransactions(String[] transactions) {
        Set<String> set=new HashSet<>();
        for (int i = 0; i < transactions.length; i++) {
            String[] split = transactions[i].split(",");
            if (Integer.parseInt(split[2])>1000){
                set.add(transactions[i]);
            }
            for (int j = i+1; j < transactions.length; j++) {
                String[] last = transactions[j].split(",");
                if (split[0].equals(last[0]) && !split[3].equals(last[3]) && Math.abs(Integer.parseInt(split[1])-Integer.parseInt(last[1]))<=60){
                    set.add(transactions[i]);
                    set.add(transactions[j]);
                }

            }
        }
        List<String> list=new ArrayList<>(set);
        return list;
    }

1170. 比较字符串最小字母出现频次

我们来定义一个函数 f(s)，其中传入参数 s 是一个非空字符串；该函数的功能是统计 s 中（按字典序比较）最小字母的出现频次。

例如，若 s = “dcce”，那么 f(s) = 2，因为最小的字母是 “c”，它出现了 2 次。

现在，给你两个字符串数组待查表 queries 和词汇表 words，请你返回一个整数数组 answer 作为答案，其中每个 answer[i] 是满足 f(queries[i]) < f(W) 的词的数目，W 是词汇表 words 中的词。
示例 1：

输入：queries = ["cbd"], words = ["zaaaz"]
输出：[1]
解释：查询 f("cbd") = 1，而 f("zaaaz") = 3 所以 f("cbd") < f("zaaaz")。

示例 2：

输入：queries = ["bbb","cc"], words = ["a","aa","aaa","aaaa"]
输出：[1,2]
解释：第一个查询 f("bbb") < f("aaaa")，第二个查询 f("aaa") 和 f("aaaa") 都 > f("cc")。

提示：

1 <= queries.length <= 2000
1 <= words.length <= 2000
1 <= queries[i].length, words[i].length <= 10
queries[i][j], words[i][j] 都是小写英文字母

代码：

public static int[] numSmallerByFrequency(String[] queries, String[] words) {
        int[] q = new int[queries.length];
        int[] w = new int[words.length];
        int[] res = new int[queries.length];
        for (int i = 0; i < queries.length; i++) {
            q[i] = fs(queries[i]);
        }
        for (int i = 0; i < words.length; i++) {
            w[i] = fs(words[i]);
        }
        Arrays.sort(w);
        for (int i = 0; i < queries.length; i++) {
            int cnt = 0;
            for (int j = words.length - 1; j >= 0; j--) {
                if (w[j] > q[i]) {
                    cnt++;
                    res[i] = cnt;
                } else {
                    res[i] = cnt;
                    break;
                }
            }
        }
        return res;
    }

    public static int fs(String word) {
        char min = word.charAt(0);
        int count = 0;
        for (int i = 0; i < word.length(); i++) {
            min = (char) Math.min(min, word.charAt(i));
        }
        
        for (int i = 0; i < word.length(); i++) {
            if (word.charAt(i) == min) {
                count++;
            }
        }
        
        return count;
    }

1171. 从链表中删去总和值为零的连续节点

给你一个链表的头节点 head，请你编写代码，反复删去链表中由 总和 值为 0 的连续节点组成的序列，直到不存在这样的序列为止。

删除完毕后，请你返回最终结果链表的头节点。

你可以返回任何满足题目要求的答案。

（注意，下面示例中的所有序列，都是对 ListNode 对象序列化的表示。）

示例 1：

输入：head = [1,2,-3,3,1]
输出：[3,1]
提示：答案 [1,2,1] 也是正确的。

示例 2：

输入：head = [1,2,3,-3,4]
输出：[1,2,4]

示例 3：

输入：head = [1,2,3,-3,-2]
输出：[1]

提示：

给你的链表中可能有 1 到 1000 个节点。
对于链表中的每个节点，节点的值：-1000 <= node.val <= 1000.

public  ListNode removeZeroSumSublists(ListNode head) {
        ListNode p = head;
        List<Integer> lists = new ArrayList<>();
        while (p != null) {
            lists.add(p.val);
            p = p.next;
        }
        boolean change = help(lists);
        while (change) {
            change = help(lists);
        }
        ListNode H = new ListNode(-1);
        p = H;
        for (int k : lists) {
            if (k != 0) {
                ListNode node = new ListNode(k);
                p.next = node;
                p = node;
            }
        }
        return H.next;
    }

    public static boolean help(List<Integer> lists) {
        boolean change = false;
        for (int i = 0; i < lists.size(); ) {
            int sum = lists.get(i);
            if (sum == 0) {
                i++;
                continue;
            }
            for (int j = i + 1; j < lists.size(); j++) {
                sum += lists.get(j);
                if (sum == 0) {
                    for (int k = i; k <= j; k++) {
                        lists.set(k, 0);
                        i = j + 1;
                        change = true;
                    }
                    break;
                }
            }
            i++;
        }
        return change;
    }