LeetCode 每日一题 Day 37-43

终于考完试了，寒假期间将会每天持续更新！

447. 回旋镖的数量(Day 37)

给定平面上 n 对互不相同的点 points ，其中 points[i] = [xi, yi] 。回旋镖是由点 (i, j, k) 表示的元组，其中 i 和 j 之间的欧式距离和 i 和 k 之间的欧式距离相等（需要考虑元组的顺序）。

返回平面上所有回旋镖的数量。

示例 1：

输入：points = [[0,0],[1,0],[2,0]]
输出：2
解释：两个回旋镖为 [[1,0],[0,0],[2,0]] 和 [[1,0],[2,0],[0,0]]
示例 2：

输入：points = [[1,1],[2,2],[3,3]]
输出：2
示例 3：

输入：points = [[1,1]]
输出：0

提示：

n == points.length
1 <= n <= 500
points[i].length == 2
-10⁴ <= x_i, y_i <= 10⁴
所有点都互不相同

枚举实现，外层枚举i ，内层枚举j

class Solution {
public:
    int numberOfBoomerangs(vector<vector<int>> &points) {
        int ans = 0;
        unordered_map<int, int> cnt;
        for (auto &p1 : points) {
            cnt.clear();
            for (auto &p2 : points) {
                int d2 = (p1[0] - p2[0]) * (p1[0] - p2[0]) + (p1[1] - p2[1]) * (p1[1] - p2[1]);
                ans += cnt[d2]++ * 2;
            }
        }
        return ans;
    }
};

