post_href
stringlengths 57
213
| python_solutions
stringlengths 71
22.3k
| slug
stringlengths 3
77
| post_title
stringlengths 1
100
| user
stringlengths 3
29
| upvotes
int64 -20
1.2k
| views
int64 0
60.9k
| problem_title
stringlengths 3
77
| number
int64 1
2.48k
| acceptance
float64 0.14
0.91
| difficulty
stringclasses 3
values | __index_level_0__
int64 0
34k
|
|---|---|---|---|---|---|---|---|---|---|---|---|
https://leetcode.com/problems/convert-the-temperature/discuss/2815504/python-solution-no-need-for-10*-5
|
class Solution:
def convertTemperature(self, celsius: float) -> List[float]:
kelvin = celsius + 273.15
fahrenheit = (celsius * 1.80) + 32.00
return [kelvin, fahrenheit]
|
convert-the-temperature
|
python solution no need for 10*-5
|
samanehghafouri
| 0 | 2 |
convert the temperature
| 2,469 | 0.909 |
Easy
| 33,900 |
https://leetcode.com/problems/convert-the-temperature/discuss/2815390/Fastest-and-Simplest-Solution-Python-(One-Liner-Code)
|
class Solution:
def convertTemperature(self, celsius: float) -> List[float]:
return [celsius + 273.15, celsius * 1.8 + 32.0]
|
convert-the-temperature
|
Fastest and Simplest Solution - Python (One-Liner Code)
|
PranavBhatt
| 0 | 2 |
convert the temperature
| 2,469 | 0.909 |
Easy
| 33,901 |
https://leetcode.com/problems/convert-the-temperature/discuss/2815231/Hardest-Problem-EVER!
|
class Solution:
def convertTemperature(self, celsius: float) -> List[float]:
return [celsius + 273.15, celsius * 1.80 + 32.00]
|
convert-the-temperature
|
Hardest Problem EVER!
|
elbasrouisama
| 0 | 6 |
convert the temperature
| 2,469 | 0.909 |
Easy
| 33,902 |
https://leetcode.com/problems/convert-the-temperature/discuss/2814881/Python3
|
class Solution:
def convertTemperature(self, celsius: float) -> List[float]:
Kelvin = celsius + 273.15
Fahrenheit = celsius * 1.80 + 32
return [Kelvin, Fahrenheit]
|
convert-the-temperature
|
Python3
|
anashaupt
| 0 | 2 |
convert the temperature
| 2,469 | 0.909 |
Easy
| 33,903 |
https://leetcode.com/problems/convert-the-temperature/discuss/2814833/Beats-100-Python
|
class Solution:
def convertTemperature(self, celsius: float) -> List[float]:
ans=[]
Kelvin=celsius + 273.15
Fahrenheit=celsius * 1.80 + 32.00
ans.append(Kelvin)
ans.append(Fahrenheit)
return ans
|
convert-the-temperature
|
Beats 100%, Python
|
prakritig2
| 0 | 2 |
convert the temperature
| 2,469 | 0.909 |
Easy
| 33,904 |
https://leetcode.com/problems/convert-the-temperature/discuss/2814701/Python-Simple-Python-Solution
|
class Solution:
def convertTemperature(self, celsius: float) -> List[float]:
Kelvin = celsius + 273.15
Fahrenheit = celsius * 1.80 + 32.00
return [Kelvin,Fahrenheit]
|
convert-the-temperature
|
[ Python ] ✅✅ Simple Python Solution🥳✌👍
|
ASHOK_KUMAR_MEGHVANSHI
| 0 | 6 |
convert the temperature
| 2,469 | 0.909 |
Easy
| 33,905 |
https://leetcode.com/problems/convert-the-temperature/discuss/2814432/Super-easy-and-fast-Python3-Answer
|
class Solution:
def convertTemperature(self, c: float) -> List[float]:
return [c + 273.15, c*1.80+32.00]
|
convert-the-temperature
|
Super easy and fast Python3 Answer
|
hyamtx
| 0 | 1 |
convert the temperature
| 2,469 | 0.909 |
Easy
| 33,906 |
https://leetcode.com/problems/convert-the-temperature/discuss/2813960/One-line-100-speed
|
class Solution:
def convertTemperature(self, celsius: float) -> List[float]:
return [celsius + 273.15, celsius * 1.80 + 32.00]
|
convert-the-temperature
|
One line, 100% speed
|
EvgenySH
| 0 | 5 |
convert the temperature
| 2,469 | 0.909 |
Easy
| 33,907 |
https://leetcode.com/problems/convert-the-temperature/discuss/2810375/Python-Solution-or-One-Liner-or-100-Faster
|
class Solution:
def convertTemperature(self, celsius: float) -> List[float]:
return [
celsius + 273.15,
(celsius * 1.80) + 32.00
]
|
convert-the-temperature
|
Python Solution | One Liner | 100% Faster
|
Gautam_ProMax
| 0 | 12 |
convert the temperature
| 2,469 | 0.909 |
Easy
| 33,908 |
https://leetcode.com/problems/convert-the-temperature/discuss/2810108/Python-Solution
|
class Solution:
def convertTemperature(self, celsius: float) -> List[float]:
return [celsius+273.15,celsius*1.80+32.00]
|
convert-the-temperature
|
Python Solution
|
CEOSRICHARAN
| 0 | 3 |
convert the temperature
| 2,469 | 0.909 |
Easy
| 33,909 |
https://leetcode.com/problems/convert-the-temperature/discuss/2809679/Easiest-Python-Solution-oror-Full-Explanation
|
class Solution:
def convertTemperature(self, celsius: float) -> List[float]:
return [celsius+273.15,celsius*1.80+32.00]
|
convert-the-temperature
|
✔💖Easiest Python Solution || Full Explanation
|
AdityaTrivedi88
| 0 | 4 |
convert the temperature
| 2,469 | 0.909 |
Easy
| 33,910 |
https://leetcode.com/problems/convert-the-temperature/discuss/2809644/Python-or-Easy-or-Faster-than-100
|
class Solution:
def convertTemperature(self, celsius: float) -> List[float]:
return [celsius + 273.15, (celsius * 1.80) + 32.00]
|
convert-the-temperature
|
Python | Easy | Faster than 100%
|
pawangupta
| 0 | 6 |
convert the temperature
| 2,469 | 0.909 |
Easy
| 33,911 |
https://leetcode.com/problems/convert-the-temperature/discuss/2809252/Easy-Python-Solution
|
class Solution:
def convertTemperature(self, celsius: float) -> List[float]:
return [celsius+ 273.15, (celsius * 1.80) + 32]
|
convert-the-temperature
|
Easy Python Solution
|
imash_9
| 0 | 4 |
convert the temperature
| 2,469 | 0.909 |
Easy
| 33,912 |
https://leetcode.com/problems/convert-the-temperature/discuss/2809215/Python3JavaScript-Self-Explanatory
|
class Solution:
def convertTemperature(self, celsius: float) -> List[float]:
kelvin = celsius + 273.15
fahrenheit = celsius * 1.80 + 32.00
return [kelvin, fahrenheit]
|
convert-the-temperature
|
✅[Python3/JavaScript] Self Explanatory
|
MusfiqDehan
| 0 | 10 |
convert the temperature
| 2,469 | 0.909 |
Easy
| 33,913 |
https://leetcode.com/problems/convert-the-temperature/discuss/2809047/Easy-python-beats-100.00-just-convert
|
class Solution:
def convertTemperature(self, c):
return [c+273.15,c*1.8+32]
|
convert-the-temperature
|
Easy python beats 100.00% [just convert]
|
U753L
| 0 | 9 |
convert the temperature
| 2,469 | 0.909 |
Easy
| 33,914 |
https://leetcode.com/problems/convert-the-temperature/discuss/2808910/One-liner-Python3-O(1)-Solution-Easiest-to-understand
|
class Solution:
def convertTemperature(self, celsius: float) -> List[float]:
return [(celsius + 273.15), (celsius * 1.80 + 32.00)]
|
convert-the-temperature
|
One liner Python3 O(1) Solution Easiest to understand
|
jubinsoni
| 0 | 8 |
convert the temperature
| 2,469 | 0.909 |
Easy
| 33,915 |
https://leetcode.com/problems/convert-the-temperature/discuss/2808873/Python-1-liner-simple-solution
|
class Solution:
def convertTemperature(self, celsius: float) -> List[float]:
return [celsius + 273.15, celsius * 1.80 + 32.00]
|
convert-the-temperature
|
✅ Python 1 liner simple solution
|
sezanhaque
| 0 | 8 |
convert the temperature
| 2,469 | 0.909 |
Easy
| 33,916 |
https://leetcode.com/problems/convert-the-temperature/discuss/2808832/return-celsius-%2B-273.15-celsius-*-1.80-%2B-32.00
|
class Solution:
def convertTemperature(self, celsius: float) -> List[float]:
return celsius + 273.15, celsius * 1.80 + 32.00
|
convert-the-temperature
|
return celsius + 273.15, celsius * 1.80 + 32.00
|
Silvia42
| 0 | 14 |
convert the temperature
| 2,469 | 0.909 |
Easy
| 33,917 |
https://leetcode.com/problems/convert-the-temperature/discuss/2808794/python-solution
|
class Solution:
def convertTemperature(self, celsius: float) -> List[float]:
return [celsius + 273.15, celsius * 1.80 + 32.00]
|
convert-the-temperature
|
python solution
|
akaghosting
| 0 | 27 |
convert the temperature
| 2,469 | 0.909 |
Easy
| 33,918 |
https://leetcode.com/problems/number-of-subarrays-with-lcm-equal-to-k/discuss/2808943/Beginners-Approach-%3A
|
class Solution:
def subarrayLCM(self, nums: List[int], k: int) -> int:
def find_lcm(num1, num2):
if(num1>num2):
num = num1
den = num2
else:
num = num2
den = num1
rem = num % den
while(rem != 0):
num = den
den = rem
rem = num % den
gcd = den
lcm = int(int(num1 * num2)/int(gcd))
return lcm
count=0
for i in range(len(nums)):
lcm=1
for j in range(i,len(nums)):
lcm=find_lcm(nums[j],lcm)
if lcm==k:
count+=1
if lcm>k:
break
return count
|
number-of-subarrays-with-lcm-equal-to-k
|
Beginners Approach :
|
goxy_coder
| 1 | 57 |
number of subarrays with lcm equal to k
| 2,470 | 0.388 |
Medium
| 33,919 |
https://leetcode.com/problems/number-of-subarrays-with-lcm-equal-to-k/discuss/2835262/Python-(Simple-Maths)
|
class Solution:
def subarrayLCM(self, nums, k):
n, count = len(nums), 0
for i in range(n):
temp = nums[i]
for j in range(i,n):
temp = math.lcm(temp,nums[j])
if temp == k:
count += 1
elif temp > k:
break
return count
|
number-of-subarrays-with-lcm-equal-to-k
|
Python (Simple Maths)
|
rnotappl
| 0 | 5 |
number of subarrays with lcm equal to k
| 2,470 | 0.388 |
Medium
| 33,920 |
https://leetcode.com/problems/number-of-subarrays-with-lcm-equal-to-k/discuss/2828569/More-Efficient-GCD-based-Solution-The-Best
|
class Solution:
def subarrayLCM(self, nums: list[int], k: int) -> int:
coprime_count = 0
for subarray_end, n in enumerate(nums):
nums[subarray_end] = k // n if k % n == 0 else None
running_gcd = 0
for subarray_start in reversed(range(subarray_end + 1)):
if not nums[subarray_start]:
break
running_gcd = gcd(running_gcd, nums[subarray_start])
coprime_count += running_gcd == 1
return coprime_count
|
number-of-subarrays-with-lcm-equal-to-k
|
More Efficient GCD-based Solution, The Best
|
Triquetra
| 0 | 19 |
number of subarrays with lcm equal to k
| 2,470 | 0.388 |
Medium
| 33,921 |
https://leetcode.com/problems/number-of-subarrays-with-lcm-equal-to-k/discuss/2824249/Python-A-DP-approach
|
class Solution:
def subarrayLCM(self, nums: List[int], k: int) -> int:
n = len(nums)
dp = [[0] * n for _ in range(n)]
result = 0
for i in range(n-1,-1,-1):
for j in range(i, n):
temp = math.lcm(nums[i], nums[j])
if i + 1 == j or i == j:
dp[i][j] = temp
else:
dp[i][j] = math.lcm(temp, dp[i+1][j-1])
if dp[i][j] == k:
result += 1
return result
|
number-of-subarrays-with-lcm-equal-to-k
|
[Python] A DP approach
|
hengsoo
| 0 | 7 |
number of subarrays with lcm equal to k
| 2,470 | 0.388 |
Medium
| 33,922 |
https://leetcode.com/problems/number-of-subarrays-with-lcm-equal-to-k/discuss/2809141/python-solution
|
class Solution:
def subarrayLCM(self, nums: List[int], k: int) -> int:
res = 0
for i in range(len(nums)):
curLcm = nums[i]
if nums[i] <= k:
for j in range(i, len(nums)):
if nums[j] <= k:
curLcm = lcm(curLcm, nums[j])
if curLcm == k:
res += 1
else:
break
return res
|
number-of-subarrays-with-lcm-equal-to-k
|
python solution
|
akaghosting
| 0 | 19 |
number of subarrays with lcm equal to k
| 2,470 | 0.388 |
Medium
| 33,923 |
https://leetcode.com/problems/number-of-subarrays-with-lcm-equal-to-k/discuss/2809139/Python-Answer-Simple-Two-Loops-(start-and-end-index)
|
class Solution:
def subarrayLCM(self, nums: List[int], k: int) -> int:
res = 0
for i in range(len(nums)):
l = nums[i]
if l == k:
res+=1
for j in range(i+1,len(nums)):
l = lcm(l,nums[j])
if l == k:
res+=1
return res
|
number-of-subarrays-with-lcm-equal-to-k
|
[Python Answer🤫🐍🐍🐍] Simple Two Loops (start and end index)
|
xmky
| 0 | 16 |
number of subarrays with lcm equal to k
| 2,470 | 0.388 |
Medium
| 33,924 |
https://leetcode.com/problems/number-of-subarrays-with-lcm-equal-to-k/discuss/2809111/Python3-running-LCM-beats-100.00
|
class Solution:
def subarrayLCM(self, nums, k):
cnt=0 # number of working subsets
for i in range(len(nums)): # left bound
runningLCM = nums[i]
for j in range(i, len(nums)):
runningLCM = lcm(runningLCM, nums[j]) # generate new gcd of given subset
if runningLCM==k:
cnt+=1
elif runningLCM>k:
break
return cnt
|
number-of-subarrays-with-lcm-equal-to-k
|
[Python3] running LCM, beats 100.00%
|
U753L
| 0 | 17 |
number of subarrays with lcm equal to k
| 2,470 | 0.388 |
Medium
| 33,925 |
https://leetcode.com/problems/number-of-subarrays-with-lcm-equal-to-k/discuss/2808985/Python3-brute-force
|
class Solution:
def subarrayLCM(self, nums: List[int], k: int) -> int:
ans = 0
for i in range(len(nums)):
val = 1
for j in range(i, len(nums)):
val = lcm(val, nums[j])
if val == k: ans += 1
return ans
|
number-of-subarrays-with-lcm-equal-to-k
|
[Python3] brute-force
|
ye15
| 0 | 15 |
number of subarrays with lcm equal to k
| 2,470 | 0.388 |
Medium
| 33,926 |
https://leetcode.com/problems/number-of-subarrays-with-lcm-equal-to-k/discuss/2808978/Python-Simple-Solution
|
class Solution:
def subarrayLCM(self, nums: List[int], k: int) -> int:
res = 0
for left in range(len(nums)):
curr = nums[left]
right = left
while right < len(nums) and k % nums[right] == 0:
curr = math.lcm(curr, nums[right])
if curr > k:
break
elif curr == k:
res += 1
right += 1
return res
|
number-of-subarrays-with-lcm-equal-to-k
|
✅ Python Simple Solution
|
sezanhaque
| 0 | 56 |
number of subarrays with lcm equal to k
| 2,470 | 0.388 |
Medium
| 33,927 |
https://leetcode.com/problems/number-of-subarrays-with-lcm-equal-to-k/discuss/2808921/Python-Brute-Force
|
class Solution:
def subarrayLCM(self, nums: List[int], k: int) -> int:
n = len(nums)
ans = 0
for i in range(n):
lcm = nums[i]
for j in range(i, n):
lcm = lcm * nums[j] // math.gcd(lcm, nums[j])
if lcm == k: ans += 1
elif lcm >k: break
return ans
|
number-of-subarrays-with-lcm-equal-to-k
|
Python Brute Force
|
rbhandu
| 0 | 17 |
number of subarrays with lcm equal to k
| 2,470 | 0.388 |
Medium
| 33,928 |
https://leetcode.com/problems/number-of-subarrays-with-lcm-equal-to-k/discuss/2808840/Optimized-Bruteforce-or-Short-and-simple-to-understand-or-with-explanation
|
class Solution:
def subarrayLCM(self, nums: List[int], k: int) -> int:
num_subarray = 0
n = len(nums)
for i in range(n):
lcm = nums[i]
for j in range(i, n):
lcm = math.lcm(lcm, nums[j])
if lcm > k:
break
else:
num_subarray += (lcm == k)
return num_subarray
|
number-of-subarrays-with-lcm-equal-to-k
|
Optimized Bruteforce | Short and simple to understand | with explanation
|
jubinsoni
| 0 | 40 |
number of subarrays with lcm equal to k
| 2,470 | 0.388 |
Medium
| 33,929 |
https://leetcode.com/problems/minimum-number-of-operations-to-sort-a-binary-tree-by-level/discuss/2808960/Python3-BFS
|
class Solution:
def minimumOperations(self, root: Optional[TreeNode]) -> int:
ans = 0
queue = deque([root])
while queue:
vals = []
for _ in range(len(queue)):
node = queue.popleft()
vals.append(node.val)
if node.left: queue.append(node.left)
if node.right: queue.append(node.right)
mp = {x : i for i, x in enumerate(sorted(vals))}
visited = [0]*len(vals)
for i in range(len(vals)):
cnt = 0
while not visited[i] and i != mp[vals[i]]:
visited[i] = 1
cnt += 1
i = mp[vals[i]]
ans += max(0, cnt-1)
return ans
|
minimum-number-of-operations-to-sort-a-binary-tree-by-level
|
[Python3] BFS
|
ye15
| 6 | 567 |
minimum number of operations to sort a binary tree by level
| 2,471 | 0.629 |
Medium
| 33,930 |
https://leetcode.com/problems/minimum-number-of-operations-to-sort-a-binary-tree-by-level/discuss/2808987/Easy-Level-order-traversal-with-comments-oror-Python
|
class Solution:
def cntSwap(self,arr):
n = len(arr)
cnt = 0
a = sorted(arr)
index = {}
# store index of elements in arr
for ind in range(n):
index[arr[ind]] = ind
for ind in range(n):
# If element in arr is out of position we need to swap hence increase cnt
if (arr[ind] != a[ind]):
cnt += 1
pos = arr[ind]
# Replace it with element that should be at this "ind" in arr using a[ind]
arr[ind], arr[index[a[ind]]] = arr[index[a[ind]]], arr[ind]
# Update the indexes for swaped elements in "index"
index[pos] = index[a[ind]]
index[a[ind]] = ind
return cnt
def minimumOperations(self, root: Optional[TreeNode]) -> int:
res = 0
q = [root]
# Level order traversal
while q :
level = []
values = []
for n in q:
if n.left :
level.append(n.left)
values.append(n.left.val)
if n.right :
level.append(n.right)
values.append(n.right.val)
res += self.cntSwap(values)
q = level
return res
|
minimum-number-of-operations-to-sort-a-binary-tree-by-level
|
Easy Level order traversal with comments || Python
|
CoderIsCodin
| 4 | 203 |
minimum number of operations to sort a binary tree by level
| 2,471 | 0.629 |
Medium
| 33,931 |
https://leetcode.com/problems/minimum-number-of-operations-to-sort-a-binary-tree-by-level/discuss/2836036/Python-(Simple-DFS-%2BSorting)
|
class Solution:
def func_(self,nums):
dict2 = {n:j for j,n in enumerate(sorted(nums))}
count, i = 0, 0
while i < len(nums):
j = dict2[nums[i]]
if i != j:
nums[i], nums[j] = nums[j], nums[i]
count += 1
else:
i += 1
return count
def minimumOperations(self, root):
if not root:
return 0
dict1 = defaultdict(list)
def dfs(node,level):
if not node:
return 0
dict1[level].append(node.val)
dfs(node.left,level+1)
dfs(node.right,level+1)
dfs(root,0)
ans = list(dict1.values())
return sum([self.func_(i) for i in ans])
|
minimum-number-of-operations-to-sort-a-binary-tree-by-level
|
Python (Simple DFS +Sorting)
|
rnotappl
| 0 | 5 |
minimum number of operations to sort a binary tree by level
| 2,471 | 0.629 |
Medium
| 33,932 |
https://leetcode.com/problems/minimum-number-of-operations-to-sort-a-binary-tree-by-level/discuss/2831314/Optimal-and-Without-Actually-Swapping-Values-The-Best
|
class Solution:
def minimumOperations(self, root: Optional[TreeNode]) -> int:
return sum([self.minimum_swaps(level) for level in self.bfs_levels(root)])
def bfs_levels(self, root: Optional[TreeNode]) -> list[list[int]]:
nodes, levels, index = [root], [0], 0
while index != len(nodes):
for child in nodes[index].left, nodes[index].right:
if child:
nodes.append(child)
levels.append(levels[index] + 1)
index += 1
values = [[] for _ in range(levels[-1] + 1)]
for index in range(len(nodes)):
values[levels[index]].append(nodes[index].val)
return values
def minimum_swaps(self, array: list[int]) -> int:
sorted_indexes = sorted(range(len(array)), key=array.__getitem__)
return len(array) - sum(self.has_cycle(sorted_indexes, index) for index in range(len(array)))
def has_cycle(self, sorted_indexes: list[int], index: int) -> bool:
had_cycle = False
while sorted_indexes[index] != -1:
sorted_indexes[index], next_index = -1, sorted_indexes[index]
index, had_cycle = next_index, True
return had_cycle
|
minimum-number-of-operations-to-sort-a-binary-tree-by-level
|
Optimal and Without Actually Swapping Values, The Best
|
Triquetra
| 0 | 5 |
minimum number of operations to sort a binary tree by level
| 2,471 | 0.629 |
Medium
| 33,933 |
https://leetcode.com/problems/minimum-number-of-operations-to-sort-a-binary-tree-by-level/discuss/2823256/Python-solution
|
class Solution:
def minimumOperations(self, root: Optional[TreeNode]) -> int:
levels = []
res = 0
def levelorder(node, level):
if level >= len(levels):
levels.append([])
if node:
levels[level].append(node.val)
if node.left:
levelorder(node.left, level + 1)
if node.right:
levelorder(node.right, level + 1)
def diff(nums):
s = sorted(nums)
dic = {}
diff = 0
for i, n in enumerate(nums):
dic[n] = i
for i in range(len(nums)):
if nums[i] != s[i]:
idx = dic[s[i]]
dic[nums[i]] = idx
dic[s[i]] = i
nums[i], nums[idx] = nums[idx], nums[i]
diff += 1
return diff
levelorder(root,0)
for i in range(len(levels)):
res += diff(levels[i])
return res
|
minimum-number-of-operations-to-sort-a-binary-tree-by-level
|
Python solution
|
maomao1010
| 0 | 8 |
minimum number of operations to sort a binary tree by level
| 2,471 | 0.629 |
Medium
| 33,934 |
https://leetcode.com/problems/minimum-number-of-operations-to-sort-a-binary-tree-by-level/discuss/2812540/Python3-Level-BFS-and-manipulate-vals-index
|
class Solution:
def minimumOperations(self, root: Optional[TreeNode]) -> int:
cur, ans = [root], 0
while cur:
nxt, nums, numidx = [], [], dict()
for node in cur:
numidx[node.val] = len(nums)
nums.append(node.val)
if node.left: nxt.append(node.left)
if node.right: nxt.append(node.right)
for i, v in enumerate(sorted(nums)):
if i != numidx[v]:
ans += 1
nums[numidx[v]] = nums[i]
numidx[nums[i]] = numidx[v]
cur = nxt
return ans
|
minimum-number-of-operations-to-sort-a-binary-tree-by-level
|
[Python3] Level BFS and manipulate vals index
|
cava
| 0 | 4 |
minimum number of operations to sort a binary tree by level
| 2,471 | 0.629 |
Medium
| 33,935 |
https://leetcode.com/problems/minimum-number-of-operations-to-sort-a-binary-tree-by-level/discuss/2809954/Python-BFS-%2B-count-swaps-required-simple-solution
|
class Solution:
def countswaps(self, arr):
count = 0
temp = sorted(arr)
h = {}
for i in range(len(arr)):
h[arr[i]] = i
for i in range(len(arr)):
if arr[i] != temp[i]:
count += 1
# swap to correct place
j = h[temp[i]]
h[arr[i]], h[arr[j]] = j, i
arr[i], arr[j] = arr[j], arr[i]
return count
def minimumOperations(self, root: Optional[TreeNode]) -> int:
q = collections.deque()
q.append(root)
ans = 0
while q:
size = len(q)
level = []
for _ in range(size):
temp = q.popleft()
level.append(temp.val)
if temp.left:
q.append(temp.left)
if temp.right:
q.append(temp.right)
ans += self.countswaps(level)
return ans
|
minimum-number-of-operations-to-sort-a-binary-tree-by-level
|
Python BFS + count swaps required simple solution
|
ishaan06
| 0 | 19 |
minimum number of operations to sort a binary tree by level
| 2,471 | 0.629 |
Medium
| 33,936 |
https://leetcode.com/problems/maximum-number-of-non-overlapping-palindrome-substrings/discuss/2808845/Python3-DP-with-Explanations-or-Only-Check-Substrings-of-Length-k-and-k-%2B-1
|
class Solution:
def maxPalindromes(self, s: str, k: int) -> int:
n = len(s)
dp = [0] * (n + 1)
for i in range(k, n + 1):
dp[i] = dp[i - 1]
for length in range(k, k + 2):
j = i - length
if j < 0:
break
if self.isPalindrome(s, j, i):
dp[i] = max(dp[i], 1 + dp[j])
return dp[-1]
def isPalindrome(self, s, j, i):
left, right = j, i - 1
while left < right:
if s[left] != s[right]:
return False
left += 1
right -= 1
return True
|
maximum-number-of-non-overlapping-palindrome-substrings
|
[Python3] DP with Explanations | Only Check Substrings of Length k and k + 1
|
xil899
| 11 | 542 |
maximum number of non overlapping palindrome substrings
| 2,472 | 0.366 |
Hard
| 33,937 |
https://leetcode.com/problems/maximum-number-of-non-overlapping-palindrome-substrings/discuss/2832974/Python3-or-Memoization
|
class Solution:
def maxPalindromes(self, s: str, k: int) -> int:
n=len(s)
def checkIfPalindrome(i,j):
while i<j:
if s[i]!=s[j]:
return False
i+=1
j-=1
return True
@lru_cache(2000)
def dp(i,j):
if i>=n or j>=n or (j-i)>k+1:
return 0
if s[i]==s[j]:
if checkIfPalindrome(i,j):
return 1+dp(j+1,j+k)
return max(dp(i,j+1),dp(i+1,j+1))
return dp(0,k-1)
|
maximum-number-of-non-overlapping-palindrome-substrings
|
Python3 | Memoization
|
Dr_Negative
| 1 | 9 |
maximum number of non overlapping palindrome substrings
| 2,472 | 0.366 |
Hard
| 33,938 |
https://leetcode.com/problems/maximum-number-of-non-overlapping-palindrome-substrings/discuss/2814448/Simplest-Greedy-Python-Solution-or-O(1)-Space-or-O(n*k)-Time
|
class Solution:
def maxPalindromes(self, s: str, k: int) -> int:
n = len(s)
# function to check whether substring is a palindrome
def valid(i, j):
# if end index is greater then length of string
if j > len(s):
return False
if s[i : j] == s[i : j][::-1]:
return True
return False
maxSubstrings = 0
start = 0
while start < n:
if valid(start, start + k):
maxSubstrings += 1
start += k
elif valid(start, start + k + 1):
maxSubstrings += 1
start += k + 1
else:
# when there is no palindrome starting at that particular index
start += 1
return maxSubstrings
|
maximum-number-of-non-overlapping-palindrome-substrings
|
Simplest Greedy Python Solution | O(1) Space | O(n*k) Time
|
deepaklaksman
| 1 | 18 |
maximum number of non overlapping palindrome substrings
| 2,472 | 0.366 |
Hard
| 33,939 |
https://leetcode.com/problems/maximum-number-of-non-overlapping-palindrome-substrings/discuss/2811830/Python-Very-simple-solution-O(n)-oror-no-DP
|
class Solution:
def maxPalindromes(self, s: str, k: int) -> int:
res = 0
lastp = -1
def helper(l, r):
nonlocal lastp, res
while l >= 0 and r < len(s) and s[l] == s[r] and l > lastp:
if r-l+1 >= k:
res += 1
lastp = r
break # find the shortest palindrome
else:
l -= 1
r += 1
for i in range(len(s)):
helper(i, i) # odd length
helper(i, i+1) # even length
return res
|
maximum-number-of-non-overlapping-palindrome-substrings
|
✅ [Python] Very simple solution - O(n) || no DP
|
Meerka_
| 1 | 22 |
maximum number of non overlapping palindrome substrings
| 2,472 | 0.366 |
Hard
| 33,940 |
https://leetcode.com/problems/maximum-number-of-non-overlapping-palindrome-substrings/discuss/2809266/Python3-greedy-only-check-length-k-and-k-%2B-1
|
class Solution:
def maxPalindromes(self, s: str, k: int) -> int:
ans = 0
l = 0
while l<len(s):
cdd1 = s[l:l+k]
if len(cdd1)>=k and cdd1 == cdd1[::-1]:
ans += 1
l = l+k
continue
cdd2 = s[l:l+k+1]
if len(cdd2)>=k and cdd2 == cdd2[::-1]:
ans += 1
l = l+k+1
continue
l += 1
return ans
|
maximum-number-of-non-overlapping-palindrome-substrings
|
[Python3] greedy - only check length k and k + 1
|
nxiayu
| 1 | 39 |
maximum number of non overlapping palindrome substrings
| 2,472 | 0.366 |
Hard
| 33,941 |
https://leetcode.com/problems/maximum-number-of-non-overlapping-palindrome-substrings/discuss/2816429/Python-Two-DP-O(NK)
|
class Solution:
def maxPalindromes(self, s: str, k: int) -> int:
n = len(s)
if k == 1: return n
ispalindromes, palidxs = [[True] * n for _ in range(n)], [[] for _ in range(n + 1)]
for step in range(1, k + 2):
for i in range(n - step):
ispalindromes[i][i + step] = (ispalindromes[i + 1][i + step - 1] and s[i] == s[i + step])
if step + 1 >= k and ispalindromes[i][i + step]: palidxs[i + step + 1].append(i)
dp = [0] * (n + 1)
for i in range(n + 1):
if i > 0: dp[i] = max(dp[i], dp[i - 1])
for j in palidxs[i]: dp[i] = max(dp[i], dp[j] + 1)
return dp[-1]
|
maximum-number-of-non-overlapping-palindrome-substrings
|
[Python] Two DP, O(NK)
|
cava
| 0 | 6 |
maximum number of non overlapping palindrome substrings
| 2,472 | 0.366 |
Hard
| 33,942 |
https://leetcode.com/problems/maximum-number-of-non-overlapping-palindrome-substrings/discuss/2814368/Python3-or-Memoization
|
class Solution:
def maxPalindromes(self, s: str, k: int) -> int:
@cache
def dp(ind):
if ind >= n-k+1:
return 0
val = 0
for i in range(k,k+2):
if s[ind:ind+i] == s[ind:ind+i][::-1]:
val = max(val,1 + dp(ind+i))
break
val = max(val,dp(ind+1))
return val
n = len(s)
return dp(0)
|
maximum-number-of-non-overlapping-palindrome-substrings
|
[Python3] | Memoization
|
swapnilsingh421
| 0 | 11 |
maximum number of non overlapping palindrome substrings
| 2,472 | 0.366 |
Hard
| 33,943 |
https://leetcode.com/problems/maximum-number-of-non-overlapping-palindrome-substrings/discuss/2811654/Non-Overlapping-Intervals-or-Greedy-or-Python3
|
class Solution:
def maxPalindromes(self, s: str, k: int) -> int:
intervals = []
n = len(s)
for i in range(n):
j = 0
while i - j > -1 and i + j < n and s[i - j] == s[i + j]:
st, e = i - j, i + j
if e - st + 1 >= k:
intervals.append([st, e])
j += 1
for i in range(n - 1):
j = 0
while i - j > -1 and i + 1 + j < n and s[i - j] == s[i + 1 + j]:
st, e = i - j, i + 1 + j
if e - st + 1 >= k:
intervals.append([st, e])
break
j += 1
intervals.sort(key = lambda x: x[1])
t = -1
ans = 0
for s, e in intervals:
if s > t:
t = e
ans += 1
return ans
|
maximum-number-of-non-overlapping-palindrome-substrings
|
Non Overlapping Intervals | Greedy | Python3
|
DheerajGadwala
| 0 | 15 |
maximum number of non overlapping palindrome substrings
| 2,472 | 0.366 |
Hard
| 33,944 |
https://leetcode.com/problems/maximum-number-of-non-overlapping-palindrome-substrings/discuss/2811186/Python-3Greedy-cutting
|
class Solution:
def maxPalindromes(self, s: str, k: int) -> int:
n = len(s)
if k == 1: return n
# palindrome length with center at x without overalpping with previous string end at index "prev"
def helper(x, prev):
i, j = x - 1, x + 1
while i > prev and j < n:
if s[i] != s[j]: break
# as long as the palindrom met the minimum length return the right index
if j - i + 1 >= k: return j
i -= 1
j += 1
i, j = x, x + 1
while i > prev and j < n:
if s[i] != s[j]: break
if j - i + 1 >= k: return j
i -= 1
j += 1
return -1
# build the right index array
idx = [-1] * n
prev = -1
for i in range(n):
tmp = helper(i, prev)
if tmp != -1:
prev = tmp
idx[i] = tmp
ans = i = 0
while i < n:
if idx[i] < 0:
i += 1
else:
ans += 1
i = idx[i] + 1
return ans
|
maximum-number-of-non-overlapping-palindrome-substrings
|
[Python 3]Greedy cutting
|
chestnut890123
| 0 | 15 |
maximum number of non overlapping palindrome substrings
| 2,472 | 0.366 |
Hard
| 33,945 |
https://leetcode.com/problems/maximum-number-of-non-overlapping-palindrome-substrings/discuss/2810522/Python-O(nk)-without-DP-or-recursion.-Simple-iterative-solution-with-explanation
|
class Solution:
def checkPalindromeAndReturnShortestGreaterThanK(self, s, i, j, beg, k):
while i > beg and j < len(s) and s[i]==s[j]:
if j-i-1 >= k:
return j-1
i-=1
j+=1
if j-i-1 >= k:
return j-1
return -1
def getShortestPalindromeEndPosition(self, s, cur, beg, k):
i = cur-1
j = cur+1
ans1 = self.checkPalindromeAndReturnShortestGreaterThanK(s, i, j, beg, k)
if ans1 != -1:
return ans1
if cur+1<len(s) and s[cur] == s[cur+1]:
i = cur-1
j = cur+2
ans2 = self.checkPalindromeAndReturnShortestGreaterThanK(s, i, j, beg, k)
if ans2 != -1:
return ans2
return cur
def maxPalindromes(self, s: str, k: int) -> int:
beg = -1
i = 0
count = 0
while i < len(s):
end = self.getShortestPalindromeEndPosition(s, i, beg, k)
if end != i or (end == i and k==1):
beg = end
count += 1
i = end + 1
return count
|
maximum-number-of-non-overlapping-palindrome-substrings
|
Python O(nk) without DP or recursion. Simple iterative solution with explanation
|
AkshayDagar
| 0 | 3 |
maximum number of non overlapping palindrome substrings
| 2,472 | 0.366 |
Hard
| 33,946 |
https://leetcode.com/problems/maximum-number-of-non-overlapping-palindrome-substrings/discuss/2809409/Python-Time-O(NK)-or-Space-O(1)
|
class Solution:
def maxPalindromes(self, s: str, k: int) -> int:
def expand(i, j):
# j - i <= k means we have to expand only until
# len(palindrome) >= k, and len(palindrome) is as small as possible
while i > left_boundary and j < len(s) and j - i <= k and s[i] == s[j]:
i -= 1
j += 1
return i + 1, j - 1
if k == 1:
return len(s)
res = 0
left_boundary = -1 # to cut the part of the string we've already seen
i = 0
while i < len(s) - 1:
left1, right1 = expand(i, i)
left2, right2 = expand(i, i + 1)
i += 1
# If an odd-length palindrome is found, it's always shorter than the one with even length
if right1 - left1 + 1 >= k:
left_boundary = right1
res += 1
i = right1 + 1
elif right2 - left2 + 1 >= k:
left_boundary = right2
res += 1
i = right2 + 1
return res
|
maximum-number-of-non-overlapping-palindrome-substrings
|
[Python] Time O(NK) | Space O(1)
|
miguel_v
| 0 | 11 |
maximum number of non overlapping palindrome substrings
| 2,472 | 0.366 |
Hard
| 33,947 |
https://leetcode.com/problems/maximum-number-of-non-overlapping-palindrome-substrings/discuss/2809306/Python-solution-with-explanation
|
class Solution:
def maxPalindromes(self, s: str, k: int) -> int:
def getPalindrome(idx, single):
i, j = idx - 1, idx + 1
length = 1
if not single:
length += 1
j += 1
while i >= 0 and j < len(s) and s[i] == s[j]:
length += 2
i -= 1
j += 1
return length
palindromes = []
for i in range(len(s)):
length = getPalindrome(i, True)
if length >= k:
palindromes.append([i - (k // 2), i + (k // 2)])
if k > 1 and i < len(s) - 1 and s[i] == s[i + 1]:
length = getPalindrome(i, False)
if length >= k:
palindromes.append([i - ((k // 2) - 1), i + (k // 2)])
last = -inf
total = 0
for start, end in sorted(palindromes, key = lambda p: p[1]):
if start > last:
last = end
total += 1
return total
|
maximum-number-of-non-overlapping-palindrome-substrings
|
Python solution with explanation
|
nawrazi
| 0 | 17 |
maximum number of non overlapping palindrome substrings
| 2,472 | 0.366 |
Hard
| 33,948 |
https://leetcode.com/problems/maximum-number-of-non-overlapping-palindrome-substrings/discuss/2809175/Python3-DP%2BGreedy
|
class Solution:
def maxPalindromes(self, s: str, k: int) -> int:
n = len(s)
palEnds = -1 # previous palindrome ending pos
res = 0
for i in range(n):
for j in range(i + k - 1, n):
if i <= palEnds and j >= palEnds:
break
pal = s[i:j+1]
if pal == pal[::-1]:
if i > palEnds:
res += 1
palEnds = j
return res
|
maximum-number-of-non-overlapping-palindrome-substrings
|
Python3 DP+Greedy
|
fengqifeng
| 0 | 10 |
maximum number of non overlapping palindrome substrings
| 2,472 | 0.366 |
Hard
| 33,949 |
https://leetcode.com/problems/maximum-number-of-non-overlapping-palindrome-substrings/discuss/2809175/Python3-DP%2BGreedy
|
class Solution:
def maxPalindromes(self, s: str, k: int) -> int:
def isPalindrome(i: int, j: int) -> bool:
while i < j:
if s[i] != s[j]:
return False
i += 1
j -= 1
return True
n, i, res = len(s), 0, 0
while i <= n - k:
if s[i] == s[i+k-1] and isPalindrome(i, i+k-1):
res += 1
i = i + k
elif i+k < n and s[i] == s[i+k] and isPalindrome(i, i+k):
res += 1
i = i + k + 1
else:
i += 1
return res
|
maximum-number-of-non-overlapping-palindrome-substrings
|
Python3 DP+Greedy
|
fengqifeng
| 0 | 10 |
maximum number of non overlapping palindrome substrings
| 2,472 | 0.366 |
Hard
| 33,950 |
https://leetcode.com/problems/maximum-number-of-non-overlapping-palindrome-substrings/discuss/2809114/Python-Answer-Until-K-%2B-2-FAST-Beats-75
|
class Solution:
def maxPalindromes(self, s: str, k: int) -> int:
@cache
def checkPall(ss):
return ss == ss[::-1]
@cache
def checkPal(i,j):
ss = s[i:j]
return checkPall(ss)
dp = [0] * (len(s) + 1)
for i in range(len(s)-k+1):
dp[i] = dp[i-1])
for j in range(i+k, i+k+2 ):
if j <= len(s) and checkPal(i,j):
dp[j] = max(dp[j], 1 + dp[i])
break
return max(dp)
'''
|
maximum-number-of-non-overlapping-palindrome-substrings
|
[Python Answer🤫🐍🐍🐍] Until K + 2 - FAST Beats 75%
|
xmky
| 0 | 7 |
maximum number of non overlapping palindrome substrings
| 2,472 | 0.366 |
Hard
| 33,951 |
https://leetcode.com/problems/maximum-number-of-non-overlapping-palindrome-substrings/discuss/2809071/Python-Greedy-Approach-O(nk)O(1)
|
class Solution:
def find_first_palindrome(self, string, i, k):
N = len(string)
L = N - i
M = L + L - 1
for j in range(M):
if j % 2 == 0:
ll = rr = i + j // 2
else:
ll = i + j // 2
rr = ll + 1
while ll >= i and rr < N and string[ll] == string[rr]:
if rr - ll + 1 >= k:
return (ll, rr)
ll -= 1
rr += 1
return
def maxPalindromes(self, s: str, k: int) -> int:
N = len(s)
if k == 1:
return N
count = 0
i = 0
while i < N:
pair = self.find_first_palindrome(s, i, k)
if pair:
count += 1
i = pair[1] + 1
else:
i = N
return count
|
maximum-number-of-non-overlapping-palindrome-substrings
|
[Python] Greedy Approach O(nk)/O(1)
|
ryanmeow
| 0 | 11 |
maximum number of non overlapping palindrome substrings
| 2,472 | 0.366 |
Hard
| 33,952 |
https://leetcode.com/problems/maximum-number-of-non-overlapping-palindrome-substrings/discuss/2809042/Very-easy-and-short-O(n)-solution-or-python
|
class Solution:
def maxPalindromes(self, s: str, k: int) -> int:
n = len(s)
if k == 1:
return n
ans = 0
i = 0
while i + k <= n:
if s[i:i + k] == s[i:i + k][::-1]:
ans += 1
i = i + k
elif s[i:i + k + 1] == s[i:i + k + 1][::-1]:
ans += 1
i = i + k + 1
else:
i += 1
return ans
|
maximum-number-of-non-overlapping-palindrome-substrings
|
Very easy and short O(n) solution | python
|
jackie890621
| 0 | 19 |
maximum number of non overlapping palindrome substrings
| 2,472 | 0.366 |
Hard
| 33,953 |
https://leetcode.com/problems/maximum-number-of-non-overlapping-palindrome-substrings/discuss/2809025/Enumerate-and-greedy-O(n*k)
|
class Solution:
def maxPalindromes(self, s: str, k: int) -> int:
n = len(s)
self.ans = 0
self.start = 0
i = 0
while i < n:
r1 = self.is_pal(i, i, s, k)
r2 = self.is_pal(i, i+1, s, k)
if r1 < n or r2 < n:
i = min(r1, r2) + 1
self.ans += 1
self.start = i
else:
i += 1
return self.ans
def is_pal(self, left, right, s, k):
size = right - left + 1
l, r = left, right
n = len(s)
ans = float("inf")
while l >= self.start and r < n and s[l] == s[r]:
if size >= k:
# self.ans += 1
# ps.add(s[l:r+1])
return r
l -= 1
r += 1
size += 2
return ans
|
maximum-number-of-non-overlapping-palindrome-substrings
|
Enumerate and greedy, O(n*k)
|
goodgoodwish
| 0 | 26 |
maximum number of non overlapping palindrome substrings
| 2,472 | 0.366 |
Hard
| 33,954 |
https://leetcode.com/problems/maximum-number-of-non-overlapping-palindrome-substrings/discuss/2808975/Python3-dp
|
class Solution:
def maxPalindromes(self, s: str, k: int) -> int:
n = len(s)
vals = [1]*n
for i in range(2*n-1):
lo, hi = i//2, (i+1)//2
while 0 <= lo <= hi < n and s[lo] == s[hi]:
if vals[lo] < k: vals[lo] = max(vals[lo], hi-lo+1)
lo -= 1
hi += 1
dp = [0]*(n+1)
for i in range(n-1, -1, -1):
dp[i] = dp[i+1]
if vals[i] >= k: dp[i] = max(dp[i], 1+dp[i+vals[i]])
return dp[0]
|
maximum-number-of-non-overlapping-palindrome-substrings
|
[Python3] dp
|
ye15
| 0 | 21 |
maximum number of non overlapping palindrome substrings
| 2,472 | 0.366 |
Hard
| 33,955 |
https://leetcode.com/problems/number-of-unequal-triplets-in-array/discuss/2834169/Python-Hashmap-O(n)-with-diagrams
|
class Solution:
def unequalTriplets(self, nums: List[int]) -> int:
c = Counter(nums)
res = 0
left = 0
right = len(nums)
for _, freq in c.items():
right -= freq
res += left * freq * right
left += freq
return res
|
number-of-unequal-triplets-in-array
|
Python Hashmap O(n) with diagrams
|
cheatcode-ninja
| 10 | 242 |
number of unequal triplets in array
| 2,475 | 0.699 |
Easy
| 33,956 |
https://leetcode.com/problems/number-of-unequal-triplets-in-array/discuss/2832078/PythonC%2B%2BJavaScript-O(n)-beats-100
|
class Solution:
def unequalTriplets(self, nums: List[int]) -> int:
count = 0
prev, nxt = 0, len(nums)
for _, frequency in Counter(nums).items():
nxt -= frequency
count += prev * frequency * nxt
prev += frequency
return count
|
number-of-unequal-triplets-in-array
|
✅ [Python/C++/JavaScript] O(n) beats 100%
|
sezanhaque
| 8 | 533 |
number of unequal triplets in array
| 2,475 | 0.699 |
Easy
| 33,957 |
https://leetcode.com/problems/number-of-unequal-triplets-in-array/discuss/2831993/Easy-Brute-Force-solution-or-Python-or-TC-O(n3)
|
class Solution:
def unequalTriplets(self, nums: List[int]) -> int:
c = 0
for i in range(len(nums)):
for j in range(i+1, len(nums)):
for k in range(j+1, len(nums)):
if nums[i]!=nums[j] and nums[i]!=nums[k] and nums[j] != nums[k]:
c+=1
return c
|
number-of-unequal-triplets-in-array
|
Easy Brute Force solution | Python | TC = O(n^3)
|
jayvardhanrathore111
| 2 | 118 |
number of unequal triplets in array
| 2,475 | 0.699 |
Easy
| 33,958 |
https://leetcode.com/problems/number-of-unequal-triplets-in-array/discuss/2834376/Python-One-Pass-O(n)-Count-invalid-triplets
|
class Solution:
def unequalTriplets(self, nums: List[int]) -> int:
from collections import Counter
num_count = Counter()
n_invalid_pairs = 0
n_invalid_triplets = 0
for (i, num) in enumerate(nums):
n_invalid_triplets += (i-num_count.get(num, 0)) * num_count.get(num, 0)
n_invalid_triplets += n_invalid_pairs
n_invalid_pairs += num_count[num]
num_count[num] += 1
n_nums = len(nums)
return n_nums * (n_nums-1) * (n_nums-2) // 6 - n_invalid_triplets
|
number-of-unequal-triplets-in-array
|
Python One Pass O(n) Count invalid triplets
|
Rinnegan_Sep
| 1 | 52 |
number of unequal triplets in array
| 2,475 | 0.699 |
Easy
| 33,959 |
https://leetcode.com/problems/number-of-unequal-triplets-in-array/discuss/2831749/Python-Simple-Python-Solution-Using-Brute-Force
|
class Solution:
def unequalTriplets(self, nums: List[int]) -> int:
result = 0
for i in range(len(nums)-2):
for j in range(i+1,len(nums)-1):
for k in range(j+1,len(nums)):
if nums[i] != nums[j] and nums[j] != nums[k] and nums[i] != nums[k]:
result = result + 1
return result
|
number-of-unequal-triplets-in-array
|
[ Python ] ✅✅ Simple Python Solution Using Brute Force🥳✌👍
|
ASHOK_KUMAR_MEGHVANSHI
| 1 | 80 |
number of unequal triplets in array
| 2,475 | 0.699 |
Easy
| 33,960 |
https://leetcode.com/problems/number-of-unequal-triplets-in-array/discuss/2849851/Python-brute-force-solution
|
class Solution:
def unequalTriplets(self, nums: List[int]) -> int:
ans = 0
for i in range(len(nums)):
for j in range(i+1,len(nums)):
for k in range(j+1, len(nums)):
if nums[i] != nums[j] and nums[i] != nums[k] and nums[j] != nums[k]:
ans += 1
return ans
|
number-of-unequal-triplets-in-array
|
Python brute force solution
|
StikS32
| 0 | 3 |
number of unequal triplets in array
| 2,475 | 0.699 |
Easy
| 33,961 |
https://leetcode.com/problems/number-of-unequal-triplets-in-array/discuss/2843209/O(n)-Simple-one-pass-Math-solution-with-detailed-explanation
|
class Solution:
def unequalTriplets(self, nums: List[int]) -> int:
n = len(nums)
combinations = math.comb(n, 3)
for num, frq in Counter(nums).items():
if frq >= 3:
combinations -= math.comb(frq, 3)
if frq >= 2:
combinations -= math.comb(frq, 2) * (n - frq)
return(combinations)
|
number-of-unequal-triplets-in-array
|
O(n) Simple one-pass Math solution with detailed explanation
|
ckush
| 0 | 10 |
number of unequal triplets in array
| 2,475 | 0.699 |
Easy
| 33,962 |
https://leetcode.com/problems/number-of-unequal-triplets-in-array/discuss/2839719/Three-loops-and-set-92-speed
|
class Solution:
def unequalTriplets(self, nums: List[int]) -> int:
ans = 0
len_nums = len(nums)
for i in range(len_nums - 2):
s = {nums[i]}
for j in range(i + 1, len_nums - 1):
if nums[j] in s:
continue
s.add(nums[j])
for k in range(j + 1, len_nums):
if nums[k] in s:
continue
ans += 1
s.remove(nums[j])
return ans
|
number-of-unequal-triplets-in-array
|
Three loops and set, 92% speed
|
EvgenySH
| 0 | 9 |
number of unequal triplets in array
| 2,475 | 0.699 |
Easy
| 33,963 |
https://leetcode.com/problems/number-of-unequal-triplets-in-array/discuss/2836490/Python-Solution
|
class Solution:
def unequalTriplets(self, nums: List[int]) -> int:
c=0
for i in range(len(nums)):
for j in range(i+1,len(nums)):
for k in range(j+1,len(nums)):
if(nums[i]!=nums[j] and nums[i]!=nums[k] and nums[j]!=nums[k]):
c+=1
return c
|
number-of-unequal-triplets-in-array
|
Python Solution
|
CEOSRICHARAN
| 0 | 9 |
number of unequal triplets in array
| 2,475 | 0.699 |
Easy
| 33,964 |
https://leetcode.com/problems/number-of-unequal-triplets-in-array/discuss/2835397/Simple-Solution-by-python
|
class Solution:
def unequalTriplets(self, nums: List[int]) -> int:
count = 0
for i in range(0,len(nums)-2):
for j in range(i+1,len(nums)-1):
for k in range(j+1,len(nums)):
if (nums[i]!=nums[j]) and (nums[j]!=nums[k]) and (nums[i]!=nums[k]):
count +=1
return count
|
number-of-unequal-triplets-in-array
|
Simple Solution by python
|
pypypymi
| 0 | 9 |
number of unequal triplets in array
| 2,475 | 0.699 |
Easy
| 33,965 |
https://leetcode.com/problems/number-of-unequal-triplets-in-array/discuss/2834252/Python3-freq-table
|
class Solution:
def unequalTriplets(self, nums: List[int]) -> int:
freq = Counter(nums)
ans = prefix = 0
suffix = len(nums)
for k, v in freq.items():
suffix -= v
ans += prefix * v * suffix
prefix += v
return ans
|
number-of-unequal-triplets-in-array
|
[Python3] freq table
|
ye15
| 0 | 17 |
number of unequal triplets in array
| 2,475 | 0.699 |
Easy
| 33,966 |
https://leetcode.com/problems/number-of-unequal-triplets-in-array/discuss/2833997/Easiest-python-solution-using-Combinations-(5-liner)
|
class Solution:
def unequalTriplets(self, nums: List[int]) -> int:
z=itertools.combinations(nums, 3)
count=0
for i in z:
if len(set(i))==3:
count+=1
return count
|
number-of-unequal-triplets-in-array
|
Easiest python solution using Combinations, (5 liner)
|
fahim_ash
| 0 | 13 |
number of unequal triplets in array
| 2,475 | 0.699 |
Easy
| 33,967 |
https://leetcode.com/problems/number-of-unequal-triplets-in-array/discuss/2833704/Python-brute-force
|
class Solution:
def unequalTriplets(self, nums: List[int]) -> int:
result = 0
for i in range(len(nums)-2):
for j in range(i+1, len(nums)-1):
for k in range(j+1, len(nums)):
if nums[i] != nums[j] and nums[j] != nums[k] and nums[i] != nums[k]:
result += 1
return result
|
number-of-unequal-triplets-in-array
|
Python, brute force
|
blue_sky5
| 0 | 6 |
number of unequal triplets in array
| 2,475 | 0.699 |
Easy
| 33,968 |
https://leetcode.com/problems/number-of-unequal-triplets-in-array/discuss/2832446/Python-one-line-brute-force
|
class Solution:
def unequalTriplets(self, nums: List[int]) -> int:
return len([[i,j,k] for i in range(len(nums)) for j in range(i,len(nums)) for k in range(j,len(nums)) if nums[i]!=nums[j] and nums[i]!=nums[k] and nums[j]!=nums[k]])
|
number-of-unequal-triplets-in-array
|
Python, one line brute force
|
Leox2022
| 0 | 14 |
number of unequal triplets in array
| 2,475 | 0.699 |
Easy
| 33,969 |
https://leetcode.com/problems/number-of-unequal-triplets-in-array/discuss/2832414/Python-easy-Solution-using-brute-force
|
class Solution:
def unequalTriplets(self, nums: List[int]) -> int:
count=0
for i in range(len(nums)):
for j in range(i+1,len(nums)):
if nums[i]!=nums[j]:
for k in range(j+1,len(nums)):
if nums[i]!=nums[k] and nums[j]!=nums[k]:
count+=1
return count
|
number-of-unequal-triplets-in-array
|
Python easy Solution using brute force
|
Motaharozzaman1996
| 0 | 2 |
number of unequal triplets in array
| 2,475 | 0.699 |
Easy
| 33,970 |
https://leetcode.com/problems/number-of-unequal-triplets-in-array/discuss/2832190/python-simple-iteration
|
class Solution:
def unequalTriplets(self, nums: List[int]) -> int:
c=0
n=len(nums)
for i in range(n-2):
for j in range(i+1,n-1):
for k in range(j+1,n):
if nums[i]!=nums[j] and nums[i]!=nums[k] and nums[j]!=nums[k]:
c+=1
return c
|
number-of-unequal-triplets-in-array
|
python simple iteration
|
insane_me12
| 0 | 11 |
number of unequal triplets in array
| 2,475 | 0.699 |
Easy
| 33,971 |
https://leetcode.com/problems/number-of-unequal-triplets-in-array/discuss/2832020/Python-Brute-Force-Solution
|
class Solution:
def unequalTriplets(self, nums: List[int]) -> int:
l = len(nums)
count = 0
for i in range(l-2):
for j in range(i+1,l-1):
for k in range(j+1,l):
if nums[i] != nums[j] and nums[j] != nums[k] and nums[k] != nums[i]:
count += 1
return count
|
number-of-unequal-triplets-in-array
|
Python Brute Force Solution
|
saivamshi0103
| 0 | 4 |
number of unequal triplets in array
| 2,475 | 0.699 |
Easy
| 33,972 |
https://leetcode.com/problems/number-of-unequal-triplets-in-array/discuss/2831882/Python-Easy-solution
|
class Solution:
def unequalTriplets(self, nums: List[int]) -> int:
count=0
for i in range(len(nums)):
for j in range(i+1,len(nums)):
for k in range(j+1,len(nums)):
if nums[i]!=nums[j] and nums[j]!=nums[k] and nums[k]!=nums[i]:
count+=1
return count
|
number-of-unequal-triplets-in-array
|
Python Easy solution
|
Vimalshetty07
| 0 | 25 |
number of unequal triplets in array
| 2,475 | 0.699 |
Easy
| 33,973 |
https://leetcode.com/problems/number-of-unequal-triplets-in-array/discuss/2831772/Python-Bruteforce-or-Easy-to-understand
|
class Solution:
def unequalTriplets(self, nums: List[int]) -> int:
n = len(nums)
trip = 0
for i in range(n):
for j in range(i+1, n):
for k in range(j+1, n):
if (nums[i] != nums[j] and nums[i] != nums[k] and nums[j] != nums[k]):
trip += 1
return trip
|
number-of-unequal-triplets-in-array
|
Python Bruteforce | Easy to understand
|
jubinsoni
| 0 | 9 |
number of unequal triplets in array
| 2,475 | 0.699 |
Easy
| 33,974 |
https://leetcode.com/problems/number-of-unequal-triplets-in-array/discuss/2831689/Python3-Simple
|
class Solution:
def unequalTriplets(self, nums: List[int]) -> int:
n=len(nums)
answ=0
for i in range(n):
for j in range(i+1,n):
for k in range(j+1,n):
answ+= len({nums[i],nums[j],nums[k]})==3
return answ
|
number-of-unequal-triplets-in-array
|
Python3, Simple
|
Silvia42
| 0 | 36 |
number of unequal triplets in array
| 2,475 | 0.699 |
Easy
| 33,975 |
https://leetcode.com/problems/number-of-unequal-triplets-in-array/discuss/2831665/pythonjava-brute-force
|
class Solution:
def unequalTriplets(self, nums: List[int]) -> int:
n = len(nums)
res = 0
for i in range(n - 2):
for j in range(i + 1, n - 1):
for k in range(j + 1, n):
if nums[i] != nums[j] and nums[i] != nums[k] and nums[j] != nums[k]:
res += 1
return res
class Solution {
public int unequalTriplets(int[] nums) {
int n = nums.length;
int res = 0;
for (int i = 0; i < n - 2; i ++) {
for (int j = i + 1; j < n - 1; j ++) {
for (int k = j + 1; k < n; k ++) {
if (nums[i] != nums[j] && nums[i] != nums[k] && nums[j] != nums[k]) {
res ++;
}
}
}
}
return res;
}
}
|
number-of-unequal-triplets-in-array
|
python/java brute force
|
akaghosting
| 0 | 23 |
number of unequal triplets in array
| 2,475 | 0.699 |
Easy
| 33,976 |
https://leetcode.com/problems/closest-nodes-queries-in-a-binary-search-tree/discuss/2831726/Binary-Search-Approach-or-Python
|
class Solution(object):
def closestNodes(self, root, queries):
def dfs(root, arr):
if not root: return
dfs(root.left, arr)
arr.append(root.val)
dfs(root.right, arr)
arr = []
dfs(root, arr)
ans = []
n = len(arr)
for key in queries:
left, right = 0, n - 1
while right >= left:
mid = (right + left) // 2
if arr[mid] == key:
break
elif arr[mid] > key:
right = mid - 1
else:
left = mid + 1
if arr[mid] == key:
ans.append([arr[mid], arr[mid]])
elif arr[mid] > key:
if (mid - 1) >= 0:
ans.append([arr[mid - 1], arr[mid]])
else:
ans.append([-1, arr[mid]])
else:
if (mid + 1) < n:
ans.append([arr[mid], arr[mid + 1]])
else:
ans.append([arr[mid], -1])
return ans
|
closest-nodes-queries-in-a-binary-search-tree
|
Binary Search Approach | Python
|
its_krish_here
| 11 | 975 |
closest nodes queries in a binary search tree
| 2,476 | 0.404 |
Medium
| 33,977 |
https://leetcode.com/problems/closest-nodes-queries-in-a-binary-search-tree/discuss/2838464/Python-solution
|
class Solution:
def closestNodes(self, root: Optional[TreeNode], queries: List[int]) -> List[List[int]]:
nums = []
def dfs(node):
if node:
nums.append(node.val)
if node.left:
dfs(node.left)
if node.right:
dfs(node.right)
dfs(root)
nums.sort()
n = len(nums)
ans = []
for i in range(len(queries)):
left = 0
right = n - 1
while right > left:
mid = (left + right)//2
if nums[mid] == queries[i]:
left = right = mid
elif nums[mid] > queries[i]:
right = mid
elif nums[mid] < queries[i]:
left = mid + 1
if nums[right] == queries[i]:
sub = (nums[left], nums[right])
elif nums[right] > queries[i]:
sub = (nums[right-1], nums[right]) if right - 1 >= 0 else (-1, nums[right])
elif nums[right] < queries[i]:
sub = (nums[left], nums[left]) if left + 1 < n else (nums[left], -1)
ans.append(sub)
return ans
|
closest-nodes-queries-in-a-binary-search-tree
|
Python solution
|
maomao1010
| 0 | 2 |
closest nodes queries in a binary search tree
| 2,476 | 0.404 |
Medium
| 33,978 |
https://leetcode.com/problems/closest-nodes-queries-in-a-binary-search-tree/discuss/2836153/Python-(Simple-DFS)
|
class Solution:
def closestNodes(self, root, queries):
ans = []
def dfs(node):
if not node:
return
dfs(node.left)
ans.append(node.val)
dfs(node.right)
dfs(root)
res = []
n = len(ans)
for i in queries:
r1 = bisect.bisect_left(ans,i)
if r1 == n: res.append([ans[-1],-1])
elif ans[r1] == i: res.append([i,i])
elif r1 == 0: res.append([-1,ans[0]])
else: res.append([ans[r1-1],ans[r1]])
return res
|
closest-nodes-queries-in-a-binary-search-tree
|
Python (Simple DFS)
|
rnotappl
| 0 | 4 |
closest nodes queries in a binary search tree
| 2,476 | 0.404 |
Medium
| 33,979 |
https://leetcode.com/problems/closest-nodes-queries-in-a-binary-search-tree/discuss/2834272/Python3-in-order-traversal
|
class Solution:
def closestNodes(self, root: Optional[TreeNode], queries: List[int]) -> List[List[int]]:
vals = []
node = root
stack = []
while node or stack:
if node:
stack.append(node)
node = node.left
else:
node = stack.pop()
vals.append(node.val)
node = node.right
ans = []
for q in queries:
ans.append([-1, -1])
lo = bisect_right(vals, q)-1
if 0 <= lo: ans[-1][0] = vals[lo]
hi = bisect_left(vals, q)
if hi < len(vals): ans[-1][1] = vals[hi]
return ans
|
closest-nodes-queries-in-a-binary-search-tree
|
[Python3] in-order traversal
|
ye15
| 0 | 4 |
closest nodes queries in a binary search tree
| 2,476 | 0.404 |
Medium
| 33,980 |
https://leetcode.com/problems/closest-nodes-queries-in-a-binary-search-tree/discuss/2832423/Inorder-%2B-Binary-search-or-Python-or-easy-method
|
class Solution:
def closestNodes(self, root: Optional[TreeNode], queries: List[int]) -> List[List[int]]:
dic = {}
inorder_array = []
res = []
def inorder(node):
if(not node):
return
inorder(node.left)
inorder_array.append(node.val)
inorder(node.right)
inorder(root)
def find(target):
start = 0
end = len(inorder_array) - 1
mid = 0
while(start <= end):
mid = (start + end) // 2
if(inorder_array[mid] == target): #if target in the tree
return [target, target]
elif(inorder_array[mid] > target):
end = mid - 1
else:
start = mid + 1
#target not in the tree and then find the interval of this target
if(inorder_array[mid] > target):
if(mid != 0):
return [inorder_array[mid - 1], inorder_array[mid]]
else:
return [-1, inorder_array[mid]] #target is at index 0
else:
if(mid != len(inorder_array) - 1):
return [inorder_array[mid], inorder_array[mid + 1]]
else:
return [inorder_array[mid], -1] #target is at last index
for i in queries:
res.append(find(i))
return res
|
closest-nodes-queries-in-a-binary-search-tree
|
Inorder + Binary search | Python | easy method
|
55337123kk3
| 0 | 16 |
closest nodes queries in a binary search tree
| 2,476 | 0.404 |
Medium
| 33,981 |
https://leetcode.com/problems/closest-nodes-queries-in-a-binary-search-tree/discuss/2831885/Inorder-Traversal
|
class Solution:
def closestNodes(self, root: Optional[TreeNode], queries: List[int]) -> List[List[int]]:
nums = []
def in_order(node):
nonlocal nums
if not node:
return
in_order(node.left)
nums.append(node.val)
in_order(node.right)
in_order(root)
q_temp = sorted(queries)
ht = {}
p = 0
for i in range(len(q_temp)):
temp = [-1, -1]
while p < len(nums) and nums[p] <= q_temp[i]:
p += 1
if p > 0 and p < len(nums):
if nums[p-1] == q_temp[i] or nums[p] == q_temp[i]:
temp = [nums[p-1], nums[p-1]]
else:
temp = [nums[p-1], nums[p]]
elif p == 0:
temp = [-1, nums[p]]
else:
if nums[p-1] == q_temp[i]:
temp = [nums[p-1], nums[p-1]]
else:
temp = [nums[p-1], -1]
ht[q_temp[i]] = temp
rst = []
for n in queries:
rst.append(ht[n])
return rst
|
closest-nodes-queries-in-a-binary-search-tree
|
Inorder Traversal
|
tiaotiao5762
| 0 | 3 |
closest nodes queries in a binary search tree
| 2,476 | 0.404 |
Medium
| 33,982 |
https://leetcode.com/problems/closest-nodes-queries-in-a-binary-search-tree/discuss/2831856/Python-Simple-Python-Solution-Using-Binary-Search
|
class Solution:
def closestNodes(self, root: Optional[TreeNode], queries: List[int]) -> List[List[int]]:
array = []
def PrintTree(node):
if node != None:
PrintTree(node.left)
array.append(node.val)
PrintTree(node.right)
PrintTree(root)
result = []
for query in queries:
left, right = 0, len(array) - 1
while right >= left:
mid = (right + left) // 2
if array[mid] == query:
break
elif array[mid] > query:
right = mid - 1
else:
left = mid + 1
if array[mid] == query:
result.append([array[mid], array[mid]])
elif array[mid] > query:
if (mid - 1) >= 0:
result.append([array[mid - 1], array[mid]])
else:
result.append([-1, array[mid]])
else:
if (mid + 1) < len(array):
result.append([array[mid], array[mid + 1]])
else:
result.append([array[mid], -1])
return result
|
closest-nodes-queries-in-a-binary-search-tree
|
[ Python ] ✅✅ Simple Python Solution Using Binary Search🥳✌👍
|
ASHOK_KUMAR_MEGHVANSHI
| 0 | 27 |
closest nodes queries in a binary search tree
| 2,476 | 0.404 |
Medium
| 33,983 |
https://leetcode.com/problems/minimum-fuel-cost-to-report-to-the-capital/discuss/2834516/Python-DFS-Picture-explanation-O(N)
|
class Solution:
def minimumFuelCost(self, roads: List[List[int]], seats: int) -> int:
n = len(roads) + 1
graph = defaultdict(list)
for a, b in roads:
graph[a].append(b)
graph[b].append(a)
def dfs(u, p):
cnt = 1
for v in graph[u]:
if v == p: continue
cnt += dfs(v, u)
if u != 0:
self.ans += math.ceil(cnt / seats) # number of litters for `cnt` people to travel from node `u` to node `p`
return cnt
self.ans = 0
dfs(0, -1)
return self.ans
|
minimum-fuel-cost-to-report-to-the-capital
|
[Python] DFS - Picture explanation - O(N)
|
hiepit
| 33 | 528 |
minimum fuel cost to report to the capital
| 2,477 | 0.53 |
Medium
| 33,984 |
https://leetcode.com/problems/minimum-fuel-cost-to-report-to-the-capital/discuss/2831713/Python-DFS
|
class Solution:
def minimumFuelCost(self, roads: List[List[int]], seats: int) -> int:
graph = defaultdict(list)
for e in roads:
graph[e[0]].append(e[1])
graph[e[1]].append(e[0])
visited = set()
fuel = [0]
def dfs(node):
visited.add(node)
people = 0
for n in graph[node]:
if n in visited:
continue
p = dfs(n)
people += p
fuel[0] += ceil(p / seats)
if not people:
return 1
return people + 1
dfs(0)
return fuel[0]
|
minimum-fuel-cost-to-report-to-the-capital
|
Python DFS
|
JSTM2022
| 7 | 220 |
minimum fuel cost to report to the capital
| 2,477 | 0.53 |
Medium
| 33,985 |
https://leetcode.com/problems/minimum-fuel-cost-to-report-to-the-capital/discuss/2839984/Python-DFS-Picture-explanation-Video-Solution-O(n)
|
class Solution:
def minimumFuelCost(self, roads: List[List[int]], seats: int) -> int:
m = defaultdict(list)
for a,b in roads:
m[a].append(b)
m[b].append(a)
ans = [0]
def dfs(node, prev):
people = 1
for i in m[node]:
if i==prev:
continue
people+=dfs(i, node)
if node!=0:
ans[0]+=math.ceil(people/seats)
return people
dfs(0, None)
return ans[0]
|
minimum-fuel-cost-to-report-to-the-capital
|
[Python] DFS - Picture explanation - Video Solution - O(n)
|
cheatcode-ninja
| 2 | 17 |
minimum fuel cost to report to the capital
| 2,477 | 0.53 |
Medium
| 33,986 |
https://leetcode.com/problems/minimum-fuel-cost-to-report-to-the-capital/discuss/2832516/Python-3-Easy-to-understand-DFS
|
class Solution:
def minimumFuelCost(self, roads, seats):
graph = defaultdict(set)
# find the adjacency list representation
for i,j in roads:
graph[i].add(j)
graph[j].add(i)
n = len(graph)
if n==0: return 0
visited = [False]*n
self.ans = 0
def dfs(city):
# return total number of representatives can be at city
# and update answer self.ans for each city
visited[city] = True
repnum = 1 # initialize with 1 representative of city
for neighbor in graph[city]:
if not visited[neighbor]:
repnum += dfs(neighbor)
if city==0: return None # do not update answer for capital
self.ans += math.ceil(repnum/seats) # update answer
return repnum
dfs(0) # execute the DFS
return self.ans
|
minimum-fuel-cost-to-report-to-the-capital
|
Python 3, Easy to understand DFS
|
cuongmng
| 1 | 24 |
minimum fuel cost to report to the capital
| 2,477 | 0.53 |
Medium
| 33,987 |
https://leetcode.com/problems/minimum-fuel-cost-to-report-to-the-capital/discuss/2839206/Python3-Concise-and-Commented-DFS-approach
|
class Solution:
def minimumFuelCost(self, roads: List[List[int]], seats: int) -> int:
# we can do dfs into the leaf nodes and on return calculate the
# amount of people that travel together. We will travel to the
# leaves first and count the collected representatives on the
# way back. During that we also continously add the fuel needed
# to travel from node to next node closer to root.
# make the graph for all of the roads in order to have a quick
# lookup
graph = collections.defaultdict(list)
for start, end in roads:
graph[start].append(end)
graph[end].append(start)
# make a instance variable to count the fuel
self.fuel = 0
# start the depth first approach
self.dfs(0, -1, graph, seats)
# return our result
return self.fuel
def dfs(self, position, parent, graph, seats):
# go deeper into the graph for all connections still open and
# add up the representatives travelling to our node. Do not
# forget to start at one representative, as our node also
# has an representative
representatives = 1
for target in graph[position]:
# check that we do not go back in root direction
if target != parent:
# count the representatives coming from nodes deeper in the
# tree
representatives += self.dfs(target, position, graph, seats)
# get the fuel costs for each car of collected representatives, but
# take care to not travel further once we are at root node ( position == 0)
if position > 0:
# calculate the number of cars we need to go further
# this is just a quick way of saying: math.ceil(representatives/2)
self.fuel += (representatives + seats-1) // seats
# go in the the root node direction and hand over the number of incoming
# representatives
return representatives
|
minimum-fuel-cost-to-report-to-the-capital
|
[Python3] - Concise and Commented DFS approach
|
Lucew
| 0 | 3 |
minimum fuel cost to report to the capital
| 2,477 | 0.53 |
Medium
| 33,988 |
https://leetcode.com/problems/minimum-fuel-cost-to-report-to-the-capital/discuss/2839206/Python3-Concise-and-Commented-DFS-approach
|
class Solution:
def minimumFuelCost(self, roads: List[List[int]], seats: int) -> int:
graph = collections.defaultdict(list)
for start, end in roads:
graph[start].append(end)
graph[end].append(start)
self.fuel = 0
self.dfs(0, -1, graph, seats)
return self.fuel
def dfs(self, position, parent, graph, seats):
representatives = 1
for target in graph[position]:
if target != parent:
representatives += self.dfs(target, position, graph, seats)
if position > 0:
self.fuel += (representatives + seats-1) // seats
return representatives
|
minimum-fuel-cost-to-report-to-the-capital
|
[Python3] - Concise and Commented DFS approach
|
Lucew
| 0 | 3 |
minimum fuel cost to report to the capital
| 2,477 | 0.53 |
Medium
| 33,989 |
https://leetcode.com/problems/minimum-fuel-cost-to-report-to-the-capital/discuss/2835335/My-Python-solution
|
class Solution:
def minimumFuelCost(self, roads: List[List[int]], seats: int) -> int:
graph = defaultdict(list)
for x, y in roads:
graph[x].append(y)
graph[y].append(x)
self.ans = 0
def dfs(i, prev, people = 1):
for x in graph[i]:
if x == prev: continue
people += dfs(x, i)
self.ans += (int(ceil(people / seats)) if i else 0)
return people
dfs(0, 0)
return self.ans
|
minimum-fuel-cost-to-report-to-the-capital
|
My Python solution
|
Chiki1601
| 0 | 5 |
minimum fuel cost to report to the capital
| 2,477 | 0.53 |
Medium
| 33,990 |
https://leetcode.com/problems/minimum-fuel-cost-to-report-to-the-capital/discuss/2834288/Python3-post-order-dfs
|
class Solution:
def minimumFuelCost(self, roads: List[List[int]], seats: int) -> int:
graph = [[] for _ in range(len(roads)+1)]
for u, v in roads:
graph[u].append(v)
graph[v].append(u)
ans = 0
def dfs(u, p):
"""Return number of people going through city u."""
nonlocal ans
ppl = 0
for v in graph[u]:
if v != p: ppl += dfs(v, u)
ppl += 1
if u: ans += (ppl + seats - 1) // seats
return ppl
dfs(0, -1)
return ans
|
minimum-fuel-cost-to-report-to-the-capital
|
[Python3] post-order dfs
|
ye15
| 0 | 12 |
minimum fuel cost to report to the capital
| 2,477 | 0.53 |
Medium
| 33,991 |
https://leetcode.com/problems/minimum-fuel-cost-to-report-to-the-capital/discuss/2832330/Naive-BFS-(bottom-up)-with-degree
|
class Solution:
def minimumFuelCost(self, roads: List[List[int]], seats: int) -> int:
import collections
node = collections.defaultdict(list)
n = len(roads)+1
degree = [0] * n
people = [1] * n
for i, j in roads:
degree[i] +=1
degree[j] +=1
node[i].append(j)
node[j].append(i)
ans = 0
dq = collections.deque([i for i, d in enumerate(degree) if d == 1 and i > 0])
while dq:
i = dq.popleft()
degree[i] = 0
for n in node[i]:
if degree[n] > 0:
ans += ceil(people[i]/seats)
people[n] += people[i]
degree[n] -= 1
if degree[n] == 1 and n > 0:
dq.append(n)
return ans
|
minimum-fuel-cost-to-report-to-the-capital
|
Naive BFS (bottom up) with degree
|
her0e1c1
| 0 | 19 |
minimum fuel cost to report to the capital
| 2,477 | 0.53 |
Medium
| 33,992 |
https://leetcode.com/problems/minimum-fuel-cost-to-report-to-the-capital/discuss/2831941/Easiest-Python-Solution
|
class Solution:
def minimumFuelCost(self, roads: List[List[int]], seats: int) -> int:
n = len(roads)
op =[0]
graph = defaultdict(list)
for i,j in roads:
graph[i].append(j)
graph[j].append(i)
vis=[0 for _ in range(n+1)]
def dfs(root,pr):
vis[root]=1
for nei in graph[root]:
if nei!=pr:
dfs(nei,root)
op[0]+=(vis[nei]+seats-1)//seats
vis[root]+=vis[nei]
dfs(0,-1)
return op[0]
|
minimum-fuel-cost-to-report-to-the-capital
|
Easiest Python Solution
|
prateekgoel7248
| 0 | 49 |
minimum fuel cost to report to the capital
| 2,477 | 0.53 |
Medium
| 33,993 |
https://leetcode.com/problems/minimum-fuel-cost-to-report-to-the-capital/discuss/2831886/DFS-divide-and-merge-sub-problems-O(n)
|
class Solution:
def minimumFuelCost(self, roads: List[List[int]], seats: int) -> int:
g = defaultdict(list)
for u, v in roads:
g[u].append(v)
g[v].append(u)
# print(f"g {g}")
def dp(u, pre):
liters = 0
people = 0
if u > 0:
people = 1
for v in g[u]:
if v == pre:
continue
lc, pc = dp(v, u)
liters += lc
people += pc
if u == 0:
return liters, people
cars = people//seats
if people % seats > 0:
cars += 1
liters += cars
# print(f"u {u} people {people} liters {liters}")
return liters, people
liters, people = dp(0, None)
return liters
|
minimum-fuel-cost-to-report-to-the-capital
|
DFS, divide and merge sub problems, O(n)
|
goodgoodwish
| 0 | 8 |
minimum fuel cost to report to the capital
| 2,477 | 0.53 |
Medium
| 33,994 |
https://leetcode.com/problems/minimum-fuel-cost-to-report-to-the-capital/discuss/2831710/Python-or-Topological-Sort
|
class Solution:
def minimumFuelCost(self, roads: List[List[int]], seats: int) -> int:
n = len(roads) + 1
deg = [0] * n
reps = [1] * n
g = defaultdict(list)
for u, v in roads:
g[u].append(v)
g[v].append(u)
deg[u] += 1
deg[v] += 1
ones = []
for i in range(n):
if deg[i] == 1:
ones.append(i)
ans = 0
while ones:
nxt = []
for u in ones:
if u == 0:
continue
r, reps[u] = reps[u], 0
for v in g[u]:
if reps[v] == 0:
continue
deg[v] -= 1
ans += (r + seats - 1) // seats
reps[v] += r
if deg[v] == 1:
nxt.append(v)
ones = nxt
return ans
|
minimum-fuel-cost-to-report-to-the-capital
|
Python | Topological Sort
|
bachelorwang
| 0 | 55 |
minimum fuel cost to report to the capital
| 2,477 | 0.53 |
Medium
| 33,995 |
https://leetcode.com/problems/minimum-fuel-cost-to-report-to-the-capital/discuss/2831694/Python3-BFS-Graph
|
class Solution:
def minimumFuelCost(self, roads: List[List[int]], seats: int) -> int:
d = defaultdict(list)
q = deque([])
c = Counter()
c_acc = Counter()
for x, y in roads:
d[x].append(y)
d[y].append(x)
c[x] += 1
c[y] += 1
for k, v in c.items():
if v == 1 and k!=0:
q.append(k)
c_acc[k] += 1
res = 0
while q:
node = q.popleft()
p = c_acc[node]
res += ceil(p/seats)
for nei in d[node]:
c_acc[nei] += p
c[nei] -= 1
if c[nei] == 1 and nei != 0:
c_acc[nei] += 1
q.append(nei)
return res
|
minimum-fuel-cost-to-report-to-the-capital
|
Python3, BFS, Graph
|
mike840609
| 0 | 74 |
minimum fuel cost to report to the capital
| 2,477 | 0.53 |
Medium
| 33,996 |
https://leetcode.com/problems/number-of-beautiful-partitions/discuss/2833244/Python-Top-down-DP-Clean-and-Concise-O(N-*-K)
|
class Solution:
def beautifulPartitions(self, s: str, k: int, minLength: int) -> int:
n = len(s)
MOD = 10**9 + 7
def isPrime(c):
return c in ['2', '3', '5', '7']
@lru_cache(None)
def dp(i, k):
if k == 0 and i <= n:
return 1
if i >= n:
return 0
ans = dp(i+1, k) # Skip
if isPrime(s[i]) and not isPrime(s[i-1]): # Split
ans += dp(i+minLength, k-1)
return ans % MOD
if not isPrime(s[0]) or isPrime(s[-1]): return 0
return dp(minLength, k-1)
|
number-of-beautiful-partitions
|
[Python] Top down DP - Clean & Concise - O(N * K)
|
hiepit
| 21 | 382 |
number of beautiful partitions
| 2,478 | 0.294 |
Hard
| 33,997 |
https://leetcode.com/problems/number-of-beautiful-partitions/discuss/2831907/Python-simple-DP-with-optimization
|
class Solution:
def beautifulPartitions(self, s: str, k: int, minLength: int) -> int:
n = len(s)
primes = ['2', '3', '5', '7']
# pruning
if k * minLength > n or s[0] not in primes or s[-1] in primes:
return 0
# posible starting indexes of a new partition
ids = [0]
for i in range(n-1):
if s[i] not in primes and s[i+1] in primes:
ids.append(i+1)
m = len(ids)
@cache
# dp(i, kk) means number of ways to partition s[ids[i]:n] into kk partitions
def dp(i, kk):
# kk==1: last remaining partition, needs to have length >= l
if kk == 1:
return 1 if ids[i]+minLength-1 <= n-1 else 0
res = 0
# iterate possible starting index of next partition
for j in range(i+1, m-kk+2):
if ids[j]-ids[i] >= minLength:
res += dp(j, kk-1)
return res % (10**9+7)
return dp(0, k)
|
number-of-beautiful-partitions
|
Python simple DP with optimization
|
zsk99881
| 7 | 353 |
number of beautiful partitions
| 2,478 | 0.294 |
Hard
| 33,998 |
https://leetcode.com/problems/number-of-beautiful-partitions/discuss/2832142/Python3-Solution-or-DP-or-100-Faster-or-Clean-and-Concise
|
class Solution:
def beautifulPartitions(self, S, K, M):
N = len(S)
P = '2357'
help = lambda a, b: a not in P and b in P
if not help(S[-1], S[0]) or K * M > N: return 0
dp = [1] * (N - M)
mod = 10 ** 9 + 7
for j in range(1, K):
dp2 = [0] * (N - M)
for i in range(j * M - 1, N - M):
dp2[i] = (dp2[i - 1] + dp[i - M] * int(help(S[i], S[i + 1]))) % mod
dp = dp2
return dp[-1]
|
number-of-beautiful-partitions
|
✔ Python3 Solution | DP | 100% Faster | Clean & Concise
|
satyam2001
| 1 | 89 |
number of beautiful partitions
| 2,478 | 0.294 |
Hard
| 33,999 |
Subsets and Splits
Top 2 Solutions by Upvotes
Identifies the top 2 highest upvoted Python solutions for each problem, providing insight into popular approaches.