- 并查集
考虑一种极端情况,数的结构类似链表,那么时间复杂度直接飙到 N 2 N^2 N2,就TLE
hashmap并查集的话,如果某个结点不存在,如x not in parent
,可以直接让parent[x]=x
,然后返回x
,这样连初始化都免了
class Solution:
def killProcess(self, pid: List[int], ppid: List[int], kill: int) -> List[int]:
result = [kill]
parent = dict(zip(pid, ppid))
parent[0] = 0
for i in parent.keys():
x = self.find(i, parent, kill)
if x == kill:
result.append(i)
return result
def find(self, x, parent, kill):
# 在kill处早停
if parent[x] == kill:
return kill
# 路径压缩
p = parent[x]
if parent[x] != x:
parent[x] = self.find(parent[x], parent, kill)
return parent[x]
- 模拟树
的确是种好方法
反正都差不多,这样就 O ( N ) O(N) O(N)了
# 模拟树(哈希表)
class Node:
def __init__(self,val,children):
self.val = val
self.children = children
class Solution:
def killProcess(self, pid: List[int], ppid: List[int], kill: int) -> List[int]:
def getAllChildren(p, l):
"""递归搜索子进程"""
for n in p.children:
l.append(n.val)
getAllChildren(n,l)
mapping = {}
for _, val in enumerate(pid):
mapping[val] = Node(val,[])
for i in range(len(ppid)): # 父子关系连接
if ppid[i] >0:
cur = mapping[ppid[i]]
cur.children.append(mapping[pid[i]])
l = []
l.append(kill)
getAllChildren(mapping[kill],l)
return l