2707. 字符串中的额外字符(Day 38）

给你一个下标从 0 开始的字符串 s 和一个单词字典 dictionary 。你需要将 s 分割成若干个互不重叠的子字符串，每个子字符串都在 dictionary 中出现过。s 中可能会有一些额外的字符不在任何子字符串中。

请你采取最优策略分割 s ，使剩下的字符最少。

示例 1：

输入：s = “leetscode”, dictionary = [“leet”,“code”,“leetcode”]
输出：1
解释：将 s 分成两个子字符串：下标从 0 到 3 的 “leet” 和下标从 5 到 8 的 “code” 。只有 1 个字符没有使用（下标为 4），所以我们返回 1 。
示例 2：

输入：s = “sayhelloworld”, dictionary = [“hello”,“world”]
输出：3
解释：将 s 分成两个子字符串：下标从 3 到 7 的 “hello” 和下标从 8 到 12 的 “world” 。下标为 0 ，1 和 2 的字符没有使用，所以我们返回 3 。

提示：

1 <= s.length <= 50
1 <= dictionary.length <= 50
1 <= dictionary[i].length <= 50
dictionary[i] 和 s 只包含小写英文字母。
dictionary 中的单词互不相同。

字典序，哈希表+DP

class Solution {
public:
    int minExtraChar(string s, vector<string>& dictionary) {
        unordered_set<string> set(dictionary.begin(), dictionary.end());
        int n = s.size();
        vector<int> f(n + 1);
        for (int i = 0; i < n; i++) {
            f[i + 1] = f[i] + 1;
            for (int j = 0; j <= i; j++) {
                if (set.count(s.substr(j, i - j + 1))) {
                    f[i + 1] = min(f[i + 1], f[j]);
                }
            }
        }
        return f[n];
    }
};

2696. 删除子串后的字符串最小长度(Day 39)

给你一个仅由大写英文字符组成的字符串 s 。

你可以对此字符串执行一些操作，在每一步操作中，你可以从 s 中删除任一个 “AB” 或 “CD” 子字符串。

通过执行操作，删除所有 “AB” 和 “CD” 子串，返回可获得的最终字符串的最小可能长度。

注意，删除子串后，重新连接出的字符串可能会产生新的 “AB” 或 “CD” 子串。

示例 1：

输入：s = “ABFCACDB”
输出：2
解释：你可以执行下述操作：

从 “ABFCACDB” 中删除子串 “AB”，得到 s = “FCACDB” 。
从 “FCACDB” 中删除子串 “CD”，得到 s = “FCAB” 。
从 “FCAB” 中删除子串 “AB”，得到 s = “FC” 。
最终字符串的长度为 2 。
可以证明 2 是可获得的最小长度。
示例 2：

输入：s = “ACBBD”
输出：5
解释：无法执行操作，字符串长度不变。

提示：

1 <= s.length <= 100
s 仅由大写英文字母组成

栈的简单应用：

class Solution {
public:
    int minLength(string s) {
        int len = s.size();
        char* stack = (char*)malloc(sizeof(char) * len);
        int top = -1;
        for (int i = 0; i < len; i++) {
            if (s[i] == 'B') {
                if (top >= 0 && stack[top] == 'A') {
                    top--;
                } else {
                    stack[++top] = s[i];
                }
            }
            else if (s[i] == 'D') {
                if (top >= 0 && stack[top] == 'C') {
                    top--;
                } else {
                    stack[++top] = s[i];
                }
            }
            else
                stack[++top] = s[i];
        }
        return top + 1;    
    }
};

2645. 构造有效字符串的最少插入数

给你一个字符串 word ，你可以向其中任何位置插入 “a”、“b” 或 “c” 任意次，返回使 word 有效需要插入的最少字母数。

如果字符串可以由 “abc” 串联多次得到，则认为该字符串有效。

示例 1：

输入：word = “b”
输出：2
解释：在 “b” 之前插入 “a” ，在 “b” 之后插入 “c” 可以得到有效字符串 “abc” 。
示例 2：

输入：word = “aaa”
输出：6
解释：在每个 “a” 之后依次插入 “b” 和 “c” 可以得到有效字符串 “abcabcabc” 。
示例 3：

输入：word = “abc”
输出：0
解释：word 已经是有效字符串，不需要进行修改。

提示：

1 <= word.length <= 50
word 仅由字母 “a”、“b” 和 “c” 组成。

这里学习了灵神的解法，实在是优雅巧妙：

class Solution {
public:
    int addMinimum(string word) {
        int ans = word[0] + 2 - word.back();
        for(int i = 1; i < word.length();i++){
            ans += (word[i] + 2 - word[i - 1]) % 3;
        }
        return ans;
    }
};

2085. 统计出现过一次的公共字符串

给你两个字符串数组 words1 和 words2 ，请你返回在两个字符串数组中都恰好出现一次的字符串的数目。

示例 1：

输入：words1 = [“leetcode”,“is”,“amazing”,“as”,“is”], words2 = [“amazing”,“leetcode”,“is”]
输出：2
解释：

“leetcode” 在两个数组中都恰好出现一次，计入答案。
“amazing” 在两个数组中都恰好出现一次，计入答案。
“is” 在两个数组中都出现过，但在 words1 中出现了 2 次，不计入答案。
“as” 在 words1 中出现了一次，但是在 words2 中没有出现过，不计入答案。
所以，有 2 个字符串在两个数组中都恰好出现了一次。
示例 2：

输入：words1 = [“b”,“bb”,“bbb”], words2 = [“a”,“aa”,“aaa”]
输出：0
解释：没有字符串在两个数组中都恰好出现一次。
示例 3：

输入：words1 = [“a”,“ab”], words2 = [“a”,“a”,“a”,“ab”]
输出：1
解释：唯一在两个数组中都出现一次的字符串是 “ab” 。

提示：

1 <= words1.length, words2.length <= 1000
1 <= words1[i].length, words2[j].length <= 30
words1[i] 和 words2[j] 都只包含小写英文字母。

哈希表的应用，哈希表计数：

class Solution {
public:
    int countWords(vector<string>& words1, vector<string>& words2) {
        unordered_map<string, int> cnt1;
        unordered_map<string, int> cnt2;
        for (auto& w : words1) {
            ++cnt1[w];
        }
        for (auto& w : words2) {
            ++cnt2[w];
        }
        int ans = 0;
        for (auto& [w, v] : cnt1) {
            ans += v == 1 && cnt2[w] == 1;
        }
        return ans;
    }
};

2182. 构造限制重复的字符串

给你一个字符串 s 和一个整数 repeatLimit ，用 s 中的字符构造一个新字符串 repeatLimitedString ，使任何字母连续出现的次数都不超过 repeatLimit 次。你不必使用 s 中的全部字符。

返回字典序最大的 repeatLimitedString 。

如果在字符串 a 和 b 不同的第一个位置，字符串 a 中的字母在字母表中出现时间比字符串 b 对应的字母晚，则认为字符串 a 比字符串 b 字典序更大。如果字符串中前 min(a.length, b.length) 个字符都相同，那么较长的字符串字典序更大。

示例 1：

输入：s = “cczazcc”, repeatLimit = 3
输出：“zzcccac”
解释：使用 s 中的所有字符来构造 repeatLimitedString “zzcccac”。
字母 ‘a’ 连续出现至多 1 次。
字母 ‘c’ 连续出现至多 3 次。
字母 ‘z’ 连续出现至多 2 次。
因此，没有字母连续出现超过 repeatLimit 次，字符串是一个有效的 repeatLimitedString 。
该字符串是字典序最大的 repeatLimitedString ，所以返回 “zzcccac” 。
注意，尽管 “zzcccca” 字典序更大，但字母 ‘c’ 连续出现超过 3 次，所以它不是一个有效的 repeatLimitedString 。
示例 2：

输入：s = “aababab”, repeatLimit = 2
输出：“bbabaa”
解释：
使用 s 中的一些字符来构造 repeatLimitedString “bbabaa”。
字母 ‘a’ 连续出现至多 2 次。
字母 ‘b’ 连续出现至多 2 次。
因此，没有字母连续出现超过 repeatLimit 次，字符串是一个有效的 repeatLimitedString 。
该字符串是字典序最大的 repeatLimitedString ，所以返回 “bbabaa” 。
注意，尽管 “bbabaaa” 字典序更大，但字母 ‘a’ 连续出现超过 2 次，所以它不是一个有效的 repeatLimitedString 。

贪心解法，当然看题解还有运用双指针实现的，感兴趣的读者可以去了解一下：

class Solution {
public:
    string repeatLimitedString(string s, int repeatLimit) {
        vector<int> cnt(26);
        for(int i=0;i<s.size();i++){
            cnt[s[i]-'a']++;
        }
        int cur=25;
        int pre=cur-1;
        int m=0;
        string res;
        while(cur>=0&&pre>=0){
            if(cnt[cur]==0){
                cur--;
                m=0;
            }
            else if(m<repeatLimit){
                cnt[cur]--;
                res.push_back('a'+cur);
                m++;
            }
            else if(pre>=cur||cnt[pre]==0){
                pre--;
            }
            else{
                res.push_back('a'+pre);
                cnt[pre]--;
                m=0;
            }
        }
        return res;
    }
};

83. 删除排序链表中的重复元素

给定一个已排序的链表的头 head ，删除所有重复的元素，使每个元素只出现一次。返回已排序的链表。

示例 1：

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

示例 2：

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

提示：

链表中节点数目在范围 [0, 300] 内
-100 <= Node.val <= 100
题目数据保证链表已经按升序排列

遍历实现：

/**
* Definition for singly-linked list.
* struct ListNode {
*     int val;
*     ListNode *next;
*     ListNode() : val(0), next(nullptr) {}
*     ListNode(int x) : val(x), next(nullptr) {}
*     ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
   ListNode* deleteDuplicates(ListNode* head) {
       if (!head) {
           return head;
       }

       ListNode* cur = head;
       while (cur->next) {
           if (cur->val == cur->next->val) {
               cur->next = cur->next->next;
           }
           else {
               cur = cur->next;
           }
       }

       return head;
   }
};