C++博客-Uriel's Corner-文章分类-Hash

[LeetCode]1239. Maximum Length of a Concatenated String with Unique Characters (Medium) Python-2024.01.23

Uriel — Tue, 23 Jan 2024 10:54:00 GMT

给出一些字符串，问取其中若干字符串能拼出的不含重复字母的最长字串
先过滤掉自身有重复字母的，然后设一个内含set的列表，每次扫一遍列表看能否加入当前字符串，最后取列表中最多字母的set

#1239
#Runtime: 97 ms (Beats 50%)
#Memory: 53.4 MB (Beats 8.49%)

class Solution(object):
    def maxLength(self, arr):
        """
        :type arr: List[str]
        :rtype: int
        """
        candidate = []
        for s in arr:
            u = set(s)
            if len(s) == len(u):
                candidate.append(u)
        ans = [set()]
        maxx = 0
        for i in candidate:
            for j in ans:
                if not i & j:
                    ans.append(i | j)
                    maxx = max(maxx, len(i | j))
        return maxx

Uriel 2024-01-23 18:54 发表评论

[LeetCode]2610. Convert an Array Into a 2D Array With Conditions (Medium) Python-2024.01.02

Uriel — Tue, 02 Jan 2024 13:04:00 GMT

给出一列数来构造数组，数组每一行由不同的数字组成，每行长度可以不一样，输出其中一种可行解
用python的Counter统计每个数字出现次数，再一次构造每一行

1 #2610
2 #Runtime: 60 ms (Beats 13.89%)
3 #Memory: 13.3 MB (Beats 80.56%)
4
5 class Solution(object):
6     def findMatrix(self, nums):
7         """
8         :type nums: List[int]
9         :rtype: List[List[int]]
10         """
11         ans = []
12         cnt = Counter(nums)
13         while cnt:
14             tp = []
15             used = []
16             for i, v in cnt.items():
17                 tp.append(i)
18                 cnt[i] -= 1
19                 if cnt[i] == 0:
20                     used.append(i)
21             for i in used:
22                 cnt.pop(i)
23             ans.append(tp)
24         return ans

Uriel 2024-01-02 21:04 发表评论

[LeetCode]1897. Redistribute Characters to Make All Strings Equal (Easy) Python-2023.12.30

Uriel — Sat, 30 Dec 2023 13:21:00 GMT

一个words集合包含若干字符串，每次操作可以将其中一个字符串的某个字符插入另一个字符串，问是否可以经过无限次操作使得每个字符串变成相同的。直接判断是否每个字符的总出现次数可以被字符串数量整除即可

1 #1897
2 #Runtime: 67 ms (Beats 16.67%)
3 #Memory: 13.6 MB (Beats 83.33%)
4
5 class Solution(object):
6     def makeEqual(self, words):
7         """
8         :type words: List[str]
9         :rtype: bool
10         """
11         total = ''.join(words)
12         chars = set(total)
13         for ch in chars:
14             if total.count(ch) % len(words) != 0:
15                 return False
16         return True

Uriel 2023-12-30 21:21 发表评论

[LeetCode]242. Valid Anagram (Easy) Python-2023.12.16

Uriel — Sat, 16 Dec 2023 10:28:00 GMT

求问两个字符串是否由完全相同的字母不同的组合而成，用python的count判断每个字出现次数

#242
#Runtime: 20 ms (Beats 96.2%)
#Memory: 13.7 MB (Beats 69.85%)

