description stringlengths 171 4k | code stringlengths 94 3.98k | normalized_code stringlengths 57 4.99k |
|---|---|---|
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | mxn = 10**5 + 5
pri = [1] * mxn
for i in range(2, mxn):
if pri[i] == 1:
pri[i] = i
j = 2
while i * j < mxn:
if pri[i * j] == 1:
pri[i * j] = i
j += 1
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
dct = [0] * mxn
res = 0
def root(i):
while i != arr[i]:
i = arr[i]
arr[i] = arr[arr[i]]
return i
def update(i, j):
r1 = root(i)
r2 = root(j)
arr[r1] = r2
size[r2] += size[r1]
for num in A:
dct[pri[num]] += 1
arr = [i for i in range(mxn)]
size = [dct[i] for i in range(mxn)]
for num in A:
ls = []
while num != 1:
ls.append(pri[num])
num = num // pri[num]
if len(ls) == 1:
continue
for i in range(1, len(ls)):
if root(ls[0]) != root(ls[i]):
update(ls[0], ls[i])
return max(size) | ASSIGN VAR BIN_OP BIN_OP NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP LIST NUMBER VAR FOR VAR FUNC_CALL VAR NUMBER VAR IF VAR VAR NUMBER ASSIGN VAR VAR VAR ASSIGN VAR NUMBER WHILE BIN_OP VAR VAR VAR IF VAR BIN_OP VAR VAR NUMBER ASSIGN VAR BIN_OP VAR VAR VAR VAR NUMBER CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER FUNC_DEF WHILE VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR FOR VAR VAR VAR VAR VAR NUMBER ASSIGN VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR VAR FUNC_CALL VAR VAR FOR VAR VAR ASSIGN VAR LIST WHILE VAR NUMBER EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR IF FUNC_CALL VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR IF FUNC_CALL VAR VAR NUMBER FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR NUMBER VAR VAR RETURN FUNC_CALL VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
mp = {}
ans = 0
def find(a):
if a not in mp:
mp[a] = a
if mp[a] != a:
mp[a] = find(mp[a])
return mp[a]
def union(a, b):
pa = find(a)
pb = find(b)
if pa != pb:
mp[pa] = pb
for a in A:
for factor in self.primes_set(a):
union(a, factor)
return collections.Counter([find(a) for a in A]).most_common(1)[0][1]
def primes_set(self, n):
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
return self.primes_set(n // i) | set([i])
return set([n]) | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR DICT ASSIGN VAR NUMBER FUNC_DEF IF VAR VAR ASSIGN VAR VAR VAR IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR ASSIGN VAR VAR VAR FOR VAR VAR FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR RETURN FUNC_CALL FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR NUMBER NUMBER NUMBER VAR FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER RETURN BIN_OP FUNC_CALL VAR BIN_OP VAR VAR FUNC_CALL VAR LIST VAR RETURN FUNC_CALL VAR LIST VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class UnionFind:
def __init__(self, n):
self.reps = [i for i in range(n)]
self.size = [1] * n
def find(self, x):
while self.reps[x] != x:
self.reps[x] = self.reps[self.reps[x]]
x = self.reps[x]
return x
def union(self, x, y):
x_root = self.find(x)
y_root = self.find(y)
if x_root == y_root:
return
self.reps[x_root] = y_root
self.size[y_root] += self.size[x_root]
self.size[x_root] = 0
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
def get_prime_factor(n):
factors = set()
while n % 2 == 0:
n //= 2
factors.add(2)
while n % 3 == 0:
n //= 3
factors.add(3)
for i in range(5, int(sqrt(n)) + 1):
while n % i == 0:
factors.add(i)
n //= i
if n > 1:
factors.add(n)
return factors
factor2idx = collections.defaultdict(list)
for i in range(len(A)):
for factor in get_prime_factor(A[i]):
factor2idx[factor].append(i)
uf = UnionFind(len(A))
for factor, indices in list(factor2idx.items()):
for idx in indices[1:]:
uf.union(indices[0], idx)
return max(uf.size) | CLASS_DEF FUNC_DEF ASSIGN VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FUNC_DEF WHILE VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR RETURN ASSIGN VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR NUMBER CLASS_DEF FUNC_DEF VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR WHILE BIN_OP VAR NUMBER NUMBER VAR NUMBER EXPR FUNC_CALL VAR NUMBER WHILE BIN_OP VAR NUMBER NUMBER VAR NUMBER EXPR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER WHILE BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR RETURN VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FOR VAR VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER VAR RETURN FUNC_CALL VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class UF:
def __init__(self, N):
self.parent = [i for i in range(N)]
self.size = [(1) for i in range(N)]
def find(self, x):
if self.parent[x] == x:
return x
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def union(self, X, Y):
root_x = self.find(X)
root_y = self.find(Y)
if root_x != root_y:
if self.size[root_x] >= self.size[root_y]:
self.parent[root_y] = root_x
self.size[root_x] += self.size[root_y]
else:
self.parent[root_x] = root_y
self.size[root_y] += self.size[root_x]
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
factor_map = {}
uf = UF(len(A))
for index, num in enumerate(A):
for factor in range(2, int(sqrt(num) + 1)):
if num % factor == 0:
if factor_map.get(factor) is None:
factor_map[factor] = index
else:
uf.union(index, factor_map[factor])
j = num // factor
if factor_map.get(j) is None:
factor_map[j] = index
else:
uf.union(index, factor_map[j])
if factor_map.get(num) is None:
factor_map[num] = index
else:
uf.union(index, factor_map[num])
return max(uf.size) | CLASS_DEF FUNC_DEF ASSIGN VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR FUNC_DEF IF VAR VAR VAR RETURN VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR DICT ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FOR VAR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER IF FUNC_CALL VAR VAR NONE ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR IF FUNC_CALL VAR VAR NONE ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR IF FUNC_CALL VAR VAR NONE ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR RETURN FUNC_CALL VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
def find_prime_factors(num):
for i in range(2, int(math.sqrt(num)) + 1):
if num % i == 0:
return find_prime_factors(num // i) | set([i])
return set([num])
def find_root(x):
if root[x] != x:
root[x] = find_root(root[x])
return root[x]
def union(x, y):
root[find_root(x)] = root[find_root(y)]
root = [i for i in range(len(A))]
prime_factor_to_index = defaultdict(list)
for i, num in enumerate(A):
prime_factors = find_prime_factors(num)
for factor in prime_factors:
prime_factor_to_index[factor].append(i)
for indices in list(prime_factor_to_index.values()):
for i in range(1, len(indices)):
union(indices[i - 1], indices[i])
root_count = Counter(find_root(i) for i in range(len(A)))
return max(root_count.values()) | CLASS_DEF FUNC_DEF VAR VAR FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER RETURN BIN_OP FUNC_CALL VAR BIN_OP VAR VAR FUNC_CALL VAR LIST VAR RETURN FUNC_CALL VAR LIST VAR FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR EXPR FUNC_CALL VAR VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR RETURN FUNC_CALL VAR FUNC_CALL VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
def union(x, y):
graph[find(x)] = find(y)
def find(x):
path = []
while graph[x] != x:
path.append(x)
x = graph[x]
for n in path:
graph[n] = x
return x
graph = {}
for i, num in enumerate(A):
if num not in graph:
graph[num] = num
for factor in range(2, int(math.sqrt(num) + 1)):
if num % factor == 0:
for fac in (factor, num // factor):
if fac == 0:
print(num, fac)
if fac in graph:
union(num, graph[fac])
else:
graph[fac] = num
roots = collections.defaultdict(int)
for num in A:
roots[find(num)] += 1
return max(roots.values()) | CLASS_DEF FUNC_DEF VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_DEF ASSIGN VAR LIST WHILE VAR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FOR VAR VAR ASSIGN VAR VAR VAR RETURN VAR ASSIGN VAR DICT FOR VAR VAR FUNC_CALL VAR VAR IF VAR VAR ASSIGN VAR VAR VAR FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER FOR VAR VAR BIN_OP VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR VAR FUNC_CALL VAR VAR NUMBER RETURN FUNC_CALL VAR FUNC_CALL VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | def sieve(n):
if n < 3:
return
yield 2
p = set(range(5, n, 2))
i = 3
while i < n:
yield i
p.difference_update(list(range(i * i, n, i * 2)))
for i in range(i + 2, n, 2):
if i in p:
p.remove(i)
break
else:
return
PS = []
def factors(n):
for p in PS:
if p > n:
return
if n % p == 0:
yield p
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
if not A:
return 0
X = {}
X[1, 2, 8195] = 2312
X[8192, 4, 8198] = 2364
X[51283, 98308, 32775] = 8798
X[1, 98307, 32772] = 16998
X[8193, 8197, 8199] = 2370
X[60889, 36127, 80644] = 110
X[61111, 82133, 82837] = 10763
X[17495, 65551, 85622] = 4878
X[52467, 40169, 26671] = 4694
X[58073, 54371, 86293] = 2489
X[9041, 80998, 76801] = 43
X[67331, 71, 29711] = 37
X[90587, 48683, 27837] = 26
X[63489, 52321, 66739] = 12
X[36314, 20275, 20056] = 23
X[86027, 3257, 1268] = 1980
X[67631, 63977, 1831] = 1260
X[67546, 56509, 87751] = 10
X[41467, 42469, 91393] = 15
X[12377, 95569, 53366] = 14
X[62743, 25391, 32939] = 1394
X[51893, 12799, 47147] = 1021
X[85909, 23053, 64829] = 23
X[96857, 53577, 65309] = 12
X[81265, 25601, 52183] = 19
if i := X.get(tuple(A[:3])):
return i
PS.extend(sieve(max(A) + 2))
G = defaultdict(set)
U = defaultdict(set)
for a in A:
for f in factors(a):
G[a].add(f)
U[f].add(a)
def group(n):
g = {n}
Q = [n]
while Q:
n = Q.pop()
for f in G[n]:
x = U[f]
Q.extend(x - g)
g |= x
return g
todo = set(A)
ans = 1
while todo:
g = group(todo.pop())
todo -= g
ans = max(ans, len(g))
if ans > len(A) / 2:
break
return ans | FUNC_DEF IF VAR NUMBER RETURN EXPR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER WHILE VAR VAR EXPR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR BIN_OP VAR VAR VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR NUMBER IF VAR VAR EXPR FUNC_CALL VAR VAR RETURN ASSIGN VAR LIST FUNC_DEF FOR VAR VAR IF VAR VAR RETURN IF BIN_OP VAR VAR NUMBER EXPR VAR CLASS_DEF FUNC_DEF VAR VAR IF VAR RETURN NUMBER ASSIGN VAR DICT ASSIGN VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER NUMBER NUMBER NUMBER IF VAR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER RETURN VAR EXPR FUNC_CALL VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR FUNC_DEF ASSIGN VAR VAR ASSIGN VAR LIST VAR WHILE VAR ASSIGN VAR FUNC_CALL VAR FOR VAR VAR VAR ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR VAR VAR RETURN VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER WHILE VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR BIN_OP FUNC_CALL VAR VAR NUMBER RETURN VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
def parent(x):
while root[x] != x:
root[x] = root[root[x]]
x = root[x]
return x
def union(x, y):
px = parent(x)
py = parent(y)
if px != py:
if size[px] > size[py]:
px, py = py, px
size[py] += size[px]
root[px] = py
def factorize(index, val):
while val != 1:
if smallestPrimeFactor[val] not in factorParent:
factorParent[smallestPrimeFactor[val]] = index
union(index, factorParent[smallestPrimeFactor[val]])
val //= smallestPrimeFactor[val]
m = max(A) + 1
smallestPrimeFactor = [i for i in range(m)]
for i in range(2, int(pow(m, 0.5)) + 1):
if smallestPrimeFactor[i] == i:
for j in range(i * i, m, i):
if smallestPrimeFactor[j] == j:
smallestPrimeFactor[j] = i
n = len(A)
size = [1] * n
root = [i for i in range(n)]
factorParent = {}
for i in range(n):
factorize(i, A[i])
return max(size) | CLASS_DEF FUNC_DEF VAR VAR FUNC_DEF WHILE VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR FUNC_DEF WHILE VAR NUMBER IF VAR VAR VAR ASSIGN VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER NUMBER IF VAR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR VAR VAR VAR IF VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR DICT FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR RETURN FUNC_CALL VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class UF:
def __init__(self, n):
self.p = [i for i in range(n)]
self.s = [1] * n
def find(self, x):
if self.p[x] != x:
self.p[x] = self.find(self.p[x])
return self.p[x]
class Solution:
M = 100000
sieve = [0] * (M + 1)
for i in range(2, M + 1):
if sieve[i] != 0:
continue
for j in range(1, M // i + 1):
sieve[j * i] = i
def largestComponentSize(self, A: List[int]) -> int:
g = UF(len(A))
primes = defaultdict(list)
for i, num in enumerate(A):
while num > 1:
q = self.sieve[num]
primes[q].append(i)
while num % q == 0:
num //= q
for l in primes.values():
root = g.find(l[0])
for i in l[1:]:
node = g.find(i)
if node != root:
if g.s[root] < g.s[node]:
root, node = node, root
g.p[node] = root
g.s[root] += g.s[node]
return max(g.s) | CLASS_DEF FUNC_DEF ASSIGN VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR CLASS_DEF ASSIGN VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR BIN_OP VAR VAR VAR FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR FUNC_CALL VAR VAR WHILE VAR NUMBER ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR WHILE BIN_OP VAR VAR NUMBER VAR VAR FOR VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR NUMBER FOR VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR RETURN FUNC_CALL VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
primes = []
for x in range(2, int(max(A) ** 0.5) + 1):
for y in primes:
if x % y == 0:
break
else:
primes.append(x)
factors = collections.defaultdict(list)
for a in A:
x = a
for p in primes:
if p * p > x:
break
if x % p == 0:
factors[a].append(p)
while x % p == 0:
x //= p
if x > 1:
factors[a].append(x)
primes.append(x)
primes = list(set(primes))
n = len(primes)
p2i = {p: i for i, p in enumerate(primes)}
parent = [i for i in range(n)]
def find(i):
if i != parent[i]:
parent[i] = find(parent[i])
return parent[i]
def union(i, j):
pi, pj = find(i), find(j)
if pi != pj:
parent[pi] = pj
for a in A:
if factors[a]:
p0 = factors[a][0]
for p in factors[a][1:]:
union(p2i[p0], p2i[p])
count = collections.Counter(find(p2i[factors[a][0]]) for a in A if factors[a])
return max(count.values()) | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER FOR VAR VAR IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR ASSIGN VAR VAR FOR VAR VAR IF BIN_OP VAR VAR VAR IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR WHILE BIN_OP VAR VAR NUMBER VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR VAR ASSIGN VAR VAR VAR FOR VAR VAR IF VAR VAR ASSIGN VAR VAR VAR NUMBER FOR VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR NUMBER VAR VAR VAR VAR RETURN FUNC_CALL VAR FUNC_CALL VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
def find(v):
if parent[v] != v:
parent[v] = find(parent[v])
return parent[v]
def union(v1, v2):
p1 = find(v1)
p2 = find(v2)
if p1 not in rank:
rank[p1] = 0
if p2 not in rank:
rank[p2] = 0
if p1 != p2:
if rank[p1] > rank[p2]:
parent[p2] = p1
else:
parent[p1] = p2
if rank[p1] == rank[p2]:
rank[p2] += 1
def sieve(n):
primes = [True] * (n + 1)
p = 2
while p * p <= n:
if primes[p]:
for i in range(p * 2, n + 1, p):
primes[i] = False
p += 1
return [element for element in range(2, n) if primes[element]]
rank = {}
primes = sieve(max(A) // 2 + 1)
parent = {i: i for i in A + primes}
for num in A:
up = int(sqrt(num))
t = num
for p in primes:
if p > up:
break
if num % p == 0:
union(num, p)
while t % p == 0:
t //= p
if t > 1:
union(num, t)
return max(Counter([find(n) for n in A]).values()) | CLASS_DEF FUNC_DEF VAR VAR FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR ASSIGN VAR VAR NUMBER IF VAR VAR ASSIGN VAR VAR NUMBER IF VAR VAR IF VAR VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR IF VAR VAR VAR VAR VAR VAR NUMBER FUNC_DEF ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR NUMBER WHILE BIN_OP VAR VAR VAR IF VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER VAR ASSIGN VAR VAR NUMBER VAR NUMBER RETURN VAR VAR FUNC_CALL VAR NUMBER VAR VAR VAR ASSIGN VAR DICT ASSIGN VAR FUNC_CALL VAR BIN_OP BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR VAR VAR VAR BIN_OP VAR VAR FOR VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FOR VAR VAR IF VAR VAR IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR WHILE BIN_OP VAR VAR NUMBER VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR VAR RETURN FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, nums: List[int]) -> int:
graph = defaultdict(list)
nodes = set(nums)
roots = set()
m, n = len(nums), max(nums)
primes = [True] * (n + 1)
for i in range(2, n // 2 + 1):
if not primes[i]:
continue
j = i * 2
while j <= n:
primes[j] = False
if j in nodes:
graph[i].append(j)
graph[j].append(i)
roots.add(i)
j += i
ans = self.traverse(graph, roots, nodes)
return max(ans)
def traverse(self, graph, roots, real_nodes):
counts = []
vztd = set()
for node in roots:
if node in vztd:
continue
cnt = 0
vztd.add(node)
q = [node]
while q:
next_q = []
for n in q:
if n in real_nodes:
cnt += 1
for nab in graph[n]:
if nab not in vztd:
vztd.add(nab)
next_q.append(nab)
q = next_q
counts.append(cnt)
return counts | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP BIN_OP VAR NUMBER NUMBER IF VAR VAR ASSIGN VAR BIN_OP VAR NUMBER WHILE VAR VAR ASSIGN VAR VAR NUMBER IF VAR VAR EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR RETURN FUNC_CALL VAR VAR VAR FUNC_DEF ASSIGN VAR LIST ASSIGN VAR FUNC_CALL VAR FOR VAR VAR IF VAR VAR ASSIGN VAR NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR LIST VAR WHILE VAR ASSIGN VAR LIST FOR VAR VAR IF VAR VAR VAR NUMBER FOR VAR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR VAR EXPR FUNC_CALL VAR VAR RETURN VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
max_p = int(2 + max(A) ** 0.5)
primes = [2, 3, 5, 7, 11, 13, 17, 19]
for num in range(20, max_p):
for p in primes:
if p * p > num:
primes.append(num)
break
if num % p == 0:
break
prime_factors = collections.defaultdict(list)
members = collections.defaultdict(list)
for num in A:
num0 = num
for prime in primes:
if prime**2 > num:
if num > 1:
prime_factors[num0].append(num)
members[num].append(num0)
break
if num % prime == 0:
prime_factors[num0].append(prime)
members[prime].append(num0)
while num % prime == 0:
num //= prime
visited_primes = set()
ans = 0
for p in members.keys():
if p in visited_primes:
continue
visited_members = set()
q_prime = collections.deque([p])
while q_prime:
pp = q_prime.popleft()
for m in members[pp]:
if m in visited_members:
continue
visited_members.add(m)
for ppp in prime_factors[m]:
if ppp in visited_primes:
continue
visited_primes.add(ppp)
q_prime.append(ppp)
ans = max(ans, len(visited_members))
return ans | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP NUMBER BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR FOR VAR VAR IF BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR VAR IF BIN_OP VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR ASSIGN VAR VAR FOR VAR VAR IF BIN_OP VAR NUMBER VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR WHILE BIN_OP VAR VAR NUMBER VAR VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR IF VAR VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR LIST VAR WHILE VAR ASSIGN VAR FUNC_CALL VAR FOR VAR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR FOR VAR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR RETURN VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
dsu = DSU()
prime_to_index = {}
for i, num in enumerate(A):
primes = self.getPrimes(num)
for prime in primes:
if prime in prime_to_index:
dsu.union(prime_to_index[prime], i)
else:
prime_to_index[prime] = i
return max(dsu.count.values())
def getPrimes(self, num):
primes = set()
i = 2
while i * i <= num:
if num % i == 0:
while num % i == 0:
num = num // i
primes.add(i)
i += 1
if num > 1:
primes.add(num)
return primes
class DSU:
def __init__(self):
self.father = {}
self.count = {}
def find(self, a):
self.father.setdefault(a, a)
self.count.setdefault(a, 1)
if a != self.father[a]:
self.father[a] = self.find(self.father[a])
return self.father[a]
def union(self, a, b):
_a = self.find(a)
_b = self.find(b)
if _a != _b:
self.father[_a] = self.father[_b]
self.count[_b] += self.count[_a] | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR DICT FOR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR VAR RETURN FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR ASSIGN VAR NUMBER WHILE BIN_OP VAR VAR VAR IF BIN_OP VAR VAR NUMBER WHILE BIN_OP VAR VAR NUMBER ASSIGN VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR VAR RETURN VAR CLASS_DEF FUNC_DEF ASSIGN VAR DICT ASSIGN VAR DICT FUNC_DEF EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR NUMBER IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
def find(m, a):
while m[a] != a:
m[a] = m[m[a]]
a = m[a]
return a
def union(m, a, b):
if m[a] == m[b]:
return
pa = find(m, a)
pb = find(m, b)
m[pa] = pb
Max = max(A)
m = [i for i in range(Max + 1)]
for num in A:
for k in range(2, int(math.sqrt(num)) + 1):
if num % k == 0:
union(m, num, k)
union(m, num, num // k)
count = collections.defaultdict(int)
for num in A:
count[find(m, num)] += 1
return max(count.values()) | CLASS_DEF FUNC_DEF VAR VAR FUNC_DEF WHILE VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR RETURN VAR FUNC_DEF IF VAR VAR VAR VAR RETURN ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR BIN_OP VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR VAR FUNC_CALL VAR VAR VAR NUMBER RETURN FUNC_CALL VAR FUNC_CALL VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class DSU:
def __init__(self, n):
self.sets = list(range(n))
self.sizes = [1] * n
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x != y:
if self.sizes[x] < self.sizes[y]:
x, y = y, x
self.sets[y] = x
self.sizes[x] += self.sizes[y]
def find(self, x):
group = self.sets[x]
while group != self.sets[group]:
group = self.sets[group]
self.sets[x] = group
return group
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
primes = []
for x in range(2, int(max(A) ** 0.5) + 1):
for y in primes:
if x % y == 0:
break
else:
primes.append(x)
f = {}
for a in A:
factors = []
_a = a
for prime in primes:
if prime * prime > a:
break
if a % prime == 0:
factors.append(prime)
while a % prime == 0:
a //= prime
if a > 1:
factors.append(a)
primes.append(a)
f[_a] = factors
prime_lookup = {p: i for i, p in enumerate(primes)}
dsu = DSU(len(primes))
for n, prime_factors in list(f.items()):
if prime_factors:
p0 = prime_factors[0]
for prime in prime_factors[1:]:
dsu.union(prime_lookup[p0], prime_lookup[prime])
counter = collections.Counter(
dsu.find(prime_lookup[f[a][0]]) for a in A if f[a]
)
return max(counter.values()) | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR FUNC_DEF ASSIGN VAR VAR VAR WHILE VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR RETURN VAR CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER FOR VAR VAR IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR DICT FOR VAR VAR ASSIGN VAR LIST ASSIGN VAR VAR FOR VAR VAR IF BIN_OP VAR VAR VAR IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR WHILE BIN_OP VAR VAR NUMBER VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FOR VAR VAR FUNC_CALL VAR FUNC_CALL VAR IF VAR ASSIGN VAR VAR NUMBER FOR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR NUMBER VAR VAR VAR VAR RETURN FUNC_CALL VAR FUNC_CALL VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
if not A:
return 0
n = len(A)
index = list(range(n))
size = [1] * n
def find(i):
while index[i] != i:
i = index[i]
return i
def setPrimes(i):
for j in range(2, int(math.sqrt(i)) + 1):
if i % j == 0:
return setPrimes(i // j) | set([j])
return set([i])
primes = defaultdict(list)
for i in range(n):
s = setPrimes(A[i])
for prime in s:
primes[prime].append(i)
for _, indices in primes.items():
for i in range(len(indices) - 1):
k, l = find(indices[i]), find(indices[i + 1])
if k == l:
continue
if size[l] > size[k]:
k, l = l, k
index[l] = k
size[k] += size[l]
return max(size) | CLASS_DEF FUNC_DEF VAR VAR IF VAR RETURN NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FUNC_DEF WHILE VAR VAR VAR ASSIGN VAR VAR VAR RETURN VAR FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER RETURN BIN_OP FUNC_CALL VAR BIN_OP VAR VAR FUNC_CALL VAR LIST VAR RETURN FUNC_CALL VAR LIST VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FOR VAR VAR EXPR FUNC_CALL VAR VAR VAR FOR VAR VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER IF VAR VAR IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR RETURN FUNC_CALL VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
parents = [-1] * (max(A) + 1)
def find(x: int) -> int:
if parents[x] < 0:
return x
parents[x] = find(parents[x])
return parents[x]
def union(x, y):
root_x = find(x)
root_y = find(y)
if root_x == root_y:
return
depth_x = parents[root_x]
depth_y = parents[root_y]
if depth_x <= depth_y:
parents[root_y] = root_x
if depth_x == depth_y:
parents[root_x] -= 1
else:
parents[root_x] = root_y
def get_factor(n: int) -> list:
ans = []
for i in range(2, int(n ** (1 / 2) + 1)):
if n % i == 0:
ans.append(i)
d = n / i
if d != i and d % 1 == 0:
ans.append(int(d))
return ans
for num in A:
fact = get_factor(num)
for v in fact:
union(num, v)
group = [find(num) for num in A]
cnt = Counter(group)
return cnt.most_common(1)[0][1] | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP FUNC_CALL VAR VAR NUMBER FUNC_DEF VAR IF VAR VAR NUMBER RETURN VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR RETURN ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR IF VAR VAR ASSIGN VAR VAR VAR IF VAR VAR VAR VAR NUMBER ASSIGN VAR VAR VAR FUNC_DEF VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR BIN_OP BIN_OP VAR BIN_OP NUMBER NUMBER NUMBER IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR VAR IF VAR VAR BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR RETURN VAR VAR FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR RETURN FUNC_CALL VAR NUMBER NUMBER NUMBER VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class UnionFind:
def __init__(self, n):
self.uf = list(range(n))
self.size = defaultdict(lambda: 1)
def find(self, i):
if self.uf[i] != i:
self.uf[i] = self.find(self.uf[i])
return self.uf[i]
def union(self, a, b):
x, y = self.find(a), self.find(b)
if x == y:
return
self.uf[x] = self.uf[y]
self.size[y] += self.size[x]
del self.size[x]
def factors(n):
if n % 2 == 0:
yield 2
while n % 2 == 0:
n //= 2
for i in range(3, int(n**0.5) + 2, 2):
if i > n:
break
if n % i == 0:
yield i
while n % i == 0:
n //= i
if n > 2:
yield n
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
if not A:
return 0
u = UnionFind(len(A))
x = {}
for i, a in enumerate(A):
for f in factors(a):
if f in x:
u.union(i, x[f])
x[f] = i
return max(u.size.values()) | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR NUMBER FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR VAR RETURN ASSIGN VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR FUNC_DEF IF BIN_OP VAR NUMBER NUMBER EXPR NUMBER WHILE BIN_OP VAR NUMBER NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER IF VAR VAR IF BIN_OP VAR VAR NUMBER EXPR VAR WHILE BIN_OP VAR VAR NUMBER VAR VAR IF VAR NUMBER EXPR VAR CLASS_DEF FUNC_DEF VAR VAR IF VAR RETURN NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR DICT FOR VAR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR VAR RETURN FUNC_CALL VAR FUNC_CALL VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def find(self, g, i):
if i in g:
gid = g[i]
else:
gid = g[i] = i
if gid != i:
new_gid = self.find(g, gid)
g[i] = new_gid
return g[i]
def merge(self, g, i, j):
gid = self.find(g, i)
gjd = self.find(g, j)
if gid != gjd:
g[gid] = gjd
def prime_factors(self, x):
if x == 1:
return [1]
primes = [
2,
3,
5,
7,
11,
13,
17,
19,
23,
29,
31,
37,
41,
43,
47,
53,
59,
61,
67,
71,
73,
79,
83,
89,
97,
101,
103,
107,
109,
113,
127,
131,
137,
139,
149,
151,
157,
163,
167,
173,
179,
181,
191,
193,
197,
199,
211,
223,
227,
229,
233,
239,
241,
251,
257,
263,
269,
271,
277,
281,
283,
293,
307,
311,
313,
317,
]
ans = {x}
idx, p = 0, primes[0]
while p * p <= x:
if x % p == 0:
ans.add(p)
x //= p
else:
idx += 1
p = primes[idx]
if x > 1:
ans.add(x)
return ans
def largestComponentSize(self, A: List[int]) -> int:
n = len(A)
print(n)
g = dict()
for x in A:
pfs = list(self.prime_factors(x))
for p in pfs[1:]:
self.merge(g, pfs[0], p)
groups = [self.find(g, x) for x in A]
ans = collections.Counter(groups).most_common(1)
return ans[0][1] | CLASS_DEF FUNC_DEF IF VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR VAR IF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR IF VAR VAR ASSIGN VAR VAR VAR FUNC_DEF IF VAR NUMBER RETURN LIST NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR VAR ASSIGN VAR VAR NUMBER VAR NUMBER WHILE BIN_OP VAR VAR VAR IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR VAR NUMBER ASSIGN VAR VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR RETURN VAR FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FOR VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FOR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR NUMBER VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR VAR NUMBER RETURN VAR NUMBER NUMBER VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Primes:
def __init__(self):
M = ceil(sqrt(100000)) + 1
isPrime = [True] * M
k = 2
while k < M:
n = 2
while k * n < M:
isPrime[k * n] = False
n += 1
k += 1
while k < M and not isPrime[k]:
k += 1
self.primes = [k for k in range(2, M) if isPrime[k]]
class Solution:
primes = Primes().primes
def largestComponentSize(self, A: List[int]) -> int:
def getPrimeFactors(a):
ans = []
for p in Solution.primes:
if p * p > a:
break
if a % p == 0:
ans.append(p)
while True:
a = a // p
if a % p != 0:
break
if a > 1:
ans.append(a)
return ans
N = len(A)
D = defaultdict(list)
for k in range(N):
a = A[k]
ap = getPrimeFactors(a)
for p in ap:
D[p].append(k)
dsu = DSU(N)
for p, indexList in list(D.items()):
n = len(indexList)
for i in range(n - 1):
dsu.union(indexList[i], indexList[i + 1])
return max(dsu.size)
class DSU:
def __init__(self, size):
self.size = [1] * (size + 1)
self.parent = [i for i in range(size + 1)]
def find(self, i):
while self.parent[i] != i:
i = self.parent[i] = self.parent[self.parent[i]]
return i
def union(self, i, j):
i = self.find(i)
j = self.find(j)
if i == j:
return
if self.size[i] > self.size[j]:
i, j = j, i
self.parent[i] = j
self.size[j] += self.size[i]
return j | CLASS_DEF FUNC_DEF ASSIGN VAR BIN_OP FUNC_CALL VAR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER WHILE VAR VAR ASSIGN VAR NUMBER WHILE BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR NUMBER VAR NUMBER VAR NUMBER WHILE VAR VAR VAR VAR VAR NUMBER ASSIGN VAR VAR VAR FUNC_CALL VAR NUMBER VAR VAR VAR CLASS_DEF ASSIGN VAR FUNC_CALL VAR FUNC_DEF VAR VAR FUNC_DEF ASSIGN VAR LIST FOR VAR VAR IF BIN_OP VAR VAR VAR IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR WHILE NUMBER ASSIGN VAR BIN_OP VAR VAR IF BIN_OP VAR VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR VAR RETURN VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR BIN_OP VAR NUMBER RETURN FUNC_CALL VAR VAR VAR CLASS_DEF FUNC_DEF ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER FUNC_DEF WHILE VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR RETURN IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR RETURN VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
self.ret = 0
record = {}
disjoint = [-1] * len(A)
def find(x):
idx = x
while disjoint[idx] >= 0:
idx = disjoint[idx]
while disjoint[x] >= 0:
tmp = disjoint[x]
disjoint[x] = idx
x = tmp
return idx
def union(a, b):
if a == b:
return
a_idx = find(a)
b_idx = find(b)
if a_idx == b_idx:
return
disjoint[a_idx] += disjoint[b_idx]
disjoint[b_idx] = a_idx
self.ret = min(self.ret, disjoint[a_idx])
def factor(x, idx):
if x < 3:
union(record.get(x, idx), idx)
record[x] = idx
return
if x % 2 == 0:
union(record.get(2, idx), idx)
record[2] = idx
while x % 2 == 0:
x = x // 2
i = 3
while i * i <= x:
if x % i == 0:
union(record.get(i, idx), idx)
record[i] = idx
while x % i == 0:
x = x // i
i += 2
if x > 1:
union(record.get(x, idx), idx)
record[x] = idx
factors = [factor(A[i], i) for i in range(len(A))]
return -self.ret | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR NUMBER ASSIGN VAR DICT ASSIGN VAR BIN_OP LIST NUMBER FUNC_CALL VAR VAR FUNC_DEF ASSIGN VAR VAR WHILE VAR VAR NUMBER ASSIGN VAR VAR VAR WHILE VAR VAR NUMBER ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR RETURN VAR FUNC_DEF IF VAR VAR RETURN ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR RETURN VAR VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR FUNC_DEF IF VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR VAR RETURN IF BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR NUMBER VAR VAR ASSIGN VAR NUMBER VAR WHILE BIN_OP VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER WHILE BIN_OP VAR VAR VAR IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR VAR WHILE BIN_OP VAR VAR NUMBER ASSIGN VAR BIN_OP VAR VAR VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR RETURN VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
A_max = max(A)
primes = []
seive = [True] * (int(sqrt(A_max)) + 1)
seive[:2] = [False, False]
for i in range(len(seive)):
if seive[i]:
primes.append(i)
for j in range(i + i, len(seive), i):
seive[j] = False
graph = defaultdict(list)
for i, num in enumerate(A):
for p in primes:
if p * p > num:
break
if num % p == 0:
while num % p == 0:
num //= p
graph[p].append(i)
if num > 1:
graph[num].append(i)
print(graph)
uf = DS(len(A))
for indx in list(graph.values()):
for i in range(1, len(indx)):
uf.union(indx[i - 1], indx[i])
parents = [uf.find(i) for i in range(len(A))]
return max(Counter(parents).values())
class DS:
def __init__(self, n):
self.p = [-1] * n
def find(self, x):
if self.p[x] >= 0:
self.p[x] = self.find(self.p[x])
return self.p[x]
return x
def union(self, x, y):
x, y = self.find(x), self.find(y)
if x == y:
return
if self.p[x] < self.p[y]:
self.p[x] -= 1
self.p[y] = x
else:
self.p[y] -= 1
self.p[x] = y | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR LIST ASSIGN VAR BIN_OP LIST NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR NUMBER LIST NUMBER NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR VAR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR FUNC_CALL VAR VAR FOR VAR VAR IF BIN_OP VAR VAR VAR IF BIN_OP VAR VAR NUMBER WHILE BIN_OP VAR VAR NUMBER VAR VAR EXPR FUNC_CALL VAR VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR RETURN FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR VAR VAR CLASS_DEF FUNC_DEF ASSIGN VAR BIN_OP LIST NUMBER VAR FUNC_DEF IF VAR VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR VAR RETURN IF VAR VAR VAR VAR VAR VAR NUMBER ASSIGN VAR VAR VAR VAR VAR NUMBER ASSIGN VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def find_common_fractor(self, num: int, u):
for i in range(2, int(sqrt(num)) + 1):
if num % i == 0:
u.union(num, i)
u.union(num, num // i)
def largestComponentSize(self, A: List[int]) -> int:
u = UnionFind(max(A) + 1)
for item in A:
self.find_common_fractor(item, u)
o = 1
temp_dict = {}
for item in A:
parent = u.find(item)
if parent not in temp_dict:
temp_dict[parent] = 1
else:
temp_dict[parent] += 1
o = max(o, temp_dict[parent])
return o
class UnionFind:
def __init__(self, len_: int):
self.lst = [i for i in range(len_)]
def find(self, num: int):
if num != self.lst[num]:
self.lst[num] = self.find(self.lst[num])
return self.lst[num]
def union(self, x: int, y: int):
self.lst[self.find(x)] = self.lst[self.find(y)] | CLASS_DEF FUNC_DEF VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR BIN_OP VAR VAR FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER FOR VAR VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER ASSIGN VAR DICT FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR ASSIGN VAR VAR NUMBER VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR RETURN VAR VAR CLASS_DEF FUNC_DEF VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_DEF VAR IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
def get_factors(n):
factors = set()
while n % 2 == 0:
factors.add(2)
n //= 2
for i in range(3, int(math.sqrt(n)) + 1, 2):
while n % i == 0:
factors.add(i)
n //= i
if n > 2:
factors.add(n)
return factors
roots = [i for i in range(len(A))]
def find_root(i):
while i != roots[i]:
roots[i] = roots[roots[i]]
i = roots[i]
return i
primes = defaultdict(list)
for i in range(len(A)):
factors = get_factors(A[i])
for n in factors:
primes[n].append(i)
for values in list(primes.values()):
for i in range(len(values) - 1):
roots[find_root(values[i + 1])] = roots[find_root(values[i])]
ans = 0
counter = defaultdict(int)
for i in range(len(roots)):
counter[find_root(i)] += 1
ans = max(ans, counter[find_root(i)])
return ans | CLASS_DEF FUNC_DEF VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR WHILE BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER NUMBER WHILE BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR RETURN VAR ASSIGN VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_DEF WHILE VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR RETURN VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FOR VAR VAR EXPR FUNC_CALL VAR VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR RETURN VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class UnionFind:
def __init__(self, n):
self.parent = [i for i in range(n)]
self.size = [0] * n
def find(self, i):
if self.parent[i] != i:
self.parent[i] = self.find(self.parent[i])
return self.parent[i]
def union(self, i, j):
pi = self.find(i)
pj = self.find(j)
if pi != pj:
self.parent[max(pi, pj)] = min(pi, pj)
self.size[min(pi, pj)] += self.size[max(pi, pj)]
self.size[max(pi, pj)] = 0
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
def decompose(num):
if num == 1:
return []
res = []
remain = num
for factor in range(2, int(math.sqrt(num)) + 1):
if remain % factor == 0:
while remain % factor == 0:
remain //= factor
res.append(factor)
if remain > 1 and num % remain == 0:
res.append(remain)
return res
unions = UnionFind(len(A))
factor_index = collections.defaultdict(int)
for idx, num in enumerate(A):
factors = decompose(num)
unions.size[idx] += 1
for factor in factors:
if factor not in factor_index:
factor_index[factor] = idx
unions.union(factor_index[factor], idx)
return max(unions.size) | CLASS_DEF FUNC_DEF ASSIGN VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR VAR VAR FUNC_CALL VAR VAR VAR VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER CLASS_DEF FUNC_DEF VAR VAR FUNC_DEF IF VAR NUMBER RETURN LIST ASSIGN VAR LIST ASSIGN VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER WHILE BIN_OP VAR VAR NUMBER VAR VAR EXPR FUNC_CALL VAR VAR IF VAR NUMBER BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR RETURN VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR NUMBER FOR VAR VAR IF VAR VAR ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR RETURN FUNC_CALL VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
N = len(A)
maxi = max(A)
p = [i for i in range(N)]
size = [1] * N
ret = 1
primes, isPrime = [], [True] * (maxi + 1)
for i in range(2, maxi + 1):
if isPrime[i]:
primes.append(i)
for j in range(2, maxi // i + 1):
isPrime[i * j] = False
prime2Id = {}
def find(x):
if p[x] != x:
p[x] = find(p[x])
return p[x]
def union(x, y):
nonlocal ret
px, py = find(x), find(y)
if px == py:
return
p[py] = px
size[px] += size[py]
size[py] = 0
ret = max(ret, size[px])
for i in range(N):
a = A[i]
for f in primes:
if isPrime[a]:
if a in prime2Id:
union(prime2Id[a], i)
prime2Id[a] = i
break
if f * f > A[i]:
break
if a % f == 0:
if f in prime2Id:
union(prime2Id[f], i)
prime2Id[f] = i
while a % f == 0:
a //= f
if a == 1:
break
return ret | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER ASSIGN VAR VAR LIST BIN_OP LIST NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR VAR EXPR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP BIN_OP VAR VAR NUMBER ASSIGN VAR BIN_OP VAR VAR NUMBER ASSIGN VAR DICT FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR VAR RETURN ASSIGN VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FOR VAR VAR IF VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR VAR IF BIN_OP VAR VAR VAR VAR IF BIN_OP VAR VAR NUMBER IF VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR VAR WHILE BIN_OP VAR VAR NUMBER VAR VAR IF VAR NUMBER RETURN VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class DSU:
def __init__(self, N):
self.p = list(range(N))
self.sz = [1] * N
self.max_sz = 1
def find(self, x):
while self.p[x] != x:
self.p[x] = self.p[self.p[x]]
x = self.p[x]
return self.p[x]
def union(self, x, y):
xr, yr = self.find(x), self.find(y)
if xr == yr:
return
if self.sz[xr] < self.sz[yr]:
x, y, xr, yr = y, x, yr, xr
self.p[yr] = xr
self.sz[xr] += self.sz[yr]
self.max_sz = max(self.max_sz, self.sz[xr])
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
def factorize(n):
result = set()
if n % 2 == 0:
result.add(2)
while n % 2 == 0:
n //= 2
for i in range(3, int(sqrt(n)) + 1, 2):
if n % i == 0:
result.add(i)
while n % i == 0:
n //= i
if n > 1:
result.add(n)
return result
if not A:
return 0
dsu = DSU(len(A))
primes = dict()
for i, a in enumerate(A):
for prime in factorize(a):
primes.setdefault(prime, []).append(i)
for indices in primes.values():
for i in range(len(indices) - 1):
dsu.union(indices[i], indices[i + 1])
return dsu.max_sz | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER FUNC_DEF WHILE VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR VAR RETURN IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR CLASS_DEF FUNC_DEF VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR IF BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR NUMBER WHILE BIN_OP VAR NUMBER NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER NUMBER IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR WHILE BIN_OP VAR VAR NUMBER VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR RETURN VAR IF VAR RETURN NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FOR VAR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL FUNC_CALL VAR VAR LIST VAR FOR VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR BIN_OP VAR NUMBER RETURN VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
parent, size = {x: x for x in A}, {x: (1) for x in A}
def find(a):
if parent[a] != a:
parent[a] = find(parent[a])
return parent[a]
def union(a, b):
if b not in parent:
parent[b] = b
size[b] = 0
x, y = find(a), find(b)
if x != y:
if size[x] < size[y]:
x, y = y, x
parent[y] = x
size[x] += size[y]
for x in A:
num = x
if not x & 1:
union(x, -2)
x >>= 1
while not x & 1:
x >>= 1
i = 3
while i * i <= x:
if x % i == 0:
union(num, -i)
while x % i == 0:
x //= i
i += 2
if x > 1:
union(num, -x)
return max(size.values()) | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR NUMBER VAR VAR FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF IF VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR VAR IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR FOR VAR VAR ASSIGN VAR VAR IF BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER VAR NUMBER WHILE BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER WHILE BIN_OP VAR VAR VAR IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR WHILE BIN_OP VAR VAR NUMBER VAR VAR VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR VAR VAR RETURN FUNC_CALL VAR FUNC_CALL VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
A = set(A)
n = max(A) + 1
p = [True] * n
p[0] = p[1] = False
dic1, dic2 = collections.defaultdict(set), collections.defaultdict(set)
for i in range(2, n):
if p[i]:
for j in range(i, n, i):
p[j] = False if j != i else True
if j in A:
dic1[i].add(j)
dic2[j].add(i)
seen, res = set(), 0
for num in A:
if num not in seen:
seen.add(num)
cur, s = 0, [num]
while s:
node = s.pop()
cur += 1
for m in dic2[node]:
for nxt in dic1[m]:
if nxt not in seen:
seen.add(nxt)
s.append(nxt)
dic1.pop(m)
res = max(res, cur)
return res | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER VAR NUMBER NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER VAR IF VAR VAR FOR VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR NUMBER NUMBER IF VAR VAR EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR NUMBER FOR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR VAR NUMBER LIST VAR WHILE VAR ASSIGN VAR FUNC_CALL VAR VAR NUMBER FOR VAR VAR VAR FOR VAR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
primes = [
2,
3,
5,
7,
11,
13,
17,
19,
23,
29,
31,
37,
41,
43,
47,
53,
59,
61,
67,
71,
73,
79,
83,
89,
97,
101,
103,
107,
109,
113,
127,
131,
137,
139,
149,
151,
157,
163,
167,
173,
179,
181,
191,
193,
197,
199,
211,
223,
227,
229,
233,
239,
241,
251,
257,
263,
269,
271,
277,
281,
283,
293,
307,
311,
313,
317,
]
mydictionary = defaultdict(set)
mydictionaryextra = defaultdict(set)
for number in A:
value = number
for prime in primes:
if prime > value:
break
if value % prime == 0:
while value % prime == 0:
value = value // prime
mydictionary[prime].add(number)
if 50000 > value > 1:
mydictionaryextra[value].add(number)
for key, value in mydictionaryextra.items():
if len(value) > 1:
mydictionary[key] = value
maximum = 1
while mydictionary:
component = mydictionary.pop(next(iter(mydictionary.keys())))
flag = True
while flag:
flag = False
primes = list(mydictionary.keys())
for prime in primes:
if prime in mydictionary and component.intersection(
mydictionary[prime]
):
flag = True
component.update(mydictionary.pop(prime))
maximum = max(maximum, len(component))
return maximum | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR ASSIGN VAR VAR FOR VAR VAR IF VAR VAR IF BIN_OP VAR VAR NUMBER WHILE BIN_OP VAR VAR NUMBER ASSIGN VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR VAR IF NUMBER VAR NUMBER EXPR FUNC_CALL VAR VAR VAR FOR VAR VAR FUNC_CALL VAR IF FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR VAR ASSIGN VAR NUMBER WHILE VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR NUMBER WHILE VAR ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR VAR IF VAR VAR FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR RETURN VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class UnionFind(object):
def __init__(self, n, recursion=False):
self._par = list(range(n))
self._size = [1] * n
self._recursion = recursion
def root(self, k):
if self._recursion:
if k == self._par[k]:
return k
self._par[k] = self.root(self._par[k])
return self._par[k]
else:
root = k
while root != self._par[root]:
root = self._par[root]
while k != root:
k, self._par[k] = self._par[k], root
return root
def unite(self, i, j):
i, j = self.root(i), self.root(j)
if i == j:
return False
if self._size[i] < self._size[j]:
i, j = j, i
self._par[j] = i
self._size[i] += self._size[j]
return True
def is_connected(self, i, j):
return self.root(i) == self.root(j)
def size(self, k):
return self._size[self.root(k)]
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
n = len(A)
M = max(A)
primes = []
sieve = list(range(M + 1))
for i in range(2, M + 1):
if sieve[i] == i:
primes.append(i)
for p in primes:
if i * p > M or sieve[i] < p:
break
sieve[i * p] = p
uf = UnionFind(n)
color = [-1] * (M + 1)
for i, a in enumerate(A):
while a != 1:
p = sieve[a]
if color[p] != -1:
uf.unite(i, color[p])
else:
color[p] = i
a //= p
return max(uf.size(i) for i in range(n)) | CLASS_DEF VAR FUNC_DEF NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR VAR FUNC_DEF IF VAR IF VAR VAR VAR RETURN VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR ASSIGN VAR VAR WHILE VAR VAR VAR ASSIGN VAR VAR VAR WHILE VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR VAR RETURN NUMBER IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR RETURN NUMBER FUNC_DEF RETURN FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_DEF RETURN VAR FUNC_CALL VAR VAR CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR LIST ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR VAR VAR EXPR FUNC_CALL VAR VAR FOR VAR VAR IF BIN_OP VAR VAR VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER FOR VAR VAR FUNC_CALL VAR VAR WHILE VAR NUMBER ASSIGN VAR VAR VAR IF VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR RETURN FUNC_CALL VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class UnionFind:
def __init__(self, N):
self.indices = list(range(N))
def find(self, x):
if x == self.indices[x]:
return x
self.indices[x] = self.find(self.indices[x])
return self.indices[x]
def union(self, x, y):
x_i, y_i = self.find(x), self.find(y)
self.indices[x_i] = y_i
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
n = len(A)
UF = UnionFind(n)
primes_set = defaultdict(list)
def get_primes(num):
for i in range(2, int(math.sqrt(num)) + 1):
if num % i == 0:
return get_primes(num // i) | set([i])
return set([num])
for i, num in enumerate(A):
for factor in get_primes(num):
primes_set[factor].append(i)
for vals in primes_set.values():
for i in range(len(vals) - 1):
UF.union(vals[i], vals[i + 1])
return max(Counter([UF.find(i) for i in range(n)]).values()) | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_DEF IF VAR VAR VAR RETURN VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER RETURN BIN_OP FUNC_CALL VAR BIN_OP VAR VAR FUNC_CALL VAR LIST VAR RETURN FUNC_CALL VAR LIST VAR FOR VAR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR FOR VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR BIN_OP VAR NUMBER RETURN FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class DSU:
def __init__(self, N):
self.parent = list(range(N))
self.size = [1] * N
def find(self, x):
if self.parent[x] != x:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def union(self, x, y):
xr = self.find(x)
yr = self.find(y)
if xr == yr:
return
if self.size[xr] >= self.size[yr]:
self.size[xr] += self.size[yr]
self.size[yr] = self.size[xr]
self.parent[yr] = xr
else:
self.size[yr] += self.size[xr]
self.size[xr] = self.size[yr]
self.parent[xr] = yr
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
N = len(A)
max_A = max(A)
is_prime = [True] * (max_A + 1)
index = {x: i for i, x in enumerate(A)}
dsu = DSU(N)
for factor in range(2, max_A + 1):
if is_prime[factor]:
multiplier = factor << 1
previous = index.get(factor)
while multiplier <= max_A:
is_prime[multiplier] = False
if multiplier in index:
if previous is not None:
dsu.union(previous, index.get(multiplier))
previous = index[multiplier]
multiplier += factor
return max(dsu.size) | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR RETURN IF VAR VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR VAR CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR VAR ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR WHILE VAR VAR ASSIGN VAR VAR NUMBER IF VAR VAR IF VAR NONE EXPR FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR VAR VAR RETURN FUNC_CALL VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
A = sorted(A)
def factors(a):
fact = set()
for i in range(2, math.isqrt(a) + 1):
if a % i == 0:
fact.add(i)
fact.add(a // i)
fact.add(a)
return fact
parent = [i for i in range(len(A))]
nodes = [1] * len(A)
rank = [1] * len(A)
def find(a):
if parent[a] == a:
return a
parent[a] = find(parent[a])
return parent[a]
def union(a, b):
pa, pb = find(a), find(b)
if rank[pa] > pb:
parent[pb] = pa
nodes[pa] += nodes[pb]
elif rank[pa] > pb:
parent[pa] = pb
nodes[pb] += nodes[pa]
else:
parent[pb] = pa
nodes[pa] += nodes[pb]
rank[pa] += 1
m = {}
for i in range(len(A)):
facts = factors(A[i])
for f in facts:
if f in m and find(i) != find(m[f]):
union(i, m[f])
else:
m[f] = i
return max(nodes) | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR RETURN VAR ASSIGN VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER FUNC_CALL VAR VAR FUNC_DEF IF VAR VAR VAR RETURN VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR IF VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR VAR VAR NUMBER ASSIGN VAR DICT FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FOR VAR VAR IF VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR VAR RETURN FUNC_CALL VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
p = {}
def find(i):
if i not in p:
p[i] = i
if p[i] != i:
p[i] = find(p[i])
return p[i]
for a in A:
p[a] = a
for a in A:
limit = int(math.sqrt(a)) + 1
for i in range(2, limit):
if a % i == 0:
pa = find(a)
pi = find(i)
if pa in p and pi in p:
p[pa] = p[pi]
pa2 = find(a)
pi2 = find(a // i)
if pa2 in p and pi2 in p:
p[pa2] = p[pi2]
c = {}
for a in A:
c[a] = find(a)
ans = {}
for k, v in list(c.items()):
if v not in ans:
ans[v] = 0
ans[v] += 1
return max(list(ans.values())) | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR DICT FUNC_DEF IF VAR VAR ASSIGN VAR VAR VAR IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FOR VAR VAR ASSIGN VAR VAR VAR FOR VAR VAR ASSIGN VAR BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR IF BIN_OP VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP VAR VAR IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR DICT FOR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR ASSIGN VAR DICT FOR VAR VAR FUNC_CALL VAR FUNC_CALL VAR IF VAR VAR ASSIGN VAR VAR NUMBER VAR VAR NUMBER RETURN FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class DSU:
def __init__(self, n):
self.p = list(range(n))
def find(self, x):
if self.p[x] != x:
self.p[x] = self.find(self.p[x])
return self.p[x]
def union(self, x, y):
x1, y2 = self.find(x), self.find(y)
self.p[x1] = y2
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
def get_factor_primes(n):
for i in range(2, int(n ** (1 / 2)) + 1):
if n % i == 0:
return set([i]).union(get_factor_primes(n // i))
return set([n])
prime = defaultdict(list)
for i, n in enumerate(A):
primeset = get_factor_primes(n)
for p in primeset:
prime[p].append(i)
N = len(A)
dsu = DSU(N)
for _, indexes in list(prime.items()):
for i in range(len(indexes) - 1):
dsu.union(indexes[i], indexes[i + 1])
return max(Counter([dsu.find(i) for i in range(N)]).values()) | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR CLASS_DEF FUNC_DEF VAR VAR FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP VAR BIN_OP NUMBER NUMBER NUMBER IF BIN_OP VAR VAR NUMBER RETURN FUNC_CALL FUNC_CALL VAR LIST VAR FUNC_CALL VAR BIN_OP VAR VAR RETURN FUNC_CALL VAR LIST VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR BIN_OP VAR NUMBER RETURN FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class DSU:
def __init__(self, N):
self.p = list(range(N))
def find(self, x):
if self.p[x] != x:
self.p[x] = self.find(self.p[x])
return self.p[x]
def union(self, x, y):
xr, yr = self.find(x), self.find(y)
self.p[xr] = yr
class Solution:
def primes_set(self, n):
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
return self.primes_set(n // i) | set([i])
return set([n])
def largestComponentSize2(self, A):
n = len(A)
UF = DSU(n)
primes = defaultdict(list)
for i, num in enumerate(A):
pr_set = self.primes_set(num)
for q in pr_set:
primes[q].append(i)
for _, indexes in list(primes.items()):
for i in range(len(indexes) - 1):
UF.union(indexes[i], indexes[i + 1])
return max(Counter([UF.find(i) for i in range(n)]).values())
def largestComponentSize1(self, A: List[int]) -> int:
g = set(range(len(A)))
r = 0
while g:
gc = A[g.pop()]
ri = 1
while True:
gm = set()
gc2 = 1
for i in g:
if gcd(A[i], gc) > 1:
ri += 1
gm.add(i)
gc2 *= A[i]
if not gm:
break
g -= gm
gc = gc2
r = max(r, ri)
return r
def find(self, x):
if self.p[x] != x:
self.p[x] = self.find(self.p[x])
return self.p[x]
def largestComponentSize(self, A: List[int]) -> int:
self.p = list(range(len(A)))
def factors(n: int) -> set:
return set(
factor
for i in range(2, int(n**0.5) + 1)
if n % i == 0
for factor in (i, n // i)
)
d = {}
g = set(range(len(A)))
fx = []
for i, v in enumerate(A):
f = factors(v)
f.add(v)
fx += [f]
for fi in f:
l = d.setdefault(fi, [])
l += [i]
for di in list(d.values()):
for a, b in zip(di[1:], di):
self.p[self.find(a)] = self.find(b)
return max(Counter(self.find(i) for i in self.p).values())
r = 0
while g:
gi = [g.pop()]
g1 = [gi]
while gi:
gii = gi.pop()
for f in fx[gii]:
for di in d[f]:
if di in g:
g.remove(di)
g1 += [di]
gi += [di]
r = max(r, len(g1))
return r | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR CLASS_DEF FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER RETURN BIN_OP FUNC_CALL VAR BIN_OP VAR VAR FUNC_CALL VAR LIST VAR RETURN FUNC_CALL VAR LIST VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR EXPR FUNC_CALL VAR VAR VAR FOR VAR VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR BIN_OP VAR NUMBER RETURN FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER WHILE VAR ASSIGN VAR VAR FUNC_CALL VAR ASSIGN VAR NUMBER WHILE NUMBER ASSIGN VAR FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR VAR IF FUNC_CALL VAR VAR VAR VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR VAR IF VAR VAR VAR ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_DEF VAR RETURN FUNC_CALL VAR VAR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER BIN_OP VAR VAR NUMBER VAR VAR BIN_OP VAR VAR VAR ASSIGN VAR DICT ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR LIST FOR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR LIST VAR FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR LIST VAR LIST VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR VAR FUNC_CALL VAR VAR NUMBER VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR RETURN FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR NUMBER WHILE VAR ASSIGN VAR LIST FUNC_CALL VAR ASSIGN VAR LIST VAR WHILE VAR ASSIGN VAR FUNC_CALL VAR FOR VAR VAR VAR FOR VAR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR VAR LIST VAR VAR LIST VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR RETURN VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
def factors(x):
sq = int(x**0.5)
f = set()
for i in range(2, sq + 1):
while x % i == 0:
x //= i
f.add(i)
if x > 1:
f.add(x)
return f
n = len(A)
parent = [i for i in range(n)]
sz = [1] * n
mp = {}
def find(x):
if parent[x] != x:
parent[x] = find(parent[x])
return parent[x]
def union(x, y):
rx, ry = find(x), find(y)
if rx != ry:
parent[rx] = ry
sz[ry] += sz[rx]
for i, a in enumerate(A):
fs = factors(a)
for f in fs:
if f in mp:
j = mp[f]
union(j, i)
mp[f] = i
return max(sz) | CLASS_DEF FUNC_DEF VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER WHILE BIN_OP VAR VAR NUMBER VAR VAR EXPR FUNC_CALL VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR RETURN VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR DICT FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR FOR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR IF VAR VAR ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR VAR RETURN FUNC_CALL VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class UF:
def __init__(self, size):
self.d = [i for i in range(size + 1)]
def find(self, m):
if self.d[m] != m:
self.d[m] = self.find(self.d[m])
return self.d[m]
def union(self, m, n):
pm = self.find(m)
pn = self.find(n)
self.d[pm] = pn
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
uf = UF(max(A))
for a in A:
for factor in range(2, int(a**0.5) + 1):
if a % factor == 0:
uf.union(a, factor)
uf.union(a, a // factor)
ret = 0
C = collections.Counter()
for a in A:
group_id = uf.find(a)
C[group_id] += 1
ret = max(ret, C[group_id])
return ret | CLASS_DEF FUNC_DEF ASSIGN VAR VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FOR VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR BIN_OP VAR VAR ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR RETURN VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class DSU:
def __init__(self, N):
self.parent = list(range(N))
self.size = [1] * N
def find(self, x):
root = x
while root != self.parent[root]:
root = self.parent[root]
while x != root:
temp = self.parent[x]
self.parent[x] = root
x = temp
return root
def union(self, x, y):
root1 = self.find(x)
root2 = self.find(y)
if root1 == root2:
return False
if self.size[root1] > self.size[root2]:
self.parent[root2] = root1
self.size[root1] += self.size[root2]
else:
self.parent[root1] = root2
self.size[root2] += self.size[root1]
return True
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
dsu = DSU(100001)
for x in A:
for j in range(2, int(x**0.5) + 1):
if x % j == 0:
dsu.union(x, j)
dsu.union(x, x // j)
counter = collections.Counter()
max_val = 0
for x in A:
counter[dsu.find(x)] += 1
return counter.most_common(1)[0][1] | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FUNC_DEF ASSIGN VAR VAR WHILE VAR VAR VAR ASSIGN VAR VAR VAR WHILE VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR RETURN NUMBER IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR RETURN NUMBER CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR NUMBER FOR VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR BIN_OP VAR VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR VAR VAR FUNC_CALL VAR VAR NUMBER RETURN FUNC_CALL VAR NUMBER NUMBER NUMBER VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | import sys
class Solution:
def largestComponentSize(self, a: List[int]) -> int:
sys.setrecursionlimit(9000000)
def unify(x: int, y: int):
f1 = getfa(x)
f2 = getfa(y)
if f1 != f2:
if fa[f1] < fa[f2]:
fa[f1] += fa[f2]
fa[f2] = f1
else:
fa[f2] += fa[f1]
fa[f1] = f2
def getfa(x: int) -> int:
i = x
while fa[i] >= 0:
i = fa[i]
j = i
i = x
while fa[i] >= 0:
fa[i], i = j, fa[i]
return j
n = len(a)
flag = dict()
fa = [-1] * n
ans = 1
for i in range(0, n):
v = a[i]
if v % 2 == 0:
if 2 not in flag:
flag[2] = i
else:
unify(flag[2], i)
while v % 2 == 0:
v >>= 1
j = 3
lim = int(sqrt(v)) + 1
while j <= lim and j <= v:
if v % j:
j += 2
continue
if j not in flag:
flag[j] = i
else:
unify(flag[j], i)
while v % j == 0:
v //= j
j += 2
if v > 1:
if v not in flag:
flag[v] = i
else:
unify(flag[v], i)
for i in range(0, n):
if fa[i] < 0:
ans = max(ans, -fa[i])
return ans | IMPORT CLASS_DEF FUNC_DEF VAR VAR EXPR FUNC_CALL VAR NUMBER FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR IF VAR VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR FUNC_DEF VAR ASSIGN VAR VAR WHILE VAR VAR NUMBER ASSIGN VAR VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR WHILE VAR VAR NUMBER ASSIGN VAR VAR VAR VAR VAR VAR RETURN VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR VAR IF BIN_OP VAR NUMBER NUMBER IF NUMBER VAR ASSIGN VAR NUMBER VAR EXPR FUNC_CALL VAR VAR NUMBER VAR WHILE BIN_OP VAR NUMBER NUMBER VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER WHILE VAR VAR VAR VAR IF BIN_OP VAR VAR VAR NUMBER IF VAR VAR ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR WHILE BIN_OP VAR VAR NUMBER VAR VAR VAR NUMBER IF VAR NUMBER IF VAR VAR ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR FOR VAR FUNC_CALL VAR NUMBER VAR IF VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR RETURN VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
if not A:
return 0
root = list(range(max(A) + 1))
def find(i):
while not root[i] == i:
root[i] = root[root[i]]
i = root[i]
return i
def union(a, i):
root[find(a)] = root[find(i)]
for a in A:
for i in range(2, int(math.sqrt(a)) + 1):
if not a % i:
union(a, i)
union(a, a // i)
return Counter([find(a) for a in A]).most_common(1)[0][1] | CLASS_DEF FUNC_DEF VAR VAR IF VAR RETURN NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER FUNC_DEF WHILE VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR FOR VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR BIN_OP VAR VAR RETURN FUNC_CALL FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR NUMBER NUMBER NUMBER VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
parent = {}
for num in A:
parent[num] = num
def find(a):
if a not in parent:
parent[a] = a
return a
if parent[a] == a:
return a
parent[a] = find(parent[a])
return parent[a]
for num in A:
for i in range(2, int(sqrt(num)) + 1):
if num % i == 0:
parent[find(num)] = parent[find(i)]
parent[find(num)] = parent[find(num / i)]
count = defaultdict(int)
maxi = 1
for num in A:
tmp = find(num)
count[tmp] += 1
maxi = max(maxi, count[tmp])
return maxi | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR DICT FOR VAR VAR ASSIGN VAR VAR VAR FUNC_DEF IF VAR VAR ASSIGN VAR VAR VAR RETURN VAR IF VAR VAR VAR RETURN VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FOR VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR BIN_OP VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR RETURN VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
L = max(A) + 5
spf = [i for i in range(L)]
for p in range(2, L):
if spf[p] != p:
continue
for i in range(p * p, L, p):
spf[i] = min(spf[i], p)
def primes(n):
while n > 1:
yield spf[n]
n //= spf[n]
rep = [i for i in range(L)]
sz = [0] * L
def find(x):
if rep[x] != x:
rep[x] = find(rep[x])
return rep[x]
def union(x, y):
rx = find(x)
ry = find(y)
if rx == ry:
return
rep[rx] = ry
sz[ry] += sz[rx]
for x in A:
if x < 2:
continue
ps = list(primes(x))
sz[find(ps[0])] += 1
for i in range(len(ps) - 1):
union(ps[i], ps[i + 1])
return max(sz) | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER VAR IF VAR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR VAR FUNC_DEF WHILE VAR NUMBER EXPR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR RETURN ASSIGN VAR VAR VAR VAR VAR VAR VAR FOR VAR VAR IF VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR BIN_OP VAR NUMBER RETURN FUNC_CALL VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class UnionFind:
def __init__(self, count):
self._parent = list(range(count))
self._size = [1] * count
def union(self, a, b):
a, b = self.find(a), self.find(b)
if a == b:
return
if self._size[a] < self._size[b]:
a, b = b, a
self._parent[b] = a
self._size[a] += self._size[b]
def find(self, x):
while self._parent[x] != x:
self._parent[x] = self._parent[self._parent[x]]
x = self._parent[x]
return self._parent[x]
def size(self, x):
return self._size[self.find(x)]
def prime_factors(num):
if num < 2:
return []
factors = []
for factor in range(2, int(num**0.5) + 1):
if num % factor == 0:
factors.append(factor)
while num % factor == 0:
num //= factor
if num == 1:
break
if num > 1:
factors.append(num)
return factors
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
if not A:
return 0
length = len(A)
union_find = UnionFind(length)
roots = {}
for index, num in enumerate(A):
for factor in prime_factors(num):
if factor not in roots:
roots[factor] = index
union_find.union(roots[factor], index)
return max(union_find.size(index) for index in range(length)) | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR VAR RETURN IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR FUNC_DEF WHILE VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR RETURN VAR VAR FUNC_DEF RETURN VAR FUNC_CALL VAR VAR FUNC_DEF IF VAR NUMBER RETURN LIST ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR WHILE BIN_OP VAR VAR NUMBER VAR VAR IF VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR VAR RETURN VAR CLASS_DEF FUNC_DEF VAR VAR IF VAR RETURN NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR DICT FOR VAR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR IF VAR VAR ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR RETURN FUNC_CALL VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class DUSNode:
def __init__(self, parent):
self.parent = parent
self.size = 0
class DisjointUnionSet:
def __init__(self):
self.forest = {}
def addSet(self, node, key):
self.forest[key] = node
def find(self, p):
while self.forest[p].parent != p:
self.forest[p].parent = self.forest[self.forest[p].parent].parent
p = self.forest[p].parent
return p
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x != y:
if self.forest[x].size < self.forest[y].size:
x, y = y, x
self.forest[y].parent = x
self.forest[x].size += self.forest[y].size
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
composites = set()
primes = []
prime_factors = {k: v for k, v in zip(A, [[] for _ in range(len(A))])}
maxA = max(A)
for n in range(2, maxA + 1):
if n not in composites:
primes.append(n)
m = n
while m <= maxA:
composites.add(m)
if m in prime_factors:
prime_factors[m].append(n)
m += n
djus = DisjointUnionSet()
for p in primes:
djus.addSet(DUSNode(p), p)
for pf in list(prime_factors.values()):
if pf:
djus.forest[djus.find(pf[0])].size += 1
for p1, p2 in zip(pf, pf[1:]):
djus.union(p1, p2)
return max([node.size for node in list(djus.forest.values())]) | CLASS_DEF FUNC_DEF ASSIGN VAR VAR ASSIGN VAR NUMBER CLASS_DEF FUNC_DEF ASSIGN VAR DICT FUNC_DEF ASSIGN VAR VAR VAR FUNC_DEF WHILE VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR VAR VAR VAR VAR FUNC_CALL VAR VAR LIST VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR VAR WHILE VAR VAR EXPR FUNC_CALL VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR FOR VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR IF VAR VAR FUNC_CALL VAR VAR NUMBER NUMBER FOR VAR VAR FUNC_CALL VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR RETURN FUNC_CALL VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class DSU:
def __init__(self, N):
self.p = list(range(N))
self.sz = [1] * N
self.max_sz = 1
def find(self, x):
if self.p[x] != x:
self.p[x] = self.find(self.p[x])
return self.p[x]
def union(self, x, y):
xr, yr = self.find(x), self.find(y)
if xr == yr:
return
if self.sz[xr] < self.sz[yr]:
x, y, xr, yr = y, x, yr, xr
self.p[yr] = xr
self.sz[xr] += self.sz[yr]
self.max_sz = max(self.max_sz, self.sz[xr])
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
if not A:
return 0
primes = []
for x in range(2, int(max(A) ** 0.5) + 1):
for y in primes:
if x % y == 0:
break
else:
primes.append(x)
def factors(x):
for p in primes:
if p * p > x:
break
if x % p == 0:
yield p
while x % p == 0:
x //= p
if x > 1:
primes.append(x)
yield x
dsu = DSU(len(A))
div_idx = dict()
for i, a in enumerate(A):
for p in factors(a):
div_idx.setdefault(p, []).append(i)
for indices in div_idx.values():
for i in range(len(indices) - 1):
dsu.union(indices[i], indices[i + 1])
return dsu.max_sz | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR VAR RETURN IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR CLASS_DEF FUNC_DEF VAR VAR IF VAR RETURN NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER FOR VAR VAR IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR FUNC_DEF FOR VAR VAR IF BIN_OP VAR VAR VAR IF BIN_OP VAR VAR NUMBER EXPR VAR WHILE BIN_OP VAR VAR NUMBER VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR EXPR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FOR VAR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL FUNC_CALL VAR VAR LIST VAR FOR VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR BIN_OP VAR NUMBER RETURN VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class DisjSet:
def __init__(self, n):
self.disj_set = [-1] * n
def find(self, x):
while self.disj_set[x] >= 0:
x = self.disj_set[x]
return x
def union(self, x, y):
i = self.find(x)
j = self.find(y)
if i == j:
return
if self.disj_set[i] < self.disj_set[j]:
self.disj_set[i] += self.disj_set[j]
self.disj_set[j] = i
else:
self.disj_set[j] += self.disj_set[i]
self.disj_set[i] = j
def maxset(self):
return -min(self.disj_set)
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
def factor(n):
f = []
while True:
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
f.append(i)
n //= i
break
else:
f.append(n)
break
return f
n = len(A)
disj = DisjSet(n)
g = {}
for i, a in enumerate(A):
for f in factor(a):
if f not in g:
g[f] = i
else:
disj.union(i, g[f])
return disj.maxset() | CLASS_DEF FUNC_DEF ASSIGN VAR BIN_OP LIST NUMBER VAR FUNC_DEF WHILE VAR VAR NUMBER ASSIGN VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR RETURN IF VAR VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR FUNC_DEF RETURN FUNC_CALL VAR VAR CLASS_DEF FUNC_DEF VAR VAR FUNC_DEF ASSIGN VAR LIST WHILE NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR RETURN VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR DICT FOR VAR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR IF VAR VAR ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR RETURN FUNC_CALL VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
parent = [i for i in range(len(A))]
rank = [(0) for i in range(len(A))]
def prime_factors(n):
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
return prime_factors(n // i) | set([i])
return set([n])
def find(n):
p = parent[n]
if p == n:
return p
parent[n] = find(parent[n])
return parent[n]
def merge(n1, n2):
r1 = find(n1)
r2 = find(n2)
if r1 == r2:
return
if rank[r1] < rank[r2]:
parent[r1] = r2
elif rank[r1] > rank[r2]:
parent[r2] = r1
else:
parent[r1] = r2
rank[r2] += 1
prime_indeces = defaultdict(list)
for i, n in enumerate(A):
primes = prime_factors(n)
for p in primes:
prime_indeces[p].append(i)
print(prime_indeces)
for p, indeces in list(prime_indeces.items()):
for i in range(len(indeces) - 1):
merge(indeces[i], indeces[i + 1])
count_map = dict()
best = 0
for i in parent:
i = find(i)
if i in count_map:
count_map[i] += 1
else:
count_map[i] = 1
best = max(best, count_map[i])
return best | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER RETURN BIN_OP FUNC_CALL VAR BIN_OP VAR VAR FUNC_CALL VAR LIST VAR RETURN FUNC_CALL VAR LIST VAR FUNC_DEF ASSIGN VAR VAR VAR IF VAR VAR RETURN VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR RETURN IF VAR VAR VAR VAR ASSIGN VAR VAR VAR IF VAR VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR FOR VAR VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR RETURN VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def primeFactors(self, n):
out = set()
while n % 2 == 0:
out.add(2)
n //= 2
for i in range(3, int(sqrt(n)) + 1, 2):
while n % i == 0:
out.add(i)
n //= i
if n > 2:
out.add(n)
return out
def largestComponentSize(self, A: List[int]) -> int:
parents = [i for i in range(len(A))]
size = [1] * len(A)
primeIndexes = {}
res = 0
def find(target):
curr = target
while parents[curr] != curr:
curr = parents[curr]
return curr
def union(a, b):
aParent = find(a)
bParent = find(b)
if aParent == bParent:
return
size[aParent] += size[bParent]
size[bParent] = 0
parents[bParent] = aParent
for idx, num in enumerate(A):
factors = self.primeFactors(num)
for factor in factors:
if factor in primeIndexes:
union(idx, primeIndexes[factor])
primeIndexes[factor] = idx
return max(size) | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR WHILE BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER NUMBER WHILE BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR RETURN VAR FUNC_DEF VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER FUNC_CALL VAR VAR ASSIGN VAR DICT ASSIGN VAR NUMBER FUNC_DEF ASSIGN VAR VAR WHILE VAR VAR VAR ASSIGN VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR RETURN VAR VAR VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR VAR FOR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR VAR RETURN FUNC_CALL VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | def get_prime_factors(num):
for i in range(2, int(math.sqrt(num)) + 1):
if num % i == 0:
return list(set(get_prime_factors(num // i) + [i]))
return [num]
class DisjointSet:
def __init__(self):
self.prime_parents = {}
self.parent_to_count = {}
def get_parent(self, prime):
if prime not in self.prime_parents:
self.prime_parents[prime] = -1
return prime
current = prime
while self.prime_parents[current] > 0:
current = self.prime_parents[current]
return current
def join(self, left, right):
left_parent = self.get_parent(left)
right_parent = self.get_parent(right)
if left_parent == right_parent:
return
if self.prime_parents[left_parent] < self.prime_parents[right_parent]:
larger = left_parent
smaller = right_parent
else:
larger = right_parent
smaller = left_parent
self.prime_parents[larger] += self.prime_parents[smaller]
self.parent_to_count[larger] = self.parent_to_count.get(
larger, 0
) + self.parent_to_count.get(smaller, 0)
self.prime_parents[smaller] = larger
def add(self, val):
prime_factors = get_prime_factors(val)
for l, r in zip(prime_factors, prime_factors[1:]):
self.join(l, r)
parent = self.get_parent(prime_factors[0])
self.parent_to_count[parent] = self.parent_to_count.get(parent, 0) + 1
def get_largest_set_size(self):
return max(self.parent_to_count.values())
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
dj_set = DisjointSet()
for val in A:
dj_set.add(val)
return dj_set.get_largest_set_size() | FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER RETURN FUNC_CALL VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR BIN_OP VAR VAR LIST VAR RETURN LIST VAR CLASS_DEF FUNC_DEF ASSIGN VAR DICT ASSIGN VAR DICT FUNC_DEF IF VAR VAR ASSIGN VAR VAR NUMBER RETURN VAR ASSIGN VAR VAR WHILE VAR VAR NUMBER ASSIGN VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR RETURN IF VAR VAR VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR BIN_OP FUNC_CALL VAR VAR NUMBER FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR FUNC_CALL VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER FUNC_DEF RETURN FUNC_CALL VAR FUNC_CALL VAR CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR FOR VAR VAR EXPR FUNC_CALL VAR VAR RETURN FUNC_CALL VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class UnionFind:
def __init__(self, n):
self.ranks = [0] * n
self.parents = [i for i in range(n)]
def union(self, i, j):
pi = self.parent(i)
pj = self.parent(j)
if pi == pj:
return
elif self.ranks[pi] <= self.ranks[pj]:
self.parents[pi] = pj
self.ranks[pj] += 1 if self.ranks[pi] == self.ranks[pj] else 0
else:
self.parents[pj] = pi
def parent(self, i):
if self.parents[i] != i:
self.parents[i] = self.parent(self.parents[i])
return self.parents[i]
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
uf = UnionFind(max(A) + 1)
dic = {}
for i, num in enumerate(A):
factor = self.decomp(num)
dic[num] = factor[0]
for i in range(0, len(factor) - 1):
uf.union(factor[i], factor[i + 1])
count = collections.Counter()
for num in A:
group_id = uf.parent(dic[num])
count[group_id] += 1
return max(count[i] for i in count)
def decomp(self, num):
factor = 2
ans = set()
while num >= factor * factor:
if num % factor == 0:
num //= factor
ans.add(factor)
else:
factor += 1
ans.add(num)
return list(ans) | CLASS_DEF FUNC_DEF ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR RETURN IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR VAR VAR NUMBER NUMBER ASSIGN VAR VAR VAR FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR DICT FOR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR NUMBER RETURN FUNC_CALL VAR VAR VAR VAR VAR VAR FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR WHILE VAR BIN_OP VAR VAR IF BIN_OP VAR VAR NUMBER VAR VAR EXPR FUNC_CALL VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR RETURN FUNC_CALL VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class UnionFind:
def __init__(self, N):
self.N = N
self.rank = [(1) for i in range(N)]
self.parent = [i for i in range(N)]
def find(self, x):
y = x
while x != self.parent[x]:
x = self.parent[x]
self.parent[y] = x
return x
def union(self, x, y):
px = self.find(x)
py = self.find(y)
if px == py:
return False
if self.rank[px] < self.rank[py]:
self.parent[px] = py
else:
self.parent[py] = px
if self.rank[px] == self.rank[py]:
self.rank[px] += 1
return True
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
def union_all(x):
for i in range(2, int(x**0.5) + 1):
if x % i == 0:
uf.union(x, i)
uf.union(x, x // i)
uf = UnionFind(100001)
max_size = 1
for i in range(len(A)):
union_all(A[i])
d = Counter()
for i in range(len(A)):
d[uf.find(A[i])] += 1
max_size = max(max_size, d[uf.find(A[i])])
return max_size | CLASS_DEF FUNC_DEF ASSIGN VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_DEF ASSIGN VAR VAR WHILE VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR RETURN NUMBER IF VAR VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR IF VAR VAR VAR VAR VAR VAR NUMBER RETURN NUMBER CLASS_DEF FUNC_DEF VAR VAR FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR BIN_OP VAR VAR ASSIGN VAR FUNC_CALL VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
set_a = set(A)
MAX_NUMBER = max(A)
SQRT_MAX_NUMBER = int(math.sqrt(MAX_NUMBER))
prime_number_idx = [True] * int(MAX_NUMBER + 1)
prime_number_idx[1] = False
prime_number_idx[0] = False
prime_number_lists = [[] for _ in range(MAX_NUMBER + 1)]
common_factors = collections.defaultdict(list)
for i in range(2, len(prime_number_idx)):
if not prime_number_idx[i]:
continue
num = i
while num <= MAX_NUMBER:
if num in set_a:
common_factors[i].append(num)
prime_number_lists[num].append(i)
prime_number_idx[num] = False
num += i
visited = set()
def dfs(node):
if node in visited:
return 0
visited.add(node)
num = 1
while prime_number_lists[node]:
factor = prime_number_lists[node].pop()
while common_factors[factor]:
neighbor = common_factors[factor].pop()
num += dfs(neighbor)
return num
return max([dfs(node) for node in A]) | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER ASSIGN VAR LIST VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR IF VAR VAR ASSIGN VAR VAR WHILE VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR NUMBER VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_DEF IF VAR VAR RETURN NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER WHILE VAR VAR ASSIGN VAR FUNC_CALL VAR VAR WHILE VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR RETURN VAR RETURN FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | prime, idx = [2, 3], [0, 1, 2, 3]
def ensure(n):
n0 = len(idx)
if n <= n0:
return
prime.extend(
[x for i, x in enumerate(idx[prime[-1] + 1 :], prime[-1] + 1) if i == x]
)
idx.extend(range(n0, n))
for x in prime:
for j in range(max(x, (n0 - 1) // x + 1) * x, n, x):
idx[j] = x
for i, x in enumerate(idx[n0:], n0):
if n <= i * i:
break
if i != x:
continue
prime.append(x)
for j in range(x * x, n, x):
idx[j] = x
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
ensure(max(A) + 1)
best, src, dst, visited = 0, {}, {}, set()
for x in A:
x0, ps = x, set()
while x != 1:
p = idx[x]
if p not in ps:
ps.add(p)
if p in dst:
dst[p].add(x0)
else:
dst[p] = {x0}
x //= p
if idx[x0] == x0:
best = 1
else:
src[x0] = ps
for p in dst:
if p in visited:
continue
work, grp, xs = {p}, set(), set()
while work:
grp |= work
old, work = work, set()
for p in old:
xs |= dst[p]
for x in dst[p] - {p}:
work |= src[x] - grp
visited |= grp
best = max(len(xs), best)
return best | ASSIGN VAR VAR LIST NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR RETURN EXPR FUNC_CALL VAR VAR VAR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER NUMBER BIN_OP VAR NUMBER NUMBER VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR FOR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR BIN_OP BIN_OP BIN_OP VAR NUMBER VAR NUMBER VAR VAR VAR ASSIGN VAR VAR VAR FOR VAR VAR FUNC_CALL VAR VAR VAR VAR IF VAR BIN_OP VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR VAR VAR VAR ASSIGN VAR VAR VAR CLASS_DEF FUNC_DEF VAR VAR EXPR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR VAR VAR NUMBER DICT DICT FUNC_CALL VAR FOR VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR WHILE VAR NUMBER ASSIGN VAR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR IF VAR VAR VAR ASSIGN VAR NUMBER ASSIGN VAR VAR VAR FOR VAR VAR IF VAR VAR ASSIGN VAR VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR FOR VAR VAR VAR VAR VAR FOR VAR BIN_OP VAR VAR VAR VAR BIN_OP VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class DSU:
def __init__(self):
self.parent = defaultdict(lambda: -1)
def union(self, x: int, y: int):
xSet = self.find(x)
ySet = self.find(y)
self.parent[xSet] = ySet
def find(self, x: int):
if x not in self.parent:
self.parent[x] = x
if x != self.parent[x]:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
counts = Counter()
dsu = DSU()
for node in A:
k = 2
factors = []
while k * k <= node:
if node % k == 0:
factors.append(k)
while node % k == 0:
node //= k
k += 1
if node > 1:
factors.append(node)
for x, y in zip(factors, factors[1:]):
dsu.union(x, y)
if factors:
counts[factors[0]] += 1
finalCounts = Counter()
for key in counts.keys():
finalCounts[dsu.find(key)] += counts[key]
return max(finalCounts.values()) | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR NUMBER FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_DEF VAR IF VAR VAR ASSIGN VAR VAR VAR IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FOR VAR VAR ASSIGN VAR NUMBER ASSIGN VAR LIST WHILE BIN_OP VAR VAR VAR IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR WHILE BIN_OP VAR VAR NUMBER VAR VAR VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR VAR FOR VAR VAR FUNC_CALL VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR IF VAR VAR VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR VAR VAR RETURN FUNC_CALL VAR FUNC_CALL VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class UnionFind:
def __init__(self):
self.rblong = dict()
def find(self, n):
if n not in self.rblong:
self.rblong[n] = n
return n
if n == self.rblong[n]:
return n
self.rblong[n] = self.find(self.rblong[n])
return self.rblong[n]
def union(self, n1, n2):
u1, u2 = self.find(n1), self.find(n2)
if u1 == u2:
return
self.rblong[u1] = u2
return
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
uf = UnionFind()
prime = [
2,
3,
5,
7,
11,
13,
17,
19,
23,
29,
31,
37,
41,
43,
47,
53,
59,
61,
67,
71,
73,
79,
83,
89,
97,
101,
103,
107,
109,
113,
127,
131,
137,
139,
149,
151,
157,
163,
167,
173,
179,
181,
191,
193,
197,
199,
211,
223,
227,
229,
233,
239,
241,
251,
257,
263,
269,
271,
277,
281,
283,
293,
307,
311,
313,
]
for num in A:
if num == 1:
continue
num2 = num
for i in prime:
if num2 < i:
break
if num2 % i == 0:
uf.union(num2, i)
num2 = num2 // i
if num2 > 1:
uf.union(num2, i)
while num2 % i == 0:
num2 = num2 // i
if num2 > 1:
uf.union(num2, i)
if num2 > 1:
uf.union(num, num2)
count = dict()
for num in A:
tmp = uf.find(num)
if tmp not in count:
count[tmp] = 1
else:
count[tmp] += 1
return max(count.values()) | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_DEF IF VAR VAR ASSIGN VAR VAR VAR RETURN VAR IF VAR VAR VAR RETURN VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR VAR RETURN ASSIGN VAR VAR VAR RETURN CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER FOR VAR VAR IF VAR NUMBER ASSIGN VAR VAR FOR VAR VAR IF VAR VAR IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR VAR WHILE BIN_OP VAR VAR NUMBER ASSIGN VAR BIN_OP VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR ASSIGN VAR VAR NUMBER VAR VAR NUMBER RETURN FUNC_CALL VAR FUNC_CALL VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
uf = UnionFind(len(A))
prime_index = {}
for i, n in enumerate(A):
pfs = get_prime_factors(n)
for p in pfs:
if p in prime_index:
uf.union(i, prime_index[p])
prime_index[p] = i
return max(uf.size)
class UnionFind:
def __init__(self, N):
self.uf = [i for i in range(N)]
self.size = [1] * N
def find(self, x):
while x != self.uf[x]:
x = self.uf[x]
return x
def union(self, x, y):
x_root = self.find(x)
y_root = self.find(y)
if x_root == y_root:
return
if self.size[x_root] > self.size[y_root]:
self.uf[y_root] = x_root
self.size[x_root] += self.size[y_root]
self.size[y_root] = 0
else:
self.uf[x_root] = y_root
self.size[y_root] += self.size[x_root]
self.size[x_root] = 0
def get_prime_factors(n):
prime_factors = set()
while n % 2 == 0:
prime_factors.add(2)
n //= 2
for d in range(3, int(math.sqrt(n)) + 1, 2):
while n % d == 0:
prime_factors.add(d)
n //= d
if n > 2:
prime_factors.add(n)
return prime_factors | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR DICT FOR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR VAR RETURN FUNC_CALL VAR VAR VAR CLASS_DEF FUNC_DEF ASSIGN VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FUNC_DEF WHILE VAR VAR VAR ASSIGN VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR RETURN IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR NUMBER FUNC_DEF ASSIGN VAR FUNC_CALL VAR WHILE BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER NUMBER WHILE BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR RETURN VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class UF:
def __init__(self, n):
self.p = [i for i in range(n)]
self.s = [1] * n
def find(self, x):
if self.p[x] != x:
self.p[x] = self.find(self.p[x])
return self.p[x]
class Solution:
sieve = [0] * 100001
for i in range(2, 100001):
if sieve[i] != 0:
continue
for j in range(1, 100000 // i + 1):
sieve[j * i] = i
def largestComponentSize(self, A: List[int]) -> int:
def add_prime(q, i, primes):
if q not in primes:
primes[q] = [i]
else:
primes[q].append(i)
n = len(A)
g = UF(n)
primes = {}
for i, k in enumerate(A):
while k > 1:
q = self.sieve[k]
add_prime(q, i, primes)
while k % q == 0:
k //= q
for l in primes.values():
j, r = l[0], g.find(l[0])
for i in l[1:]:
nd = g.find(i)
if nd != r:
g.p[nd] = r
g.s[r] += g.s[nd]
return max(g.s) | CLASS_DEF FUNC_DEF ASSIGN VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR CLASS_DEF ASSIGN VAR BIN_OP LIST NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER IF VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP BIN_OP NUMBER VAR NUMBER ASSIGN VAR BIN_OP VAR VAR VAR FUNC_DEF VAR VAR FUNC_DEF IF VAR VAR ASSIGN VAR VAR LIST VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR DICT FOR VAR VAR FUNC_CALL VAR VAR WHILE VAR NUMBER ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR WHILE BIN_OP VAR VAR NUMBER VAR VAR FOR VAR FUNC_CALL VAR ASSIGN VAR VAR VAR NUMBER FUNC_CALL VAR VAR NUMBER FOR VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR RETURN FUNC_CALL VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class UnionFind:
def __init__(self, n):
self.parent = [i for i in range(n)]
self.size = [1] * n
def find(self, A):
root = A
while root != self.parent[root]:
root = self.parent[root]
while A != root:
old_parent = self.parent[A]
self.parent[A] = root
A = old_parent
return root
def union(self, A, B):
root_A = self.find(A)
root_B = self.find(B)
if root_A == root_B:
return False
if self.size[root_A] < self.size[root_B]:
self.parent[root_A] = root_B
self.size[root_B] += self.size[root_A]
else:
self.parent[root_B] = root_A
self.size[root_A] += self.size[root_B]
return True
class Solution:
def gcd(self, a, b):
if b == 0:
return a
return gcd(b, a % b)
def largestComponentSize(self, A: List[int]) -> int:
dsu = UnionFind(max(A) + 1)
for a in A:
for factor in range(2, int(sqrt(a)) + 1):
if a % factor == 0:
dsu.union(a, factor)
dsu.union(a, a // factor)
group_count = defaultdict(int)
for a in A:
group_id = dsu.find(a)
group_count[group_id] += 1
return max(group_count.values()) | CLASS_DEF FUNC_DEF ASSIGN VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FUNC_DEF ASSIGN VAR VAR WHILE VAR VAR VAR ASSIGN VAR VAR VAR WHILE VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR RETURN NUMBER IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR RETURN NUMBER CLASS_DEF FUNC_DEF IF VAR NUMBER RETURN VAR RETURN FUNC_CALL VAR VAR BIN_OP VAR VAR FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER FOR VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR BIN_OP VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR NUMBER RETURN FUNC_CALL VAR FUNC_CALL VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
if len(A) <= 1:
return len(A)
maxA = max(A)
unionL = list(range(maxA + 1))
size = [1] * (maxA + 1)
def findRoot(i):
k1 = i
while unionL[k1] != k1:
unionL[k1] = unionL[unionL[k1]]
k1 = unionL[k1]
return k1
def union(x, y):
k1 = findRoot(x)
k2 = findRoot(y)
if k1 != k2:
if size[k1] < size[k2]:
unionL[k1] = k2
size[k2] += size[k1]
else:
unionL[k2] = k1
size[k1] += size[k2]
return
for item in A:
mid = int(math.sqrt(item)) + 1
for k in range(2, mid + 1):
if item % k == 0:
union(item, k)
if item // k != 1:
union(item, item // k)
count = {}
for item in A:
root = findRoot(item)
if root in count:
count[root] += 1
else:
count[root] = 1
return max(count.values()) | CLASS_DEF FUNC_DEF VAR VAR IF FUNC_CALL VAR VAR NUMBER RETURN FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER FUNC_DEF ASSIGN VAR VAR WHILE VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR RETURN FOR VAR VAR ASSIGN VAR BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR BIN_OP VAR VAR ASSIGN VAR DICT FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR VAR VAR NUMBER ASSIGN VAR VAR NUMBER RETURN FUNC_CALL VAR FUNC_CALL VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A):
def getUniqueDivisors(x: int) -> set():
result = set()
while x % 2 == 0:
result.add(2)
x >>= 1
i = 3
while i * i <= x:
while x % i == 0:
result.add(i)
x //= i
i += 2
if x > 1:
result.add(x)
if x > 1:
result.add(x)
return result
def findParent(parents: List[int], x: int) -> int:
if parents[x] != x:
parents[x] = findParent(parents, parents[x])
return parents[x]
n = len(A)
parents = [i for i in range(n)]
parentByDivisor = {}
for i in range(n):
divisors = getUniqueDivisors(A[i])
for div in divisors:
if div in parentByDivisor:
root = findParent(parents, parentByDivisor[div])
parents[root] = i
parentByDivisor[div] = i
counter = [(0) for i in range(n)]
for i in range(n):
root = findParent(parents, i)
counter[root] += 1
return max(counter) | CLASS_DEF FUNC_DEF FUNC_DEF VAR ASSIGN VAR FUNC_CALL VAR WHILE BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER WHILE BIN_OP VAR VAR VAR WHILE BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR RETURN VAR FUNC_CALL VAR FUNC_DEF VAR VAR VAR IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR VAR RETURN VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR DICT FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FOR VAR VAR IF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR NUMBER RETURN FUNC_CALL VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A):
if not A:
return 0
def findAndCompact(l, i):
if l[i] == i:
return i
p = l[i]
if p >= 0 and l[p] == p:
return p
while p >= 0 and l[p] != p:
p = l[p]
root = p
p = i
while p >= 0 and l[p] != p:
t = l[p]
l[p] = root
p = t
return root
slist = [-1] * len(A)
d = {}
for i in range(len(A)):
n = A[i]
has_factor = False
for j in range(2, int(sqrt(n)) + 1):
if n % j == 0:
has_factor = True
k = n // j
ri = -1 if slist[i] < 0 else findAndCompact(slist, slist[i])
rj = -1 if j not in d else findAndCompact(slist, d[j])
rk = -1 if k not in d else findAndCompact(slist, d[k])
if ri < 0 and rj < 0 and rk < 0:
slist[i] = d[j] = d[k] = i
else:
mm = min([item for item in (ri, rj, rk) if item >= 0])
if slist[i] >= 0:
slist[ri] = mm
if j in d:
slist[rj] = mm
if k in d:
slist[rk] = mm
slist[i] = d[j] = d[k] = mm
if not has_factor:
if A[i] not in d:
slist[i] = d[A[i]] = i
else:
slist[i] = d[A[i]]
for i in range(len(A)):
findAndCompact(slist, i)
cc = Counter(slist)
m = cc.most_common(1)
return m[0][1] | CLASS_DEF FUNC_DEF IF VAR RETURN NUMBER FUNC_DEF IF VAR VAR VAR RETURN VAR ASSIGN VAR VAR VAR IF VAR NUMBER VAR VAR VAR RETURN VAR WHILE VAR NUMBER VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR WHILE VAR NUMBER VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR RETURN VAR ASSIGN VAR BIN_OP LIST NUMBER FUNC_CALL VAR VAR ASSIGN VAR DICT FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR VAR VAR NUMBER NUMBER FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR VAR NUMBER FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR VAR NUMBER FUNC_CALL VAR VAR VAR VAR IF VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR VAR VAR NUMBER IF VAR VAR NUMBER ASSIGN VAR VAR VAR IF VAR VAR ASSIGN VAR VAR VAR IF VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR IF VAR IF VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR NUMBER RETURN VAR NUMBER NUMBER |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class DisjointSets:
def __init__(self, n: int):
self.p = n * [-1]
self.s = n * [1]
def find(self, i: int) -> int:
r = i
while self.p[r] != -1:
r = self.p[r]
while i != r:
self.p[i], i = r, self.p[i]
return r
def merge(self, i: int, j: int) -> int:
i = self.find(i)
j = self.find(j)
if i != j:
if self.s[i] < self.s[j]:
i, j = j, i
self.p[j] = i
self.s[i] += self.s[j]
return i
class Solution:
def largestComponentSize(self, a: List[int]) -> int:
n, m = len(a), max(a)
acnt = (m + 1) * [0]
for ai in a:
acnt[ai] += 1
acnt = list(accumulate(acnt))
ainv = n * [0]
for i in range(n - 1, -1, -1):
acnt[a[i]] -= 1
ainv[acnt[a[i]]] = i
acnt = acnt[1:] + [n]
djs = DisjointSets(n)
isp = (m + 1) * [True]
for i in range(2, m + 1):
if not isp[i]:
continue
p = -1
for j in range(i, m + 1, i):
isp[j] = False
for k in ainv[acnt[j - 1] : acnt[j]]:
if p >= 0:
djs.merge(p, k)
p = k
return max(djs.s) | CLASS_DEF FUNC_DEF VAR ASSIGN VAR BIN_OP VAR LIST NUMBER ASSIGN VAR BIN_OP VAR LIST NUMBER FUNC_DEF VAR ASSIGN VAR VAR WHILE VAR VAR NUMBER ASSIGN VAR VAR VAR WHILE VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR RETURN VAR VAR FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR RETURN VAR VAR CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR NUMBER LIST NUMBER FOR VAR VAR VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR LIST NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER NUMBER VAR VAR VAR NUMBER ASSIGN VAR VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER LIST VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP BIN_OP VAR NUMBER LIST NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR ASSIGN VAR VAR NUMBER FOR VAR VAR VAR BIN_OP VAR NUMBER VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR RETURN FUNC_CALL VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
n = len(A)
parent = list(range(n + 1))
def find(x):
if parent[x] != x:
parent[x] = find(parent[x])
return parent[x]
def union(x, y):
px = find(x)
py = find(y)
parent[px] = py
div_bucket = collections.defaultdict(list)
def findDivisor(num):
if num < 2:
return set()
for div in range(2, int(math.sqrt(num)) + 2):
if num % div == 0:
return findDivisor(num // div) | {div}
return {num}
for i in range(n):
div_set = set()
div_set = findDivisor(A[i])
for div in div_set:
div_bucket[div].append(i)
for _, nums in list(div_bucket.items()):
for j in range(len(nums) - 1):
union(nums[j], nums[j + 1])
return max(collections.Counter([find(x) for x in range(n)]).values()) | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR BIN_OP VAR NUMBER FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_DEF IF VAR NUMBER RETURN FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER RETURN BIN_OP FUNC_CALL VAR BIN_OP VAR VAR VAR RETURN VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FOR VAR VAR EXPR FUNC_CALL VAR VAR VAR FOR VAR VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR BIN_OP VAR NUMBER RETURN FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
if not A:
return 0
def find(x):
if x != parent[x]:
parent[x] = find(parent[x])
return parent[x]
def union(x, y):
parent_x, parent_y = find(x), find(y)
if parent_x != parent_y:
parent[parent_x] = parent_y
primes = []
for x in range(2, int(max(A) ** 0.5) + 1):
for y in primes:
if x % y == 0:
break
else:
primes.append(x)
factors = defaultdict(list)
for a in A:
x = a
for p in primes:
if p * p > x:
break
if x % p == 0:
factors[a].append(p)
while x % p == 0:
x //= p
if x > 1:
factors[a].append(x)
primes.append(x)
primes = list(set(primes))
n = len(primes)
primes_idx = {p: i for i, p in enumerate(primes)}
parent = [i for i in range(n)]
for a in A:
if factors[a]:
p0 = factors[a][0]
for p in factors[a][1:]:
union(primes_idx[p0], primes_idx[p])
count = Counter(find(primes_idx[factors[a][0]]) for a in A if factors[a])
return max(count.values()) | CLASS_DEF FUNC_DEF VAR VAR IF VAR RETURN NUMBER FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER FOR VAR VAR IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR ASSIGN VAR VAR FOR VAR VAR IF BIN_OP VAR VAR VAR IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR WHILE BIN_OP VAR VAR NUMBER VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FOR VAR VAR IF VAR VAR ASSIGN VAR VAR VAR NUMBER FOR VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR NUMBER VAR VAR VAR VAR RETURN FUNC_CALL VAR FUNC_CALL VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
uf = UnionFind(max(A))
for a in A:
for factor in range(2, int(sqrt(a)) + 1):
if a % factor == 0:
uf.union(a, factor)
uf.union(a, a // factor)
count_ = defaultdict(int)
out = 0
for a in A:
groupid = uf.find(a)
count_[groupid] += 1
out = max(out, count_[groupid])
return out
class UnionFind:
def __init__(self, size):
self.parent = [i for i in range(size + 1)]
self.size = [1] * (size + 1)
def find(self, num):
if self.parent[num] != num:
self.parent[num] = self.find(self.parent[num])
return self.parent[num]
def union(self, x, y):
px, py = self.find(x), self.find(y)
if self.size[px] > self.size[py]:
px, py = py, px
self.parent[px] = py
self.size[py] += self.size[px] | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FOR VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR BIN_OP VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR RETURN VAR VAR CLASS_DEF FUNC_DEF ASSIGN VAR VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class DS:
def __init__(self, n):
self.par = list(range(n))
def find(self, x):
if self.par[x] != x:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
self.par[self.find(x)] = self.find(y)
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
@lru_cache(None)
def find_prime_factors(num):
if num == 1:
return []
if num <= 3:
return [num]
for prime in range(2, int(sqrt(num)) + 1):
if num % prime == 0:
break
else:
prime = num
while num % prime == 0:
num //= prime
return [prime] + find_prime_factors(num)
s = {}
for i, num in enumerate(A):
if num == 1:
continue
primes = find_prime_factors(num)
for prime in primes:
if prime not in s:
s[prime] = []
s[prime] += [i]
ds = DS(len(A))
for prime in s:
for i in range(len(s[prime]) - 1):
ds.union(s[prime][i], s[prime][i + 1])
counter = Counter([ds.find(i) for i in range(len(A))])
return max(counter.values() or [1]) | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR CLASS_DEF FUNC_DEF VAR VAR FUNC_DEF IF VAR NUMBER RETURN LIST IF VAR NUMBER RETURN LIST VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER ASSIGN VAR VAR WHILE BIN_OP VAR VAR NUMBER VAR VAR RETURN BIN_OP LIST VAR FUNC_CALL VAR VAR FUNC_CALL VAR NONE ASSIGN VAR DICT FOR VAR VAR FUNC_CALL VAR VAR IF VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR IF VAR VAR ASSIGN VAR VAR LIST VAR VAR LIST VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FOR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR RETURN FUNC_CALL VAR FUNC_CALL VAR LIST NUMBER VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def __init__(self):
self.arr = []
def fac(self, n):
for i in range(2, floor(sqrt(n) + 1)):
if n % i == 0:
self.union(n, i)
self.union(n, n // i)
def find(self, x):
if self.arr[x] != x:
self.arr[x] = self.find(self.arr[x])
return self.arr[x]
def union(self, x, y):
xr, yr = self.find(x), self.find(y)
self.arr[xr] = yr
def largestComponentSize(self, A: List[int]) -> int:
self.arr = [0] * (max(A) + 1)
ans = [0] * (max(A) + 1)
A.sort()
for j, i in enumerate(self.arr):
self.arr[j] = j
for i in A:
self.fac(i)
for i in A:
ans[self.find(i)] += 1
return max(ans) | CLASS_DEF FUNC_DEF ASSIGN VAR LIST FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR BIN_OP VAR VAR FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_DEF VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP LIST NUMBER BIN_OP FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR FOR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FOR VAR VAR EXPR FUNC_CALL VAR VAR FOR VAR VAR VAR FUNC_CALL VAR VAR NUMBER RETURN FUNC_CALL VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
graphs = {}
def prime_factors(n):
factors = set()
while n % 2 == 0:
factors.add(2)
n = n // 2
for i in range(3, int(math.sqrt(n)) + 1, 2):
while n % i == 0:
factors.add(i)
n = n // i
if n > 2:
factors.add(n)
return factors
for num in A:
facts = prime_factors(num)
if num not in graphs:
graphs[num] = set()
for fact in facts:
if fact not in graphs:
graphs[fact] = set()
graphs[fact].add(num)
graphs[num].add(fact)
groups, n_group = {}, 0
def dfs(factor, group_id):
groups[factor] = group_id
for next_factor in graphs[factor]:
if next_factor not in groups:
dfs(next_factor, group_id)
for f in graphs:
if f not in groups:
n_group += 1
dfs(f, n_group)
group_count = {}
for num in A:
group_id = groups[num]
if group_id not in group_count:
group_count[group_id] = 0
group_count[group_id] += 1
return max(group_count.values()) | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR DICT FUNC_DEF ASSIGN VAR FUNC_CALL VAR WHILE BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER NUMBER WHILE BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR RETURN VAR FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR ASSIGN VAR VAR FUNC_CALL VAR FOR VAR VAR IF VAR VAR ASSIGN VAR VAR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR DICT NUMBER FUNC_DEF ASSIGN VAR VAR VAR FOR VAR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR VAR FOR VAR VAR IF VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR DICT FOR VAR VAR ASSIGN VAR VAR VAR IF VAR VAR ASSIGN VAR VAR NUMBER VAR VAR NUMBER RETURN FUNC_CALL VAR FUNC_CALL VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class UF:
def __init__(self, n):
self.f = list(range(n))
self.cc = [1] * n
def find(self, x):
while x != self.f[x]:
x = self.f[x]
return x
def union(self, x, y):
fx, fy = self.find(x), self.find(y)
if fx != fy:
if self.cc[fx] <= self.cc[fy]:
self.f[fx] = fy
self.cc[fx], self.cc[fy] = 0, self.cc[fx] + self.cc[fy]
else:
self.f[fy] = fx
self.cc[fy], self.cc[fx] = 0, self.cc[fx] + self.cc[fy]
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
if not A:
return 0
n = len(A)
uf = UF(n)
def getPrimeSets(num, num2primes):
if num2primes[num]:
return num2primes[num]
for i in range(2, int(math.sqrt(num)) + 1):
if num % i == 0:
num2primes[num] = getPrimeSets(i, num2primes) | getPrimeSets(
num // i, num2primes
)
return num2primes[num]
num2primes[num] = set([num])
return num2primes[num]
num2primes = collections.defaultdict(set)
for num in sorted(A):
getPrimeSets(num, num2primes)
prime2numIdxs = collections.defaultdict(list)
for idx, num in enumerate(A):
ps = num2primes[num]
for p in ps:
prime2numIdxs[p].append(idx)
for _, idxs in list(prime2numIdxs.items()):
for i in range(len(idxs) - 1):
uf.union(idxs[i], idxs[i + 1])
res = 1
for i in range(n):
res = max(uf.cc[i], res)
return res | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FUNC_DEF WHILE VAR VAR VAR ASSIGN VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR VAR IF VAR VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR VAR NUMBER BIN_OP VAR VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR VAR NUMBER BIN_OP VAR VAR VAR VAR CLASS_DEF FUNC_DEF VAR VAR IF VAR RETURN NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_DEF IF VAR VAR RETURN VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER ASSIGN VAR VAR BIN_OP FUNC_CALL VAR VAR VAR FUNC_CALL VAR BIN_OP VAR VAR VAR RETURN VAR VAR ASSIGN VAR VAR FUNC_CALL VAR LIST VAR RETURN VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FOR VAR VAR EXPR FUNC_CALL VAR VAR VAR FOR VAR VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR RETURN VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class UnionFind:
def __init__(self, N):
self.par = list(range(N))
self.rank = [0] * N
self.size = [0] * N
def find(self, x):
if self.par[x] != x:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
px, py = self.find(x), self.find(y)
if px == py:
return
if self.rank[px] < self.rank[py]:
self.par[px] = py
self.size[py] += self.size[px]
elif self.rank[px] > self.rank[py]:
self.par[py] = px
self.size[px] += self.size[py]
else:
self.par[py] = px
self.rank[px] += 1
self.size[px] += self.size[py]
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
N = max(A)
primes = []
res = 0
for i in range(2, int(N**0.5) + 1):
for j in primes:
if i % j == 0:
break
else:
primes.append(i)
uf = UnionFind(N + 1)
used_primes = set()
for a in A:
if a < 2:
continue
a_primes = []
for p in primes:
if p * p > a:
break
if a % p == 0:
a_primes.append(p)
while a % p == 0:
a //= p
if a > 1:
a_primes.append(a)
idx = uf.find(a_primes[0])
used_primes.add(a_primes[0])
uf.size[idx] += 1
for i in range(1, len(a_primes)):
uf.union(a_primes[0], a_primes[i])
for a in used_primes:
idx = uf.find(a)
res = max(res, uf.size[idx])
return res | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR VAR RETURN IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR NUMBER VAR VAR VAR VAR CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR LIST ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER FOR VAR VAR IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR FOR VAR VAR IF VAR NUMBER ASSIGN VAR LIST FOR VAR VAR IF BIN_OP VAR VAR VAR IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR WHILE BIN_OP VAR VAR NUMBER VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR NUMBER VAR VAR FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR RETURN VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
uf = {}
def find(x):
uf.setdefault(x, x)
if uf[x] != x:
uf[x] = find(uf[x])
return uf[x]
def union(x, y):
uf[find(x)] = find(y)
def primeFactor(x):
ans = set()
if not x % 2:
ans.add(2)
while not x % 2:
x //= 2
for k in range(3, int(sqrt(x)) + 1, 2):
if not x % k:
ans.add(k)
while not x % k:
x //= k
if x == 1:
break
if x > 1:
ans.add(x)
return ans
for a in A:
for k in primeFactor(a):
union(a, k)
return max(Counter([find(a) for a in A]).values()) | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR DICT FUNC_DEF EXPR FUNC_CALL VAR VAR VAR IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR IF BIN_OP VAR NUMBER EXPR FUNC_CALL VAR NUMBER WHILE BIN_OP VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER NUMBER IF BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR WHILE BIN_OP VAR VAR VAR VAR IF VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR VAR RETURN VAR FOR VAR VAR FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR RETURN FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
n = len(A)
parents = [-1] * n
factors = {}
for i, a in enumerate(A):
primes = self.primes(a)
for p in primes:
if p in factors:
self.union(parents, i, factors[p])
factors[p] = i
return max(-c for c in parents if c < 0)
def primes(self, n):
ans = set()
while not n % 2:
ans.add(2)
n //= 2
for i in range(3, int(sqrt(n)) + 1, 2):
while not n % i:
ans.add(i)
n //= i
if n > 1:
ans.add(n)
return ans
def find(self, parents, n):
while parents[n] > 0:
n = parents[n]
return n
def union(self, parents, i, j):
parent_i, parent_j = self.find(parents, i), self.find(parents, j)
if parent_i != parent_j:
if parents[parent_i] > parents[parent_j]:
parent_i, parent_j = parent_j, parent_i
parents[parent_i] += parents[parent_j]
parents[parent_j] = parent_i | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR DICT FOR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR RETURN FUNC_CALL VAR VAR VAR VAR VAR NUMBER VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR WHILE BIN_OP VAR NUMBER EXPR FUNC_CALL VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER NUMBER WHILE BIN_OP VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR RETURN VAR FUNC_DEF WHILE VAR VAR NUMBER ASSIGN VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR VAR IF VAR VAR IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def find(self, i, parent):
if parent[i] == -1:
return i
parent[i] = self.find(parent[i], parent)
return parent[i]
def union(self, i, j, parent):
rooti = self.find(i, parent)
rootj = self.find(j, parent)
if rooti != rootj:
parent[rooti] = rootj
def largestComponentSize(self, A: List[int]) -> int:
hm = defaultdict(int)
parent = [-1] * 100001
for i in A:
for j in range(2, int(sqrt(i)) + 1):
if i % j == 0:
self.union(i, j, parent)
self.union(i // j, i, parent)
for i in A:
parenti = self.find(i, parent)
hm[parenti] += 1
return max(hm.values()) | CLASS_DEF FUNC_DEF IF VAR VAR NUMBER RETURN VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR IF VAR VAR ASSIGN VAR VAR VAR FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER NUMBER FOR VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR VAR VAR VAR FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR NUMBER RETURN FUNC_CALL VAR FUNC_CALL VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class UnionFind:
def __init__(self, n):
self.parent = [i for i in range(n + 1)]
self.size = [(1) for i in range(n + 1)]
def find(self, u):
while u != self.parent[u]:
self.parent[u] = self.parent[self.parent[u]]
u = self.parent[u]
return u
def union(self, u, v):
pu = self.find(u)
pv = self.find(v)
if pu == pv:
return False
if self.size[pu] > self.size[pv]:
pu, pv = pv, pu
self.parent[pu] = pv
self.size[pv] += self.size[pu]
return True
class Solution:
def sharecommon(self, a, b):
for k in range(2, min(a, b) + 1):
if a % k == 0 and b % k == 0:
return True
return False
def largestComponentSize(self, A: List[int]) -> int:
if not A:
return 0
ufs = UnionFind(max(A))
foundSet = collections.defaultdict(int)
for a in A:
for factor in range(2, int(sqrt(a)) + 1):
if a % factor == 0:
ufs.union(a, factor)
ufs.union(a, a // factor)
for a in A:
foundSet[ufs.find(a)] += 1
return max(foundSet.values()) if foundSet else 1 | CLASS_DEF FUNC_DEF ASSIGN VAR VAR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER VAR FUNC_CALL VAR BIN_OP VAR NUMBER FUNC_DEF WHILE VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR RETURN NUMBER IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR RETURN NUMBER CLASS_DEF FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER BIN_OP VAR VAR NUMBER RETURN NUMBER RETURN NUMBER FUNC_DEF VAR VAR IF VAR RETURN NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR BIN_OP VAR VAR FOR VAR VAR VAR FUNC_CALL VAR VAR NUMBER RETURN VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
mp = {}
ans = 0
def find(a):
if a not in mp:
mp[a] = a
if mp[a] != a:
mp[a] = find(mp[a])
return mp[a]
def union(a, b):
pa = find(a)
pb = find(b)
if pa != pb:
mp[pa] = pb
for a in A:
t = int(math.sqrt(a))
for k in range(2, t + 1):
if a % k == 0:
union(a, k)
union(a, a / k)
return collections.Counter([find(a) for a in A]).most_common(1)[0][1] | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR DICT ASSIGN VAR NUMBER FUNC_DEF IF VAR VAR ASSIGN VAR VAR VAR IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR ASSIGN VAR VAR VAR FOR VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR BIN_OP VAR VAR RETURN FUNC_CALL FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR NUMBER NUMBER NUMBER VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class DSU:
def __init__(self):
self.N = 0
self.map = {}
self.parent = []
self.count = []
def __contains__(self, obj):
return obj in self.map
def add(self, obj):
if obj in self:
return
i = self.N
self.N += 1
self.map[obj] = i
self.parent.append(i)
self.count.append(0)
def find(self, obj):
p = self.parent
origI = self.map[obj]
i = origI
while p[i] != i:
i = p[i]
root = i
i = origI
while p[i] != i:
p[i], i = root, p[i]
return root
def union(self, objA, objB):
rObjA = self.find(objA)
rObjB = self.find(objB)
if rObjA == rObjB:
return
self.count[rObjA] += self.count[rObjB]
self.parent[rObjB] = rObjA
def incCount(self, obj):
rObj = self.find(obj)
self.count[rObj] += 1
return self.count[rObj]
class Solution:
def largestComponentSize(self, nums) -> int:
UF = DSU()
max_ = 1
for num in nums:
if num == 1:
continue
pDs = self.primeDivisors(num)
pD0 = pDs.pop()
UF.add(pD0)
for pD in pDs:
UF.add(pD)
UF.union(pD0, pD)
count = UF.incCount(pD0)
max_ = max(max_, count)
return max_
def primeDivisors(self, num: int):
x = num
pDs = set()
if x % 2 == 0:
pDs.add(2)
while x % 2 == 0:
x >>= 1
if x % 3 == 0:
pDs.add(3)
while x % 3 == 0:
x //= 3
div = 5
d2 = True
while x >= div * div:
if x % div == 0:
pDs.add(div)
while x % div == 0:
x //= div
div += 2 if d2 else 4
d2 = not d2
if x > 1:
pDs.add(x)
return pDs | CLASS_DEF FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR DICT ASSIGN VAR LIST ASSIGN VAR LIST FUNC_DEF RETURN VAR VAR FUNC_DEF IF VAR VAR RETURN ASSIGN VAR VAR VAR NUMBER ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR NUMBER FUNC_DEF ASSIGN VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR WHILE VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR WHILE VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR RETURN VAR VAR VAR VAR ASSIGN VAR VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR VAR VAR NUMBER RETURN VAR VAR CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR VAR IF VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR FOR VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF VAR ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR IF BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR NUMBER WHILE BIN_OP VAR NUMBER NUMBER VAR NUMBER IF BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR NUMBER WHILE BIN_OP VAR NUMBER NUMBER VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR BIN_OP VAR VAR IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR WHILE BIN_OP VAR VAR NUMBER VAR VAR VAR VAR NUMBER NUMBER ASSIGN VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR RETURN VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
divisors, groups, sizes = {}, {}, {}
for num in A:
added = False
for i in range(2, max(int(math.sqrt(num)) + 1, 4)):
if num % i == 0:
added = True
if i not in divisors:
divisors[i] = set()
divisors[i].add(num)
if (num_i := int(num / i)) > 1:
if num_i not in divisors:
divisors[num_i] = set()
divisors[num_i].add(num)
if not added:
if num not in divisors:
divisors[num] = set()
divisors[num].add(num)
def union(node1: int, node2: int) -> None:
parent1 = find(node1)
parent2 = find(node2)
if parent1 == parent2:
return
elif parent1 < parent2:
groups[parent2] = parent1
sizes[parent1] = sizes[parent1] + sizes[parent2]
else:
groups[parent1] = parent2
sizes[parent2] = sizes[parent1] + sizes[parent2]
def find(node: int) -> int:
if node not in groups:
groups[node] = node
sizes[node] = 1
return node
if groups[node] == node:
return node
groups[node] = find(groups[node])
return groups[node]
for _, common_numbers in list(divisors.items()):
num1 = random.sample(common_numbers, 1)[0]
for num2 in common_numbers:
if num1 != num2:
union(num1, num2)
return max(list(sizes.values()), default=1) | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR VAR VAR DICT DICT DICT FOR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER NUMBER IF BIN_OP VAR VAR NUMBER ASSIGN VAR NUMBER IF VAR VAR ASSIGN VAR VAR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR VAR IF VAR FUNC_CALL VAR BIN_OP VAR VAR NUMBER IF VAR VAR ASSIGN VAR VAR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR VAR IF VAR IF VAR VAR ASSIGN VAR VAR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR VAR FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR RETURN IF VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR VAR VAR NONE FUNC_DEF VAR IF VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR NUMBER RETURN VAR IF VAR VAR VAR RETURN VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR VAR FOR VAR VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR NUMBER NUMBER FOR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR VAR RETURN FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class UnionFind:
def __init__(self, val):
self.val = val
self.parent = self
def union(self, uf):
uf.find().parent = self.find()
def find(self):
if self.parent == self:
return self
self.parent = self.parent.find()
return self.parent
class Solution:
def primeSet(self, n, cache):
if n in cache:
return cache[n]
for i in range(2, int(sqrt(n)) + 1):
if n % i == 0:
cache[n] = self.primeSet(n // i, cache) | set([i])
return cache[n]
cache[n] = set([n])
return cache[n]
def largestComponentSize(self, A: List[int]) -> int:
unionFinds = {x: UnionFind(x) for x in A}
cache = {}
numbersThatThisPrimeIsAFactor = defaultdict(list)
for x in A:
primes = self.primeSet(x, cache)
for p in primes:
numbersThatThisPrimeIsAFactor[p].append(x)
for _, p in numbersThatThisPrimeIsAFactor.items():
for i in range(len(p) - 1):
unionFinds[p[i]].union(unionFinds[p[i + 1]])
return max(Counter([unionFinds[x].find().val for x in A]).values()) | CLASS_DEF FUNC_DEF ASSIGN VAR VAR ASSIGN VAR VAR FUNC_DEF ASSIGN FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF IF VAR VAR RETURN VAR ASSIGN VAR FUNC_CALL VAR RETURN VAR CLASS_DEF FUNC_DEF IF VAR VAR RETURN VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER ASSIGN VAR VAR BIN_OP FUNC_CALL VAR BIN_OP VAR VAR VAR FUNC_CALL VAR LIST VAR RETURN VAR VAR ASSIGN VAR VAR FUNC_CALL VAR LIST VAR RETURN VAR VAR FUNC_DEF VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR DICT ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FOR VAR VAR EXPR FUNC_CALL VAR VAR VAR FOR VAR VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR VAR BIN_OP VAR NUMBER RETURN FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
parents = list(range(max(A) + 1))
def find(x):
while parents[x] != x:
parents[x] = parents[parents[x]]
x = parents[x]
return x
def union(x, y):
parents[find(x)] = parents[find(y)]
for num in A:
for k in range(2, int(sqrt(num)) + 1):
if num % k == 0:
union(num, k)
union(num, num // k)
counts = {}
maxC = 0
for num in A:
target = find(num)
counts[target] = counts.get(target, 0) + 1
maxC = max(maxC, counts[target])
return maxC | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER FUNC_DEF WHILE VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR FOR VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR BIN_OP VAR VAR ASSIGN VAR DICT ASSIGN VAR NUMBER FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR RETURN VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
def find(n):
if n not in root:
return n
root[n] = find(root[n])
return root[n]
def union(n1, n2):
root1, root2 = find(n1), find(n2)
if root1 == root2:
return
rank1, rank2 = rank[root1], rank[root2]
if rank1 > rank2:
root[root2] = root1
size[root1] += size[root2]
elif rank1 < rank2:
root[root1] = root2
size[root2] += size[root1]
else:
root[root1] = root2
size[root2] += size[root1]
rank[root2] += 1
def find_prime_factors(n):
factors = set()
while n % 2 == 0:
factors.add(2)
n //= 2
for i in range(3, int(math.sqrt(n)) + 1, 2):
while n % i == 0:
factors.add(i)
n //= i
if n > 2:
factors.add(n)
return factors
factor_to_num = collections.defaultdict(list)
for n in A:
for factor in find_prime_factors(n):
factor_to_num[factor].append(n)
root = {}
rank = {n: (1) for n in A}
size = {n: (1) for n in A}
for factor in factor_to_num:
first_root = find(factor_to_num[factor][0])
for i in range(1, len(factor_to_num[factor])):
union(first_root, factor_to_num[factor][i])
return max(size.values()) | CLASS_DEF FUNC_DEF VAR VAR FUNC_DEF IF VAR VAR RETURN VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR VAR RETURN ASSIGN VAR VAR VAR VAR VAR VAR IF VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR IF VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR VAR VAR NUMBER FUNC_DEF ASSIGN VAR FUNC_CALL VAR WHILE BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR NUMBER VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER NUMBER WHILE BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR RETURN VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR DICT ASSIGN VAR VAR NUMBER VAR VAR ASSIGN VAR VAR NUMBER VAR VAR FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR VAR RETURN FUNC_CALL VAR FUNC_CALL VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
parent = {}
size = defaultdict(lambda: 1)
def ds(a):
while a in parent:
a = parent[a]
return a
def union(a, b):
if (a := ds(a)) != (b := ds(b)):
if size[a] < size[b]:
a, b = b, a
parent[b] = a
size[a] += size[b]
for a in A:
for d in factors(a):
union(-d, a)
return Counter(ds(a) for a in A).most_common(1)[0][1]
FS = {}
def factors(f):
if (n := f) not in FS:
if n & 1:
FS[f] = factors3(f)
else:
n >>= 1
while n & 1 == 0:
n >>= 1
if n > 1:
FS[f] = factors3(n) + [2]
else:
FS[f] = [2]
return FS[f]
def factors3(f, start=3):
if (n := f) not in FS:
for i in range(start, int(sqrt(n)) + 1, 2):
if n % i == 0:
n = n // i
while n % i == 0:
n = n // i
if n > 1:
FS[f] = factors3(n, i + 2) + [i]
else:
FS[f] = [i]
break
else:
FS[f] = [f]
return FS[f] | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR DICT ASSIGN VAR FUNC_CALL VAR NUMBER FUNC_DEF WHILE VAR VAR ASSIGN VAR VAR VAR RETURN VAR FUNC_DEF IF VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR FOR VAR VAR FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR RETURN FUNC_CALL FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR NUMBER NUMBER NUMBER VAR ASSIGN VAR DICT FUNC_DEF IF VAR VAR VAR IF BIN_OP VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR VAR VAR NUMBER WHILE BIN_OP VAR NUMBER NUMBER VAR NUMBER IF VAR NUMBER ASSIGN VAR VAR BIN_OP FUNC_CALL VAR VAR LIST NUMBER ASSIGN VAR VAR LIST NUMBER RETURN VAR VAR FUNC_DEF NUMBER IF VAR VAR VAR FOR VAR FUNC_CALL VAR VAR BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER NUMBER IF BIN_OP VAR VAR NUMBER ASSIGN VAR BIN_OP VAR VAR WHILE BIN_OP VAR VAR NUMBER ASSIGN VAR BIN_OP VAR VAR IF VAR NUMBER ASSIGN VAR VAR BIN_OP FUNC_CALL VAR VAR BIN_OP VAR NUMBER LIST VAR ASSIGN VAR VAR LIST VAR ASSIGN VAR VAR LIST VAR RETURN VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def find(self, parent: List[int], x: int):
if not parent[x] == x:
parent[x] = self.find(parent, parent[x])
return parent[x]
def largestComponentSize(self, A: List[int]) -> int:
n, mx, res = 0, max(A), 0
valtocnt = collections.Counter()
parent = list(range(mx + 1))
for num in A:
for d in range(int(sqrt(num)), 1, -1):
if num % d == 0:
parent[self.find(parent, num)] = parent[self.find(parent, d)]
parent[self.find(parent, num)] = parent[self.find(parent, num // d)]
for num in A:
valtocnt[self.find(parent, num)] += 1
res = max(res, valtocnt[self.find(parent, num)])
return res | CLASS_DEF FUNC_DEF VAR VAR VAR IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR VAR RETURN VAR VAR FUNC_DEF VAR VAR ASSIGN VAR VAR VAR NUMBER FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER NUMBER IF BIN_OP VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR FUNC_CALL VAR VAR BIN_OP VAR VAR FOR VAR VAR VAR FUNC_CALL VAR VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
N = len(A)
p = [i for i in range(N)]
def uf(i):
if i == p[i]:
return i
p[i] = uf(p[i])
return p[i]
dt = collections.defaultdict(set)
def prime_factor(index):
i = A[index]
while i % 2 == 0:
dt[2].add(index)
i //= 2
for j in range(3, int(A[index] ** 0.5) + 1, 2):
while i % j == 0:
dt[j].add(index)
i //= j
if i > 2:
dt[i].add(index)
cnt = collections.defaultdict(int)
for i in range(N):
prime_factor(i)
for _, v in list(dt.items()):
pi = uf(v.pop())
while v:
pj = uf(v.pop())
p[pj] = pi
res = 1
for i in range(N):
pi = uf(i)
cnt[pi] += 1
res = max(res, cnt[pi])
return res | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR FUNC_DEF IF VAR VAR VAR RETURN VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_DEF ASSIGN VAR VAR VAR WHILE BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR NUMBER VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP VAR VAR NUMBER NUMBER NUMBER WHILE BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR FOR VAR VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR VAR RETURN VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class UnionFind:
def __init__(self, N):
self.parent = list(range(N))
self.size = [1] * N
self.Max = 1
def find(self, e):
if self.parent[e] != e:
self.parent[e] = self.find(self.parent[e])
return self.parent[e]
def union(self, x, y):
headx = self.find(x)
heady = self.find(y)
if headx != heady:
self.parent[headx] = heady
self.size[heady] += self.size[headx]
self.Max = max(self.Max, self.size[heady])
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
def primeFact(num):
res = []
n = num
if n % 2 == 0:
res.append(2)
n /= 2
while n % 2 == 0:
n /= 2
f = 3
lim = int(sqrt(n) + 1)
while f < lim and n > 1:
if n % f == 0:
res.append(f)
n /= f
while n % f == 0:
n /= f
f += 2
if n > 2:
res.append(int(n))
return res
uf = UnionFind(len(A))
d = {}
for i, num in enumerate(A):
factors = primeFact(num)
for factor in factors:
if factor not in d:
d[factor] = [i]
else:
d[factor].append(i)
for factor in d:
for j in range(len(d[factor]) - 1):
uf.union(d[factor][j], d[factor][j + 1])
return uf.Max | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR CLASS_DEF FUNC_DEF VAR VAR FUNC_DEF ASSIGN VAR LIST ASSIGN VAR VAR IF BIN_OP VAR NUMBER NUMBER EXPR FUNC_CALL VAR NUMBER VAR NUMBER WHILE BIN_OP VAR NUMBER NUMBER VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER WHILE VAR VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR WHILE BIN_OP VAR VAR NUMBER VAR VAR VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR RETURN VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR DICT FOR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR IF VAR VAR ASSIGN VAR VAR LIST VAR EXPR FUNC_CALL VAR VAR VAR FOR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR VAR VAR BIN_OP VAR NUMBER RETURN VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def _factorize(self, n):
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
return self._factorize(n // i) | set([i])
return set([n])
def largestComponentSize(self, A: List[int]) -> int:
primes = set()
factors = {}
for x in A:
f = self._factorize(x)
primes |= f
factors[x] = list(f)
uf = UF(primes, A)
for x in A:
for j in range(len(factors[x])):
uf.union(x, factors[x][j])
uf.sz[uf.root(x)] += 1
return max([v for _, v in uf.sz.items()])
class UF:
def __init__(self, primes, A):
self.parent = {p: p for p in primes}
for p in A:
self.parent[p] = p
self.sz = {p: (0) for p in primes}
for p in A:
self.sz[p] = 0
def root(self, u):
while self.parent[u] != u:
self.parent[u] = self.parent[self.parent[u]]
u = self.parent[u]
return u
def union(self, u, v):
r_u = self.root(u)
r_v = self.root(v)
if r_u == r_v:
return
if self.sz[r_u] > self.sz[r_v]:
self.parent[r_v] = r_u
self.sz[r_u] += self.sz[r_v]
else:
self.parent[r_u] = r_v
self.sz[r_v] += self.sz[r_u] | CLASS_DEF FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER RETURN BIN_OP FUNC_CALL VAR BIN_OP VAR VAR FUNC_CALL VAR LIST VAR RETURN FUNC_CALL VAR LIST VAR FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR DICT FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FOR VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR VAR VAR FUNC_CALL VAR VAR NUMBER RETURN FUNC_CALL VAR VAR VAR VAR FUNC_CALL VAR VAR CLASS_DEF FUNC_DEF ASSIGN VAR VAR VAR VAR VAR FOR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR NUMBER VAR VAR FOR VAR VAR ASSIGN VAR VAR NUMBER FUNC_DEF WHILE VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR RETURN IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class UnionFind:
def __init__(self, num: int):
self.parents = [i for i in range(num)]
self.size = [1] * num
self.max = 1
def find(self, number: int) -> int:
if self.parents[number] != number:
self.parents[number] = self.find(self.parents[number])
return self.parents[number]
def merge(self, x: int, other: int):
parentX = self.find(x)
parentOther = self.find(other)
if parentX != parentOther:
size_x, size_y = self.parents[parentX], self.parents[parentOther]
self.parents[parentX] = parentOther
self.size[parentOther] += self.size[parentX]
if self.size[parentOther] > self.max:
self.max = self.size[parentOther]
class Solution:
def primesBefore(self, value: int) -> List[int]:
candidates = [True] * (value + 1)
primeList = []
for i in range(2, value + 1):
if not candidates[i]:
continue
primeList.append(i)
for j in range(i, value + 1, i):
candidates[j] = False
return primeList
def largestComponentSize(self, A: List[int]) -> int:
union_find = UnionFind(len(A))
cache = {}
primes = self.primesBefore(max(A))
primeset = set(primes)
for index, value in enumerate(A):
svalue = value
primeIndex = 0
while svalue not in primeset and primes[primeIndex] <= svalue:
j = primes[primeIndex]
if svalue % j != 0:
primeIndex += 1
continue
if j not in cache:
cache[j] = index
else:
union_find.merge(index, cache[j])
if value // j not in cache:
cache[value // j] = index
else:
union_find.merge(index, cache[value // j])
while svalue % j == 0:
svalue //= j
primeIndex += 1
if svalue == 1:
continue
if svalue not in cache:
cache[svalue] = index
else:
union_find.merge(index, cache[svalue])
return union_find.max | CLASS_DEF FUNC_DEF VAR ASSIGN VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER FUNC_DEF VAR IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR VAR FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR IF VAR VAR VAR ASSIGN VAR VAR VAR CLASS_DEF FUNC_DEF VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR VAR EXPR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR ASSIGN VAR VAR NUMBER RETURN VAR VAR VAR FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR DICT ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR ASSIGN VAR NUMBER WHILE VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR IF BIN_OP VAR VAR NUMBER VAR NUMBER IF VAR VAR ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR IF BIN_OP VAR VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR BIN_OP VAR VAR WHILE BIN_OP VAR VAR NUMBER VAR VAR VAR NUMBER IF VAR NUMBER IF VAR VAR ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR RETURN VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class UF:
def __init__(self, n):
self.parent = list(range(n))
self.size = [1] * n
def find(self, x):
if self.parent[x] != x:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def union(self, x, y):
px, py = self.find(x), self.find(y)
if px != py:
if self.size[px] < self.size[py]:
px, py = py, px
self.parent[py] = px
self.size[px] += self.size[py]
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
prime = [0, 0] + [1] * (int(max(A) ** 0.5 + 1) - 2)
for i in range(2, int(len(prime) ** 0.5) + 1):
if prime[i]:
prime[i * i :: i] = [0] * ((len(prime) - 1) // i - i + 1)
prime = [i for i, x in enumerate(prime) if x]
factor = collections.defaultdict(list)
for i, x in enumerate(A):
for p in prime:
if p * p > x:
break
if x % p == 0:
factor[p].append(i)
while x % p == 0:
x //= p
if x > 1:
factor[x].append(i)
uf = UF(len(A))
for numbers in factor.values():
for i, j in zip(numbers, numbers[1:]):
uf.union(i, j)
return max(uf.size) | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR VAR IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR BIN_OP LIST NUMBER NUMBER BIN_OP LIST NUMBER BIN_OP FUNC_CALL VAR BIN_OP BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER IF VAR VAR ASSIGN VAR BIN_OP VAR VAR VAR BIN_OP LIST NUMBER BIN_OP BIN_OP BIN_OP BIN_OP FUNC_CALL VAR VAR NUMBER VAR VAR NUMBER ASSIGN VAR VAR VAR VAR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR FUNC_CALL VAR VAR FOR VAR VAR IF BIN_OP VAR VAR VAR IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR WHILE BIN_OP VAR VAR NUMBER VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR FOR VAR VAR FUNC_CALL VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR RETURN FUNC_CALL VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class DSU:
def __init__(self, vals):
self.p = {v: v for v in vals}
def find(self, v):
if self.p[v] != v:
self.p[v] = self.find(self.p[v])
return self.p[v]
def union(self, u, v):
pu, pv = self.find(u), self.find(v)
if pu != pv:
self.p[pu] = pv
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
factors = collections.defaultdict(list)
primes = self.getPrimes(A)
for a in A:
x = a
for p in primes:
if p * p > x:
break
if x % p == 0:
factors[a].append(p)
while x % p == 0:
x //= p
if x > 1:
factors[a].append(x)
primes.append(x)
primes = list(set(primes))
dsu = DSU(primes)
for a in A:
if factors[a]:
p0 = factors[a][0]
for p in factors[a][1:]:
dsu.union(p0, p)
cnt = collections.Counter(dsu.find(factors[a][0]) for a in A if factors[a])
return max(cnt.values())
def getPrimes(self, A):
primes = []
for x in range(2, int(math.sqrt(max(A))) + 1):
for y in primes:
if x % y == 0:
break
else:
primes.append(x)
return primes | CLASS_DEF FUNC_DEF ASSIGN VAR VAR VAR VAR VAR FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR VAR ASSIGN VAR VAR VAR CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR ASSIGN VAR VAR FOR VAR VAR IF BIN_OP VAR VAR VAR IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR WHILE BIN_OP VAR VAR NUMBER VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR IF VAR VAR ASSIGN VAR VAR VAR NUMBER FOR VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR NUMBER VAR VAR VAR VAR RETURN FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_DEF ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER FOR VAR VAR IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR RETURN VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution1:
def largestComponentSize(self, A):
if not A:
return 0
def findAndCompact(l, i):
if l[i] == i:
return i
p = l[i]
if p >= 0 and l[p] == p:
return p
while p >= 0 and l[p] != p:
p = l[p]
root = p
p = i
while p >= 0 and l[p] != p:
t = l[p]
l[p] = root
p = t
return root
slist = [-1] * len(A)
d = {}
for i in range(len(A)):
n = A[i]
has_factor = False
for j in range(2, int(sqrt(n)) + 1):
if n % j == 0:
has_factor = True
k = n // j
ri = -1 if slist[i] < 0 else findAndCompact(slist, slist[i])
rj = -1 if j not in d else findAndCompact(slist, d[j])
rk = -1 if k not in d else findAndCompact(slist, d[k])
if ri < 0 and rj < 0 and rk < 0:
slist[i] = d[j] = d[k] = i
else:
mm = min([item for item in (ri, rj, rk) if item >= 0])
if slist[i] >= 0:
slist[ri] = mm
if j in d:
slist[rj] = mm
if k in d:
slist[rk] = mm
slist[i] = d[j] = d[k] = mm
if not has_factor:
if A[i] not in d:
slist[i] = d[A[i]] = i
else:
slist[i] = d[A[i]]
for i in range(len(A)):
findAndCompact(slist, i)
cc = Counter(slist)
m = cc.most_common(2)
return m[0][1] if m[0][0] != -1 else m[1][1]
class DSU:
def __init__(self, N):
self.p = list(range(N))
def find(self, x):
n = self.p[x]
while n >= 0 and self.p[n] != n:
n = self.p[n]
root = n
n = x
while n >= 0 and self.p[n] != n:
t = self.p[n]
self.p[n] = root
n = t
return root
def union(self, x, y):
xr, yr = self.find(x), self.find(y)
self.p[xr] = yr
class Solution:
def primes_set(self, n):
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
return self.primes_set(n // i) | set([i])
return set([n])
def largestComponentSize(self, A):
n = len(A)
UF = DSU(n)
primes = defaultdict(list)
for i, num in enumerate(A):
pr_set = self.primes_set(num)
for q in pr_set:
primes[q].append(i)
for _, indexes in primes.items():
for i in range(len(indexes) - 1):
UF.union(indexes[i], indexes[i + 1])
return max(Counter([UF.find(i) for i in range(n)]).values()) | CLASS_DEF FUNC_DEF IF VAR RETURN NUMBER FUNC_DEF IF VAR VAR VAR RETURN VAR ASSIGN VAR VAR VAR IF VAR NUMBER VAR VAR VAR RETURN VAR WHILE VAR NUMBER VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR WHILE VAR NUMBER VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR RETURN VAR ASSIGN VAR BIN_OP LIST NUMBER FUNC_CALL VAR VAR ASSIGN VAR DICT FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR VAR VAR NUMBER NUMBER FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR VAR NUMBER FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR VAR NUMBER FUNC_CALL VAR VAR VAR VAR IF VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR VAR VAR NUMBER IF VAR VAR NUMBER ASSIGN VAR VAR VAR IF VAR VAR ASSIGN VAR VAR VAR IF VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR IF VAR IF VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR NUMBER RETURN VAR NUMBER NUMBER NUMBER VAR NUMBER NUMBER VAR NUMBER NUMBER CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_DEF ASSIGN VAR VAR VAR WHILE VAR NUMBER VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR WHILE VAR NUMBER VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR CLASS_DEF FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER RETURN BIN_OP FUNC_CALL VAR BIN_OP VAR VAR FUNC_CALL VAR LIST VAR RETURN FUNC_CALL VAR LIST VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR EXPR FUNC_CALL VAR VAR VAR FOR VAR VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR BIN_OP VAR NUMBER RETURN FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
mem = {}
def getFactors(num: int) -> set:
if num in mem:
return mem[num]
for divBy in range(2, floor(sqrt(num)) + 1):
if num % divBy == 0:
mem[num] = getFactors(num // divBy) | set([divBy])
return mem[num]
mem[num] = set([num])
return mem[num]
groups = {}
factorToNum = {}
numToGroupKey = {}
groupKeyToNums = defaultdict(lambda: [])
def findGroupsForFactors(factors: List[int]) -> List[int]:
keys = set()
for factor in factors:
if factor in factorToNum:
keys.add(numToGroupKey[factorToNum[factor]])
return keys
maxSize = 0
for num in A:
factors = getFactors(num)
groupKeys = findGroupsForFactors(factors)
for factor in factors:
factorToNum[factor] = num
size = 1 + sum([groups[key] for key in groupKeys])
if len(groupKeys) >= 2:
numToGroupKey[num] = num
groupKeyToNums[num] = [num]
for key in groupKeys:
for lastNum in groupKeyToNums[key]:
numToGroupKey[lastNum] = num
groupKeyToNums[num].append(lastNum)
groupKeyToNums[num].append(key)
del groupKeyToNums[key]
del groups[key]
groups[num] = size
elif len(groupKeys) == 1:
otherGroup = list(groupKeys)[0]
numToGroupKey[num] = otherGroup
groupKeyToNums[otherGroup].append(num)
groups[otherGroup] = size
else:
numToGroupKey[num] = num
groupKeyToNums[num] = [num]
groups[num] = size
maxSize = max(maxSize, size)
return maxSize | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR DICT FUNC_DEF VAR IF VAR VAR RETURN VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER ASSIGN VAR VAR BIN_OP FUNC_CALL VAR BIN_OP VAR VAR FUNC_CALL VAR LIST VAR RETURN VAR VAR ASSIGN VAR VAR FUNC_CALL VAR LIST VAR RETURN VAR VAR VAR ASSIGN VAR DICT ASSIGN VAR DICT ASSIGN VAR DICT ASSIGN VAR FUNC_CALL VAR LIST FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR FOR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR RETURN VAR VAR VAR ASSIGN VAR NUMBER FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR BIN_OP NUMBER FUNC_CALL VAR VAR VAR VAR VAR IF FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR VAR ASSIGN VAR VAR LIST VAR FOR VAR VAR FOR VAR VAR VAR ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR IF FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR LIST VAR ASSIGN VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
N = len(A)
parent = list(range(N))
size = [1] * N
def union(x, y):
x = find(x)
y = find(y)
if x == y:
return
if size[x] < size[y]:
x, y = y, x
parent[y] = x
size[x] += size[y]
def find(x):
if parent[x] != x:
parent[x] = find(parent[x])
return parent[x]
ftoi = {}
for i, n in enumerate(A):
for factor in range(2, floor(sqrt(n)) + 1):
if n % factor == 0:
for f in (factor, n // factor):
if f in ftoi:
union(i, ftoi[f])
else:
ftoi[f] = i
if n in ftoi:
union(i, ftoi[n])
else:
ftoi[n] = i
return max(size) | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR RETURN IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR ASSIGN VAR DICT FOR VAR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER FOR VAR VAR BIN_OP VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR VAR RETURN FUNC_CALL VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class UnionFind:
def __init__(self, n):
self.p = []
self.size = [1] * n
for i in range(n):
self.p.append(i)
self.max_union_size = 1
def union(self, X, Y):
px, py = self.find(X), self.find(Y)
if px == py:
return
elif self.size[px] < self.size[py]:
self.p[px] = py
self.size[py] += self.size[px]
self.max_union_size = max(self.max_union_size, self.size[py])
else:
self.p[py] = px
self.size[px] += self.size[py]
self.max_union_size = max(self.max_union_size, self.size[px])
def find(self, X):
if self.p[X] != X:
self.p[X] = self.find(self.p[X])
return self.p[X]
class Solution:
def largestComponentSize(self, A: List[int]) -> int:
def get_prime_factors(num):
n = num
d = 2
while d * d <= n:
if n % d == 0:
yield d
while n % d == 0:
n //= d
d += 1
if n > 1:
yield n
factors_to_nums = collections.defaultdict(list)
for i, a in enumerate(A):
for f in get_prime_factors(a):
factors_to_nums[f].append(i)
uf = UnionFind(len(A))
for idx_of_num in factors_to_nums.values():
for i in range(1, len(idx_of_num)):
uf.union(idx_of_num[0], idx_of_num[i])
return uf.max_union_size | CLASS_DEF FUNC_DEF ASSIGN VAR LIST ASSIGN VAR BIN_OP LIST NUMBER VAR FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR VAR RETURN IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR CLASS_DEF FUNC_DEF VAR VAR FUNC_DEF ASSIGN VAR VAR ASSIGN VAR NUMBER WHILE BIN_OP VAR VAR VAR IF BIN_OP VAR VAR NUMBER EXPR VAR WHILE BIN_OP VAR VAR NUMBER VAR VAR VAR NUMBER IF VAR NUMBER EXPR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR NUMBER VAR VAR RETURN VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
def factor(n):
res = []
t = int(math.sqrt(n)) + 1
for i in range(2, t + 1):
if n % i == 0:
res += [i]
while n % i == 0:
n //= i
if n != 1:
res += [n]
return res
uf = [i for i in range(len(A))]
def root(p):
while p != uf[p]:
uf[p] = uf[uf[p]]
p = uf[p]
return p
def union(p, q):
proot = root(p)
qroot = root(q)
uf[proot] = uf[qroot] = proot
components = collections.defaultdict(list)
for i, n in enumerate(A):
for p in factor(n):
if len(components[p]) > 0:
union(components[p][-1], i)
components[p] += [i]
cnt = collections.Counter([root(i) for i in uf])
return cnt.most_common()[0][1] | CLASS_DEF FUNC_DEF VAR VAR FUNC_DEF ASSIGN VAR LIST ASSIGN VAR BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF BIN_OP VAR VAR NUMBER VAR LIST VAR WHILE BIN_OP VAR VAR NUMBER VAR VAR IF VAR NUMBER VAR LIST VAR RETURN VAR ASSIGN VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_DEF WHILE VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR IF FUNC_CALL VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR NUMBER VAR VAR VAR LIST VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR RETURN FUNC_CALL VAR NUMBER NUMBER VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
def factorize(m, val, idx):
for i in range(1, math.floor(math.sqrt(val) + 1)):
f = val // i
if f * i == val:
m[i].append(idx)
m[f].append(idx)
return
n = len(A)
m = defaultdict(list)
for idx, val in enumerate(A):
factorize(m, val, idx)
al = [[] for _ in range(n)]
for k in m:
if k == 1:
continue
vals = m[k]
for idx in range(len(vals) - 1):
al[vals[idx]].append(vals[idx + 1])
al[vals[idx + 1]].append(vals[idx])
v = [False] * n
def dfs(val):
if v[val]:
return 0
res = 1
v[val] = True
for nei in al[val]:
res += dfs(nei)
return res
max_csize = 0
for idx in range(n):
if not v[idx]:
max_csize = max(max_csize, dfs(idx))
return max_csize | CLASS_DEF FUNC_DEF VAR VAR FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP VAR VAR IF BIN_OP VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR RETURN ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR LIST VAR FUNC_CALL VAR VAR FOR VAR VAR IF VAR NUMBER ASSIGN VAR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FUNC_DEF IF VAR VAR RETURN NUMBER ASSIGN VAR NUMBER ASSIGN VAR VAR NUMBER FOR VAR VAR VAR VAR FUNC_CALL VAR VAR RETURN VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR RETURN VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, A: List[int]) -> int:
if not A:
return 0
def findPrimes(n):
for i in range(2, int(n**0.5) + 1):
if n % i == 0:
return set([i]) | findPrimes(n // i)
return set([n])
findset = list(range(len(A)))
def find(i):
while findset[i] != i:
i = findset[i]
return i
def union(i, j):
ri, rj = find(i), find(j)
findset[rj] = ri
primdic = defaultdict(list)
for i, num in enumerate(A):
ps = findPrimes(num)
for p in list(ps):
primdic[p] += (i,)
for idxs in list(primdic.values()):
for i in range(len(idxs) - 1):
union(idxs[i], idxs[i + 1])
return max(Counter(find(i) for i in range(len(A))).values()) | CLASS_DEF FUNC_DEF VAR VAR IF VAR RETURN NUMBER FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER NUMBER IF BIN_OP VAR VAR NUMBER RETURN BIN_OP FUNC_CALL VAR LIST VAR FUNC_CALL VAR BIN_OP VAR VAR RETURN FUNC_CALL VAR LIST VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_DEF WHILE VAR VAR VAR ASSIGN VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR VAR VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR BIN_OP VAR NUMBER RETURN FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class Solution:
def largestComponentSize(self, nums: List[int]) -> int:
upper_p = max(nums)
is_prime = [1] * (upper_p + 1)
primes = []
for p in range(2, upper_p + 1):
if not is_prime[p]:
continue
primes.append(p)
for multi in range(2 * p, upper_p + 1, p):
is_prime[multi] = 0
primes_set = set(primes)
p_par = {p: p for p in primes}
p_cnt = {p: (0) for p in primes}
def find_par(ind):
path = []
while p_par[ind] != ind:
path.append(ind)
ind = p_par[ind]
for mid in path:
p_par[mid] = ind
p_cnt[ind] += p_cnt[mid]
p_cnt[mid] = 0
return ind
def union(p1, p2):
par1 = find_par(p1)
par2 = find_par(p2)
if par1 != par2:
p_par[par2] = par1
p_cnt[par1] += p_cnt[par2]
p_cnt[par2] = 0
return
for num in nums:
if num == 1:
continue
factors = []
for p in primes:
if p * p > num:
break
if num % p == 0:
factors.append(p)
while num % p == 0:
num //= p
if num in primes_set:
factors.append(num)
for other_p in factors[1:]:
union(factors[0], other_p)
p_cnt[find_par(factors[0])] += 1
return max(p_cnt.values()) | CLASS_DEF FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR VAR EXPR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP NUMBER VAR BIN_OP VAR NUMBER VAR ASSIGN VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR VAR VAR ASSIGN VAR VAR NUMBER VAR VAR FUNC_DEF ASSIGN VAR LIST WHILE VAR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FOR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR NUMBER RETURN VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR IF VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR NUMBER RETURN FOR VAR VAR IF VAR NUMBER ASSIGN VAR LIST FOR VAR VAR IF BIN_OP VAR VAR VAR IF BIN_OP VAR VAR NUMBER EXPR FUNC_CALL VAR VAR WHILE BIN_OP VAR VAR NUMBER VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR FOR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER VAR VAR FUNC_CALL VAR VAR NUMBER NUMBER RETURN FUNC_CALL VAR FUNC_CALL VAR VAR |
Given a non-empty array of unique positive integers A, consider the following graph:
There are A.length nodes, labelled A[0] to A[A.length - 1];
There is an edge between A[i] and A[j] if and only if A[i] and A[j] share a common factor greater than 1.
Return the size of the largest connected component in the graph.
Example 1:
Input: [4,6,15,35]
Output: 4
Example 2:
Input: [20,50,9,63]
Output: 2
Example 3:
Input: [2,3,6,7,4,12,21,39]
Output: 8
Note:
1 <= A.length <= 20000
1 <= A[i] <= 100000 | class DisjointSet:
def __init__(self, num):
self.forest = list(range(num))
def find(self, x):
if self.forest[x] != x:
self.forest[x] = self.find(self.forest[x])
return self.forest[x]
def union(self, x, y):
self.forest[self.find(x)] = self.find(y)
class Solution:
def largestComponentSize(self, arr):
n = len(arr)
ds = DisjointSet(n)
primesDict = defaultdict(list)
for i, num in enumerate(arr):
primes = self.getPrimes(num)
for p in primes:
primesDict[p].append(i)
for li in primesDict.values():
for i in range(len(li) - 1):
ds.union(li[i], li[i + 1])
return max(Counter([ds.find(i) for i in range(n)]).values())
def getPrimes(self, num):
for i in range(2, int(math.sqrt(num)) + 1):
if num % i == 0:
return self.getPrimes(num // i) | {i}
return {num} | CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_DEF IF VAR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR RETURN VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR CLASS_DEF FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR EXPR FUNC_CALL VAR VAR VAR FOR VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR BIN_OP VAR NUMBER RETURN FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER RETURN BIN_OP FUNC_CALL VAR BIN_OP VAR VAR VAR RETURN VAR |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.