#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
#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
]]>
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
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
]]>
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
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
]]>
#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
#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
]]>
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
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
]]>
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
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
]]>
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
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
]]>
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
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
]]>
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
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
]]>
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
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
]]>
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)
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)
]]>
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
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
]]>
鍥犱負鏁版嵁鑼冨洿涓嶈秴榪?00k錛屽埄鐢╬ython鐨刣ict鍙互瀹炵幇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
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
]]>
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
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
]]>
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
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
]]>
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
鍐欐硶涓錛氱敤瀛楀吀璁板綍浠庢瘡涓崟璇嶅埌涓涓瓧姣嶇殑鏄犲皠錛屽啀鐢ㄤ竴涓猻et淇濆瓨宸茬粡鎷ユ湁鏄犲皠鍊肩殑瀛楁瘝錛堝惁鍒檈xample3浼氶敊錛?br />
鍐欐硶浜岋細鐢ㄥ瓧鍏歌褰曚粠姣忎釜鍗曡瘝鍒頒竴涓瓧姣嶇殑鏄犲皠錛屾瘡嬈℃煡鎵懼瓧鍏哥殑values鏉ュ垽鏂槸鍚︿笌宸叉湁鐨勬槧灝勫奸噸澶嶏紙榪欐牱鏃墮棿鏁堢巼涓嶅set錛?br />
鍐欐硶涓錛氱敤瀛楀吀璁板綍浠庢瘡涓崟璇嶅埌涓涓瓧姣嶇殑鏄犲皠錛屽啀鐢ㄤ竴涓猻et淇濆瓨宸茬粡鎷ユ湁鏄犲皠鍊肩殑瀛楁瘝錛堝惁鍒檈xample3浼氶敊錛?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
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錛?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
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
]]>
1 <= nums.length <= 1000
-231 <= nums[i] <= 231 - 1
榪欓鎸夌収鎬濊礬鏉ヨ錛屽ぇ姒傛槸Medium闅懼害鐨凞P錛岀敤python涔熺壒鍒柟渚垮ソ鍐欙紝浜庢槸闂茶亰鏃犺闈炶鐢–鍐欎簡涓閬嶏紝灝辯湡鐨勫彉Hard妯″紡浜嗭紝鎼炰簡n嬈℃墠AC錛屽彂鐜版灉鐒舵病鏈夊埆浜虹敤C鏉ュ啓銆傘? =||鎬葷殑鎬濊礬錛歞p[i][dif]淇濆瓨澶勭悊鍒扮i涓暟錛屼笖鐩擱偦鏁板樊鍊間負dif鐨勫瓙鏁板垪涓暟錛宒p鏇存柊錛?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寰堝ソ鍐欙紝鐢╠ict淇濆瓨鎵鏈夊彲鑳界殑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
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閲岄潰娌℃湁濂界敤鐨刣ict錛屾墍浠ョ敤浜咹ash錛孡eetCode鏀寔uthash錛屽彟澶栧鏋滅洿鎺ash錛岄偅涔坉if鐨勫彲鑳芥т細闈炲父澶э紙cnt淇濆瓨鎵鏈塪if鐨勫彲鑳芥ф暟閲忥級錛宒p鏁扮粍娌℃硶寮閭ｄ箞澶э紝浜庢槸錛屽彧淇濆瓨鐪熺殑褰㈡垚浜?涓垨浠ヤ笂鏁板瓧鐨勭瓑宸暟鍒楃殑dif鍊鹼紙鐢╟nt2鏉ヤ繚瀛樼鍚堣繖鏍鋒潯浠剁殑dif鍊肩殑鏁伴噺錛夛紝鍦ㄥ紑dp鏁扮粍鐨勬椂鍊欑浜岀淮寮澶氬ぇ涔熸湁涓鐐瑰皬trick
浜や笂鍘葷殑緇撴灉錛?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 a<b?a:b;
22 }
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 }
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 a<b?a:b;
22 }
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 }
]]>