class Solution(object):
    def isAnagram(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        if len(s) != len(t):
            return False
        for i in set(s):
            if s.count(i) != t.count(i):
                return False
        return True

Uriel 2023-12-16 18:28 发表评论

[LeetCode]1436. Destination City (Easy) Python-2023.12.15

Uriel — Fri, 15 Dec 2023 08:28:00 GMT

给出每一条路的起始和终止城市（string），输出唯一的终点城市（没有从该城市出发的任何路），数据保证结果唯一，两个hash表，一个存所有出现过的城市，一个存所有作为过起点的城市

1 #1436
2 #Runtime: 34 ms (Beats 59.12%)
3 #Memory: 13.6 MB (Beats 19.34%)
4
5 class Solution(object):
6     def destCity(self, paths):
7         """
8         :type paths: List[List[str]]
9         :rtype: str
10         """
11         st = set()
12         cities = set()
13         for x, y in paths:
14             st.add(x)
15             cities.add(x)
16             cities.add(y)
17         for x in cities:
18             if x not in st:
19                 return x

Uriel 2023-12-15 16:28 发表评论

[LeetCode]1647. Minimum Deletions to Make Character Frequencies Unique (Medium) Python-2023.09.12

Uriel — Tue, 12 Sep 2023 09:17:00 GMT

给出一堆字符，问最少去掉几个字符可以保证每种字符出现的次数不同，用python的counter统计次数，然后用set记录已经出现过的字符频次，若有冲突，不断去掉字符直至不冲突

1 #1647
2 #Runtime: 274 ms (Beats 29.54%)
3 #Memory: 14.2 MB (Beats 87.50%)
4
5 class Solution(object):
6     def minDeletions(self, s):
7         """
8         :type s: str
9         :rtype: int
10         """
11         ans = 0
12         fq_set = set()
13         cnt = collections.Counter(s)
14         for ch, fq in cnt.items():
15             while fq  and fq in fq_set:
16                 fq -= 1
17                 ans += 1
18             fq_set.add(fq)
19         return ans

Uriel 2023-09-12 17:17 发表评论

[LeetCode]1282. Group the People Given the Group Size They Belong To (Medium) Python-2023.09.11

Uriel — Mon, 11 Sep 2023 08:24:00 GMT

给出数组groupSizes，每个元素代表第i个人属于size为groupSizes[i]的组，输出每个组的组成
用python的dict存每个不同size的group的成员，然后分到不同list输出

1 #1282
2 #Runtime: 55 ms (Beats 33.33%)
3 #Memory: 13.3 MB (Beats 84.85%)
4
5 class Solution(object):
6     def groupThePeople(self, groupSizes):
7         """
8         :type groupSizes: List[int]
9         :rtype: List[List[int]]
10         """
11         ans = []
12         dic = defaultdict(list)
13         for i, sz in enumerate(groupSizes):
14             dic[sz].append(i)
15         for k, lst in dic.items():
16             for i in range(0, len(lst), k):
17                 ans.append(lst[i : i + k])
18         return ans

Uriel 2023-09-11 16:24 发表评论

[LeetCode]403. Frog Jump (Hard) Python-2023.08.27

Uriel — Sun, 27 Aug 2023 08:33:00 GMT

给出一堆数字stones代表stones[i]处有石子，青蛙从第一个石子处出发，第一次必须跳1步，之后每次可以跳的步数为k-1~k+1，k为前一步跳的步数，问是否可达最后一个石子。
O(n^2)的dp，用dict存储stones位置，dict的value为跳到这个位置所有可能的上一步的长度，参考了Discussion -> https://leetcode.com/problems/frog-jump/solutions/3964842/python3-solution/

1 #403
2 #Runtime: 191 ms (Beats 50.94%)
3 #Memory: 14.9 MB (Beats 79.25%)
4
5 class Solution(object):
6     def canCross(self, stones):
7         """
8         :type stones: List[int]
9         :rtype: bool
10         """
11         n = len(stones)
12         dp = {stone:set() for stone in stones}
13         dp[0].add(0)
14         for i in range(n):
15             for j in dp[stones[i]]:
16                 for d in range(j - 1, j + 2):
17                     if d and stones[i] + d in dp:
18                         dp[stones[i] + d].add(d)
19         return len(dp[stones[-1]]) > 0

Uriel 2023-08-27 16:33 发表评论

[LeetCode]1218. Longest Arithmetic Subsequence of Given Difference (Medium) Python-2023.07.14

Uriel — Fri, 14 Jul 2023 09:15:00 GMT

给出一列数和等差数列的相邻数之差，问符合这个差值的最长的子串长度，DP+hash

1 #1218
2 #Runtime: 499 ms (Beats 50%)
3 #Memory: 24.2 MB (Beats 100%)
4
5 class Solution(object):
6     def longestSubsequence(self, arr, difference):
7         """
8         :type arr: List[int]
9         :type difference: int
10         :rtype: int
11         """
12         ans = 0
13         num = {}
14         for i in range(len(arr)):
15             t = arr[i]
16             if t - difference in num:
17                 num[t] = num[t - difference] + 1
18             else:
19                 num[t] = 1
20             ans = max(ans, num[t])
21         return ans

Uriel 2023-07-14 17:15 发表评论

[LeetCode]1027. Longest Arithmetic Subsequence (Medium) Python-2023.06.22

Uriel — Fri, 23 Jun 2023 09:20:00 GMT

求一个数列中最长的等差数列子串长度，python的dict的妙用
参考了Discussion -> https://leetcode.com/problems/longest-arithmetic-subsequence/solutions/3671637/hashmap-video-java-c-python/

1 #1027
2 #Runtime: 2571 ms (Beats 66.4%)
3 #Memory: 45.1 MB (Beats 60.38%)
4
5 class Solution(object):
6     def longestArithSeqLength(self, nums):
7         """
8         :type nums: List[int]
9         :rtype: int
10         """
11         ans = 0
12         n = len(nums)
13         dp = [defaultdict(int) for _ in range(n)]
14         for i in range(n):
15             for j in range(i):
16                 dif = nums[j] - nums[i]
17                 dp[i][dif] = dp[j].get(dif, 1) + 1
18                 ans = max(ans, dp[i][dif])
19         return ans

Uriel 2023-06-23 17:20 发表评论

[LeetCode]705. Design HashSet (Easy) Python-2023.05.30

Uriel — Tue, 30 May 2023 13:15:00 GMT

模拟哈希表，python set打卡题

1 #705
2 #Runtime: 129 ms (Beats 88.7%)
3 #Memory: 18.8 MB (Beats 62.84%)
4
5 class MyHashSet(object):
6
7     def __init__(self):
8         self.h_set = set()
9
10     def add(self, key):
11         """
12         :type key: int
13         :rtype: None
14         """
15         self.h_set.add(key)
16
17     def remove(self, key):
18         """
19         :type key: int
20         :rtype: None
21         """
22         if key in self.h_set:
23             self.h_set.remove(key)
24
25     def contains(self, key):
26         """
27         :type key: int
28         :rtype: bool
29         """
30         if key in self.h_set:
31             return True
32         return False
33
34
35
36 # Your MyHashSet object will be instantiated and called as such:
37 # obj = MyHashSet()
38 # obj.add(key)
39 # obj.remove(key)
40 # param_3 = obj.contains(key)

Uriel 2023-05-30 21:15 发表评论

[LeetCode]2405. Optimal Partition of String (Medium) Python-2023.04.04

Uriel — Tue, 04 Apr 2023 07:42:00 GMT

给出一个字符串，问最少切分成几个子串可以保证每个子串的每个字符都不相同，hash，用python set很方便

1 #2405
2 #Runtime: 105 ms (Beats 70.83%)
3 #Memory: 14.8 MB (Beats 95.83%)
4
5 class Solution(object):
6     def partitionString(self, s):
7         """
8         :type s: str
9         :rtype: int
10         """
11         ans = 1
12         ch_set = set()
13         for i in s:
14             if i in ch_set:
15                 ch_set = set()
16                 ans += 1
17             ch_set.add(i)
18         return ans

Uriel 2023-04-04 15:42 发表评论

[LeetCode]912. Sort an Array (Medium) Python-2022.03.01

Uriel — Wed, 01 Mar 2023 11:01:00 GMT

实现O(nlogn)的排序，可能有重复的数

因为数据范围不超过100k，利用python的dict可以实现O(n)，但是空间复杂度就不太好看了

1 #912
2 #Runtime: 710 ms (Beats 84.97%)
3 #Memory: 27.6 MB (Beats 10.48%)
4
5 class Solution(object):
6     def sortArray(self, nums):
7         """
8         :type nums: List[int]
9         :rtype: List[int]
10         """
11         num_dict = defaultdict(lambda:0)
12         min_num = 50001
13         max_num = -50001
14         for i in nums:
15             num_dict[i] += 1
16             min_num = min(min_num, i)
17             max_num = max(max_num, i)
18         ans = []
19         for i in range(min_num, max_num + 1):
20             ans.extend([i] * num_dict[i])
21         return ans

Uriel 2023-03-01 19:01 发表评论

[LeetCode]652. Find Duplicate Subtrees (Medium) Python-2023.02.28

Uriel — Tue, 28 Feb 2023 14:15:00 GMT

输出二叉树所有出现次数大于1的子数
DFS，用Counter()记录每一种子树出现次数（将子树先序遍历并且转化为字符串）

1 #652
2 #Runtime: 43 ms (Beats 62%)
3 #Memory: 20.1 MB (Beats 78%)
4
5 # Definition for a binary tree node.
6 # class TreeNode(object):
7 #     def __init__(self, val=0, left=None, right=None):
8 #         self.val = val
9 #         self.left = left
10 #         self.right = right
11 class Solution(object):
12     def findDuplicateSubtrees(self, root):
13         """
14         :type root: TreeNode
15         :rtype: List[TreeNode]
16         """
17
18         ans = []
19         cnt = collections.Counter()
20
21         def DFS(r):
22             if not r:
23                 return ''
24             tree_str = str(r.val) + '.' + DFS(r.left) + '.' + DFS(r.right)
25             if cnt[tree_str] == 1:
26                 ans.append(r)
27             cnt[tree_str] += 1
28             return tree_str
29
30         DFS(root)
31         return ans

Uriel 2023-02-28 22:15 发表评论

[LeetCode]2306. Naming a Company (Hard) Python-2023.02.08

Uriel — Thu, 09 Feb 2023 11:46:00 GMT

给出一堆候选公司名（str），每次从中任意选两个，如果交换首字母之后的两个单词在原先的候选名单里都没有出现，那么拼合这两个单词之后的公司名为最终候选公司名，问一共可以组成几个候选公司名
Python的set()用法，参考了Discussion->https://leetcode.com/problems/naming-a-company/solutions/3162477/clean-codes-full-explanation-set-of-array-c-java-python3/

1 #2306
2 #Runtime: 513 ms (Beats 66.67%)
3 #Memory: 33.1 MB (Beats 50%)
4
5 class Solution(object):
6     def distinctNames(self, ideas):
7         """
8         :type ideas: List[str]
9         :rtype: int
10         """
11         suf = [set() for _ in range(26)]
12         for c in ideas:
13             suf[ord(c[0]) - ord('a')].add(c[1:])
14         ans = 0
15         for i in range(25):
16             for j in range(i + 1, 26):
17                 cnt = len(suf[i] & suf[j])
18                 ans += 2 * (len(suf[i]) - cnt) * (len(suf[j]) - cnt)
19         return ans

Uriel 2023-02-09 19:46 发表评论

[LeetCode]290. Word Pattern (Easy) Python-2021.01.31/2023.01.01

Uriel — Sun, 01 Jan 2023 08:03:00 GMT

给定一个字符组成的pattern，和一个单词组成的字符串（单词以空格分开），问字符串是否满足单词的pattern，例：

Example 1:

Input: pattern = "abba", s = "dog cat cat dog"

Output: true

Example 2:

Input: pattern = "abba", s = "dog cat cat fish"

Output: false

Example 3:

Input: pattern = "aaaa", s = "dog cat cat dog"

Output: false

写法一：用字典记录从每个单词到一个字母的映射，再用一个set保存已经拥有映射值的字母（否则example3会错）

1 #290
2 #Runtime: 18 ms (Beats 81.66%)
3 #Memory: 13.2 MB (Beats 98.30%)
4
5 class Solution(object):
6     def wordPattern(self, pattern, s):
7         """
8         :type pattern: str
9         :type s: str
10         :rtype: bool
11         """
12         str_lst = s.split()
13         str_dct = {}
14         chr_set = set()
15         i = 0
16         if len(pattern) != len(str_lst):
17             return False
18         for i in range(len(str_lst)):
19             if str_lst[i] in str_dct:
20                 if str_dct[str_lst[i]] != pattern[i]:
21                     return False
22             else:
23                 if pattern[i] in chr_set:
24                     return False
25                 chr_set.add(pattern[i])
26                 str_dct[str_lst[i]] = pattern[i]
27             i += 1
28         return True

写法二：用字典记录从每个单词到一个字母的映射，每次查找字典的values来判断是否与已有的映射值重复（这样时间效率不如set）

1 #290
2 #Runtime: 36 ms (Beats 15.62%)
3 #Memory: 13.5 MB (Beats 71.99%)
4
5 class Solution(object):
6     def wordPattern(self, pattern, s):
7         """
8         :type pattern: str
9         :type s: str
10         :rtype: bool
11         """
12         str_list = s.split(" ")
13         dt = {}
14         if len(pattern) != len(str_list):
15             return False
16         for i in range(0, len(pattern)):
17             if dt.has_key(pattern[i]):
18                 if dt[pattern[i]] != str_list[i]:
19                     return False
20             else:
21                 if str_list[i] in dt.values():
22                     return False
23                 dt[pattern[i]] = str_list[i]
24         return True

Uriel 2023-01-01 16:03 发表评论

[LeetCode]446. Arithmetic Slices II - Subsequence (Hard) C/Python-2022.11.27

Uriel — Sun, 27 Nov 2022 16:03:00 GMT

给定一列数，如果三个或以上的数满足等差数列定义，则称为arithmetic subsequences，问给定的一列数有多少个arithmetic subsequences

1 <= nums.length <= 1000

-2³¹ <= nums[i] <= 2³¹ - 1

这题按照思路来说，大概是Medium难度的DP，用python也特别方便好写，于是闲聊无视非要用C写了一遍，就真的变Hard模式了，搞了n次才AC，发现果然没有别人用C来写。。= =||
总的思路：dp[i][dif]保存处理到第i个数，且相邻数差值为dif的子数列个数，dp更新：

for i in range(len(nums)):

for j in range(i):

dif = nums[j] - nums[i]

dp[i][dif] += dp[j][dif] + 1

ans += dp[j][dif]

Python很好写，用dict保存所有可能的dif值就行：

1 #446
2 #Runtime: 2028 ms
3 #Memory Usage: 74.3 MB
4
5 class Solution(object):
6     def numberOfArithmeticSlices(self, nums):
7         """
8         :type nums: List[int]
9         :rtype: int
10         """
11         dp = [defaultdict(int) for _ in range(len(nums))]
12         ans = 0
13         for i in range(len(nums)):
14             for j in range(i):
15                 dif = nums[j] - nums[i]
16                 dp[i][dif] += dp[j][dif] + 1
17                 ans += dp[j][dif]
18         return ans

C语言版，思路同上，但因为C里面没有好用的dict，所以用了Hash，LeetCode支持uthash，另外如果直接hash，那么dif的可能性会非常大（cnt保存所有dif的可能性数量），dp数组没法开那么大，于是，只保存真的形成了3个或以上数字的等差数列的dif值（用cnt2来保存符合这样条件的dif值的数量），在开dp数组的时候第二维开多大也有一点小trick
交上去的结果：

Runtime: 799 ms, faster than 100.00% of C online submissions for Arithmetic Slices II - Subsequence.

Memory Usage: 240.9 MB, less than 100.00% of C online submissions for Arithmetic Slices II - Subsequence.

Accepted Solutions Runtime Distribution

Sorry. We do not have enough accepted submissions to show distribution chart.

Accepted Solutions Memory Distribution

Sorry. We do not have enough accepted submissions to show distribution chart.

Invite friends to challenge Arithmetic Slices II - Subsequence

1 //446
2 //Runtime: 799 ms
3 //Memory Usage: 240.9 MB
4
5 struct hashTable {
6     long long key;
7     int val;
8     int init;
9     UT_hash_handle hh;
10 };
11
12 struct hashTable* dict;
13
14 struct hashTable* find(long long k) {
15     struct hashTable* t;
16     HASH_FIND(hh, dict, &k, sizeof(long long), t);
17     return t;
18 }
19
20 int min(int a, int b) {
21     return a22 }
23
24 void insert(long long k, int v, int id) {
25     struct hashTable* t = malloc(sizeof(struct hashTable));
26     t->key = k;
27     t->val = v;
28     t->init = id;
29     HASH_ADD(hh, dict, key, sizeof(long long), t);
30 }
31
32 int numberOfArithmeticSlices(int* nums, int numsSize){
33     int ans = 0;
34     int cnt = 0;
35     int idx[numsSize*numsSize];
36     int cnt2 = 0;
37     int dp[numsSize][min(numsSize*numsSize,(int)10000000/numsSize)];
38     memset(dp, 0, sizeof(dp));
39     memset(idx, -1, sizeof(idx));
40     dict = NULL;
41     for(int i = 0; i < numsSize; ++i) {
42         for(int j  = 0; j < i; ++j) {
43             long long dif = (long long)nums[j] - (long long)nums[i];
44             struct hashTable* it = find(dif);
45             if(it == NULL) {
46                 insert(dif, cnt, i);
47                 ++cnt;
48             }
49             else {
50                 if(idx[it->val] == -1) {
51                     idx[it->val] = cnt2;
52                     dp[it->init][cnt2] = 1;
53                     dp[i][cnt2] += dp[j][cnt2] + 1;
54                     ans += dp[j][cnt2];
55                     ++cnt2;
56                 }
57                 else {
58                     dp[i][idx[it->val]] += dp[j][idx[it->val]] + 1;
59                     ans += dp[j][idx[it->val]];
60                 }
61             }
62
63         }
64     }
65     return ans;
66 }

Uriel 2022-11-28 00:03 发表评论