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/course-schedule/discuss/2795313/Python-Solution-Beats-97-Solutions | class Solution:
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
graph = [[] for _ in range(numCourses)]
indegree = [0 for _ in range(numCourses)]
for edge in prerequisites:
graph[edge[0]].append(edge[1])
indegree[edge[1]] += 1
que... | course-schedule | Python Solution Beats 97% Solutions | manishchhipa | 0 | 7 | course schedule | 207 | 0.454 | Medium | 3,500 |
https://leetcode.com/problems/course-schedule/discuss/2784880/Simple-Python-Solution | class Solution:
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
# cycle detection problem
preMap = { i:[] for i in range(numCourses) }
for crs, pre in prerequisites:
preMap[crs].append(pre)
# visitSet = all courses along the curr DFS path (c... | course-schedule | Simple Python Solution | ekomboy012 | 0 | 4 | course schedule | 207 | 0.454 | Medium | 3,501 |
https://leetcode.com/problems/course-schedule/discuss/2774671/Topological-easy-to-understand | class Solution:
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
graph = collections.defaultdict(list)
indegree = [0] * numCourses
topologicalSort = []
# Build graph and calculate indegree
for course,prerec in prerequisites:
g... | course-schedule | Topological easy to understand | Sarthaksin1857 | 0 | 4 | course schedule | 207 | 0.454 | Medium | 3,502 |
https://leetcode.com/problems/course-schedule/discuss/2769438/Topological-Sorting-easily-written-in-python | class Solution:
# topological sorting in python
def canFinish(self, n: int, pre: List[List[int]]) -> bool:
graph = defaultdict(list)
indegree = defaultdict(int)
for a, b in pre:
graph[a].append(b)
graph[b].append(a)
indegree[a] += 1
q = deque()... | course-schedule | Topological Sorting easily written in python | shiv-codes | 0 | 13 | course schedule | 207 | 0.454 | Medium | 3,503 |
https://leetcode.com/problems/course-schedule/discuss/2761106/Simple-Beginner-Friendly-Approach-or-DFS-or-O(V%2BE) | class Solution:
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
self.graph = defaultdict(list)
for pre in prerequisites:
self.graph[pre[0]].append(pre[1])
self.visited = set()
self.path = set()
self.order = []
for course in ra... | course-schedule | Simple Beginner Friendly Approach | DFS | O(V+E) | sonnylaskar | 0 | 8 | course schedule | 207 | 0.454 | Medium | 3,504 |
https://leetcode.com/problems/course-schedule/discuss/2760799/simple-detect-DAG-using-DFS-striver-solution | class Solution:
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
dic=defaultdict(list)
for a,b in prerequisites:
dic[a]+=[b]
vis=[0]*(numCourses)
dfsvis=[0]*numCourses
def dfs(node):
vis[node]=1
dfsvis[node]=1... | course-schedule | simple detect DAG using DFS , striver solution | aryan3012 | 0 | 14 | course schedule | 207 | 0.454 | Medium | 3,505 |
https://leetcode.com/problems/course-schedule/discuss/2752083/Python3-or-Two-Approach-or-TopoSort-or-Cycle-Detection | class Solution:
def canFinish(self, numCourses: int, pre: List[List[int]]) -> bool:
def TopoSort(graph,indegree):
ans=[]
stack=[course for course in range(numCourses) if indegree[course]==0]
while stack:
currCourse=stack.pop()
ans.append(cu... | course-schedule | [Python3] | Two Approach | TopoSort | Cycle Detection | swapnilsingh421 | 0 | 7 | course schedule | 207 | 0.454 | Medium | 3,506 |
https://leetcode.com/problems/course-schedule/discuss/2752083/Python3-or-Two-Approach-or-TopoSort-or-Cycle-Detection | class Solution:
def canFinish(self, numCourses: int, pre: List[List[int]]) -> bool:
graph=[[] for i in range(numCourses)]
vis=set()
temp_vis=set()
def dfs(course):
for it in graph[course]:
if it in temp_vis:
return True
... | course-schedule | [Python3] | Two Approach | TopoSort | Cycle Detection | swapnilsingh421 | 0 | 7 | course schedule | 207 | 0.454 | Medium | 3,507 |
https://leetcode.com/problems/course-schedule/discuss/2739412/Python-dfs-solution | class Solution:
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
adjMap = collections.defaultdict(list)
for course, pre in prerequisites:
adjMap[course].append(pre)
visited = set()
def dfs(crs):
if crs in visited:
... | course-schedule | Python dfs solution | gcheng81 | 0 | 20 | course schedule | 207 | 0.454 | Medium | 3,508 |
https://leetcode.com/problems/course-schedule/discuss/2739343/Python-Simple-Cycle-Detection-Method | class Solution:
def buildGraph(self, numCourses, prerequisites):
self.graph = [[] for _ in range(numCourses)]
for course, prerequisite in prerequisites:
self.graph[prerequisite].append(course)
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
if n... | course-schedule | Python Simple Cycle Detection Method | Rui_Liu_Rachel | 0 | 16 | course schedule | 207 | 0.454 | Medium | 3,509 |
https://leetcode.com/problems/course-schedule/discuss/2735127/simple-pythonor-DFS | class Solution:
def traversed(self, now_point):
#print(self.onpath, self.flag, now_point)
if self.onpath[now_point]:
self.flag = True
return
if self.visited[now_point] or self.flag:
return
self.visited[now_point] = True
self.onpath[now_po... | course-schedule | simple python| DFS | lucy_sea | 0 | 1 | course schedule | 207 | 0.454 | Medium | 3,510 |
https://leetcode.com/problems/course-schedule/discuss/2733375/Python-DFS | class Solution:
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
graph = defaultdict(list)
seen = set()
for next_course, prev_course in prerequisites:
graph[prev_course].append(next_course)
def detectCycle(node, path):
... | course-schedule | Python DFS | alexdomoryonok | 0 | 6 | course schedule | 207 | 0.454 | Medium | 3,511 |
https://leetcode.com/problems/course-schedule/discuss/2718675/DFS-coloring-python3-solution | class Solution:
# O(V + E) time,
# O(V + E) space,
# Approach: dfs coloring, topological sort
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
graph = defaultdict(list)
for course, required in prerequisites:
graph[required].appen... | course-schedule | DFS coloring python3 solution | destifo | 0 | 4 | course schedule | 207 | 0.454 | Medium | 3,512 |
https://leetcode.com/problems/course-schedule/discuss/2710789/PYTHON-SOLUTION | class Solution:
def canFinish(self, num: int, pre: List[List[int]]) -> bool:
graph=defaultdict(list)
indegree=[0]*num
for u,v in pre:
indegree[v]+=1
graph[u].append(v)
queue=deque()
for v in range(num):
if indegree[v]==0:
qu... | course-schedule | PYTHON SOLUTION | shashank_2000 | 0 | 20 | course schedule | 207 | 0.454 | Medium | 3,513 |
https://leetcode.com/problems/course-schedule/discuss/2661459/Python3-Topological-Sort | class Solution:
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
# topological sort
# must take course b before taking course a
in_degrees = {key: [] for key in range(numCourses)}
out_degrees = {key: [] for key in range(numCourses)}
top_sort = []
... | course-schedule | Python3, Topological Sort | jzhao49 | 0 | 5 | course schedule | 207 | 0.454 | Medium | 3,514 |
https://leetcode.com/problems/course-schedule/discuss/2655428/BFS-(Kahns-Algorithm)-Python | class Solution:
def getCounts(self, graph):
counts = {node: 0 for node in graph}
for parent in graph:
for child in graph[parent]:
counts[child] += 1
return counts
def topoSort(self, numCourses,graph):
q = deque()
counts = self.getCounts(graph)... | course-schedule | BFS (Kahns Algorithm) - Python | user3734a | 0 | 5 | course schedule | 207 | 0.454 | Medium | 3,515 |
https://leetcode.com/problems/course-schedule/discuss/2374271/Python-runtime-28.97-memory-63.14 | class Solution:
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
d = {}
for i in range(numCourses):
d[i] = []
for pre in prerequisites:
d[pre[1]].append(pre[0])
for num in range(numCourses):
if not self.check(num, set()... | course-schedule | Python, runtime 28.97%, memory 63.14% | tsai00150 | 0 | 63 | course schedule | 207 | 0.454 | Medium | 3,516 |
https://leetcode.com/problems/course-schedule/discuss/2343372/Python-topological-sort | class Solution:
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
# { course : List[classes with course as prereq] }
prerequisites_map = defaultdict(list)
# number of prerequisites each course has
indegrees = defaultdict(int)
# Fill in val... | course-schedule | Python topological sort | chromium-52 | 0 | 75 | course schedule | 207 | 0.454 | Medium | 3,517 |
https://leetcode.com/problems/course-schedule/discuss/2329370/Python3-or-Topological-Sorting-using-Kahn's-Algorithm-BFS | class Solution:
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
#First, we will process each and every prerequisite to get a sense of each course
#node's indegree and map out an adjacency list representation of the directed
#graph in a 2d array!
#list co... | course-schedule | Python3 | Topological Sorting using Kahn's Algorithm BFS | JOON1234 | 0 | 41 | course schedule | 207 | 0.454 | Medium | 3,518 |
https://leetcode.com/problems/course-schedule/discuss/2329095/Python3-or-Need-Help-Figuring-Key-Error-for-TopSort-Approach | class Solution:
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
#First, we will process each and every prerequisite to get a sense of each course
#node's indegree and map out an adjacency list representation of the directed
#graph!
indegrees = [... | course-schedule | Python3 | Need Help Figuring Key Error for TopSort Approach | JOON1234 | 0 | 4 | course schedule | 207 | 0.454 | Medium | 3,519 |
https://leetcode.com/problems/course-schedule/discuss/2297675/Python-BFS-Topological-Sort | class Solution:
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
graph = defaultdict(list)
deg = defaultdict(int)
for course, pre in prerequisites:
graph[pre].append(course)
deg[course] += 1
queue = deque... | course-schedule | Python BFS Topological Sort | willager | 0 | 44 | course schedule | 207 | 0.454 | Medium | 3,520 |
https://leetcode.com/problems/course-schedule/discuss/2274217/Clear-Python-solution-using-directed-graph-and-DFS-traversal | class Solution:
hasCycle = False
onPaths = []
visited = []
def __init(self):
self.hasCycle = hasCycle
self.onPaths = onPaths
self.visited = visited
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
# check if there exists a mutual dep... | course-schedule | Clear Python solution using directed graph and DFS traversal | leqinancy | 0 | 32 | course schedule | 207 | 0.454 | Medium | 3,521 |
https://leetcode.com/problems/course-schedule/discuss/2272158/Python3-Simple-Solution-or-Iteration | class Solution:
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
if len(prerequisites) == 0 : return True
primary, secondary = [], []
for x in prerequisites :
primary.append(x[1])
secondary.append(x[0])
... | course-schedule | Python3 Simple Solution | Iteration | jasoriasaksham01 | 0 | 69 | course schedule | 207 | 0.454 | Medium | 3,522 |
https://leetcode.com/problems/course-schedule/discuss/2184476/Based-on-Cycle-Detection-in-a-directed-graph-oror-DFS | class Solution:
def dfs(self, i, graph, color):
color[i] = "GRAY"
for neighbour in graph[i]:
if color[neighbour] == "GRAY":
return True
elif color[neighbour] == "WHITE" and self.dfs(neighbour, graph, color):
return True
... | course-schedule | Based on Cycle Detection in a directed graph || DFS | Vaibhav7860 | 0 | 73 | course schedule | 207 | 0.454 | Medium | 3,523 |
https://leetcode.com/problems/course-schedule/discuss/2153401/207.-Java-and-Python-solution-with-My-comments | class Solution:
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
# idea: topological sort to find if there is a cycle in graph, dfs
# if cycle exsits, then it is not possible to finish courses.
# save a graph by using matrix/array
graph = [[] for... | course-schedule | 207. Java & Python solution with My comments | JunyiLin | 0 | 54 | course schedule | 207 | 0.454 | Medium | 3,524 |
https://leetcode.com/problems/course-schedule/discuss/2056354/Python3-or-Topo-Sort-or-Easy-Understand | class Solution:
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
def count_parents(graph):
counts = {node: 0 for node in graph}
for parent in graph:
for node in graph[parent]:
counts[node] += 1
return count... | course-schedule | Python3 | Topo Sort | Easy Understand | itachieve | 0 | 83 | course schedule | 207 | 0.454 | Medium | 3,525 |
https://leetcode.com/problems/course-schedule/discuss/2009740/Clean-Python-3-Solution-(Topological-Sorting-%2B-BFS) | class Solution:
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
in_degrees = [0] * numCourses
for v, _ in prerequisites:
in_degrees[v] += 1
q = []
for i in range(len(in_degrees)):
if in_degrees[i] == 0:
q.append(i... | course-schedule | Clean Python 3 Solution (Topological Sorting + BFS) | Hongbo-Miao | 0 | 176 | course schedule | 207 | 0.454 | Medium | 3,526 |
https://leetcode.com/problems/course-schedule/discuss/1999693/Easy-Python3-cycle-detection-with-recursive-DFS-(clear-comments) | class Solution:
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
#The prerequisites can be represented as a directed graph, thus
#let's do a dfs to detect a dependency cycle
#course -> [prereqs]
graph = {}
#Prepare graph of cours... | course-schedule | Easy Python3 cycle detection with recursive DFS (clear comments) | Zikker | 0 | 43 | course schedule | 207 | 0.454 | Medium | 3,527 |
https://leetcode.com/problems/course-schedule/discuss/1970724/Python-BFS-topological-sort | class Solution:
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
children = defaultdict(list)
count_parents = defaultdict(int)
nodes = set()
for child, parent in prerequisites:
children[parent].append(child)
count_parents[child] +=... | course-schedule | Python, BFS topological sort | blue_sky5 | 0 | 103 | course schedule | 207 | 0.454 | Medium | 3,528 |
https://leetcode.com/problems/course-schedule/discuss/1970682/Python-DFS-cycle-detection | class Solution:
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
STATUS_VISITING = 0
STATUS_VISITED = 1
def no_cycle(node):
if node in status:
if status[node] == STATUS_VISITED:
return True
... | course-schedule | Python, DFS cycle detection | blue_sky5 | 0 | 75 | course schedule | 207 | 0.454 | Medium | 3,529 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/1774062/Python-Explanation-of-sliding-window-using-comments | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
left = 0 # keep track of left pointer
rsum = 0 # keep the running sum
res = None # Answer we will return
# Iterate through the array, the index will be your right pointer
for righ... | minimum-size-subarray-sum | Python - Explanation of sliding window using comments | iamricks | 8 | 376 | minimum size subarray sum | 209 | 0.445 | Medium | 3,530 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/2348029/Python-Easy-sliding-window-with-explanation | class Solution:
def minSubArrayLen(self, target, nums):
# Init left pointer and answer
l, ans = 0, len(nums) + 1
# Init sum of subarray
s = 0
# Iterate through all numbers as right subarray
for r in range(len(nums)):
# Add right number to sum
s += nums[r]
# Check fo... | minimum-size-subarray-sum | [Python] Easy sliding window with explanation | drblessing | 6 | 301 | minimum size subarray sum | 209 | 0.445 | Medium | 3,531 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/862364/O(N*LOG(N))-SOLUTION-EXPLAINED-PYTHON | class Solution:
def minSubArrayLen(self, s: int, nums: List[int]) -> int:
"""
O(N*LOG(N)) Solution using prefix-sum array
Since, we know all of the elements are positive, we can
generate a prefix-sum array for the given nums array,
which will be guaranteed to be in ... | minimum-size-subarray-sum | O(N*LOG(N)) SOLUTION EXPLAINED PYTHON | nyc_coder | 3 | 130 | minimum size subarray sum | 209 | 0.445 | Medium | 3,532 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/2802486/Python-oror-Easy-ororSliding-Window | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
n=len(nums)
i=j=0
s=nums[0]
m=9999999
while j<n and i<=j:
if s>=target:
m=min(m,j-i+1)
s-=nums[i]
i+=1
else:
... | minimum-size-subarray-sum | Python || Easy ||Sliding Window | DareDevil_007 | 2 | 116 | minimum size subarray sum | 209 | 0.445 | Medium | 3,533 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/2564106/Python-or-Two-Pointers-w-comments | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
l = 0
curSum = 0
minLen = float('inf')
for r in range(len(nums)):
# add to curSum
curSum += nums[r]
while curSum >= target and l <= r:
# update minlen
minLen = min(minLen, (r - l)+1)
# minlen ever hits 1, jus... | minimum-size-subarray-sum | Python | Two Pointers w/ comments | Mark5013 | 1 | 120 | minimum size subarray sum | 209 | 0.445 | Medium | 3,534 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/2398279/Binary-Search-%2B-Sliding-Window | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
low, high = 1, len(nums) + 1
while (low < high):
mid = (low + high)//2
if self.slidingWin(target, nums, mid):
high = mid
else:
... | minimum-size-subarray-sum | Binary Search + Sliding Window | logeshsrinivasans | 1 | 178 | minimum size subarray sum | 209 | 0.445 | Medium | 3,535 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/1620080/Python-oror-Easy-Solution-oror-O(n)-and-O(1) | class Solution:
def minSubArrayLen(self, t: int, lst: List[int]) -> int:
i, j = 0, 0
count = 0
maxi = 10 ** 5
while j < len(lst):
count += lst[j]
if count == t:
if maxi > (j - i + 1):
maxi = (j - i + 1)
count -= lst[i]
i += 1
j += 1
elif count > t:
if maxi > (j - i + 1):
... | minimum-size-subarray-sum | Python || Easy Solution || O(n) and O(1) | naveenrathore | 1 | 224 | minimum size subarray sum | 209 | 0.445 | Medium | 3,536 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/1378327/Python-O(N)-2-solutions | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
left = 0
mx = float('inf')
N = len(nums)
currentSum = 0
for right in range(N):
currentSum += nums[right]
while currentSum >= target:
mx = min(mx, right - lef... | minimum-size-subarray-sum | [Python] O(N) 2 solutions | ShSaktagan | 1 | 180 | minimum size subarray sum | 209 | 0.445 | Medium | 3,537 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/1378327/Python-O(N)-2-solutions | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
left = right = 0
mx = float('inf')
N = len(nums)
currentSum = 0
while left < N or right < N:
if currentSum >= target:
mx = min(mx, right - left)
if currentSu... | minimum-size-subarray-sum | [Python] O(N) 2 solutions | ShSaktagan | 1 | 180 | minimum size subarray sum | 209 | 0.445 | Medium | 3,538 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/1227341/Sliding-Window-of-Python3 | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
length = len(nums)
if length == 0:
return 0
left, total, ans = 0, 0, float('inf')
for i in range(length):
total += nums[i]
while total >= ... | minimum-size-subarray-sum | Sliding Window of Python3 | faris-shi | 1 | 59 | minimum size subarray sum | 209 | 0.445 | Medium | 3,539 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/2842053/BEATS-99-SUBMISSIONS-oror-FASTEST-AND-EASIEST-oror-SLIDING-WINDOW | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
l,total=0,0
res=float("inf")
for r in range(len(nums)):
total += nums[r]
while total >=target:
res =min((r-l +1),res)
total -=nums[l]
l +=1
... | minimum-size-subarray-sum | BEATS 99% SUBMISSIONS || FASTEST AND EASIEST || SLIDING WINDOW | Pritz10 | 0 | 2 | minimum size subarray sum | 209 | 0.445 | Medium | 3,540 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/2838746/Python-O(n)-solution-Accepted | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
left: int = 0
curr_sum: int = 0
min_len = len(nums)
for i in range(len(nums)):
curr_sum += nums[i]
while curr_sum >= target:
min_len = min(min_len, i - left + 1)
... | minimum-size-subarray-sum | Python O(n) solution [Accepted] | lllchak | 0 | 3 | minimum size subarray sum | 209 | 0.445 | Medium | 3,541 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/2838377/Python-Solution-Clear | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
ans=float('inf')
left=0
summ=0
for i in range(len(nums)):
summ+=nums[i]
while summ>=target:
ans=min(ans,i+1-left)
summ-=nums[left]
le... | minimum-size-subarray-sum | Python Solution - Clear | jainsiddharth99 | 0 | 2 | minimum size subarray sum | 209 | 0.445 | Medium | 3,542 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/2809775/Python-Solution-with-sliding-window | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
res = float("inf")
total = 0
l,r = 0,-1
while r<len(nums):
if total<target:
r+=1
if r>=len(nums): break
total += nums[r]
else:
... | minimum-size-subarray-sum | [Python] Solution with sliding window | kevin-shu | 0 | 4 | minimum size subarray sum | 209 | 0.445 | Medium | 3,543 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/2802193/Minimum-size-subarray-sum | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
if target in nums:
return 1
res=1e9
s=0;left=0
for right,val in enumerate(nums):
s+=val
while s>=target:
res=min(res,right-left+1)
s-=num... | minimum-size-subarray-sum | Minimum size subarray sum | hemanth_12 | 0 | 3 | minimum size subarray sum | 209 | 0.445 | Medium | 3,544 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/2796577/Easy-Python-Solution-using-Sliding-Window-Approach | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
min_length = float('inf')
num_sum = 0
left = 0
for right, _ in enumerate(nums):
num_sum += nums[right]
while num_sum >= target:
min_length = min(min_length, right... | minimum-size-subarray-sum | Easy Python Solution using Sliding Window Approach | nadirahcodes | 0 | 2 | minimum size subarray sum | 209 | 0.445 | Medium | 3,545 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/2794176/Clean-Python-Sliding-Window-solution | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
minLen = 100001
start = 0
end = 0
s = 0
while end < len(nums):
s += nums[end]
while s >= target:
minLen = min(minLen, end - start + 1)
... | minimum-size-subarray-sum | Clean Python Sliding Window solution | disturbedbrown1 | 0 | 1 | minimum size subarray sum | 209 | 0.445 | Medium | 3,546 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/2791236/sliding-window-and-Time-complexity%3AO(n) | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
minimum=math.inf
start,end,summ=0,0,0
while end<len(nums):
summ=summ+nums[end]
end=end+1
while summ>=target and end>start:
summ=summ-nums[start]
... | minimum-size-subarray-sum | sliding window & Time complexity:O(n) | ManojDluffy | 0 | 3 | minimum size subarray sum | 209 | 0.445 | Medium | 3,547 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/2783718/Sliding-Window-O(N)-solution | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
start, end , cur_max = 0, 0 , math.inf
if len(nums) == 0 : return 0
running_sum = 0
while start <= end and end < len(nums):
if running_sum + nums[end] >= target:
cur_max = min(c... | minimum-size-subarray-sum | Sliding Window O(N) solution | ishitakumardps | 0 | 3 | minimum size subarray sum | 209 | 0.445 | Medium | 3,548 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/2697615/Python-solution | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
ans = float('inf')
sums = 0
length = len(nums)
left = 0
for right in range(length):
sums += nums[right]
while sums >= target and right >= left:
... | minimum-size-subarray-sum | Python solution | maomao1010 | 0 | 6 | minimum size subarray sum | 209 | 0.445 | Medium | 3,549 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/2692034/Python-O(N)-O(1) | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
l = r = curr = 0
res = sys.maxsize
for r in range(len(nums)):
curr += nums[r]
while curr >= target and l <= r:
res = min(res, r - l + 1)
curr -= nums[l]
... | minimum-size-subarray-sum | Python - O(N), O(1) | Teecha13 | 0 | 10 | minimum size subarray sum | 209 | 0.445 | Medium | 3,550 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/2662977/slidding-Window-technique-python | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
l, total = 0, 0
res = float("inf")
for r in range(len(nums)):
total += nums[r]
while total >= target:
res = min(r - l + 1, res)
total -= nums[l]
... | minimum-size-subarray-sum | slidding Window technique python | sahilkumar158 | 0 | 2 | minimum size subarray sum | 209 | 0.445 | Medium | 3,551 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/2552734/Python-Solution-or-Beats-97 | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
i=0
s=0
n=len(nums)
mini=1e9
for j in range(n):
s+=nums[j]
while s>=target:
mini=min(mini, j-i+1)
s-=nums[i]
i+=1
if ... | minimum-size-subarray-sum | Python Solution | Beats 97% | Siddharth_singh | 0 | 82 | minimum size subarray sum | 209 | 0.445 | Medium | 3,552 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/2504239/fast-or-easy-python-code | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
n=len(nums)
if n==0:
return 0
i=0
j=0
minlen=n
currsum=0
valid=False
while j<n:
currsum+=nums[j]
j+=1
while currsum>=target:
... | minimum-size-subarray-sum | fast | easy python code | ayushigupta2409 | 0 | 40 | minimum size subarray sum | 209 | 0.445 | Medium | 3,553 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/2407765/Min-Size-Subarray-Sum-or-Python-or-Sliding-Window-or-Time-Complexity%3A-O(n) | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
minimum = float("inf")
window_sum, window_start = 0,0
for window_end in range(len(nums)):
window_sum += nums[window_end]
while window_sum >= target:
#... | minimum-size-subarray-sum | Min Size Subarray Sum | Python | Sliding Window | Time Complexity: O(n) | obaissa | 0 | 56 | minimum size subarray sum | 209 | 0.445 | Medium | 3,554 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/2406225/Sliding-Window-and-Two-Pointer | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
if nums[0]>=target:
return 1
summ=nums[0]
left=0
l=float('inf')
for right in range(1,len(nums)):
if nums[right]>=target:
return 1
summ+=nums[righ... | minimum-size-subarray-sum | Sliding Window and Two Pointer | Neerajbirajdar | 0 | 41 | minimum size subarray sum | 209 | 0.445 | Medium | 3,555 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/2277144/Python-O(n)-easy | class Solution(object):
def minSubArrayLen(self, s, nums):
if sum(nums)< s:
return 0
ans, sum_ = sys.maxsize, 0
i = 0
j = 0
while j<len(nums):
sum_+= nums[j]
if sum_>=s:
while sum_>=s:
ans = min(ans, j-... | minimum-size-subarray-sum | Python O(n) easy | Abhi_009 | 0 | 128 | minimum size subarray sum | 209 | 0.445 | Medium | 3,556 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/2191209/Sliding-Window-Approach | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
i, j, n = 0, 0, len(nums)
s = 0
minLength = float('inf')
while j < n:
s += nums[j]
if s < target:
j += 1
else:
while s >= target:
... | minimum-size-subarray-sum | Sliding Window Approach | Vaibhav7860 | 0 | 85 | minimum size subarray sum | 209 | 0.445 | Medium | 3,557 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/2166807/Python-Sliding-Window-(Thought-Process) | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
# Handle null/empty scenario
if not nums:
return 0
# Define start/end pointers, running counter
start = 0
end = 0
counter = nums[0]
# Since we're compa... | minimum-size-subarray-sum | [Python] Sliding Window (Thought Process) | ernestshackleton | 0 | 145 | minimum size subarray sum | 209 | 0.445 | Medium | 3,558 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/2144806/Python-two-pointers | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
start = 0
end = -1
sum_ = 0
result = math.inf
while end < len(nums):
if sum_ < target:
if end < len(nums) - 1:
sum_ += nums[end + 1]
... | minimum-size-subarray-sum | Python, two pointers | blue_sky5 | 0 | 21 | minimum size subarray sum | 209 | 0.445 | Medium | 3,559 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/2092765/O(n)-Time-Complexity-Python-Solution | class Solution:
def minSubArrayLen(self, target, nums):
res = float("inf")
sumcheck = length = 0
for inx,num in enumerate(nums):
sumcheck,length = sumcheck+num,length+1
if sumcheck >= target:
#while subtracting elements from the left doesn't unsatisfy the constraint
while (val... | minimum-size-subarray-sum | O(n) Time Complexity Python Solution | tomaetotomahto | 0 | 87 | minimum size subarray sum | 209 | 0.445 | Medium | 3,560 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/2080577/Python-or-Easy-Solution-Using-Two-Pointer | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
# ///// TC: O(N) and SC: O(1) ////////
l,total = 0,0
res = float('inf')
for r in range(len(nums)):
total += nums[r]
while total >= target:
res = min(res,(r-l+1))
... | minimum-size-subarray-sum | Python | Easy Solution Using Two Pointer | __Asrar | 0 | 95 | minimum size subarray sum | 209 | 0.445 | Medium | 3,561 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/2065685/Python-3-or-Sliding-Window-or-faster-than-93.43 | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
res = math.inf
l = r = s = 0
while r < len(nums):
s += nums[r]
if s >= target:
while l <= r and s >= target:
s -= nums[l]
... | minimum-size-subarray-sum | Python 3 | Sliding Window | faster than 93.43% | anels | 0 | 27 | minimum size subarray sum | 209 | 0.445 | Medium | 3,562 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/1923041/5-Lines-Python-Solution-oror-99-Faster-oror-Memory-less-than-60 | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
l=0 ; sm=0 ; ans=len(nums)+1
for r in range(len(nums)):
sm+=nums[r]
while sm>=target: ans=min(ans,r-l+1) ; sm-=nums[l] ; l+=1
return 0 if ans>len(nums) else ans | minimum-size-subarray-sum | 5-Lines Python Solution || 99% Faster || Memory less than 60% | Taha-C | 0 | 98 | minimum size subarray sum | 209 | 0.445 | Medium | 3,563 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/1856292/Python-(Simple-Approach-and-Beginner-friendly) | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
total = 0
mini = float('inf')
j = 0
for i in range(len(nums)):
total+=nums[i]
while total >= target:
mini = min(mini, len(nums[j:i+1]))
total-=nums[j... | minimum-size-subarray-sum | Python (Simple Approach and Beginner-friendly) | vishvavariya | 0 | 75 | minimum size subarray sum | 209 | 0.445 | Medium | 3,564 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/1834369/Python-easy-to-read-and-understand-or-sliding-window | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
ans, i, sums = float("inf"), 0, 0
for j in range(len(nums)):
sums += nums[j]
while sums >= target:
ans = min(ans, j-i+1)
sums -= nums[i]
i = i+1
... | minimum-size-subarray-sum | Python easy to read and understand | sliding window | sanial2001 | 0 | 141 | minimum size subarray sum | 209 | 0.445 | Medium | 3,565 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/1801655/Python-Single-Loop-Sliding-Window-11-LoC | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
i, j, runningSum = 0, 0, 0
minLen = sys.maxsize
while j < len(nums):
if runningSum + nums[j] >= target:
minLen = min(minLen, j - i + 1)
runningSum -= nums[i]
... | minimum-size-subarray-sum | Python - Single Loop Sliding Window - 11 LoC | olsonj | 0 | 92 | minimum size subarray sum | 209 | 0.445 | Medium | 3,566 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/1712179/Two-pointers-and-binary-search | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
left = 0
sum_ = 0
count = len(nums)
for right in range(len(nums)):
sum_ += nums[right]
if sum_<target:
continue
while ... | minimum-size-subarray-sum | Two pointers and binary search | michaelniki | 0 | 35 | minimum size subarray sum | 209 | 0.445 | Medium | 3,567 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/1712179/Two-pointers-and-binary-search | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
prefix_sum = [0]
for n in nums:
prefix_sum.append(prefix_sum[-1] + n)
res = inf
for start in range(len(prefix_sum) - 1):
left, right = start, len(prefix_sum) - 1
... | minimum-size-subarray-sum | Two pointers and binary search | michaelniki | 0 | 35 | minimum size subarray sum | 209 | 0.445 | Medium | 3,568 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/1692536/Python-faster-than-99.6-with-only-one-loop | class Solution:
def minSubArrayLen(self, s: int, nums: List[int]) -> int:
i = j = 0
length = len(nums)
lastIndex = length - 1
minimum = length
summ = nums[i]
while (i < length):
if (nums[i] >= s):
return 1
if (j < lastIndex and ... | minimum-size-subarray-sum | Python faster than 99.6%, with only one loop | hikoichihara | 0 | 158 | minimum size subarray sum | 209 | 0.445 | Medium | 3,569 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/1468233/Python3-Sliding-window-solution-O(n) | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
begin, cur_sum = 0, 0
_min = len(nums) + 1
for end in range(len(nums)):
cur_sum += nums[end]
while cur_sum >= target:
_min = min(_min, end - begin + 1)... | minimum-size-subarray-sum | [Python3] Sliding window solution O(n) | maosipov11 | 0 | 37 | minimum size subarray sum | 209 | 0.445 | Medium | 3,570 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/1231620/Detailed-explanation-using-two-pointers-faster-than-99-submission | class Solution:
def minSubArrayLen(self, s: int, nums: List[int]) -> int:
slow = 0
fast = 1
curr_sum = nums[0]
res = len(nums) + 1
n = len(nums)
while fast < n:
if curr_sum >= s:
res = min(res, fast-slow)
curr_sum -= nums[sl... | minimum-size-subarray-sum | Detailed explanation using two pointers, faster than 99% submission | PatrickPro2 | 0 | 58 | minimum size subarray sum | 209 | 0.445 | Medium | 3,571 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/1138542/python-solution-(faster-than-99.5-solutions) | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
start=0
end=0
n=len(nums)
curr_len=n+1
curr=0
while(end<n):
while(curr<target and end<n):
curr+=nums[end]
end+=1
while(curr>=target and start<n):
if end... | minimum-size-subarray-sum | python solution (faster than 99.5% solutions) | samarthnehe | 0 | 236 | minimum size subarray sum | 209 | 0.445 | Medium | 3,572 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/1110558/Python3-solution | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
result: Union[float, int] = float('inf')
left: int = 0
cur_sum: int = 0
for i in range(len(nums)):
cur_sum += nums[i]
while cur_sum >= target:
... | minimum-size-subarray-sum | Python3 solution | alexforcode | 0 | 115 | minimum size subarray sum | 209 | 0.445 | Medium | 3,573 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/1095463/Python-solutions | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
left = summ = 0
res = float('inf')
for i in range(len(nums)):
summ += nums[i]
while(summ >= target):
res = min(res, i+1-left)
summ -= nums[left]
... | minimum-size-subarray-sum | Python solutions | ginaaiusing | 0 | 285 | minimum size subarray sum | 209 | 0.445 | Medium | 3,574 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/978970/Python-faster-than-96 | class Solution:
def minSubArrayLen(self, s: int, nums: List[int]) -> int:
result = float('inf')
left = 0
total = 0
for i in range(len(nums)):
total += nums[i]
while total >= s:
#result = min(result, i+1 - left)
if result > i+1-left:
result... | minimum-size-subarray-sum | Python faster than 96% | Skywalker5423 | 0 | 321 | minimum size subarray sum | 209 | 0.445 | Medium | 3,575 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/862306/TWO-POINTER-SOLUTION-EXPLAINED-PYTHON | class Solution:
def minSubArrayLen(self, s: int, nums: List[int]) -> int:
n = len(nums)
if not n:
return 0
left = right = 0
answer = float('inf')
total = 0
while right < n:
total += nums[right]
if total >= s:
answer ... | minimum-size-subarray-sum | TWO POINTER SOLUTION EXPLAINED PYTHON | nyc_coder | 0 | 43 | minimum size subarray sum | 209 | 0.445 | Medium | 3,576 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/734704/Python3-sliding-window | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
ans = inf
ii = 0
for i, x in enumerate(nums):
target -= x
while ii <= i and target <= 0:
ans = min(ans, i - ii + 1)
target += nums[ii]
ii... | minimum-size-subarray-sum | [Python3] sliding window | ye15 | 0 | 99 | minimum size subarray sum | 209 | 0.445 | Medium | 3,577 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/495388/Python3-O(n)-solution-using-two-pointers | class Solution:
def minSubArrayLen(self, s: int, nums: List[int]) -> int:
if s in nums: return 1
res,n,left_index,sums = float("inf"),len(nums),0,0
for i in range(n):
sums += nums[i]
while s<=sums:
res=min(res,i+1-left_index)
sums -= nu... | minimum-size-subarray-sum | Python3 O(n) solution using two pointers | jb07 | 0 | 94 | minimum size subarray sum | 209 | 0.445 | Medium | 3,578 |
https://leetcode.com/problems/minimum-size-subarray-sum/discuss/1190414/python3-Two-pointers-easy | class Solution:
def minSubArrayLen(self, target: int, nums: List[int]) -> int:
lb = 0
ub = 0
wSum = nums[0]
numLen = len(nums)
ans = []
while lb<numLen:
# print(lb, ub, wSum)
if wSum >= target:
ans.append(ub-lb+1)
... | minimum-size-subarray-sum | python3 Two pointers easy | GC_in | -1 | 230 | minimum size subarray sum | 209 | 0.445 | Medium | 3,579 |
https://leetcode.com/problems/course-schedule-ii/discuss/1327646/Elegant-Python-DFS | class Solution:
def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
# Handle edge case.
if not prerequisites: return [course for course in range(numCourses)]
# 'parents' maps each course to a list of its pre
# -requisites.
parents = ... | course-schedule-ii | Elegant Python DFS | soma28 | 4 | 467 | course schedule ii | 210 | 0.481 | Medium | 3,580 |
https://leetcode.com/problems/course-schedule-ii/discuss/1642387/Python3-ITERATIVE-TOPOSORT-(-_-)-Explained | class Solution:
def findOrder(self, numCourses: int, pr: List[List[int]]) -> List[int]:
# Build adjacency list
adj = defaultdict(list)
for a, b in prerequisites:
adj[b].append(a)
# TopoSort
topo = list()
vis = set()
processed = set()... | course-schedule-ii | ✔️ [Python3] ITERATIVE TOPOSORT (´-_ゝ-`), Explained | artod | 3 | 170 | course schedule ii | 210 | 0.481 | Medium | 3,581 |
https://leetcode.com/problems/course-schedule-ii/discuss/822651/Python3-DFS-and-BFS | class Solution:
def findOrder(self, numCourses: int, prerequisites):
# DFS 用递归
# 先找到 上了某门课以后可以解锁的全后置课，放入dict neighborNode 中
# 再做一个 status dict, 用来记录查找的状态, 默认value 0 代表没访问过
# dfs 更改 status, 0 代表没访问; 1 代表访问中; 2 代表访问过
# 如果递归遇到1，表示已成环，则无法上完所有课，返回 false；否则递归更新上课顺序在 result 里
... | course-schedule-ii | Python3 DFS and BFS | meiyaowen | 2 | 90 | course schedule ii | 210 | 0.481 | Medium | 3,582 |
https://leetcode.com/problems/course-schedule-ii/discuss/822651/Python3-DFS-and-BFS | class Solution:
def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
# BFS 用deque
from collections import deque
q = deque([])
result = deque([])
inDegree = [0]*numCourses
neighborNodes = collections.defaultdict(list)
# 计算... | course-schedule-ii | Python3 DFS and BFS | meiyaowen | 2 | 90 | course schedule ii | 210 | 0.481 | Medium | 3,583 |
https://leetcode.com/problems/course-schedule-ii/discuss/2368808/Python-Easy-Short-Optimal-or-Simple-DFS-or-94-time-percentile | class Solution:
def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
preq = defaultdict(list)
for x in prerequisites:
preq[x[0]] += [x[1]]
order = []
visited = {}
def isCycleDFS(node):
if node in visited:
... | course-schedule-ii | [Python] Easy, Short, Optimal | Simple DFS | 94% time percentile | LongQ | 1 | 42 | course schedule ii | 210 | 0.481 | Medium | 3,584 |
https://leetcode.com/problems/course-schedule-ii/discuss/2314708/Python-Simple-Solution-2-Dicts-%2B-BFS | class Solution:
def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
if numCourses <= 0:
return []
inDegree = {}
adjList = {}
for i in range(numCourses):
inDegree[i] = 0
adjList[i] = []
fo... | course-schedule-ii | Python - Simple Solution - 2 Dicts + BFS | worldofthomas | 1 | 29 | course schedule ii | 210 | 0.481 | Medium | 3,585 |
https://leetcode.com/problems/course-schedule-ii/discuss/1753718/Clean-Python-Topological-Sort-Solution | class Solution:
def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
graph = {i:[] for i in range(numCourses)}
in_degree = {i: 0 for i in range(numCourses)}
for dest, prev in prerequisites:
graph[prev].append(dest)
in_degree[des... | course-schedule-ii | Clean Python Topological Sort Solution | Chingtat27 | 1 | 119 | course schedule ii | 210 | 0.481 | Medium | 3,586 |
https://leetcode.com/problems/course-schedule-ii/discuss/1672343/Python3-BFS-98.2-or-Detailed-Explained-or-Beginner-Friendly | class Solution:
def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
# init DAG: Course pre -> Course
d = defaultdict(list)
# indegree list: there are # courses as pre-requisites for takign Course A
indeg = [0] * numCourses
# c: course; p: pre ... | course-schedule-ii | Python3 BFS 98.2% | Detailed Explained | Beginner Friendly | doneowth | 1 | 70 | course schedule ii | 210 | 0.481 | Medium | 3,587 |
https://leetcode.com/problems/course-schedule-ii/discuss/1643809/Python3-(Beats-95)-Intuitive-%2B-Easy-to-Understand-%2B-Comments-or-BFS | class Solution:
def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
cToP = {c: 0 for c in range(numCourses)} # Maps course to number of prerequisites
pToC = {p: [] for p in range(numCourses)} # Maps prerequisite to list of courses
for c, p in prerequisites:
... | course-schedule-ii | [Python3] (Beats 95%) Intuitive + Easy to Understand + Comments | BFS | PatrickOweijane | 1 | 180 | course schedule ii | 210 | 0.481 | Medium | 3,588 |
https://leetcode.com/problems/course-schedule-ii/discuss/1583778/Python3-or-Faster-%3A-95.06-or-Recursive-Approach | class Solution:
def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
def dfs(node, seen):
if node in seen:
self.cycle = True
else:
if not self.visited[node]:
self.visited[node] = True
seen.add(node)
if node in self.dict_:
for pre_course in self.dict_[... | course-schedule-ii | Python3 | Faster : 95.06 | Recursive Approach | Call-Me-AJ | 1 | 219 | course schedule ii | 210 | 0.481 | Medium | 3,589 |
https://leetcode.com/problems/course-schedule-ii/discuss/824281/Q269-Alien-Dictionary-BFS | class Solution:
def alienOrder(self, words: List[str]) -> str:
# BFS
# https://leetcode-cn.com/problems/alien-dictionary/solution/python3-tuo-bu-pai-xu-by-bbqq-2/
neighborNodes = collections.defaultdict(list)
queue = collections.deque([])
result = collections.deque([])
... | course-schedule-ii | Q269 Alien Dictionary BFS | meiyaowen | 1 | 101 | course schedule ii | 210 | 0.481 | Medium | 3,590 |
https://leetcode.com/problems/course-schedule-ii/discuss/735092/Python3-tri-color-approach | class Solution:
def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
graph = {}
for u, v in prerequisites:
graph.setdefault(v, []).append(u)
def fn(x):
"""Return True if cycle is deteced."""
if visited[x]: return vi... | course-schedule-ii | [Python3] tri-color approach | ye15 | 1 | 183 | course schedule ii | 210 | 0.481 | Medium | 3,591 |
https://leetcode.com/problems/course-schedule-ii/discuss/735092/Python3-tri-color-approach | class Solution:
def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
graph = [[] for _ in range(numCourses)]
indeg = [0] * numCourses
for v, u in prerequisites:
graph[u].append(v)
indeg[v] += 1
ans = []
for i, x in enumer... | course-schedule-ii | [Python3] tri-color approach | ye15 | 1 | 183 | course schedule ii | 210 | 0.481 | Medium | 3,592 |
https://leetcode.com/problems/course-schedule-ii/discuss/342214/Python3-100-DFS-solution-100ms | class Solution:
def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
# create graph
graph = [[] for _ in range(numCourses)]
for pre in prerequisites:
graph[pre[0]].append(pre[1])
ans = []
seen = [0 for _ in range(numCourses... | course-schedule-ii | [Python3] 100% DFS solution 100ms | PrGxw | 1 | 124 | course schedule ii | 210 | 0.481 | Medium | 3,593 |
https://leetcode.com/problems/course-schedule-ii/discuss/2833655/Python3-Beats-75-Double-Dictionaries | class Solution:
def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
needed = {i:set() for i in range(numCourses)}
satisfies = {i:set() for i in range(numCourses)}
for [a, b] in prerequisites:
needed[b].add(a)
satisfies[a].add(b)
... | course-schedule-ii | Python3 Beats 75% Double Dictionaries | godshiva | 0 | 2 | course schedule ii | 210 | 0.481 | Medium | 3,594 |
https://leetcode.com/problems/course-schedule-ii/discuss/2826124/Easy-understand-solution | class Solution:
def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
routes = collections.defaultdict(list)
need = collections.defaultdict(set)
lst = [0] * numCourses
for premise in prerequisites:
lst[premise[0]] += 1
routes[premi... | course-schedule-ii | Easy understand solution | lllymka | 0 | 4 | course schedule ii | 210 | 0.481 | Medium | 3,595 |
https://leetcode.com/problems/course-schedule-ii/discuss/2822539/Python3-Both-BFS-and-DFS-methods | class Solution:
def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:.
self.graph = [[] for _ in range(numCourses)] # Directed graph. index = from. value = to.
self.visited = [False] * numCourses
self.onPath = [False] * numCourses
self.postOrder = []
... | course-schedule-ii | [Python3] Both BFS and DFS methods | Cceline00 | 0 | 6 | course schedule ii | 210 | 0.481 | Medium | 3,596 |
https://leetcode.com/problems/course-schedule-ii/discuss/2822106/cycle-check-with-dos-in-python | class Solution:
def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
if prerequisites == []:
return range(numCourses)
graph = [[] for i in range(numCourses)]
for ls in prerequisites:
graph[ls[1]].append(ls[0])
hasCycle = False
... | course-schedule-ii | cycle check with dos in python | ychhhen | 0 | 3 | course schedule ii | 210 | 0.481 | Medium | 3,597 |
https://leetcode.com/problems/course-schedule-ii/discuss/2819063/Python-solution-or-DFS | class Solution:
def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
prerequisite = defaultdict(list)
ans = []
# 0 : Unchecked, 1: Checking, 2: Completed
Status = [0] * numCourses
for cur, pre in prerequisites:
prerequisite[cur].appen... | course-schedule-ii | Python solution | DFS | maomao1010 | 0 | 5 | course schedule ii | 210 | 0.481 | Medium | 3,598 |
https://leetcode.com/problems/course-schedule-ii/discuss/2819060/Python-or-DAG-or-Topological-Sort | class Solution:
def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
adjlist = [[] for _ in range(numCourses)]
for src, dst in prerequisites:
adjlist[src].append(dst)
visited = [-1]*numCourses
departure = [-1]*numCourses
topsort = [... | course-schedule-ii | Python | DAG | Topological Sort | ajay_gc | 0 | 3 | course schedule ii | 210 | 0.481 | Medium | 3,599 |
Subsets and Splits
Top 2 Solutions by Upvotes
Identifies the top 2 highest upvoted Python solutions for each problem, providing insight into popular approaches.