双周赛 2022.1.8 题解汇总

T1 5960. 将标题首字母大写

给你一个字符串 title ，它由单个空格连接一个或多个单词组成，每个单词都只包含英文字母。请你按以下规则将每个单词的首字母 大写 ：

如果单词的长度为 1 或者 2 ，所有字母变成小写。
否则，将单词首字母大写，剩余字母变成小写。
请你返回 大写后 的 title 。

 

 

 

解题思路：① 将字符串全部转成小写，然后用  " "  分割整个字符串得到字符串数组。

                  ② 遍历字符串数组，如果长度 <= 2，用Stringbulider直接append字符串，并且append 一个空格。

                  ③ 如果长度 >2 则将其首位的字符减 32 变为大写， 用Stringbulider直接append字符串，并且append 一个空格。

                  ④ 删掉Stringbulider最后一个字符，也就是多的那个空格，然后将其转换成String进行返回。

代码和提交结果如下：

class Solution {
    public String capitalizeTitle(String title) {
        String small = title.toLowerCase();
        String[] split = small.split(" ");
        StringBuilder res = new StringBuilder();
        for (int i = 0; i < split.length; i++) {
            if(split[i].length() <= 2){
                res.append(split[i]);
                res.append(" ");
                continue;
            }
            char[] array = split[i].toCharArray();
            array[0] -= 32;
            split[i] = new String(array);
            res.append(split[i]);
            res.append(" ");
        }
        res.deleteCharAt(res.length()-1);
        return new String(res);
    }
}

T2 5961. 链表最大孪生和 

在一个大小为 n 且 n 为 偶数 的链表中，对于 0 <= i <= (n / 2) - 1 的 i ，第 i 个节点（下标从 0 开始）的孪生节点为第 (n-1-i) 个节点 。

比方说，n = 4 那么节点 0 是节点 3 的孪生节点，节点 1 是节点 2 的孪生节点。这是长度为 n = 4 的链表中所有的孪生节点。
孪生和 定义为一个节点和它孪生节点两者值之和。

给你一个长度为偶数的链表的头节点 head ，请你返回链表的 最大孪生和 。

 

 

 

解题思路：翻转链表

① 找到链表 中间部分，然后将后半部分链表翻转。

② 直接同时遍历前半部分链表以及翻转完成的后半部分链表，计数求最大即可。

代码和提交结果如下：

class Solution {
    public int pairSum(ListNode head) {
        int len = 0;
        ListNode pre = head;
        while(pre  != null){
            len++;
            pre = pre.next;
        }
        pre = head;
        for(int i = 0 ; i < len/2 ; i++){
            pre = pre.next;
        }
        ListNode reverse = reverseList(pre);
        int max = 0;
        int sum = 0;
        for(int i = 0 ; i < len/2 ; i++){
            sum = head.val + reverse.val;
            if(sum > max){
                max = sum;
            }
            head = head.next;
            reverse = reverse.next;
        }
        return max;
    }
    public ListNode reverseList(ListNode head) {
        ListNode reverse = null;
        ListNode pre = head;
        while(pre != null){
            ListNode temp = pre.next;
            pre.next = reverse;
            reverse = pre;
            pre = temp;
        }
        return reverse;
    }
}

T3 5962. 连接两字母单词得到的最长回文串 

给你一个字符串数组 words 。words 中每个元素都是一个包含 两个 小写英文字母的单词。

请你从 words 中选择一些元素并按 任意顺序 连接它们，并得到一个 尽可能长的回文串 。每个元素 至多 只能使用一次。

请你返回你能得到的最长回文串的 长度 。如果没办法得到任何一个回文串，请你返回 0 。

回文串 指的是从前往后和从后往前读一样的字符串。

 

 

 

解题思路： 使用hashMap，模拟计数

① 遍历字符串数组，预先统计出每种字符串的个数
② 先考虑需要在两侧分别添加的情况：遍历一次字符串数组，求出每个字符串的逆序串。如果当前字符串是两个字符相同的字符串，那么必须该字符串剩余出现次数>=2，以保证两侧能够分别添加一个；如果是两个字符不同的字符串，那么需要该字符串与其逆序串出现次数分别>=1。
③ 考虑可以在回文串的正中间添加一个串特殊情况：如果某个串为两个字符相同的字符串，且其剩余出现次数>=1，那么则可以添加一个串。

代码加了注释，提交结果如下

class Solution {
    public int longestPalindrome(String[] words) {
         // 统计每种字符串的个数
        HashMap<String, Integer> map = new HashMap<>();
        for (int i = 0; i < words.length; i++) {
            map.put(words[i],map.getOrDefault(words[i],0)+1);
        }
        int count = 0;
        for (int i = 0; i < words.length; i++) {
            // 如果是两个字符不同的字符串，并且该类字符串与其反转串剩余个数均>=1，那么便可在回文串两侧分别添加一个该字符串与其反转串
            if(words[i].charAt(0) != words[i].charAt(1) && map.getOrDefault(reverse(words[i]),0) >= 1 && map.getOrDefault(words[i],0) >= 1){
                count+=2;
                map.put(words[i],map.getOrDefault(words[i],0) - 1);
                map.put(reverse(words[i]),map.getOrDefault(reverse(words[i]),0) - 1);
            }
            // 如果是两个字符相同的字符串，并且该类字符串剩余个数>=2，那么便可在回文串两侧分别添加一个该字符串
            if(words[i].charAt(0) == words[i].charAt(1) && map.getOrDefault(words[i],0) >= 2){
                count += 2;
                map.put(words[i],map.getOrDefault(words[i],0) - 2);
            }
        }
        // 如果存在两个字符相同的字符串，可以添加到回文串的正中间（最多只能有一个）
        for(int i = 0 ; i < words.length; i++){
            if(words[i].charAt(0) == words[i].charAt(1) && map.getOrDefault(words[i],0) >=1){
                count += 1;
                break;
            }
        }
        return count*2;
    }
    private String reverse(String s){
        return ""+s.charAt(1)+s.charAt(0);
    }
    
}

总结：还好吧