欧美日韩影院,欧美精品乱人伦久久久久久,国产欧美一区二区精品婷婷

[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

�l�出一些字�W�串�Q�问取其中若�q�字�W�串能拼出的不含重复字母的最长字�?br />先过滤掉自��n有重复字母的�Q�然后设一个内含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

�l�出一列数来构造数�l�，数组每一行由不同的数字组成，每行长度可以不一��P��输出其中一�U�可行解
用python的Counter�l�计每个数字出现�ơ数�Q�再一�ơ构造每一�?br />

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集合包含若干字符�Ԍ��每次操作可以��其中一个字�W�串的某个字�W�插入另一个字�W�串�Q�问是否可以�l�过无限�ơ操作��得每个字�W�串变成相同的。直接判断是否每个字�W�的��d��现次数可以被字符串数量整除即�?br />

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

求问两个字符串是否由完全相同的字母不同的�l�合而成�Q�用python的count判断每个字出现次�?br />

#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

�l�出每一条�\的�v始和�l�止城市�Q�string�Q�，输出唯一的终点城市（没有从该城市出发的�Q何�\�Q�，数据保证�l�果唯一�Q�两个hash表，一个存所有出现过的城市，一个存所有作��L��的城�?br />

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

�l�出一堆字�W�，问最��去掉几个字�W�可以保证每�U�字�W�出现的�ơ数不同�Q�用python的counter�l�计�ơ数�Q�然后用set记录已经出现�q�的字符频次�Q�若有冲�H�，不断��L��字符直至不冲�H?br />

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

�l�出数组groupSizes�Q�每个元素代表第i个�h属于size为groupSizes[i]的组�Q�输出每个组的组�?br />用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

�l�出一堆数字stones代表stones[i]处有矛_��Q�青蛙从�W�一个石子处出发�Q�第一�ơ必��蟩1步，之后每次可以跳的步数为k-1~k+1�Q�k为前一步蟩的步敎ͼ�问是否可达最后一个石子�?br />O(n^2)的dp�Q�用dict存储stones位置�Q�dict的value��到这个位�|�所有可能的上一步的长度�Q�参考了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

�l�出一列数和等差数列的盔R��C��差，问符合这个差值的最长的子串长度�Q�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

求一个数列中最长的�{�差数列子串长度�Q�python的dict的妙�?br />参考了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打卡�?br />

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

�l�出一个字�W�串�Q�问最��切分成几个子串可以保证每个子串的每个字�W�都不相同，hash�Q�用python set很方�?br />

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)的排序，可能有重复的�?br />
因�ؓ数据范围不超�q?00k�Q�利用python的dict可以实现O(n)�Q�但是空间复杂度��׃��太好看了

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

输出二叉树所有出现次数大�?的子�?br />DFS�Q�用Counter()记录每一�U�子树出现次敎ͼ��子树先序遍历�ƈ且�{化�ؓ字符�Ԍ��

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

�l�出一堆候选公司名�Q�str�Q�，每次从中��L��选两个，如果交换首字母之后的两个单词在原先的候选名单里都没有出玎ͼ�那么拼合�q�两个单词之后的公司名�ؓ最�l�候选公司名�Q�问一共可以组成几个候选公司名
Python的set()用法�Q�参考了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

�l�定一个字�W�组成的pattern�Q�和一个单词组成的字符�Ԍ��单词以空格分开�Q�，问字�W�串是否满��单词的pattern�Q�例�Q?br />

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

写法一�Q�用字典记录从每个单词到一个字母的映射�Q�再用一个set保存已经拥有映射值的字母�Q�否则example3会错�Q?br />

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

写法二：用字典记录从每个单词��C��个字母的映射�Q�每�ơ查扑֭�典的values来判断是否与已有的映��值重复（�q�样旉��效率不如set�Q?br />

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

�l�定一列数�Q�如果三个或以上的数满��{�差数列定义�Q�则�U�Cؓarithmetic subsequences�Q�问�l�定的一列数有多��个arithmetic subsequences

1 <= nums.length <= 1000

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

�q�题按照思�\来说�Q�大概是Medium隑ֺ�的DP�Q�用python也特别方便好写，于是闲聊无视非要用C写了一遍，��q��的变Hard模式了，搞了n�ơ才AC�Q�发现果然没有别人用C来写。�? =||
�ȝ��思�\�Q�dp[i][dif]保存处理到第i个数�Q�且盔R��数差��gؓdif的子数列个数�Q�dp更新�Q?br />

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语言版，思�\同上�Q�但因�ؓC里面没有好用的dict�Q�所以用了Hash�Q�LeetCode支持uthash�Q�另外如果直接hash�Q�那么dif的可能性会非常大（cnt保存所有dif的可能性数量）�Q�dp数组没法开那么大，于是�Q�只保存真的形成�?个或以上数字的等差数列的dif��|��用cnt2来保存符合这��h��件的dif值的数量�Q�，在开dp数组的时候第二维开多大也有一点小trick
交上�ȝ��l�果�Q?br />

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 发表评论