s_id stringlengths 10 10 | p_id stringlengths 6 6 | u_id stringlengths 10 10 | date stringlengths 10 10 | language stringclasses 1
value | original_language stringclasses 11
values | filename_ext stringclasses 1
value | status stringclasses 1
value | cpu_time stringlengths 1 5 | memory stringlengths 1 7 | code_size stringlengths 1 6 | code stringlengths 1 539k |
|---|---|---|---|---|---|---|---|---|---|---|---|
s560163810 | p02285 | u881590806 | 1449668448 | Python | Python | py | Runtime Error | 10 | 6392 | 2175 | def insert(tree,k):
y = None
x = tree
z = {'key':k, 'parent':None, 'left':None, 'right':None}
while x != None:
y = x
if x['key'] > k:
x = x['left']
else:
x = x['right']
z['parent'] = y
if y == None:
tree = z
elif y['key'] > k:
y['left'] = z
else:
y['right'] = z
return tree
def get_successor(x):
if x['right'] != None:
return get_minimum(x['right'])
else:
y = x['parent']
while y != None and x == y['left']:
x = y
y = y['parent']
return y
def get_minimum(x):
while x['left'] != None:
x = x['left']
return x
def delete_node(tree,z):
if z['left'] == None or z['right'] == None:
y = z
else:
y = get_successor(z)
if y['left'] != None:
x = y['left']
else:
x = y['right']
if x != None:
x['parent'] = y['parent']
if y['parent'] == None:
tree = x
else:
if y['parent']['left']['key'] == y['key']:
y['parent']['left'] = x
else:
y['parent']['right'] = x
z['key'] = y['key']
return tree
def find(tree,k):
x = tree
while x != None:
if x['key'] == k:
return x
elif x['key'] > k:
x = x['left']
else:
x = x['right']
return None
def middleorder(x):
if x != None:
middleorder(x['left'])
print x['key'],
middleorder(x['right'])
def preorder(x):
if x != None:
print x['key'],
preorder(x['left'])
preorder(x['right'])
tree = None
m = int(raw_input())
for i in range(m):
c = raw_input().strip()
if c[0] == 'i':
tree = insert(tree, int(c[7:]))
elif c[0] == 'f':
x = find(tree, int(c[5:]))
if x == None:
print "no"
else:
print "yes"
elif c[0] == 'd':
z = find(tree, int(c[7:]))
if not z == None: tree = delete_node(tree,z)
elif c[0] == 'p':
print '',
middleorder(tree)
print
print '',
preorder(tree)
print |
s679489398 | p02285 | u797673668 | 1454182412 | Python | Python3 | py | Runtime Error | 30 | 7768 | 2282 | class Tree:
root = None
def insert(self, node):
y = None
x = self.root
while x:
y = x
x = x.left if node.key < x.key else x.right
node.parent = y
if not y:
self.root = node
elif node.key < y.key:
y.left = node
else:
y.right = node
def find_node(self, value):
return self.root.find(value)
def find(self, value):
print('yes' if self.find_node(value) else 'no')
def delete(self, value):
self.find_node(value).delete()
def print(self):
print(' ', end='')
print(*self.root.print_in())
print(' ', end='')
print(*self.root.print_pre())
class Node:
def __init__(self, key):
self.parent = self.left = self.right = None
self.key = key
def find(self, value):
diff = self.key - value
if diff == 0:
return self
elif diff > 0:
return self.left and self.left.find(value)
else:
return self.right and self.right.find(value)
def delete(self):
if self.left:
self.delete_connect(self.parent, self.left)
elif self.right:
self.delete_connect(self.parent, self.right)
else:
self.delete_connect(self.parent, None)
def delete_connect(self, parent, child):
if parent:
if parent.key > self.key:
parent.left = child
else:
parent.right = child
if child:
child.parent = parent
def print_pre(self):
yield self.key
if self.left:
for k in self.left.print_pre(): yield k
if self.right:
for k in self.right.print_pre(): yield k
def print_in(self):
if self.left:
for k in self.left.print_in(): yield k
yield self.key
if self.right:
for k in self.right.print_in(): yield k
tree = Tree()
m = int(input())
while m:
l = input()
f = l[0]
if f == 'i':
tree.insert(Node(int(l.split()[1])))
elif f == 'f':
tree.find(int(l.split()[1]))
elif f == 'd':
tree.delete(int(l.split()[1]))
else:
tree.print()
m -= 1 |
s247645851 | p02285 | u247976584 | 1455382247 | Python | Python3 | py | Runtime Error | 20 | 7892 | 2579 | class BinarySearchTree:
root = None
def insert(self, k):
y = None
x = self.root
z = Node(k)
while x:
y = x
if z.k < x.k:
x = x.l
else:
x = x.r
z.p = y
if y == None:
self.root = z
else:
if z.k < y.k:
y.l = z
else:
y.r = z
def find(self, x, k):
while x != None and k != x.k:
if k < x.k:
x = x.l
else:
x = x.r
return x
def deleteNode(self, z):
y = None
x = None
if z.l == None or x.r == None:
y = z
else:
y = self.getSuccessor(z)
if y.l != None:
x = y.l
else:
x = y.r
if x != None:
x.p = y.p
if y.p == None:
self.root = x
else:
if y == y.p.l:
y.p.l = x
else:
y.p.r = x
if y != z:
z.k = y.k
def getSuccessor(self, x):
if x.r != None:
return self.getMinimum(x.r)
y = x.p
while y != None and x == y.r:
x = y
y = y.p
return y
def getMinimum(self, x):
while x.l != None:
x = x.l
return x
def preParse(self, u):
if u == None:
return
print("", str(u.k), end = "")
self.preParse(u.l)
self.preParse(u.r)
def inParse(self, u):
if u == None:
return
self.inParse(u.l)
print("", str(u.k), end = "")
self.inParse(u.r)
class Node:
def __init__(self, k):
self.k = k
self.p = None
self.l = None
self.r = None
if __name__ == '__main__':
n = int(input().rstrip())
x = BinarySearchTree()
for i in range(n):
com = input().rstrip()
if com.startswith("insert"):
k = int(com.split(" ")[1])
x.insert(k)
elif com.startswith("find"):
k = int(com.split(" ")[1])
if x.find(x.root, k) != None:
print("yes")
else:
print("no")
elif com.startswith("delete"):
k = int(com.split(" ")[1])
x.deleteNode(x.find(x.root, k))
else:
x.inParse(x.root)
print()
x.preParse(x.root)
print() |
s387900155 | p02285 | u342312206 | 1463422152 | Python | Python3 | py | Runtime Error | 80 | 7776 | 5512 | import sys
import os
class Node:
def __init__(self, value):
self.value = value
self.left = None
self.right = None
def insert_node(self, node):
if node.value <= self.value:
if self.left is None:
self.left = node
else:
self.left.insert_node(node)
else:
if self.right is None:
self.right = node
else:
self.right.insert_node(node)
def find_node_by_value(self, value):
if self.value == value:
return self
elif value < self.value:
if self.left is None:
return None
else:
return self.left.find_node_by_value(value)
elif value > self.value:
if self.right is None:
return None
else:
return self.right.find_node_by_value(value)
else:
assert(False)
def next_node_in_inorder(self):
if self.right is not None:
return self.right.smallest_offspring(self)
else:
return None
def smallest_offspring(self, parent):
if self.left is not None:
return smallest_offspring(self.left, self)
else:
return (self, parent)
def get_parent_of(self, value, parent_cand=None, is_left_child=None):
if self.value == value:
return parent_cand, is_left_child
else:
if value < self.value and self.left is not None:
return self.left.get_parent_of(value, self, True)
elif value > self.value and self.right is not None:
return self.right.get_parent_of(value, self, False)
else:
assert(False)
def delete_child(self, node):
if self.left == node:
self.left = None
elif self.right == node:
self.right = None
else:
assert(False)
def delete_node(self, parent, value):
# recursive
if value < self.value and self.left is not None:
self.left.delete_node(self, value)
elif self.value < value and self.right is not None:
self.right.delete_node(self, value)
# delete
elif self.left is None and self.right is None:
# no children
parent.delete_child(self)
elif self.left is not None and self.right is not None:
n, p = self.next_node_in_inorder()
self.value = n.value
n.delete_node(p, n.value)
elif self.left is not None:
self.value = self.left.value
self.right = self.left.right
self.left = self.left.left
elif self.right is not None:
self.value = self.right.value
self.left = self.right.left
self.right = self.right.right
# def delete_node_by_value(self, value):
# node = self.find_node_by_value(value)
# parent, node_is_left_child = self.get_parent_of(value)
# if node.left is None and node.right is None:
# # hard delete
# if parent is not None:
# if node_is_left_child:
# parent.left = None
# else:
# parent.right = None
# else:
# return 'DELETE_BST'
# else:
# self.forcedelete(node, parent, node_is_left_child)
def print_node_by_preorder(self):
print('', self.value, end='')
if self.left is not None:
self.left.print_node_by_preorder()
if self.right is not None:
self.right.print_node_by_preorder()
def print_node_by_inorder(self):
if self.left is not None:
self.left.print_node_by_inorder()
print('', self.value, end='')
if self.right is not None:
self.right.print_node_by_inorder()
class BST:
def __init__(self):
self.root = None
def cmd_insert(self, k):
if self.root is None:
self.root = Node(k)
else:
self.root.insert_node(Node(k))
def cmd_find(self, k):
if self.root is None:
return False
else:
return (self.root.find_node_by_value(k) is not None)
def cmd_delete(self, k):
if self.root is None:
pass
else:
self.root.delete_node(parent=self, value=k)
def delete_child(self, node):
assert(self.root == node)
self.root = None
def cmd_print(self):
if self.root is not None:
self.root.print_node_by_inorder()
print()
self.root.print_node_by_preorder()
print()
if __name__ == '__main__':
bst = BST()
lines = []
for line in sys.stdin:
lines.append(line.rstrip())
num_cmds = int(lines[0])
for line in lines[1:1+num_cmds]:
line_split = line.split(' ')
cmd = line_split[0]
try:
val = int(line_split[1])
except:
pass
if cmd == 'insert':
bst.cmd_insert(val)
elif cmd == 'find':
if bst.cmd_find(val):
print('yes')
else:
print('no')
elif cmd == 'print':
bst.cmd_print()
elif cmd == 'delete':
bst.cmd_delete(val)
else:
assert(False)
|
s290572618 | p02285 | u890722286 | 1475422754 | Python | Python3 | py | Runtime Error | 20 | 7760 | 2354 | def insert(r, n):
if 0 == len(T):
T[n] = [None, None, None]
else:
if n < r:
left = T[r][0]
if left == None:
T[r][0] = n
T[n] = [None, None, r]
else:
insert(left, n)
if r < n:
right = T[r][1]
if right == None:
T[r][1] = n
T[n] = [None, None, r]
else:
insert(right, n)
def find(n):
if n in T:
return True
else:
return False
def dele(r, n):
z = T[n]
left = z[0]
right = z[1]
p = z[2]
if left is None and right is None:
T[p][1] = None
del z
elif left is None and right is not None:
T[p][1] = right
T[right][2] = z[2]
del z
elif left is not None and right is None:
T[p][0] = left
T[left][2] = z[2]
del z
elif left is not None and right is not None:
inorder = list(map(int, print_inorder(r).split()))
next_n = inorder[inorder.index(n) + 1]
if r == n:
r = next_n
dele(r, next_n)
T[next_n] = T[n]
del T[n]
for k,v in T.items():
if v[0] == n:
v[0] = next_n
if v[1] == n:
v[1] = next_n
if v[2] == n:
v[2] = next_n
return r
def print_inorder(r):
left = T[r][0]
right = T[r][1]
ans = ""
if left != None:
ans += print_inorder(left)
ans += " {}".format(r)
if right != None:
ans += print_inorder(right)
return ans
def print_preorder(r):
left = T[r][0]
right = T[r][1]
ans = " {}".format(r)
if left != None:
ans += print_preorder(left)
if right != None:
ans += print_preorder(right)
return ans
n = int(input())
T = {}
root = None
for i in range(n):
inst = input()
if inst[0] == 'i':
num = int(inst[7:])
if i == 0:
root = num
insert(root, num)
elif inst[0] == 'f':
num = int(inst[5:])
if find(num):
print("yes")
else:
print("no")
elif inst[0] == 'd':
num = int(inst[7:])
root = dele(root, num)
elif inst[0] == 'p':
print(print_inorder(root))
print(print_preorder(root)) |
s216977630 | p02285 | u890722286 | 1475426516 | Python | Python3 | py | Runtime Error | 30 | 7820 | 2717 | def insert(r, n):
if 0 == len(T):
T[n] = [None, None, None]
else:
if n < r:
left = T[r][0]
if left == None:
T[r][0] = n
T[n] = [None, None, r]
else:
insert(left, n)
if r < n:
right = T[r][1]
if right == None:
T[r][1] = n
T[n] = [None, None, r]
else:
insert(right, n)
def find(n):
if n in T:
return True
else:
return False
def dele(r, n):
if find(n):
z = T[n]
left = z[0]
right = z[1]
p = z[2]
if left is None and right is None:
i = T[p].index(n)
T[p][i] = None
del T[n]
elif left is None and right is not None:
x = T[p].index(n)
T[p][x] = right
T[right][2] = z[2]
del T[n]
elif left is not None and right is None:
x = T[p].index(n)
T[p][x] = left
T[left][2] = z[2]
del T[n]
elif left is not None and right is not None:
inorder = list(map(int, print_inorder(r).split()))
next_n = inorder[inorder.index(n) + 1]
if r == n:
r = next_n
dele(r, next_n)
T[next_n] = T[n]
del T[n]
next_l = T[next_n][0]
if next_l is not None:
for i in T[next_l]:
if n == i:
T[next_l][i] = n
next_r = T[next_n][1]
if next_r is not None:
for i in T[next_r]:
if n == i:
T[next_r][i] = n
return r
def print_inorder(r):
left = T[r][0]
right = T[r][1]
ans = ""
if left != None:
ans += print_inorder(left)
ans += " {}".format(r)
if right != None:
ans += print_inorder(right)
return ans
def print_preorder(r):
left = T[r][0]
right = T[r][1]
ans = " {}".format(r)
if left != None:
ans += print_preorder(left)
if right != None:
ans += print_preorder(right)
return ans
n = int(input())
T = {}
root = None
for i in range(n):
inst = input()
if inst[0] == 'i':
num = int(inst[7:])
if i == 0:
root = num
insert(root, num)
elif inst[0] == 'f':
num = int(inst[5:])
if find(num):
print("yes")
else:
print("no")
elif inst[0] == 'd':
num = int(inst[7:])
root = dele(root, num)
elif inst[0] == 'p':
print(print_inorder(root))
print(print_preorder(root)) |
s450938898 | p02285 | u367979558 | 1477437112 | Python | Python3 | py | Runtime Error | 30 | 7860 | 3481 | import sys
class Node:
def __init__(self, x, parent=None):
self.key = x
self.left = None
self.right = None
self.parent = parent
def append_child(self, child):
if self.key > child.key:
self.left = child
child.parent = self
elif self.key < child.key:
self.right = child
child.parent = self
else:
raise "cannot append a child with same key"
def remove(self, tree):
parent = self.parent
if self.left and self.right:
child = self.right
while child.left is not None:
child = child.left
child.remove()
self.key = child.key
elif self.left or self.right:
child = self.left or self.right
if parent is None: # if this is root
self.root = child
child.parent = None
else:
parent.append_child(child)
else:
if parent is None: # if this is root
tree.root = None
elif self is parent.left:
parent.left = None
else:
parent.right = None
class BinaryTree:
def __init__(self):
self.root = None
def insert(self, x):
inserted = Node(x)
if self.root is None:
self.root = inserted
return inserted
node = self.root
parent = None
while node is not None:
if x > node.key:
parent = node
node = node.right
elif x < node.key:
parent = node
node = node.left
else:
return node
parent.append_child(inserted)
return inserted
def delete(self, x):
deleted = self.find(x)
if deleted is None:
return False
deleted.remove(self)
return True
def find(self, x):
node = self.root
while node is not None:
if x == node.key:
return node
elif x > node.key:
node = node.right
else:
node = node.left
return None
def pre_order(self):
keys = []
self.do_pre_order(self.root, keys)
print(' ' + ' '.join(map(str, keys)))
def do_pre_order(self, node, keys):
if node is None:
return
keys.append(node.key)
self.do_pre_order(node.left, keys)
self.do_pre_order(node.right, keys)
def in_order(self):
keys = []
self.do_in_order(self.root, keys)
print(' ' + ' '.join(map(str, keys)))
def do_in_order(self, node, keys):
if node is None:
return
self.do_in_order(node.left, keys)
keys.append(node.key)
self.do_in_order(node.right, keys)
# main
tree = BinaryTree()
lines = sys.stdin.readlines()
for line in lines[1:]:
if len(line.rstrip()) == 0:
continue
command = line.rstrip().split(' ')
if command[0] == 'insert':
tree.insert(int(command[1]))
elif command[0] == 'print':
tree.in_order()
tree.pre_order()
elif command[0] == 'find':
if (tree.find(int(command[1]))):
print('yes')
else:
print('no')
elif command[0] == 'delete':
tree.delete(int(command[1]))
else:
raise 'unknown command: ' + command[0] |
s997698070 | p02285 | u159356473 | 1479113486 | Python | Python3 | py | Runtime Error | 0 | 0 | 1101 |
def Pre(t,l):
l.append(str(t.n))
if t.left!=None:
Pre(t.left,l)
if t.right!=None:
Pre(t.right,l)
def In(t,l):
if t.left!=None:
In(t.left,l)
l.append(str(t.n))
if t.right!=None:
In(t.right,l)
def BST3(A,n):
tree=None
for i in range(n):
if A[i]=="print":
PreAns=[]
InAns=[]
Pre(tree,PreAns)
In(tree,InAns)
print(" "+" ".join(InAns))
print(" "+" ".join(PreAns))
else:
if A[i].split(" ")[0]=="find":
point=int(A[i].split(" ")[1])
if Find(tree,point)==True:
print("yes")
else:
print("no")
elif A[i].split(" ")[0]=="delete":
point=int(A[i].split(" ")[1])
Delete(tree,point)
else:
z=Node(int(A[i].split(" ")[1]))
tree=Insert(tree,z)
if __name__=="__main__":
n=int(input())
A=[]
for i in range(n):
A.append(input())
BST3(A,n) |
s880062429 | p02285 | u159356473 | 1479113752 | Python | Python3 | py | Runtime Error | 30 | 7756 | 2373 | #coding:UTF-8
class Node:
def __init__(self,point):
self.n=point
self.left=None
self.right=None
def Insert(t,z):
y=None
x=t
while x!=None:
y=x
if z.n<x.n:
x=x.left
else:
x=x.right
if y==None:
return z
else:
if z.n<y.n:
y.left=z
else:
y.right=z
return t
def Find(t,p):
if t.n == p:
return True
elif t.left!=None and t.n>p:
a=Find(t.left,p)
elif t.right!=None and t.n<p:
a=Find(t.right,p)
else:
return False
return a
def Delete(t,p):
if t.left.n==p:
if t.left.left==None and t.left.right==None:
t.left=None
elif t.left.left==None and t.left.right!=None:
t.left=t.left.right
else:
t.left=t.left.left
elif t.right.n==p:
if t.right.left==None and t.right.right==None:
t.right=None
elif t.right.left==None and t.right.right!=None:
t.right=t.right.right
else:
t.right=t.right.left
else:
if t.n>p and t.left!=None:
Delete(t.left,p)
elif t.n<p and t.right!=None:
Delete(t.right,p)
def Pre(t,l):
l.append(str(t.n))
if t.left!=None:
Pre(t.left,l)
if t.right!=None:
Pre(t.right,l)
def In(t,l):
if t.left!=None:
In(t.left,l)
l.append(str(t.n))
if t.right!=None:
In(t.right,l)
def BST3(A,n):
tree=None
for i in range(n):
if A[i]=="print":
PreAns=[]
InAns=[]
Pre(tree,PreAns)
In(tree,InAns)
print(" "+" ".join(InAns))
print(" "+" ".join(PreAns))
else:
if A[i].split(" ")[0]=="find":
point=int(A[i].split(" ")[1])
if Find(tree,point)==True:
print("yes")
else:
print("no")
elif A[i].split(" ")[0]=="delete":
point=int(A[i].split(" ")[1])
Delete(tree,point)
else:
z=Node(int(A[i].split(" ")[1]))
tree=Insert(tree,z)
if __name__=="__main__":
n=int(input())
A=[]
for i in range(n):
A.append(input())
BST3(A,n) |
s135585703 | p02285 | u742013327 | 1480576471 | Python | Python3 | py | Runtime Error | 40 | 7844 | 3586 | #http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_8_A
#???????????? 15??? 8A????????????
def insert(root, insert_node):
focus_node = root
parent = None
while not focus_node == None:
parent = focus_node
if focus_node["data"] > insert_node["data"]:
focus_node = focus_node["left"]
else:
focus_node = focus_node["right"]
if parent["data"] > insert_node["data"]:
parent["left"] = insert_node
insert_node["parent"] = parent
else:
parent["right"] = insert_node
insert_node["parent"] = parent
def get_preorder(node):
if node == None:
return []
r = []
r.append(str(node["data"]))
r.extend(get_preorder(node["left"]))
r.extend(get_preorder(node["right"]))
return r
def get_inorder(node):
if node == None:
return []
r = []
r.extend(get_inorder(node["left"]))
r.append(str(node["data"]))
r.extend(get_inorder(node["right"]))
return r
def delete_tree(root, target):
delete_node = find_tree(root, target)
parent = delete_node["parent"]
if parent["left"] == delete_node:
parent_direction = "left"
else:
parent_direction = "right"
while True:
if delete_node["left"] == None and delete_node["right"] == None:
parent[parent_direction] = None
break
elif delete_node["left"] and delete_node["right"]:
p = get_inorder(root)
next_num = int(p[p.index(str(delete_node["data"])) + 1])
tmp_delete_node = find_tree(root, next_num)
delete_node["data"] = next_num
delete_node = tmp_delete_node
parent = delete_node["parent"]
if parent == None:
parent_direction = None
elif parent["left"] == delete_node:
parent_direction = "left"
else:
parent_direction = "right"
else:
if delete_node["left"]:
parent[parent_direction] = delete_node["left"]
delete_node["left"]["parent"] = parent
else:
parent[parent_direction] = delete_node["right"]
delete_node["right"]["parent"] = parent
break
def find_tree(root, target):
focus_node = root
while not focus_node == None:
if focus_node["data"] == target:
return focus_node
elif focus_node["data"] < target:
focus_node = focus_node["right"]
else:
focus_node = focus_node["left"]
return None
def print_tree(root):
print(" " + " ".join(get_inorder(root)))
print(" " + " ".join(get_preorder(root)))
def main():
n_line = int(input())
input_list = [input() for i in range(n_line)]
root = {"left":None, "right": None, "data":int(input_list[0].split()[1]), "parent": None}
for line in input_list[1:]:
if line == "print":
print_tree(root)
else:
split_line = line.split()
target = int(split_line[1])
if split_line[0] == "insert":
node = {"left":None, "right": None, "data":target, "parent":None}
insert(root, node)
elif split_line[0] == "find":
if find_tree(root, target):
print("yes")
else:
print("no")
elif split_line[0] == "delete":
delete_tree(root, target)
if __name__ == "__main__":
main() |
s286631900 | p02285 | u811733736 | 1481003950 | Python | Python3 | py | Runtime Error | 30 | 7772 | 5861 | class Node(object):
root = None
def __init__(self, key, parent=None, left=None, right=None):
self.key = key
self.parent = parent
self.left = left
self.right = right
self.height = None
@classmethod
def insert(cls, z):
y = None
x = cls.root
while x != None: # root???????????????????????????y????????\????????????????????¨???????????§??¨????????????
y = x
if z.key < x.key:
x = x.left
else:
x = x.right
# ?????\?????¨?????????????????????????¨??????????
z.parent = y
if y == None:
cls.root = z
elif z.key < y.key:
y.left = z
else:
y.right = z
# return z
@classmethod
def find(cls, k):
""" ??????k?????????????????¢?????????????????????????????°None????????? """
x = cls.root
while x != None and k != x.key:
if k < x.key:
x = x.left
else:
x = x.right
return x
@classmethod
def walk_preorder(cls, node):
""" ??????????????? """
# results = []
# results.append(node.key)
print(' {0}'.format(node.key), end='')
if node.left != None:
# results.append(cls.walk_preorder(node.left))
cls.walk_preorder(node.left)
if node.right != None:
# results.append(cls.walk_preorder(node.right))
cls.walk_preorder(node.right)
#return results
@classmethod
def walk_inorder(cls, node):
""" ??????????????? """
# results = []
if node.left != None:
# results.append(cls.walk_inorder(node.left))
cls.walk_inorder(node.left)
# results.append(node.key)
print(' {0}'.format(node.key), end='')
if node.right != None:
# results.append(cls.walk_inorder(node.right))
cls.walk_inorder(node.right)
# return results
@classmethod
def delete_node(cls, z):
if z.left == None or z.right == None:
y = z
else:
y = Node.get_successor(z)
if y.left != None:
x = y.left
else:
x = y.right
if x != None:
x.parent = y.parent
if y.parent == None:
Node.root = x
elif y == y.parent.left:
y.parent.left = x
else:
y.parent.right = x
if y != z:
z.key = y.key
@classmethod
def get_successor(cls, x):
if x.right != None:
return self.get_minimum(x.right)
y = x.parent
while y != None and x == y.right:
x = yy = y.parent
return y
@classmethod
def get_minimum(cls, x):
""" ??????x????????¨????????¨?????¨????????§????°?????????????????????????????????? """
while x.left != None:
x = x.left
return x
def get_type(self):
if self.parent == None:
return 'root'
elif self.left == None and self.right == None:
return 'leaf'
else:
return 'internal node'
def get_depth(self):
if self.parent == None:
return 0
else:
depth = 1
t = self.parent
while t.parent != None:
t = t.parent
depth += 1
return depth
def get_height(self):
if self.height:
return self.height
h_left = 0
h_right = 0
if self.left != None:
h_left = self.left.get_height() + 1
if self.right != None:
h_right = self.right.get_height() + 1
self.height = max(h_left, h_right)
return self.height
def get_degree(self):
degree = 0
if self.left != None:
degree += 1
if self.right != None:
degree += 1
return degree
def get_sibling(self):
if self.parent == None:
return -1
p = self.parent
if p.left != self and p.left != None:
return p.left
if p.right != self and p.right != None:
return p.right
def process_node_data(node_data):
for inst in node_data:
if inst[0] == 'print':
result = Node.walk_inorder(Node.root)
print('')
# print(' {0}'.format(' '.join(map(str, flatten(result)))))
result = Node.walk_preorder(Node.root)
# print(' {0}'.format(' '.join(map(str, flatten(result)))))
print('')
elif inst[0] == 'insert':
node_key = int(inst[1])
new_node = Node(node_key)
Node.insert(new_node)
elif inst[0] == 'find':
result = Node.find(int(inst[1]))
if result:
print('yes')
else:
print('no')
elif inst[0] == 'delete':
result = Node.delete_node(Node.find(int(inst[1])))
def flatten(l):
""" http://stackoverflow.com/questions/2158395/flatten-an-irregular-list-of-lists-in-python """
import collections
for el in l:
if isinstance(el, collections.Iterable) and not isinstance(el, (str, bytes)):
yield from flatten(el)
else:
yield el
if __name__ == '__main__':
# ??????????????\???
num_of_nodes = int(input())
node_data = [input().split(' ') for _ in range(num_of_nodes)]
# node_data = []
# with open('ALDS1_8_A-in4.txt') as f:
# for line in f:
# if ' ' not in line:
# num_of_nodes = (int(line))
# else:
# node_data.append(line.split(' '))
# ???????????????
# ??¨???????????????
process_node_data(node_data)
# ??????????????? |
s612748559 | p02285 | u923668099 | 1485033821 | Python | Python3 | py | Runtime Error | 20 | 7884 | 3209 | import sys
NIL = -1
class Node:
def __init__(self, key):
self.key = key
self.parent = NIL
self.left = NIL
self.right = NIL
class Tree:
def __init__(self):
self.root = NIL
def insert(self, z):
y = NIL
x = self.root
while x != NIL:
y = x
if z.key < x.key:
x = x.left
else:
x = x.right
z.parent = y
if y == NIL:
self.root = z
elif z.key < y.key:
y.left = z
else:
y.right = z
def find(self, value, node):
if node == NIL:
return False
elif node.key == value:
return True
elif value < node.key:
# print('go to left')
return self.find(value, node=node.left)
else:
# print('go to right')
return self.find(value, node=node.right)
def delete(self, value, node):
if node == NIL:
return None
elif value < node.key:
self.delete(value, node.left)
elif value > node.key:
self.delete(value, node.right)
else:
check = (node.left != NIL) + (node.right != NIL)
if check == 0:
if node.parent.left.key == value:
node.parent.left = NIL
else:
node.parent.right = NIL
elif check == 1:
if node.left != NIL:
child = node.left
else:
child = node.right
if node.parent.left.key == value:
node.parent.left = child
child.parent = node.parent
else:
node.parent.right = child
child.parent = node.parent
else:
jisetu = node.right
while jisetu.left != NIL:
jisetu = jisetu.left
node.key = jisetu.key
self.delete(jisetu.key, jisetu)
def inorder_walk(self, node):
if node == NIL:
return None
if node.left != NIL:
self.inorder_walk(node=node.left)
print(' ' + str(node.key), end='')
if node.right != NIL:
self.inorder_walk(node=node.right)
def preorder_walk(self, node):
if node == NIL:
return None
print(' ' + str(node.key), end='')
if node.left != NIL:
self.preorder_walk(node=node.left)
if node.right != NIL:
self.preorder_walk(node=node.right)
def show(self):
self.inorder_walk(self.root)
print()
self.preorder_walk(self.root)
print()
n = int(sys.stdin.readline())
T = Tree()
for i in range(n):
line = sys.stdin.readline().split()
if len(line) == 1:
T.show()
elif line[0] == 'insert':
key = int(line[1])
T.insert(Node(key))
elif line[0] == 'find':
key = int(line[1])
print('yes' if T.find(key, T.root) else 'no')
else:
key = int(line[1])
T.delete(key, T.root) |
s380049206 | p02285 | u462831976 | 1489839444 | Python | Python3 | py | Runtime Error | 50 | 11704 | 5485 | # -*- coding: utf-8 -*-
import random
import sys
import os
class Tree:
def __init__(self):
self.root = None
def __str__(self):
if self.root == None:
return None
else:
return "TODO"
def print_inorder(self):
self.inorder_list = []
self.__inorder(self.root)
return self.inorder_list
def __inorder(self, node):
"""
:param node: Node
:return:
"""
if node is None:
return
else:
self.__inorder(node.left)
self.inorder_list.append(node.key)
self.__inorder(node.right)
def print_preorder(self):
self.preorder_list = []
self.__preorder(self.root)
return self.preorder_list
def __preorder(self, node):
"""
:param node: Node
:return:
"""
if node is None:
return
else:
self.preorder_list.append(node.key)
self.__preorder(node.left)
self.__preorder(node.right)
def insert(self, node):
"""
:param node: Node
:return:
"""
if self.root is None:
self.root = node
else:
x = self.root
parent_candidate = x
while x is not None:
parent_candidate = x
if x.key > node.key:
x = x.left
else:
x = x.right
# child to parent link
x = node
x.parent = parent_candidate
# parent to child link
if x.key < x.parent.key:
x.parent.left = x
else:
x.parent.right = x
def find(self, value):
"""
:param value:
:rtype: Node
:return:
"""
x = self.root
while x is not None and x.key != value:
if x.key > value:
x = x.left
else:
x = x.right
return x
def delete(self, value):
found_node = self.find(value)
if found_node is None:
print("value is nothing")
else:
# has no child
if found_node.is_leaf():
# delete link from parent
# print(found_node.parent.left.key)
# print(found_node.key)
if found_node.parent.left.key == found_node.key:
found_node.parent.left = None
else:
found_node.parent.right = None
else:
# has one child
if found_node.has_one_child():
one_child = found_node.get_one_child()
# change link to parent
one_child.parent = found_node.parent
# chagne link from parent
if found_node.parent.left == found_node:
found_node.parent.left = one_child
else:
found_node.parent.right = one_child
# has two child
else:
next_section_point = found_node.get_next_section_point()
# ?¬???????????????????????????????????????????????¬?????????????????????? p217
# ????????????
key = next_section_point.key
self.delete(next_section_point.key)
found_node.key = key
class Node:
def __init__(self, key):
self.parent = None # type: Node
self.left = None # type: Node
self.right = None # type: Node
self.key = key # type: int
def has_one_child(self):
if self.left is None and self.right is not None:
return True
elif self.left is not None and self.right is None:
return True
else:
return False
def get_one_child(self):
if not self.has_one_child():
return None
else:
if self.left is not None:
return self.left
else:
return self.right
def get_next_section_point(self):
"""?¬??????????????????????"""
# ????????????????????´???
if self.right is not None:
return self.right.get_minimum()
# ???????????????????????´???????¬???????????????´?????????
else:
# ?
return self.parent
def is_leaf(self):
if self.left is None and self.right is None:
return True
else:
return False
def get_minimum(self):
if self.left is None:
return self
else:
return self.left.get_minimum()
tree = Tree()
s = input()
n = int(s)
for _ in range(n):
s = input()
if 'insert' in s:
value = int(s.split(" ")[-1])
node = Node(value)
tree.insert(node)
if 'print' in s:
in_list = tree.print_inorder()
in_list = map(str, in_list)
print(' ' + ' '.join(in_list))
pre_list = tree.print_preorder()
pre_list = map(str, pre_list)
print(' ' + ' '.join(pre_list))
if 'find' in s:
value = int(s.split(" ")[-1])
node = tree.find(value)
if node is None:
print('no')
else:
print('yes')
if 'delete' in s:
value = int(s.split(" ")[-1])
tree.delete(value) |
s136748110 | p02285 | u089830331 | 1493691624 | Python | Python3 | py | Runtime Error | 20 | 7648 | 1801 | class Node:
def __init__(self, num):
self.key = num
self.p = None
self.left = None
self.right = None
class BinarySearchTree:
def __init__(self):
self.root = None
def insert(self, z):
y = None
x = self.root
while x != None:
y = x
if z.key < x.key:
x = x.left
else:
x = x.right
z.p = y
if y is None:
self.root = z
elif z.key < y.key:
y.left = z
else:
y.right = z
def find(self, key):
node = self.root
while node:
if node.key == key: return node
if key < node.key:
node = node.left
else:
node = node.right
return None
def delete(self, node):
if node.left and node.right:
node.key = node.right.key
self.delete(node.right)
elif node.left:
node.left.p = node.p
node.p.left = node.left
elif node.right:
node.right.p = node.p
node.p.right = node.right
else:
if node.key < node.p.key:
node.p.left = None
else:
node.p.right = None
def print_inorder(node):
if node is None: return
print_inorder(node.left)
print(" {}".format(node.key), end="")
print_inorder(node.right)
def print_preorder(node):
if node is None: return
print(" {}".format(node.key), end="")
print_preorder(node.left)
print_preorder(node.right)
T = BinarySearchTree()
for i in range(int(input())):
params = input().split()
if params[0] == "insert":
T.insert(Node(int(params[1])))
elif params[0] == "find":
if T.find(int(params[1])):
print("yes")
else:
print("no")
elif params[0] == "delete":
node = T.find(int(params[1]))
T.delete(node)
elif params[0] == "print":
print_inorder(T.root)
print("")
print_preorder(T.root)
print("") |
s658491441 | p02285 | u603049633 | 1496368528 | Python | Python3 | py | Runtime Error | 20 | 7800 | 2941 | #BinarySearchTree
class TreeNode():
def __init__(self):
self.key = None
self.parent = None
self.left = None
self.right = None
def inoder(self):
r=[]
if self.left:
r += self.left.inoder()
r += [self.key]
if self.right:
r += self.right.inoder()
return r
def preoder(self):
r = [self.key]
if self.left:
r += self.left.preoder()
if self.right:
r += self.right.preoder()
return r
class BinaryTree():
def __init__(self):
self.root = None
def insert(self, z):
y = None
x = self.root
while x != None:
y = x
if z.key < x.key:
x = x.left
else:
x = x.right
z.parent = y
if y == None:
self.root = z
elif z.key < y.key:
y.left = z
else:
y.right = z
def show(self):
x = self.root
print(" " + " ".join(map(str, self.root.inoder())))
print(" " + " ".join(map(str, self.root.preoder())))
def find(self, key):
currentNode = self.root
while currentNode:
if key == currentNode.key:
return currentNode
else:
if key < currentNode.key:
currentNode = currentNode.left
else:
currentNode = currentNode.right
return False
def next(self, key):
return self.min(key.right)
def min (self, key):
while key.left != None:
key = key.left
return key
def delete(self, key):
currentNode = self.find(key)
if currentNode.left == None or currentNode.right == None:
z = currentNode
else:
z = self.next(z)
if z.left != None:
z.left.parent = z.parent
if z.parent.key > z.left.key:
z.parent.left = z.left
else:
z.parent.right = z.left
if z.right != None:
z.right.parent = z.parent
if z.parent.key > z.right.key:
z.parent.left = z.right
else:
z.parent.right = z.right
if z.right == None and z.left == None:
if z.parent.key > z.key:
z.parent.left = None
else:
z.parent.right = None
if z != currentNode:
currentNode = z
n = int(input())
Tree = BinaryTree()
for i in range(n):
L = input().split()
if L[0] == "insert":
Node = TreeNode()
Node.key = int(L[1])
Tree.insert(Node)
elif L[0] =="print":
Tree.show()
elif L[0] =="find":
if Tree.find(int(L[1])) == False:
print("no")
else:
print("yes")
else:
Tree.delete(int(L[1])) |
s266235921 | p02285 | u067677727 | 1498791300 | Python | Python3 | py | Runtime Error | 20 | 7900 | 3077 | import sys
class Node:
def __init__(self, x):
self.data = x
self.left = None
self.right = None
def insert(node, x):
if node == None:
return Node(x)
elif x == node.data:
return node
elif x < node.data:
node.left = Node.insert(node.left, x)
else:
node.right = Node.insert(node.right, x)
return node
def find(node, x):
if node.data == x:
return True
elif node.left != None and node.data > x:
return Node.find(node.left, x)
elif node.right != None and node.data < x:
return Node.find(node.right, x)
else:
return False
def delete(node, x):
if node.data == x:
if node.left == None and node.right == None:
return None
elif node.left == None:
return node.right
elif node.right == None:
return node.left
else:
#????????????
node.data = Node.serch_min(node.right)
node.right = Node.delete_min(node.right)
return node
elif node.data > x:
node.left = Node.delete(node.left, x)
else:
node.right = Node.delete(node.right, x)
return node
def serch_min(node):
if node.left != None:
return Node.serch_min(node.left)
else:
return node.data
def delete_min(node):
if node.left == None:
return Node.right
else:
return Node.delete_min(node.left)
def inorder_print(node):
if node.left != None:
Node.inorder_print(node.left)
print("",node.data, end="")
if node.right != None:
Node.inorder_print(node.right)
def preorder_print(node):
print("",node.data, end="")
if node.left != None:
Node.preorder_print(node.left)
if node.right != None:
Node.preorder_print(node.right)
class BinaryTree:
def __init__(self):
self.root = None
def insert(self, x):
self.root = Node.insert(self.root, x)
def find(self, x):
if Node.find(self.root, x):
print("yes")
else:
print("no")
def delete(self, x):
self.root = Node.delete(self.root, x)
def print_tree(self):
Node.inorder_print(self.root)
print()
Node.preorder_print(self.root)
print()
def main():
T = BinaryTree()
m = int(sys.stdin.readline())
for i in range(m):
s = sys.stdin.readline().strip()
if(s == "print"):
T.print_tree()
elif s.split()[0] == "find":
T.find(int(s.split()[1]))
elif s.split()[0] == "delete":
T.delete(int(s.split()[1]))
else:
z = int(s.split()[1])
T.insert(z)
if __name__ == "__main__":
main() |
s911997217 | p02285 | u067677727 | 1498791344 | Python | Python3 | py | Runtime Error | 30 | 7812 | 3077 | import sys
class Node:
def __init__(self, x):
self.data = x
self.left = None
self.right = None
def insert(node, x):
if node == None:
return Node(x)
elif x == node.data:
return node
elif x < node.data:
node.left = Node.insert(node.left, x)
else:
node.right = Node.insert(node.right, x)
return node
def find(node, x):
if node.data == x:
return True
elif node.left != None and node.data > x:
return Node.find(node.left, x)
elif node.right != None and node.data < x:
return Node.find(node.right, x)
else:
return False
def delete(node, x):
if node.data == x:
if node.left == None and node.right == None:
return None
elif node.left == None:
return node.right
elif node.right == None:
return node.left
else:
#????????????
node.data = Node.serch_min(node.right)
node.right = Node.delete_min(node.right)
return node
elif node.data > x:
node.left = Node.delete(node.left, x)
else:
node.right = Node.delete(node.right, x)
return node
def serch_min(node):
if node.left != None:
return Node.serch_min(node.left)
else:
return node.data
def delete_min(node):
if node.left == None:
return Node.right
else:
return Node.delete_min(node.left)
def inorder_print(node):
if node.left != None:
Node.inorder_print(node.left)
print("",node.data, end="")
if node.right != None:
Node.inorder_print(node.right)
def preorder_print(node):
print("",node.data, end="")
if node.left != None:
Node.preorder_print(node.left)
if node.right != None:
Node.preorder_print(node.right)
class BinaryTree:
def __init__(self):
self.root = None
def insert(self, x):
self.root = Node.insert(self.root, x)
def find(self, x):
if Node.find(self.root, x):
print("yes")
else:
print("no")
def delete(self, x):
self.root = Node.delete(self.root, x)
def print_tree(self):
Node.inorder_print(self.root)
print()
Node.preorder_print(self.root)
print()
def main():
T = BinaryTree()
m = int(sys.stdin.readline())
for i in range(m):
s = sys.stdin.readline().strip()
if(s == "print"):
T.print_tree()
elif s.split()[0] == "find":
T.find(int(s.split()[1]))
elif s.split()[0] == "delete":
T.delete(int(s.split()[1]))
else:
z = int(s.split()[1])
T.insert(z)
if __name__ == "__main__":
main() |
s957522152 | p02285 | u796784914 | 1500101679 | Python | Python | py | Runtime Error | 10 | 6496 | 3052 | import sys
def main():
n = input()
tree = MyBinaryTree(n)
for i in range(n):
cmd = map(str,raw_input().split())
if cmd[0] == "insert":
insert(tree,MyNode(int(cmd[1])))
elif cmd[0] == "print":
tree.inorder(tree.root)
print ""
tree.preorder(tree.root)
print ""
elif cmd[0] == "find":
find(tree,int(cmd[1]))
elif cmd[0] == "delete":
delete(tree,int(cmd[1]))
class MyBinaryTree():
def __init__(self,num_nodes):
self.root = None
def preorder(self,node):
sys.stdout.write(" {}".format(node.key))
l = node.left
r = node.right
if l is not None:
self.preorder(l)
if r is not None:
self.preorder(r)
def inorder(self,node):
l = node.left
r = node.right
if l is not None:
self.inorder(l)
sys.stdout.write(" {}".format(node.key))
if r is not None:
self.inorder(r)
def insert(T,z):
y = None
x = T.root
while x is not None:
y = x
if z.key < x.key:
x = x.left
else:
x = x.right
z.parent = y
if y is None:
T.root = z
elif z.key < y.key:
y.left = z
else:
y.right = z
def find(T,key):
x = T.root
while x is not None and key != x.key:
if key < x.key:
x = x.left
else:
x = x.right
if x is not None:
print "yes"
else:
print "no"
def delete(T,key):
x = T.root
where = None
while x is not None and key != x.key:
if key < x.key:
x = x.left
where = 0
else:
x = x.right
where = 1
if x is not None:
if x.left is None:
if x.right is None:
if where == 0:
x.parent.left = None
else:
x.parent.right = None
elif where == 0:
x.parent.left = x.right
x.right.parent = x.parent
else:
x.parent.right = x.right
x.right.parent = x.parent
x = None
elif x.rightt is None :
if where == 0:
x.parent.left = x.left
x.left.parent = x.parent
else:
x.parent.right = x.left
x.left.parent = x.parent
x = None
else:
y = x.right
while y.left is not None:
y = y.left
x.key = y.key
if y.right is not None:
y.right.parent = y.parent
y.parent.left = y.right
else:
y.parent.left = None
y = None
class MyNode():
def __init__(self,key):
self.key =key
self.parent = None
self.left = None
self.right = None
if __name__ == "__main__":
main() |
s423814458 | p02285 | u193453446 | 1502259715 | Python | Python3 | py | Runtime Error | 20 | 7828 | 3080 |
import sys
YES = "yes"
NO = "no"
class Node:
def __init__(self, value, p = None, l = None, r = None):
self.key = value
self.p = p
self.left = l
self.right = r
def chgchild(parent, old, new = None):
if parent == None:
return
else:
# print("parent:{}".format(parent.key))
if parent.left == old:
parent.left = new
else:
parent.right = new
if new != None:
new.p = parent
def delete(node):
if node == None:
return
# print("delete key:{}".format(node.key))
if node.left == None:
chgchild(node.p, node, node.right)
elif node.right == None:
chgchild(node.p, node, node.left)
else:
ino = []
inorder(node,ino)
next = 0
for i in range(ino):
if ino[i].key == value:
next = i + 1
break
node.key = ino[next].key
delete(ino[next])
def getroot(x):
if x.p != None:
return getroot(x.p)
return x
def keylist(A):
B = []
for i in A:
B.append(i.key)
return B
def preorder(x, A):
if x == None:
return
A.append(x)
preorder(x.left, A)
preorder(x.right, A)
def inorder(x, A):
if x == None:
return
inorder(x.left, A)
A.append(x)
inorder(x.right, A)
def postorder(x, A):
if x == None:
return
postorder(x.left, A)
postorder(x.right, A)
A.append(x)
def ptree(root):
pre = []
ino = []
preorder(root, pre)
inorder(root, ino)
ap = keylist(pre)
ip = keylist(ino)
print(" {}".format(" ".join(map(str,ip))))
print(" {}".format(" ".join(map(str,ap))))
def find(value, root):
if root == None:
return None
elif value < root.key:
return find(value,root.left)
elif value > root.key:
return find(value,root.right)
return root
def insert(Tree, root, z):
y = None # x ??????
x = root # 'T ??????'
while x != None:
y = x # ???????¨????
if z.key < x.key:
x = x.left # ?????????????§????
else:
x = x.right # ?????????????§????
z.p = y
Tree.append(z)
if y == None: # T ???????????´???
return z
elif z.key < y.key:
y.left = z # z ??? y ?????????????????????
else:
y.right = z # z ??? y ?????????????????????
return root
def main():
""" ????????? """
num = int(input().strip())
istr = sys.stdin.read()
cmds = list(istr.splitlines())
Tree = []
root = None
for i in range(num):
cmd = cmds[i][0]
if cmd == "i":
n = Node(int(cmds[i][7:]))
root = insert(Tree, root, n)
elif cmd == "f":
if find(int(cmds[i][5:]),root) == None:
print(NO)
else:
print(YES)
elif cmd == "p":
ptree(root)
elif cmd == "d":
node = find(int(cmds[i][7:]),root)
delete(node)
if __name__ == '__main__':
main() |
s792540443 | p02285 | u491916705 | 1502717357 | Python | Python | py | Runtime Error | 10 | 6576 | 3713 | class Node():
def __init__(self, id, left=-1, right=-1, parent=-1, type=None):
self.id = id
self.left = left
self.right = right
self.parent = parent
def show(self):
print 'node %d: parent = %d, left = %d, right = %d' % (self.id, self.parent, self.left, self.right)
class Stack():
def __init__(self):
self.el = []
def add(self, el):
self.el.append(el)
def pop(self):
return self.el.pop()
def printOrder(T):
global rootId
### inorder ###
pos = rootId
st = Stack()
ans = []
while True:
if T[pos].left != -1 and T[pos].left not in ans:
if T[pos].right != -1:
st.add(T[pos].right)
st.add(pos)
pos = T[pos].left
elif T[pos].left == -1 and T[pos].right != -1 and T[pos].right not in ans:
ans.append(pos)
pos = T[pos].right
else:
ans.append(pos)
if len(ans) == len(T):
break
pos = st.pop()
print '', ' '.join(map(str, ans))
### preorder ###
pos = rootId
st = Stack()
ans = []
while True:
ans.append(pos)
if len(ans) == len(T):
break
if T[pos].left != -1 and T[pos].right != -1:
st.add(T[pos].right)
if T[pos].left != -1:
pos = T[pos].left
elif T[pos].left == -1 and T[pos].right != -1:
pos = T[pos].right
else:
pos = st.pop()
print '', ' '.join(map(str, ans))
def insert(T, z):
global rootId
y = None
if rootId:
x = T[rootId]
while x != None:
y = x
if z.id < x.id:
if x.left == -1:
break
x = T[x.left]
else:
if x.right == -1:
break
x = T[x.right]
z.parent = x.id
if y == None:
rootId = z.id
elif z.id < y.id:
y.left = z.id
else:
y.right = z.id
T[z.id] = z
return T
def find(T, z):
global rootId
y = None
if rootId:
x = T[rootId]
while True:
y = x
if z == x.id:
print 'yes'
break
elif z < x.id:
if x.left == -1:
print 'no'
break
x = T[x.left]
else:
if x.right == -1:
print 'no'
break
x = T[x.right]
def delete(T, z):
global rootId
y = None
if rootId:
x = T[rootId]
while True:
y = x
if z == x.id:
if x.right != -1:
T[x.right].parent = x.parent
elif x.left != -1:
T[x.left].parent = x.parent
if T[x.parent].right == z:
T[x.parent].right = x.right
else:
T[x.parent].left = x.left
break
elif z < x.id:
if x.left == -1:
break
x = T[x.left]
else:
if x.right == -1:
break
x = T[x.right]
del T[z]
return T
### input ###
T = {}
a = []
n = int(raw_input())
rootId = None
for i in range(n):
tmp = raw_input().split()
if tmp[0] == 'insert':
T[int(tmp[1])] = Node(int(tmp[1]))
T = insert(T, Node(int(tmp[1])))
elif tmp[0] == 'find':
find(T, int(tmp[1]))
elif tmp[0] == 'delete':
T = delete(T, int(tmp[1]))
elif tmp[0] == 'print':
printOrder(T) |
s228178932 | p02285 | u519227872 | 1503239339 | Python | Python3 | py | Runtime Error | 20 | 7756 | 2483 | m = int(input())
class Node:
def __init__(self, key, left ,right):
self.key = key
self.left = left
self.right = right
class BinaryTree():
def __init__(self):
self.root = None
def getRoot(self):
return self.root
def setRoot(self, v):
self.root = v
def inorder(self, v=None):
if v is None:
v = self.root
if v.left is not None:
self.inorder(v.left)
print(' ' + str(v.key), end='')
if v.right is not None:
self.inorder(v.right)
def preorder(self, v=None):
if v is None:
v = self.root
print(' ' + str(v.key), end='')
if v.left is not None:
self.preorder(v.left)
if v.right is not None:
self.preorder(v.right)
def insert(T, z):
y = None
x = T.getRoot()
while x is not None:
y = x
if z.key < x.key:
x = x.left
else:
x = x.right
z.p = y
if y is None:
T.setRoot(z)
elif z.key < y.key:
y.left = z
else:
y.right = z
def find(T, k, noprint=False):
x = T.getRoot()
while x is not None:
if x.key == k:
if not noprint:
print('yes')
return x
elif x.key < k:
x = x.right
else:
x = x.left
print('no')
def getNext(v):
if v.left is not None:
return v.left
if v.right is not None:
return v.right
def delete(T, z):
if not z.left and not z.right:
p = z.p
if z.key < p.key:
p.left = None
else:
p.right = None
elif z.left and not z.right:
p = z.p
c = z.left
if z.key > p.key:
p.right = c
else:
p.left = c
c.p = p
elif not z.left and z.right:
p = z.p
c = z.right
if z.key > p.key:
p.right = c
else:
p.left = c
c.p = p
else:
n = getNext(z)
z.key = n.key
delete(T, n)
T = BinaryTree()
for i in range(m):
inp = input().split()
if inp[0] == 'print':
T.inorder()
print()
T.preorder()
print()
elif inp[0] == 'find':
find(T, int(inp[1]))
elif inp[0] == 'delete':
delete(T, find(T, int(inp[1]),True))
else:
v = Node(int(inp[1]), None, None)
insert(T, v) |
s092615453 | p02285 | u024715419 | 1510050987 | Python | Python3 | py | Runtime Error | 30 | 7888 | 2975 | class BinaryTree():
def __init__(self):
self.root = None
def insert(self, insert_node):
p = None
r = self.root
while r:
p = r
if insert_node.value < r.value:
r = r.left
else:
r = r.right
if not p:
self.root = insert_node
elif insert_node.value < p.value:
p.left = insert_node
else:
p.right = insert_node
def find(self, find_value):
r = self.root
while r:
if find_value == r.value:
return "yes"
if find_value < r.value:
r = r.left
else:
r = r.right
return "no"
def delete(self, delete_value):
flag = None
p = None
r = self.root
while True:
if delete_value == r.value:
if r.left == r.right == None:
if flag == "l":
p.left = None
else:
p.right = None
return
elif r.left == None:
if flag == "l":
p.left = r.right
else:
p.right = r.right
return
elif r.right == None:
if flag == "l":
p.left = r.left
else:
p.right = r.left
return
else:
swap_value = search_min(r.right)
self.delete(swap_value)
r.value = swap_value
elif delete_value < r.value:
p = r
r = r.left
flag = "l"
else:
p = r
r = r.right
flag = "r"
class Node():
def __init__(self, value, left, right):
self.value = value
self.left = left
self.right = right
def pre_order_search(self):
l = self.left
r = self.right
print("",self.value, end="")
if l:
l.pre_order_search()
if r:
r.pre_order_search()
def in_order_search(self):
l = self.left
r = self.right
if l:
l.in_order_search()
print("",self.value, end="")
if r:
r.in_order_search()
def search_min(self):
l = self.left
while l:
search_min(l)
return self.value
m = int(input())
tree = BinaryTree()
for i in range(m):
inp = input().split()
if inp[0] == "insert":
tree.insert(Node(int(inp[1]), None, None))
elif inp[0] == "find":
print(tree.find(int(inp[1])))
elif inp[0] == "delete":
tree.delete(int(inp[1]))
else:
tree.root.in_order_search()
print()
tree.root.pre_order_search()
print() |
s741820554 | p02285 | u024715419 | 1510052250 | Python | Python3 | py | Runtime Error | 20 | 7824 | 2976 | class BinaryTree():
def __init__(self):
self.root = None
def insert(self, insert_node):
p = None
r = self.root
while r:
p = r
if insert_node.value < r.value:
r = r.left
else:
r = r.right
if not p:
self.root = insert_node
elif insert_node.value < p.value:
p.left = insert_node
else:
p.right = insert_node
def find(self, find_value):
r = self.root
while r:
if find_value == r.value:
return "yes"
if find_value < r.value:
r = r.left
else:
r = r.right
return "no"
def delete(self, delete_value):
flag = None
p = None
r = self.root
while True:
if delete_value == r.value:
if r.left == r.right == None:
if flag == "l":
p.left = None
else:
p.right = None
return
elif r.left == None:
if flag == "l":
p.left = r.right
else:
p.right = r.right
return
elif r.right == None:
if flag == "l":
p.left = r.left
else:
p.right = r.left
return
else:
r2 = r.right
while r2:
p = r2
r2 = r2.left
swap_value = p.value
self.delete(swap_value)
r.value = swap_value
elif delete_value < r.value:
p = r
r = r.left
flag = "l"
else:
p = r
r = r.right
flag = "r"
class Node():
def __init__(self, value, left, right):
self.value = value
self.left = left
self.right = right
def pre_order_search(self):
l = self.left
r = self.right
print("",self.value, end="")
if l:
l.pre_order_search()
if r:
r.pre_order_search()
def in_order_search(self):
l = self.left
r = self.right
if l:
l.in_order_search()
print("",self.value, end="")
if r:
r.in_order_search()
m = int(input())
tree = BinaryTree()
for i in range(m):
inp = input().split()
if inp[0] == "insert":
tree.insert(Node(int(inp[1]), None, None))
elif inp[0] == "find":
print(tree.find(int(inp[1])))
elif inp[0] == "delete":
tree.delete(int(inp[1]))
else:
tree.root.in_order_search()
print()
tree.root.pre_order_search()
print() |
s335531148 | p02285 | u248416507 | 1512966532 | Python | Python | py | Runtime Error | 10 | 4864 | 3462 |
class Node(object):
def __init__(self, key):
self.left = None
self.right = None
self.parent = None
self.key = key
class Tree(object):
def __init__(self):
self.root = None
def insert(self, new_key):
x = self.root
y = None
while x is not None:
y = x
if new_key < y.key:
x = y.left
else:
x = y.right
new_node = Node(new_key)
new_node.parent = y
if y is None:
self.root = new_node
elif new_key < y.key:
y.left = new_node
else:
y.right = new_node
def inorder(self, now):
visited = list()
if now is None:
return visited
visited.extend(self.inorder(now.left))
visited.append(now.key)
visited.extend(self.inorder(now.right))
return visited
def preorder(self, now):
visited = list()
if now is None:
return visited
visited.append(now.key)
visited.extend(self.preorder(now.left))
visited.extend(self.preorder(now.right))
return visited
def order_print(self):
keys = list()
keys.append(self.inorder(self.root))
keys.append(self.preorder(self.root))
for visited_keys in keys:
print "",
print " ".join(map(str, visited_keys))
def find(self, key):
"""
keys = self.inorder(self.root)
if key in keys:
print "yes"
else:
print "no"
"""
x = self.root
y = None
while not (x is None or x.key == key):
y = x
if key < y.key:
x = y.left
else:
x = y.right
if x is not None:
print "yes"
else:
print "no"
def min_node(self, now):
"""min_node
Return the node with the minimum key,
treeting now as the root of a sub tree.
"""
if now.left is not None:
return min_node(now.left)
return now
def delete(self, key):
x = self.root
y = None
while x.key != key:
y = x
if key < y.key:
x = y.left
else:
x = y.right
# y is parent of x here
if x.left is None and x.right is None:
if y.left == x:
y.left = None
else:
y.right = None
elif x.left is None or x.right is None:
child = x.left if x.left is not None else x.right
child.parent = y
if y.left == x:
y.left = child
else:
y.right = child
else:
next_node = self.min_node(x.right)
x.key = next_node.key
self.delete(next_node)
def main():
tree = Tree()
num_orders = int(raw_input())
for _ in xrange(num_orders):
order = raw_input()
if order[0] == 'i':
new_key = int(order.split()[1])
tree.insert(new_key)
elif order[0] == 'p':
tree.order_print()
elif order[0] == 'f':
key = int(order.split()[1])
tree.find(key)
elif order[0] == 'd':
key = int(order.split()[1])
tree.delete(key)
if __name__ == "__main__":
main() |
s833525987 | p02285 | u426534722 | 1518024018 | Python | Python3 | py | Runtime Error | 20 | 5624 | 3366 | import sys
readline = sys.stdin.readline
class Node:
__slots__ = ['value', 'p', 'left', 'right']
def __init__(self, value = None, p = None, left = None, right = None):
self.value = value
self.p = p
self.left = left
self.right = right
class BinTree:
__slots__ = ['_tree', 'result']
def __init__(self):
self._tree = None
def insert(self, value):
p = None
c = self._tree
while c is not None:
p = c
if value < c.value:
c = c.left
else:
c = c.right
if p is None:
self._tree = Node(value)
elif value < p.value:
p.left = Node(value, p)
else:
p.right = Node(value, p)
def find(self, value):
c = self._tree
while c is not None:
if value == c.value:
return True
elif value < c.value:
c = c.left
else:
c = c.right
return False
def delete(self, value):
c = self._tree
while c is not None:
if value == c.value:
if c.left is None and c.right is None:
if c.p.left is c:
c.p.left = None
else:
c.p.right = None
elif c.left is not None and c.right is not None:
if c.right.left is None:
c.p.left = c.right
c.right.left = c.left
c.right.p = c.p
else:
c.value, c.right.left.value = c.right.left.value, c.value
self.delete(c.value)
return
elif c.left is not None:
if c.p.left is c:
c.p.left = c.left
else:
c.p.right = c.left
c.left.p = c.p
elif c.right is not None:
if c.p.right is c:
c.p.right = c.right
else:
c.p.left = c.right
c.right.p = c.p
c = None
return
elif value < c.value:
c = c.left
else:
c = c.right
def preoder_walk(self):
self.result = []
def preoder(node):
if node is not None:
self.result.append(node.value)
preoder(node.left)
preoder(node.right)
preoder(self._tree)
print(" " + " ".join(map(str, self.result)))
def inorder_walk(self):
self.result = []
def inorder(node):
if node is not None:
inorder(node.left)
self.result.append(node.value)
inorder(node.right)
inorder(self._tree)
print(" " + " ".join(map(str, self.result)))
n = int(input())
tree = BinTree()
for _ in range(n):
com = readline().split()
if com[0] == "insert":
tree.insert(int(com[1]))
elif com[0] == "find":
print("yes" if tree.find(int(com[1])) else "no")
elif com[0] == "delete":
tree.delete(int(com[1]))
else:
tree.inorder_walk()
tree.preoder_walk()
|
s049975866 | p02285 | u426534722 | 1518200760 | Python | Python3 | py | Runtime Error | 20 | 5624 | 2740 | import sys
readline = sys.stdin.readline
class Node:
__slots__ = ['value', 'left', 'right']
def __init__(self, value = None, left = None, right = None):
self.value = value
self.left = left
self.right = right
class BinTree:
__slots__ = ['_tree', 'result']
def __init__(self):
self._tree = None
def insert(self, value):
p = None
c = self._tree
while c is not None:
p = c
if value < c.value:
c = c.left
else:
c = c.right
if p is None:
self._tree = Node(value)
elif value < p.value:
p.left = Node(value)
else:
p.right = Node(value)
def find(self, value):
c = self._tree
while c is not None:
if value == c.value:
return True
elif value < c.value:
c = c.left
else:
c = c.right
return False
def delete(self, value):
def node_move(p, c, a):
if p.left == c:
p.left = a
else:
p.right = a
c = self._tree
p = Node(None, c)
while c.value != value:
p = c
if c is None:
return
if value < c.value:
c = c.left
else:
c = c.right
if c.left is None:
node_move(p, c, c.right)
elif c.right is None or c.right.left is None:
node_move(p, c, c.left)
else:
q = c.right
while q.left.left is not None:
q = q.left
c.value = q.left.value
q.left = q.left.right
return
def preoder_walk(self):
self.result = []
def preoder(node):
if node is not None:
self.result.append(node.value)
preoder(node.left)
preoder(node.right)
preoder(self._tree)
print(" " + " ".join(map(str, self.result)))
def inorder_walk(self):
self.result = []
def inorder(node):
if node is not None:
inorder(node.left)
self.result.append(node.value)
inorder(node.right)
inorder(self._tree)
print(" " + " ".join(map(str, self.result)))
n = int(input())
tree = BinTree()
for _ in range(n):
com = readline().split()
if com[0] == "insert":
tree.insert(int(com[1]))
elif com[0] == "find":
print("yes" if tree.find(int(com[1])) else "no")
elif com[0] == "delete":
tree.delete(int(com[1]))
else:
tree.inorder_walk()
tree.preoder_walk()
|
s077990273 | p02285 | u426534722 | 1518200817 | Python | Python3 | py | Runtime Error | 20 | 5624 | 2846 | import sys
readline = sys.stdin.readline
class Node:
__slots__ = ['value', 'left', 'right']
def __init__(self, value = None, left = None, right = None):
self.value = value
self.left = left
self.right = right
class BinTree:
__slots__ = ['_tree', 'result']
def __init__(self):
self._tree = None
def insert(self, value):
p = None
c = self._tree
while c is not None:
p = c
if value < c.value:
c = c.left
else:
c = c.right
if p is None:
self._tree = Node(value)
elif value < p.value:
p.left = Node(value)
else:
p.right = Node(value)
def find(self, value):
c = self._tree
while c is not None:
if value == c.value:
return True
elif value < c.value:
c = c.left
else:
c = c.right
return False
def delete(self, value):
def node_move(p, c, a):
if p.left == c:
p.left = a
else:
p.right = a
c = self._tree
p = Node(None, c)
while c.value != value:
p = c
if c is None:
return
if value < c.value:
c = c.left
else:
c = c.right
if c.left is None:
node_move(p, c, c.right)
elif c.right is None or c.right.left is None:
node_move(p, c, c.left)
elif c.right.left is None:
c.right.left = c.left
node_move(p, c, c.right)
else:
q = c.right
while q.left.left is not None:
q = q.left
c.value = q.left.value
q.left = q.left.right
return
def preoder_walk(self):
self.result = []
def preoder(node):
if node is not None:
self.result.append(node.value)
preoder(node.left)
preoder(node.right)
preoder(self._tree)
print(" " + " ".join(map(str, self.result)))
def inorder_walk(self):
self.result = []
def inorder(node):
if node is not None:
inorder(node.left)
self.result.append(node.value)
inorder(node.right)
inorder(self._tree)
print(" " + " ".join(map(str, self.result)))
n = int(input())
tree = BinTree()
for _ in range(n):
com = readline().split()
if com[0] == "insert":
tree.insert(int(com[1]))
elif com[0] == "find":
print("yes" if tree.find(int(com[1])) else "no")
elif com[0] == "delete":
tree.delete(int(com[1]))
else:
tree.inorder_walk()
tree.preoder_walk()
|
s340711662 | p02285 | u426534722 | 1518200864 | Python | Python3 | py | Runtime Error | 20 | 5624 | 2837 | import sys
readline = sys.stdin.readline
class Node:
__slots__ = ['value', 'left', 'right']
def __init__(self, value = None, left = None, right = None):
self.value = value
self.left = left
self.right = right
class BinTree:
__slots__ = ['_tree', 'result']
def __init__(self):
self._tree = None
def insert(self, value):
p = None
c = self._tree
while c is not None:
p = c
if value < c.value:
c = c.left
else:
c = c.right
if p is None:
self._tree = Node(value)
elif value < p.value:
p.left = Node(value)
else:
p.right = Node(value)
def find(self, value):
c = self._tree
while c is not None:
if value == c.value:
return True
elif value < c.value:
c = c.left
else:
c = c.right
return False
def delete(self, value):
def node_move(p, c, a):
if p.left == c:
p.left = a
else:
p.right = a
p = None
c = self._tree
while c.value != value:
p = c
if c is None:
return
if value < c.value:
c = c.left
else:
c = c.right
if c.left is None:
node_move(p, c, c.right)
elif c.right is None or c.right.left is None:
node_move(p, c, c.left)
elif c.right.left is None:
c.right.left = c.left
node_move(p, c, c.right)
else:
q = c.right
while q.left.left is not None:
q = q.left
c.value = q.left.value
q.left = q.left.right
return
def preoder_walk(self):
self.result = []
def preoder(node):
if node is not None:
self.result.append(node.value)
preoder(node.left)
preoder(node.right)
preoder(self._tree)
print(" " + " ".join(map(str, self.result)))
def inorder_walk(self):
self.result = []
def inorder(node):
if node is not None:
inorder(node.left)
self.result.append(node.value)
inorder(node.right)
inorder(self._tree)
print(" " + " ".join(map(str, self.result)))
n = int(input())
tree = BinTree()
for _ in range(n):
com = readline().split()
if com[0] == "insert":
tree.insert(int(com[1]))
elif com[0] == "find":
print("yes" if tree.find(int(com[1])) else "no")
elif com[0] == "delete":
tree.delete(int(com[1]))
else:
tree.inorder_walk()
tree.preoder_walk()
|
s479544306 | p02285 | u177808190 | 1519676917 | Python | Python3 | py | Runtime Error | 30 | 6020 | 3770 | import collections
sent = -1
def insert(hoge, new_node, root):
#print(hoge)
parent_maybe = sent
now_looking = root
hoge[new_node]['node_id'] = new_node
while now_looking != sent:
parent_maybe = now_looking
if new_node < hoge[now_looking]['node_id']:
now_looking = hoge[now_looking]['left']
else:
now_looking = hoge[now_looking]['right']
hoge[new_node]['parent'] = parent_maybe
if parent_maybe == sent:
root = new_node
hoge[new_node]['parent'] = sent
hoge[new_node]['left'] = sent
hoge[new_node]['right'] = sent
elif new_node < hoge[parent_maybe]['node_id']:
hoge[parent_maybe]['left'] = new_node
hoge[new_node]['left'] = sent
hoge[new_node]['right'] = sent
else:
hoge[parent_maybe]['right'] = new_node
hoge[new_node]['left'] = sent
hoge[new_node]['right'] =sent
return root
def inorder(node_id):
if node_id == sent:
return None
inorder(hoge[node_id]['left'])
print(' {}'.format(node_id), end='')
inorder(hoge[node_id]['right'])
def preorder(node_id):
if node_id == sent:
return None
print(' {}'.format(node_id), end='')
preorder(hoge[node_id]['left'])
preorder(hoge[node_id]['right'])
def getTree(root):
inorder(root)
print()
preorder(root)
print()
def searchNode(hoge, num, node_id):
if node_id == sent:
return 'no'
if num == node_id:
return 'yes'
elif num < node_id:
return searchNode(hoge, num, hoge[node_id]['left'])
elif num > node_id:
return searchNode(hoge, num, hoge[node_id]['right'])
def deleteNode(hoge, node_id):
left_child = hoge[node_id]['left']
right_child = hoge[node_id]['right']
parent = hoge[node_id]['parent']
if left_child == sent and right_child == sent:
if hoge[parent]['left'] == node_id:
hoge[parent]['left'] = sent
else:
hoge[parent]['right'] = sent
elif left_child == sent and right_child != sent:
if hoge[parent]['left'] == node_id:
hoge[parent]['left'] = right_child
else:
hoge[parent]['right'] = right_child
hoge[right_child]['parent'] = parent
elif right_child == sent and left_child != sent:
if hoge[parent]['left'] == node_id:
hoge[parent]['left'] == left_child
else:
hoge[parent]['right'] == left_child
hoge[left_child]['parent'] = parent
else:
min_node = getMin(hoge, node_id)
hoge[left_child]['parent'] = min_node
hoge[right_child]['parent'] = min_node
hoge[min_node]['left'] = left_child
hoge[min_node]['right'] = right_child
min_parent = hoge[min_node]['parent']
if hoge[min_node]['right'] == sent:
hoge[min_parent]['left'] = sent
else:
min_node_rchild = hoge[min_node]['right']
hoge[min_parent]['left'] = min_node_rchild
hoge[min_node_rchild]['parent'] = min_parent
del hoge[node_id]
def getMin(hoge, node_id):
while hoge[node_id]['left'] != sent:
node_id = hoge[node_id]['left']
return node_id
if __name__ == '__main__':
num = int(input())
hoge = collections.defaultdict(dict)
root = -1
for _ in range(num):
command = input()
if command.split()[0] == 'insert':
root = insert(hoge, int(command.split()[1]), root)
elif command.split()[0] == 'find':
print(searchNode(hoge, int(command.split()[1]), root))
elif command.split()[0] == 'delete':
deleteNode(hoge, int(command.split()[1]))
else:
getTree(root)
|
s069318709 | p02285 | u177808190 | 1519682280 | Python | Python3 | py | Runtime Error | 30 | 6028 | 4155 | import collections
sent = None
def insert(hoge, new_node, root):
parent_maybe = sent
now_looking = root
hoge[new_node]['node_id'] = new_node
while now_looking != sent:
parent_maybe = now_looking
if new_node < hoge[now_looking]['node_id']:
now_looking = hoge[now_looking]['left']
else:
now_looking = hoge[now_looking]['right']
hoge[new_node]['parent'] = parent_maybe
if parent_maybe == sent:
root = new_node
hoge[new_node]['parent'] = sent
hoge[new_node]['left'] = sent
hoge[new_node]['right'] = sent
elif new_node < hoge[parent_maybe]['node_id']:
hoge[parent_maybe]['left'] = new_node
hoge[new_node]['left'] = sent
hoge[new_node]['right'] = sent
else:
hoge[parent_maybe]['right'] = new_node
hoge[new_node]['left'] = sent
hoge[new_node]['right'] =sent
return root
def inorder(node_id):
if node_id == sent:
return None
inorder(hoge[node_id]['left'])
print(' {}'.format(node_id), end='')
inorder(hoge[node_id]['right'])
def preorder(node_id):
if node_id == sent:
return None
print(' {}'.format(node_id), end='')
preorder(hoge[node_id]['left'])
preorder(hoge[node_id]['right'])
def getTree(root):
inorder(root)
print()
preorder(root)
print()
def searchNode(hoge, num, node_id):
if node_id == sent:
return 'no'
if num == node_id:
return 'yes'
elif num < node_id:
return searchNode(hoge, num, hoge[node_id]['left'])
elif num > node_id:
return searchNode(hoge, num, hoge[node_id]['right'])
def deleteNode(hoge, node_id):
left_child = hoge[node_id]['left']
right_child = hoge[node_id]['right']
parent = hoge[node_id]['parent']
if left_child == sent and right_child == sent:
if hoge[parent]['left'] == node_id:
hoge[parent]['left'] = sent
else:
hoge[parent]['right'] = sent
elif left_child == sent and right_child != sent:
if hoge[parent]['left'] == node_id:
hoge[parent]['left'] = right_child
else:
hoge[parent]['right'] = right_child
hoge[right_child]['parent'] = parent
elif right_child == sent and left_child != sent:
if hoge[parent]['left'] == node_id:
hoge[parent]['left'] = left_child
else:
hoge[parent]['right'] == left_child
hoge[left_child]['parent'] = parent
else:
min_node = getMin(hoge, hoge[node_id]['right'])
min_parent = hoge[min_node]['parent']
if hoge[min_node]['right'] == sent:
flag = True
else:
flag = False
hoge[left_child]['parent'] = min_node
hoge[right_child]['parent'] = min_node
hoge[min_node]['left'] = left_child
if min_node != right_child:
hoge[min_node]['right'] = right_child
hoge[min_node]['parent'] = parent
if hoge[parent]['left'] == node_id:
hoge[parent]['left'] = min_node
else:
hoge[parent]['right'] = min_node
if flag:
hoge[min_parent]['left'] = sent
else:
min_node_rchild = hoge[min_node]['right']
hoge[min_parent]['left'] = min_node_rchild
hoge[min_node_rchild]['parent'] = min_parent
del hoge[node_id]
def getMin(hoge, node_id):
while hoge[node_id]['left'] != sent:
node_id = hoge[node_id]['left']
return node_id
if __name__ == '__main__':
num = int(input())
hoge = collections.defaultdict(dict)
root = sent
for _ in range(num):
command = input()
#print(command)
if command.split()[0] == 'insert':
root = insert(hoge, int(command.split()[1]), root)
elif command.split()[0] == 'find':
print(searchNode(hoge, int(command.split()[1]), root))
elif command.split()[0] == 'delete':
deleteNode(hoge, int(command.split()[1]))
else:
getTree(root)
#print(hoge)
#print()
|
s742306974 | p02285 | u177808190 | 1519721157 | Python | Python3 | py | Runtime Error | 30 | 6032 | 4164 | import collections
sent = None
def insert(hoge, new_node, root):
parent_maybe = sent
now_looking = root
hoge[new_node]['node_id'] = new_node
while now_looking != sent:
parent_maybe = now_looking
#print(hoge[now_looking], now_looking)
if new_node < hoge[now_looking]['node_id']:
now_looking = hoge[now_looking]['left']
else:
now_looking = hoge[now_looking]['right']
hoge[new_node]['parent'] = parent_maybe
if parent_maybe == sent:
root = new_node
hoge[new_node]['parent'] = sent
hoge[new_node]['left'] = sent
hoge[new_node]['right'] = sent
elif new_node < hoge[parent_maybe]['node_id']:
hoge[parent_maybe]['left'] = new_node
hoge[new_node]['left'] = sent
hoge[new_node]['right'] = sent
else:
hoge[parent_maybe]['right'] = new_node
hoge[new_node]['left'] = sent
hoge[new_node]['right'] =sent
return root
def inorder(node_id):
if node_id == sent:
return None
inorder(hoge[node_id]['left'])
print(' {}'.format(node_id), end='')
inorder(hoge[node_id]['right'])
def preorder(node_id):
if node_id == sent:
return None
print(' {}'.format(node_id), end='')
preorder(hoge[node_id]['left'])
preorder(hoge[node_id]['right'])
def getTree(root):
inorder(root)
print()
preorder(root)
print()
def searchNode(hoge, num, node_id):
if node_id == sent:
return 'no'
if num == node_id:
return 'yes'
elif num < node_id:
return searchNode(hoge, num, hoge[node_id]['left'])
elif num > node_id:
return searchNode(hoge, num, hoge[node_id]['right'])
def deleteNode(hoge, node_id):
left_child = hoge[node_id]['left']
right_child = hoge[node_id]['right']
parent = hoge[node_id]['parent']
if left_child == sent and right_child == sent:
if hoge[parent]['left'] == node_id:
hoge[parent]['left'] = sent
else:
hoge[parent]['right'] = sent
elif left_child == sent and right_child != sent:
if hoge[parent]['left'] == node_id:
hoge[parent]['left'] = right_child
else:
hoge[parent]['right'] = right_child
hoge[right_child]['parent'] = parent
elif right_child == sent and left_child != sent:
if hoge[parent]['left'] == node_id:
hoge[parent]['left'] = left_child
else:
hoge[parent]['right'] == left_child
hoge[left_child]['parent'] = parent
else:
min_node = getMin(hoge, hoge[node_id]['right'])
min_parent = hoge[min_node]['parent']
if hoge[min_node]['right'] == sent:
flag = True
else:
flag = False
hoge[left_child]['parent'] = min_node
hoge[right_child]['parent'] = min_node
hoge[min_node]['left'] = left_child
if min_node != right_child:
hoge[min_node]['right'] = right_child
hoge[min_node]['parent'] = parent
if hoge[parent]['left'] == node_id:
hoge[parent]['left'] = min_node
else:
hoge[parent]['right'] = min_node
if flag:
hoge[min_parent]['left'] = sent
else:
min_node_rchild = hoge[min_node]['right']
hoge[min_parent]['left'] = min_node_rchild
hoge[min_node_rchild]['parent'] = min_parent
del hoge[node_id]
def getMin(hoge, node_id):
while hoge[node_id]['left'] != sent:
node_id = hoge[node_id]['left']
return node_id
if __name__ == '__main__':
num = int(input())
hoge = collections.defaultdict(dict)
root = sent
for _ in range(num):
command = input()
#print(command)
if command.split()[0] == 'insert':
root = insert(hoge, int(command.split()[1]), root)
elif command.split()[0] == 'find':
print(searchNode(hoge, int(command.split()[1]), root))
elif command.split()[0] == 'delete':
deleteNode(hoge, int(command.split()[1]))
else:
getTree(root)
|
s502182930 | p02285 | u613534067 | 1522284191 | Python | Python3 | py | Runtime Error | 20 | 5616 | 2656 | # Binary Search Tree
class Node:
def __init__(self, v):
self.value = v
self.parent = None
self.left = None
self.right = None
# 再帰を使わないパターンの方が早い
def insert(node):
global root
y = None
x = root
while x is not None:
y = x
if node.value < x.value:
x = x.left
else:
x = x.right
node.parent = y
if y is None:
root = node
elif node.value < y.value:
y.left = node
else:
y.right = node
def find(num):
global root
x = root
while x is not None:
if num == x.value:
return True
elif num < x.value:
x = x.left
else:
x = x.right
return False
def delete(num):
global root
y = None # xの親
x = root
isLeft = False
while x is not None:
if num == x.value:
break
elif num < x.value:
x = x.left
isLeft = True
else:
x = x.right
isLeft = False
y = x
if x is None:
return
if x.left is None and x.right is None:
if x.parent is not None:
if isLeft:
x.parent.left = None
else:
x.parent.right = None
elif x.left is None:
if x.parent is not None:
if isLeft:
x.parent.left = x.right
else:
x.parent.right = x.right
x.right.parent = x.parent
elif x.right is None:
if x.parent is not None:
if isLeft:
x.parent.left = x.left
else:
x.parent.right = x.left
x.left.parent = x.parent
else:
delete(x.left.value)
x.value = x.left.value
def preorder_walk(node):
if node:
yield node.value
for x in preorder_walk(node.left):
yield x
for x in preorder_walk(node.right):
yield x
def inorder_walk(node):
if node:
for x in inorder_walk(node.left):
yield x
yield node.value
for x in inorder_walk(node.right):
yield x
root = None
n = int(input())
for i in range(n):
cmd, *val = input().split()
if cmd == "insert":
#root = insert(root, int(val[0]))
insert(Node(int(val[0])))
elif cmd == "print":
print("", *inorder_walk(root))
print("", *preorder_walk(root))
elif cmd == "find":
if find(int(val[0])):
print("yes")
else:
print("no")
elif cmd == "delete":
delete(int(val[0]))
|
s413123620 | p02285 | u126478680 | 1526977821 | Python | Python3 | py | Runtime Error | 30 | 5640 | 3155 | class BinaryTreeNode():
def __init__(self, val, parent=None, left=None, right=None):
self.parent = parent
self.left = None
self.right = None
self.val = val
def get_child_num(self):
num = 0
if self.left != None: num += 1
if self.right != None: num += 1
return num
def get_successor(self):
x = self
if x.right != None:
return self.get_minimum(x.right)
y = x.parent
while y != None and x == y.right:
x = y
y = y.parent
return y
def get_minimum(self):
x = self
while x.left != None:
x = x.left
return x
class BinarySearchTree():
def __init__(self):
self.root = None
def insert(self, val):
y = None
x = self.root
while x != None:
y = x
if val < x.val:
x = x.left
else:
x = x.right
node = BinaryTreeNode(val=val, parent=y)
if y == None:
self.root = node
elif node.val < y.val:
y.left = node
else:
y.right = node
def find(self, val):
x = self.root
while x != None:
if x.val == val:
return x
elif x.val < val:
x = x.right
else:
x = x.left
return None
def delete(self, val):
z = self.find(val)
if z == None: return
y = None
if z.get_child_num() < 2:
y = z
else:
y = z.get_successor()
x = None
if y.left != None:
x = y.left
else:
x = y.right
if x != None:
x.parent = y.parent
if y.parent == None:
self.root = x
elif y == y.parent.left:
y.parent.left = x
else:
y.parent.right = x
if y != z:
x.key = y.key
def preorder(self):
self.preorder_list = []
self.preorder_bfs(self.root)
return self.preorder_list
def preorder_bfs(self, u):
if u == None: return
self.preorder_list.append(u.val)
self.preorder_bfs(u.left)
self.preorder_bfs(u.right)
def inorder(self):
self.inorder_list = []
self.inorder_dfs(self.root)
return self.inorder_list
def inorder_dfs(self, u):
if u == None: return
self.inorder_dfs(u.left)
self.inorder_list.append(u.val)
self.inorder_dfs(u.right)
def print_elements(arr):
print(' ' + ' '.join([str(item) for item in arr]))
m = int(input())
bst = BinarySearchTree()
for i in range(m):
op = input()
if op.startswith('insert'):
num = int(op[7:])
bst.insert(num)
elif op.startswith('delete'):
num = int(op[7:])
bst.delete(num)
elif op.startswith('find'):
num = int(op[5:])
if bst.find(num):
print('yes')
else:
print('no')
else:
print_elements(bst.inorder())
print_elements(bst.preorder())
|
s697770948 | p02285 | u912237403 | 1374055917 | Python | Python | py | Runtime Error | 0 | 0 | 2092 | import sys
tree={}
np = -1
home=0
tree[home]=[None, None, None]
def search(p, x):
node_pos=[None,None]
while p != None:
tmp = tree[p]
if tmp[0] == x:
node_pos[0] = p
return node_pos
node_pos[1] = p
if x < tmp[0]:
p = tmp[1]
else:
p = tmp[2]
return node_pos
def node(x):
global np
np += 1
tree[np] = [x, None, None]
return np
def insert(p, x):
if p == None or np == -1: return node(x)
tmp = tree[p]
if x== tmp[0]: return p
elif x<tmp[0]:
tree[p][1]=insert(tmp[1],x)
else:
tree[p][2]=insert(tmp[2],x)
return p
def deletenode(p, parent, child=None):
if tree[parent][1]==p:
tree[parent][1] = child
elif tree[parent][2]==p:
tree[parent][2] = child
del tree[p]
def searchmin(p):
if tree[p][1]!=none:
p = tree[p][1]
return p
def delete(x):
p, parent = search(0,x)
if tree[p][1:3]==[None,None]:
deletenode(p,parent)
elif tree[p][1]==None:
deletenode(p, parent, tree[p][2])
elif tree[p][2]==None:
deletenode(p, parent, tree[p][1])
else:
p1=searchmin(tree[p][2])
if tree[parent][1]==p:
tree[parent][1] = p1
elif tree[parent][2]==p:
tree[parent][2] = p1
tree[p1][1]=tree[p][1]
tree[p1][2]=tree[p][2]
del tree[p]
return
def preorder(p):
if p == None: return []
p1, p2 = tree[p][1:3]
return [tree[p][0]] + preorder(p1) + preorder(p2)
def inorder(p):
if p == None: return []
p1, p2 = tree[p][1:3]
return inorder(p1) + [tree[p][0]] +inorder(p2)
n = int(input())
i = 0
while i<n:
s = raw_input()
if s[0]=='i':
insert(0,int(s[7:]))
elif s[0]=='f':
if search(0,int(s[5:]))[0]!=None: print 'yes'
else print 'no'
elif s[0]=='d':
delete(0,int(s[7:]))
elif s[0]=='p':
print ' ' + ' '.join(map(str, inorder(home)))
print ' ' + ' '.join(map(str, preorder(home)))
i += 1 |
s779959076 | p02285 | u912237403 | 1374056420 | Python | Python | py | Runtime Error | 20 | 4444 | 2091 | import sys
tree={}
np = -1
home=0
tree[home]=[None, None, None]
def search(p, x):
node_pos=[None,None]
while p != None:
tmp = tree[p]
if tmp[0] == x:
node_pos[0] = p
return node_pos
node_pos[1] = p
if x < tmp[0]:
p = tmp[1]
else:
p = tmp[2]
return node_pos
def node(x):
global np
np += 1
tree[np] = [x, None, None]
return np
def insert(p, x):
if p == None or np == -1: return node(x)
tmp = tree[p]
if x== tmp[0]: return p
elif x<tmp[0]:
tree[p][1]=insert(tmp[1],x)
else:
tree[p][2]=insert(tmp[2],x)
return p
def deletenode(p, parent, child=None):
if tree[parent][1]==p:
tree[parent][1] = child
elif tree[parent][2]==p:
tree[parent][2] = child
del tree[p]
def searchmin(p):
if tree[p][1]!=none:
p = tree[p][1]
return p
def delete(x):
p, parent = search(0,x)
if tree[p][1:3]==[None,None]:
deletenode(p,parent)
elif tree[p][1]==None:
deletenode(p, parent, tree[p][2])
elif tree[p][2]==None:
deletenode(p, parent, tree[p][1])
else:
p1=searchmin(tree[p][2])
if tree[parent][1]==p:
tree[parent][1] = p1
elif tree[parent][2]==p:
tree[parent][2] = p1
tree[p1][1]=tree[p][1]
tree[p1][2]=tree[p][2]
del tree[p]
return
def preorder(p):
if p == None: return []
p1, p2 = tree[p][1:3]
return [tree[p][0]] + preorder(p1) + preorder(p2)
def inorder(p):
if p == None: return []
p1, p2 = tree[p][1:3]
return inorder(p1) + [tree[p][0]] +inorder(p2)
n = int(input())
i = 0
while i<n:
s = raw_input()
if s[0]=='i':
insert(0,int(s[7:]))
elif s[0]=='f':
if search(0,int(s[5:]))[0]!=None: print 'yes'
else: print 'no'
elif s[0]=='d':
delete(int(s[7:]))
elif s[0]=='p':
print ' ' + ' '.join(map(str, inorder(home)))
print ' ' + ' '.join(map(str, preorder(home)))
i += 1 |
s039258973 | p02286 | u686180487 | 1559201043 | Python | Python3 | py | Runtime Error | 0 | 0 | 2030 | # -*- coding: utf-8 -*-
class Node:
def __init__(self, key, priority):
self.key = key
self.priority = priority
self.left = None
self.right = None
def rightRotate(t):
s = t.left
t.left = s.right
s.right = t
return s
def leftRotate(t):
s = t.right
t.right = s.left
s.left = t
return s
def insert(t, key, priority):
if not t: return Node(key, priority)
if key == t.key: return t
if key < t.key:
t.left = insert(t.left, key, priority)
if t.priority < t.left.priority:
t = rightRotate(t)
else:
t.right = insert(t.right, key, priority)
if t.priority < t.right.priority:
t = leftRotate(t)
return t
def erase(t, key):
if not t: return None
if key == t.key:
if (not t.left) and (not t.right): return None
elif not t.left:
t = leftRotate(t)
elif not t.right:
t = rightRotate(t)
else:
if t.left.priority > t.right.priority:
t = rightRotate(t)
else:
t = leftRotate(t)
return erase(t, key)
if key < t.key:
t.left = erase(t.left, key)
else:
t.right = erase(t.right, key)
return t
def find(t, key):
if t.key == key:
print("yes")
return 0
elif t.key < key and (not t.right):
find(t.right, key)
elif t.key > key and (not t.left):
find(t.left, key)
else:
print("no")
return 0
def in_print(t):
if not t.left:
in_print(t.left)
print(" " + str(t), end='')
if not t.right:
in_print(t.right)
def pre_print(t):
print(" " + str(t), end='')
if not t.left:
pre_print(t.left)
if not t.right:
pre_print(t.right)
Treap = None
num = int(input())
for i in range(num):
string = list(input().split())
if string[0] == "insert":
key = int(string[1])
priority = int(string[2])
insert(Treap, key, priority)
elif string[0] == "find":
key = int(string[1])
find(key)
elif string[0] == "delete":
key = int(string[1])
erase(Treap, key)
else:
in_print(Treap)
print()
pre_print(Treap)
print()
|
s788602531 | p02286 | u686180487 | 1559202368 | Python | Python3 | py | Runtime Error | 0 | 0 | 2037 | # -*- coding: utf-8 -*-
class Node:
def __init__(self, key, priority):
self.key = key
self.priority = priority
self.left = None
self.right = None
def rightRotate(t):
s = t.left
t.left = s.right
s.right = t
return s
def leftRotate(t):
s = t.right
t.right = s.left
s.left = t
return s
def insert(t, key, priority):
if not t: return Node(key, priority)
if key == t.key: return t
if key < t.key:
t.left = insert(t.left, key, priority)
if t.priority < t.left.priority:
t = rightRotate(t)
else:
t.right = insert(t.right, key, priority)
if t.priority < t.right.priority:
t = leftRotate(t)
return t
def erase(t, key):
if not t: return None
if key == t.key:
if (not t.left) and (not t.right): return None
elif not t.left:
t = leftRotate(t)
elif not t.right:
t = rightRotate(t)
else:
if t.left.priority > t.right.priority:
t = rightRotate(t)
else:
t = leftRotate(t)
return erase(t, key)
if key < t.key:
t.left = erase(t.left, key)
else:
t.right = erase(t.right, key)
return t
def find(t, key):
if t.key == key:
print("yes")
return 0
elif t.key < key and (not t.right):
find(t.right, key)
elif t.key > key and (not t.left):
find(t.left, key)
else:
print("no")
return 0
def in_print(t):
if not t.left:
in_print(t.left)
print(" " + str(t), end='')
if not t.right:
in_print(t.right)
def pre_print(t):
print(" " + str(t), end='')
if not t.left:
pre_print(t.left)
if not t.right:
pre_print(t.right)
Treap = None
num = int(input())
for i in range(num):
string = list(input().split())
if string[0] == "insert":
key = int(string[1])
priority = int(string[2])
insert(Treap, key, priority)
elif string[0] == "find":
key = int(string[1])
find(Treap, key)
elif string[0] == "delete":
key = int(string[1])
erase(Treap, key)
else:
in_print(Treap)
print()
pre_print(Treap)
print()
|
s360246109 | p02286 | u686180487 | 1559202550 | Python | Python3 | py | Runtime Error | 0 | 0 | 2053 | # -*- coding: utf-8 -*-
class Node:
def __init__(self, key, priority):
self.key = key
self.priority = priority
self.left = None
self.right = None
def rightRotate(t):
s = t.left
t.left = s.right
s.right = t
return s
def leftRotate(t):
s = t.right
t.right = s.left
s.left = t
return s
def insert(t, key, priority):
if not t: return Node(key, priority)
if key == t.key: return t
if key < t.key:
t.left = insert(t.left, key, priority)
if t.priority < t.left.priority:
t = rightRotate(t)
else:
t.right = insert(t.right, key, priority)
if t.priority < t.right.priority:
t = leftRotate(t)
return t
def erase(t, key):
if not t: return None
if key == t.key:
if (not t.left) and (not t.right): return None
elif not t.left:
t = leftRotate(t)
elif not t.right:
t = rightRotate(t)
else:
if t.left.priority > t.right.priority:
t = rightRotate(t)
else:
t = leftRotate(t)
return erase(t, key)
if key < t.key:
t.left = erase(t.left, key)
else:
t.right = erase(t.right, key)
return t
def find(t, key):
if t.key == key:
print("yes")
return 0
elif t.key < key and (not t.right):
find(t.right, key)
elif t.key > key and (not t.left):
find(t.left, key)
else:
print("no")
return 0
def in_print(t):
if t.left != None:
in_print(t.left)
print(" " + str(t), end='')
if t.right != None:
in_print(t.right)
def pre_print(t):
print(" " + str(t), end='')
if t.left != None:
pre_print(t.left)
if t.right != None:
pre_print(t.right)
Treap = None
num = int(input())
for i in range(num):
string = list(input().split())
if string[0] == "insert":
key = int(string[1])
priority = int(string[2])
insert(Treap, key, priority)
elif string[0] == "find":
key = int(string[1])
find(Treap, key)
elif string[0] == "delete":
key = int(string[1])
erase(Treap, key)
else:
in_print(Treap)
print()
pre_print(Treap)
print()
|
s604940630 | p02286 | u686180487 | 1559202639 | Python | Python3 | py | Runtime Error | 0 | 0 | 2077 | # -*- coding: utf-8 -*-
class Node:
def __init__(self, key, priority, left=None, right=None):
self.key = key
self.priority = priority
self.left = left
self.right = right
def rightRotate(t):
s = t.left
t.left = s.right
s.right = t
return s
def leftRotate(t):
s = t.right
t.right = s.left
s.left = t
return s
def insert(t, key, priority):
if not t: return Node(key, priority)
if key == t.key: return t
if key < t.key:
t.left = insert(t.left, key, priority)
if t.priority < t.left.priority:
t = rightRotate(t)
else:
t.right = insert(t.right, key, priority)
if t.priority < t.right.priority:
t = leftRotate(t)
return t
def erase(t, key):
if not t: return None
if key == t.key:
if (not t.left) and (not t.right): return None
elif not t.left:
t = leftRotate(t)
elif not t.right:
t = rightRotate(t)
else:
if t.left.priority > t.right.priority:
t = rightRotate(t)
else:
t = leftRotate(t)
return erase(t, key)
if key < t.key:
t.left = erase(t.left, key)
else:
t.right = erase(t.right, key)
return t
def find(t, key):
if t.key == key:
print("yes")
return 0
elif t.key < key and (not t.right):
find(t.right, key)
elif t.key > key and (not t.left):
find(t.left, key)
else:
print("no")
return 0
def in_print(t):
if t.left != None:
in_print(t.left)
print(" " + str(t), end='')
if t.right != None:
in_print(t.right)
def pre_print(t):
print(" " + str(t), end='')
if t.left != None:
pre_print(t.left)
if t.right != None:
pre_print(t.right)
Treap = None
num = int(input())
for i in range(num):
string = list(input().split())
if string[0] == "insert":
key = int(string[1])
priority = int(string[2])
insert(Treap, key, priority)
elif string[0] == "find":
key = int(string[1])
find(Treap, key)
elif string[0] == "delete":
key = int(string[1])
erase(Treap, key)
else:
in_print(Treap)
print()
pre_print(Treap)
print()
|
s605174680 | p02286 | u686180487 | 1559203552 | Python | Python3 | py | Runtime Error | 0 | 0 | 2068 | # -*- coding: utf-8 -*-
class Node:
def __init__(self, key, priority, left=None, right=None):
self.key = key
self.priority = priority
self.left = left
self.right = right
def rightRotate(t):
s = t.left
t.left = s.right
s.right = t
return s
def leftRotate(t):
s = t.right
t.right = s.left
s.left = t
return s
def insert(t, key, priority):
if not t: return Node(key, priority)
if key == t.key: return t
if key < t.key:
t.left = insert(t.left, key, priority)
if t.priority < t.left.priority:
t = rightRotate(t)
else:
t.right = insert(t.right, key, priority)
if t.priority < t.right.priority:
t = leftRotate(t)
return t
def erase(t, key):
if not t: return None
if key == t.key:
if (not t.left) and (not t.right): return None
elif not t.left:
t = leftRotate(t)
elif not t.right:
t = rightRotate(t)
else:
if t.left.priority > t.right.priority:
t = rightRotate(t)
else:
t = leftRotate(t)
return erase(t, key)
if key < t.key:
t.left = erase(t.left, key)
else:
t.right = erase(t.right, key)
return t
def find(t, key):
if t.key == key:
print("yes")
elif t.key < key and t.right != None:
find(t.right, key)
elif t.key > key and t.left != None:
find(t.left, key)
else:
print("no")
return 0
def in_print(t):
if t.left != None:
in_print(t.left)
print(" " + str(t), end='')
if t.right != None:
in_print(t.right)
def pre_print(t):
print(" " + str(t), end='')
if t.left != None:
pre_print(t.left)
if t.right != None:
pre_print(t.right)
Treap = None
num = int(input())
for i in range(num):
string = list(input().split())
if string[0] == "insert":
key = int(string[1])
priority = int(string[2])
insert(Treap, key, priority)
elif string[0] == "find":
key = int(string[1])
find(Treap, key)
elif string[0] == "delete":
key = int(string[1])
erase(Treap, key)
else:
in_print(Treap)
print()
pre_print(Treap)
print()
|
s477913671 | p02286 | u686180487 | 1559204035 | Python | Python3 | py | Runtime Error | 0 | 0 | 2084 | # -*- coding: utf-8 -*-
class Node:
def __init__(self, key, priority, left=None, right=None):
self.key = key
self.priority = priority
self.left = left
self.right = right
def rightRotate(t):
s = t.left
t.left = s.right
s.right = t
return s
def leftRotate(t):
s = t.right
t.right = s.left
s.left = t
return s
def insert(t, key, priority):
if not t: return Node(key, priority)
if key == t.key: return t
if key < t.key:
t.left = insert(t.left, key, priority)
if t.priority < t.left.priority:
t = rightRotate(t)
else:
t.right = insert(t.right, key, priority)
if t.priority < t.right.priority:
t = leftRotate(t)
return t
def erase(t, key):
if not t: return None
if key == t.key:
if (not t.left) and (not t.right): return None
elif not t.left:
t = leftRotate(t)
elif not t.right:
t = rightRotate(t)
else:
if t.left.priority > t.right.priority:
t = rightRotate(t)
else:
t = leftRotate(t)
return erase(t, key)
if key < t.key:
t.left = erase(t.left, key)
else:
t.right = erase(t.right, key)
return t
def find(t, key):
if t.key == key:
print("yes")
elif t.key < key and t.right != None:
find(t.right, key)
elif t.key > key and t.left != None:
find(t.left, key)
else:
print("no")
return 0
def in_print(t):
if t.left != None:
in_print(t.left)
print(" " + str(t), end='')
if t.right != None:
in_print(t.right)
def pre_print(t):
print(" " + str(t), end='')
if t.left != None:
pre_print(t.left)
if t.right != None:
pre_print(t.right)
Treap = None
num = int(input())
for i in range(num):
string = list(input().split())
if string[0] == "insert":
key = int(string[1])
priority = int(string[2])
Treap = insert(Treap, key, priority)
elif string[0] == "find":
key = int(string[1])
find(Treap, key)
elif string[0] == "delete":
key = int(string[1])
Treap = erase(Treap, key)
else:
in_print(Treap)
print()
pre_print(Treap)
print()
|
s645249951 | p02286 | u686180487 | 1559204359 | Python | Python3 | py | Runtime Error | 0 | 0 | 1999 | # -*- coding: utf-8 -*-
class Node:
def __init__(self, key, priority, left=None, right=None):
self.key = key
self.priority = priority
self.left = left
self.right = right
def rightRotate(t):
s = t.left
t.left = s.right
s.right = t
return s
def leftRotate(t):
s = t.right
t.right = s.left
s.left = t
return s
def insert(t, key, priority):
if not t: return Node(key, priority)
if key == t.key: return t
if key < t.key:
t.left = insert(t.left, key, priority)
if t.priority < t.left.priority:
t = rightRotate(t)
else:
t.right = insert(t.right, key, priority)
if t.priority < t.right.priority:
t = leftRotate(t)
return t
def erase(t, key):
if not t: return None
if key == t.key:
if (not t.left) and (not t.right): return None
elif not t.left:
t = leftRotate(t)
elif not t.right:
t = rightRotate(t)
else:
if t.left.priority > t.right.priority:
t = rightRotate(t)
else:
t = leftRotate(t)
return erase(t, key)
def find(t, key):
if t.key == key:
print("yes")
elif t.key < key and t.right != None:
find(t.right, key)
elif t.key > key and t.left != None:
find(t.left, key)
else:
print("no")
return 0
def in_print(t):
if t.left != None:
in_print(t.left)
print(" " + str(t), end='')
if t.right != None:
in_print(t.right)
def pre_print(t):
print(" " + str(t), end='')
if t.left != None:
pre_print(t.left)
if t.right != None:
pre_print(t.right)
Treap = None
num = int(input())
for i in range(num):
string = list(input().split())
if string[0] == "insert":
key = int(string[1])
priority = int(string[2])
Treap = insert(Treap, key, priority)
elif string[0] == "find":
key = int(string[1])
find(Treap, key)
elif string[0] == "delete":
key = int(string[1])
Treap = erase(Treap, key)
else:
in_print(Treap)
print()
pre_print(Treap)
print()
|
s342737246 | p02286 | u825008385 | 1527002690 | Python | Python3 | py | Runtime Error | 0 | 0 | 2556 | # Treap
class Node():
def __init__(self, k, p):
self.k = k
self.p = p
self.left = None
self.right = None
def rightRotate(t):
s = t.left
t.left = s.right
s.right = t
return s
def leftRotate(t):
s = t.right
t.right = s.left
s.left = t
return s
def insert(t, key, pri):
if t == None:
return Node(key, pri)
if key == t.k:
return t
if key < t.k:
t.left = insert(t.left, key, pri)
if t.p < t.left.p:
t = rightRotate(t)
else:
t.right = insert(t.right, key, pri)
if t.p < t.right.p:
t = leftRotate(t)
return t
def erase(t, key):
if t == None:
return None
if key == t.k:
if t.left == None and t.right == None:
return None
elif t.left == None:
t = leftRotate(t)
elif t.right == None:
t = rightRotate(t)
else:
if t.left.p > t.right.p:
t = rightRotate(t)
else:
t = leftRotate(t)
return erase(t, key)
if key < t.k:
t.left = erase(t.left, key)
else:
t.right = erase(t.right, key)
return t
"""
def find(t, k):
if t == None:
return -1
if t.k == k:
return 1
if find(t.left, k) == 1:
return 1
if find(t.right, k) == 1:
return 1
"""
def inorder(t):
if t == None:
return
inorder(t.left)
print(" " + str(t.k), end="")
inorder(t.right)
def preorder(t):
if t == None:
return
print(" " + str(t.k), end="")
preorder(t.left)
preorder(t.right)
def output(t):
inorder(t)
print()
preorder(t)
print()
t = None
data = []
dict = {}
m = int(input())
for i in range(m):
data.append(list(input().split()))
for i in range(m):
if data[i][0] == "insert":
if (data[i][1] in dict) == False:
t = insert(t, int(data[i][1]), int(data[i][2]))
dict[data[i][1]] = True
elif data[i][0] == "print":
output(t)
elif data[i][0] == "find":
#result = find(t, int(data[i][1]))
#if result == 1:
#print(dict)
#result = data[i][1] in dict
#print("result", result)
#print("2", result == True)
#print(data[i][1] in dict, data[i][1])
if (data[i][1] in dict) == True:
#print("12345")
print("yes")
else:
print("no")
else:
t = erase(t, int(data[i][1]))
del dict[data[i][1]]
|
s718839646 | p02287 | u643021750 | 1545223782 | Python | Python3 | py | Runtime Error | 0 | 0 | 798 | #include<iostream>
using namespace std;
#define MAX 100000 // defineは文字列を指定した文字で置き換える。constは変数を格納している。
// 2分接点の各情報を出力する
int parent(int i) { return i / 2;}
int left(int i) { return 2 * i;}
int right(int i) { return 2 * i + 1;}
int main() {
int H, i, A[MAX+1]; // 1-オリジンのため +1する
cin >> H;
for (i =1; i <= H; i++) cin >> A[i];
for (i = 1;i <= H; i++) {
cout << "node " << i << ": key = " << A[i] << ", ";
// <<はストリームへの入力
if (parent(i) >= 1 ) cout << "parent key = " << A[parent(i)] << ", ";
if (left(i) <= H ) cout << "left key = " << A[left(i)] << ", ";
if (right(i) <= H ) cout << "right key = " << A[right(i)] << ", ";
cout << endl;
}
}
|
s783922582 | p02287 | u130979865 | 1460500529 | Python | Python | py | Runtime Error | 0 | 0 | 472 | # -*- coding: utf-8 -*-
n = int(raw_input())
l = map(int, raw_input().split())
A = [0]
for i in range(n):
A.append(l[i])
print "node %d: key = %d, left key = %d, right key = %d, " %(1, A[1], A[2*1], A[2*1+1])
for i in range(2, int(n/2+1)):
print "node %d: key = %d, parent key = %d, left key = %d, right key = %d, " %(i, A[i], A[int(i/2)], A[2*i], A[2*i+1])
for i in range(int(n/2+1), n+1):
print "node %d: key = %d, parent key = %d, " %(i, A[i], A[int(i/2)]) |
s850927894 | p02287 | u603356762 | 1470473459 | Python | Python3 | py | Runtime Error | 0 | 0 | 769 | n = int(input())
keys = list(map(int, input().split()))
#n=5
#heap_keys = [7,8,1,2,3]
heap = []
for i,x in enumerate(heap_keys):
node = i+1
key = x
parent_key = heap_keys[int(node/2)-1] if i > 0 else None
left_key = heap_keys[2*node-1] if 2*node-1 <len(heap_keys) else None
right_key = heap_keys[2*node] if 2*node <len(heap_keys) else None
heap.append({"node":node, "key":x, "parent_key":parent_key, "left_key":left_key, "right_key":right_key})
for h in heap:
out_str = "node %s: key = %s, " % (h["node"],h["key"])
if h["parent_key"]:out_str += "parent key = %s, " % h["parent_key"]
if h["left_key"]:out_str += "left key = %s, " % h["left_key"]
if h["right_key"]:out_str += "right key = %s, " % h["right_key"]
print(out_str) |
s250392539 | p02287 | u091533407 | 1500164750 | Python | Python3 | py | Runtime Error | 0 | 0 | 1227 | def print_heap():
for i in range(n):
if (i-1)//2 in range(n):
if 2*i+1 in range(n):
if 2*1+2 in range(n):
print("node {}: key = {}, parent key = {}, left key = {}, right key = {},"
.format(i+1, heap[i], heap[(i-1)//2], heap[2*i+1], heap[2*i+2]))
else:
print("node {}: key = {}, parent key = {}, left key = {},"
.format(i+1, heap[i], heap[(i-1)//2], heap[2*i+1]))
else:
print("node {}: key = {}, parent key = {},"
.format(i+1, heap[i], heap[(i-1)//2]))
else:
if 2*i+1 in range(n):
if 2*1+2 in range(n):
print("node {}: key = {}, left key = {}, right key = {},"
.format(i+1, heap[i], heap[2*i+1], heap[2*i+2]))
else:
print("node {}: key = {}, left key = {},"
.format(i+1, heap[i], heap[2*i+1]))
else:
print("node {}: key = {},".format(i+1, heap[i]))
if __name__ == "__main__":
n = int(input())
heap = list(map(int, input().split()))
print_heap() |
s701368653 | p02287 | u135421061 | 1523855589 | Python | Python3 | py | Runtime Error | 0 | 0 | 692 | import sys
import numpy as np
def BinaryTree(array):
for i in range(1,len(array)):
print("node " + str(i) + ": key = " + str(array[i]),end="")
if(i != 1):
print(", parent key = " + str(array[int(i / 2)]),end="")
if(2*i < len(array)):
print(", left key = " + str(array[2*i]),end = "")
if(2*i + 1 < len(array)):
print(", right key = " + str(array[2 * i + 1]),end = "")
print(", ")
if __name__ == "__main__":
h = input()
array = [1]
array[0] = 0
array.extend(list(map(int,input().split())))
print(array)
array = np.array(array)
print(array.shape)
binarytree = BinaryTree(array)
|
s286274197 | p02287 | u135421061 | 1523855677 | Python | Python3 | py | Runtime Error | 0 | 0 | 694 | import sys
import numpy as np
def BinaryTree(array):
for i in range(1,len(array)):
print("node " + str(i) + ": key = " + str(array[i]),end="")
if(i != 1):
print(", parent key = " + str(array[int(i / 2)]),end="")
if(2*i < len(array)):
print(", left key = " + str(array[2*i]),end = "")
if(2*i + 1 < len(array)):
print(", right key = " + str(array[2 * i + 1]),end = "")
print(", ")
if __name__ == "__main__":
h = input()
array = [1]
array[0] = 0
array.extend(list(map(int,input().split())))
#print(array)
array = np.array(array)
#print(array.shape)
binarytree = BinaryTree(array)
|
s088216588 | p02287 | u135421061 | 1523855723 | Python | Python3 | py | Runtime Error | 0 | 0 | 694 | import sys
import numpy as np
def BinaryTree(array):
for i in range(1,len(array)):
print("node " + str(i) + ": key = " + str(array[i]),end="")
if(i != 1):
print(", parent key = " + str(array[int(i / 2)]),end="")
if(2*i < len(array)):
print(", left key = " + str(array[2*i]),end = "")
if(2*i + 1 < len(array)):
print(", right key = " + str(array[2 * i + 1]),end = "")
print(", ")
if __name__ == "__main__":
h = input()
array = [1]
array[0] = 0
array.extend(list(map(int,input().split())))
#print(array)
array = np.array(array)
#print(array.shape)
binarytree = BinaryTree(array)
|
s465232623 | p02287 | u135421061 | 1523855939 | Python | Python3 | py | Runtime Error | 0 | 0 | 682 | import sys
import numpy as np
def BinaryTree(array):
for i in range(1,len(array)):
print("node " + str(i) + ": key = " + str(array[i]),end="")
if(i != 1):
print(", parent key = " + str(array[int(i / 2)]),end="")
if(2*i < len(array)):
print(", left key = " + str(array[2*i]),end = "")
if(2*i + 1 < len(array)):
print(", right key = " + str(array[2 * i + 1]),end = "")
print(", ")
if __name__ == "__main__":
h = input()
array = [1]
array[0] = 0
array.extend(list(map(int,input().split())))
#print(array)
#array = np.array(array)
#print(array.shape)
BinaryTree(array)
|
s719250334 | p02287 | u135421061 | 1523855976 | Python | Python3 | py | Runtime Error | 0 | 0 | 682 | import sys
import numpy as np
def BinaryTree(array):
for i in range(1,len(array)):
print("node " + str(i) + ": key = " + str(array[i]),end="")
if(i != 1):
print(", parent key = " + str(array[int(i / 2)]),end="")
if(2*i < len(array)):
print(", left key = " + str(array[2*i]),end = "")
if(2*i + 1 < len(array)):
print(", right key = " + str(array[2 * i + 1]),end = "")
print(", ")
if __name__ == "__main__":
h = input()
array = [1]
array[0] = 0
array.extend(list(map(int,input().split())))
#print(array)
#array = np.array(array)
#print(array.shape)
BinaryTree(array)
|
s199345060 | p02287 | u135421061 | 1523855999 | Python | Python3 | py | Runtime Error | 0 | 0 | 682 | import sys
import numpy as np
def BinaryTree(array):
for i in range(1,len(array)):
print("node " + str(i) + ": key = " + str(array[i]),end="")
if(i != 1):
print(", parent key = " + str(array[int(i / 2)]),end="")
if(2*i < len(array)):
print(", left key = " + str(array[2*i]),end = "")
if(2*i + 1 < len(array)):
print(", right key = " + str(array[2 * i + 1]),end = "")
print(", ")
if __name__ == "__main__":
h = input()
array = [1]
array[0] = 0
array.extend(list(map(int,input().split())))
#print(array)
#array = np.array(array)
#print(array.shape)
BinaryTree(array)
|
s905206531 | p02287 | u724548524 | 1525409702 | Python | Python3 | py | Runtime Error | 0 | 0 | 309 | n = int(input())
a = [0] + list(map(int, input().split()))
for i in range(1, n + 1):
print(f"node {i}: key = {a[i]}," + (f" parent key = {a[int(i / 2)]}," if i != 1: else "") + (f"{ left key = {a[2 * i]}, " if i * 2 <= n: else = "") + (f" right key = {a[2 * i + 1]}," if 2 * i + 1 <= n: else = ""))
|
s321964193 | p02287 | u559106458 | 1529408524 | Python | Python3 | py | Runtime Error | 0 | 0 | 705 | #coding-utf8
#Complete Binary Tree
list=[]
list.append("sentinel")
def parent(i):
return i//2
def left(i):
return i*2
def right(i):
return i*2+1
def main():
H=int(input())
for i in range(H):
i+=1
list.append(int(input()))
for i in range(H):
i+=1
print("node "+str(i)+": key = "+str(list[i])+", ",end="")
if(parent(i)):
print("parent key = "+str(list[parent(i)])+", ",end="")
if(left(i)<=H):
print("left key = "+str(list[left(i)])+", ",end="")
if(right(i)<=H):
print("right key = "+str(list[right(i)])+", ",end="")
print()
return 0
if __name__ == "__main__":
main()
|
s239324120 | p02287 | u559106458 | 1529408574 | Python | Python3 | py | Runtime Error | 0 | 0 | 705 | #coding-utf8
#Complete Binary Tree
list=[]
list.append("sentinel")
def parent(i):
return i//2
def left(i):
return i*2
def right(i):
return i*2+1
def main():
H=int(input())
for i in range(H):
i+=1
list.append(int(input()))
for i in range(H):
i+=1
print("node "+str(i)+": key = "+str(list[i])+", ",end="")
if(parent(i)):
print("parent key = "+str(list[parent(i)])+", ",end="")
if(left(i)<=H):
print("left key = "+str(list[left(i)])+", ",end="")
if(right(i)<=H):
print("right key = "+str(list[right(i)])+", ",end="")
print()
return 0
if __name__ == "__main__":
main()
|
s568942580 | p02287 | u559106458 | 1529408593 | Python | Python3 | py | Runtime Error | 0 | 0 | 705 | #coding-utf8
#Complete Binary Tree
list=[]
list.append("sentinel")
def parent(i):
return i//2
def left(i):
return i*2
def right(i):
return i*2+1
def main():
H=int(input())
for i in range(H):
i+=1
list.append(int(input()))
for i in range(H):
i+=1
print("node "+str(i)+": key = "+str(list[i])+", ",end="")
if(parent(i)):
print("parent key = "+str(list[parent(i)])+", ",end="")
if(left(i)<=H):
print("left key = "+str(list[left(i)])+", ",end="")
if(right(i)<=H):
print("right key = "+str(list[right(i)])+", ",end="")
print()
return 0
if __name__ == "__main__":
main()
|
s261014024 | p02288 | u805716376 | 1551282300 | Python | Python3 | py | Runtime Error | 0 | 0 | 341 | H=int(input())+1
A=[0]+list(map(int,input().split()))
def h(i):
l=2*i;r=l+1
if r<H &&l<H :
if A[i]<A[l]:
if A[l]<A[r]:A[i],A[r]=A[r],A[i];h(r)
else:A[i],A[l]=A[l],A[i];h(l)
elif A[i]<A[r]:A[i],A[r]=A[r],A[i];h(r)
elif l<H and A[i]<A[l]:A[i],A[l]=A[l],A[i];h(l)
for i in range(H//2,0,-1):h(i)
print(' '+' '.join(map(str,A[1:])))
|
s648651381 | p02288 | u805716376 | 1551282333 | Python | Python3 | py | Runtime Error | 0 | 0 | 341 | H=int(input())+1
A=[0]+list(map(int,input().split()))
def h(i):
l=2*i;r=l+1
if r<H && l<H:
if A[i]<A[l]:
if A[l]<A[r]:A[i],A[r]=A[r],A[i];h(r)
else:A[i],A[l]=A[l],A[i];h(l)
elif A[i]<A[r]:A[i],A[r]=A[r],A[i];h(r)
elif l<H and A[i]<A[l]:A[i],A[l]=A[l],A[i];h(l)
for i in range(H//2,0,-1):h(i)
print(' '+' '.join(map(str,A[1:])))
|
s450718300 | p02288 | u879226672 | 1432123846 | Python | Python | py | Runtime Error | 0 | 0 | 546 | # coding: utf-8
def maxHeapify(A, i):
l = A[2*(i+1)-1]
r = A[2*(i+1)]
if l <= H and A[l] > A[i]:
largest = l
else:
largest = i
if r <= H and A[r] > A[largest]:
largest = r
if largest != i:???# i ???????????????????????§????????´???
A[i],A[largest] = A[largest],A[i]
maxHeapify(A, largest) # ?????°??????????????????
def buildMaxHeap(A):
for i in range(H/2,0,-1):
maxHeapify(A,i)
H = int(raw_input())
A = map(int, raw_input().split())
buildMaxHeap(A)
print A |
s666534089 | p02288 | u811733736 | 1481014527 | Python | Python3 | py | Runtime Error | 0 | 0 | 810 | def max_heapify(A, i):
l = 2 * i
r = 2 * i + 1
largest = i
if l <= len(A) and A[l] > A[i]:
largest = l
else:
largest = i
if r < len(A) and A[r] > A[largest]:
largest = r
if largest != i:
temp = A[i]
A[i] = A[largest]
A[largest] = temp
max_heapify(A, largest)
def build_maxheap(A):
i = len(A) // 2
while i >= 1:
max_heapify(A, i)
i -= 1
if __name__ == '__main__':
# ??????????????\???
num_of_data = int(input())
A = [int(x) for x in input().split(' ')]
A.insert(0, 0) # ?????????1??????????????????????????????????????????
# ???????????????
build_maxheap(A)
A = A[1:] # ???????????????????????????
# ???????????????
print(' {0}'.format(' '.join(map(str, A)))) |
s195331766 | p02288 | u742013327 | 1481621209 | Python | Python3 | py | Runtime Error | 20 | 7604 | 788 | #http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_9_B
#???????????? 17:55~
def maxHeapify(heap, index):
left_index = 2 * index
right_index = 2 * index + 1
left = heap[left_index] if left_index < len(heap) else -1
right = heap[right_index] if right_index < len(heap) else -1
largest_index = heap.index(max([left, right, heap[index]]))
if not largest_index == index:
heap[index], heap[largest_index] = heap[largest_index], heap[index]
maxHeapify(heap, largest_index)
def main():
n_node = int(input())
target_list = [""] + [int(n) for n in input().split()]
for i in range(1, int(len(target_list) / 2) + 1)[::-1]:
maxHeapify(target_list, i)
print(*target_list)
if __name__ == "__main__":
main() |
s575975270 | p02288 | u112247126 | 1487816773 | Python | Python3 | py | Runtime Error | 0 | 0 | 569 | def maxHeapify(heap, i):
while (i + 1) * 2 <= len(heap):
left = (i + 1) * 2 - 1
right = (i + 1) * 2
largest = left if heap[left] > heap[i] else i
largest = right if heap[right] > heap[largest]
if largest != i:
heap[i], heap[largest] = heap[largest], heap[i]
else:
break
def buildMaxHeap(heap):
for i in range(len(heap), 1):
maxHeapify(heap, i)
n = int(input())
heap = list(map(int, input().split()))
buildMaxHeap(heap)
out = ''
for key in heap:
out += ' str(key)'
print(out) |
s350820194 | p02288 | u112247126 | 1487816885 | Python | Python3 | py | Runtime Error | 0 | 0 | 620 | def maxHeapify(heap, i):
while (i + 1) * 2 <= len(heap):
left = (i + 1) * 2 - 1
right = (i + 1) * 2
largest = left if heap[left] > heap[i] and left <= len(heap) else i
largest = right if heap[right] > heap[largest] and right <= len(heap)
if largest != i:
heap[i], heap[largest] = heap[largest], heap[i]
maxHeapify(heap, largest)
def buildMaxHeap(heap):
for i in range(len(heap), 1):
maxHeapify(heap, i)
n = int(input())
heap = list(map(int, input().split()))
buildMaxHeap(heap)
out = ''
for key in heap:
out += ' str(key)'
print(out) |
s359450692 | p02288 | u112247126 | 1487817436 | Python | Python3 | py | Runtime Error | 0 | 0 | 591 | def maxHeapify(heap, i):
left = (i + 1) * 2 - 1
right = (i + 1) * 2
largest = left if heap[left] > heap[i] and left <= len(heap) else i
largest = right if heap[right] > heap[largest] and right <= len(heap) else largest
if largest != i:
heap[i], heap[largest] = heap[largest], heap[i]
maxHeapify(heap, largest)
def buildMaxHeap(heap):
for i in range(len(heap) // 2, -1, -1):
maxHeapify(heap, i)
n = int(input())
heap = list(map(int, input().split()))
buildMaxHeap(heap)
out = ''
for key in heap:
out += (' {}'.format(str(key)))
print(out) |
s331273783 | p02288 | u112247126 | 1487817506 | Python | Python3 | py | Runtime Error | 0 | 0 | 591 | def maxHeapify(heap, i):
left = (i + 1) * 2 - 1
right = (i + 1) * 2
largest = left if heap[left] > heap[i] and left <= len(heap) else i
largest = right if heap[right] > heap[largest] and right <= len(heap) else largest
if largest != i:
heap[i], heap[largest] = heap[largest], heap[i]
maxHeapify(heap, largest)
def buildMaxHeap(heap):
for i in range(len(heap) // 2, -1, -1):
maxHeapify(heap, i)
n = int(input())
heap = list(map(int, input().split()))
buildMaxHeap(heap)
out = ''
for key in heap:
out += (' {}'.format(str(key)))
print(out) |
s058814189 | p02288 | u112247126 | 1487817598 | Python | Python3 | py | Runtime Error | 0 | 0 | 616 | def maxHeapify(heap, i):
left = (i + 1) * 2 - 1
right = (i + 1) * 2
largest = left if heap[left] > heap[i] and left <= len(heap) else i
largest = right if heap[right] > heap[largest] and right <= len(heap) else largest
if largest != i:
heap[i], heap[largest] = heap[largest], heap[i]
maxHeapify(heap, largest)
def buildMaxHeap(heap):
for i in range(len(heap) // 2, -1, -1):
maxHeapify(heap, i)
n = int(input())
heap = list(map(int, input().split()))
buildMaxHeap(heap)
print('', *heap)
'''
out = ''
for key in heap:
out += (' {}'.format(str(key)))
print(out)
''' |
s892248710 | p02288 | u112247126 | 1487817724 | Python | Python3 | py | Runtime Error | 0 | 0 | 590 | def maxHeapify(heap, i):
left = (i + 1) * 2 - 1
right = (i + 1) * 2
largest = left if heap[left] > heap[i] and left < len(heap) else i
largest = right if heap[right] > heap[largest] and right < len(heap) else largest
if largest != i:
heap[i], heap[largest] = heap[largest], heap[i]
maxHeapify(heap, largest)
def buildMaxHeap(heap):
for i in range(len(heap) // 2, -1, -1):
maxHeapify(heap, i)
n = int(input())
heap = list(map(int, input().split()))
buildMaxHeap(heap)
out = ''
for key in heap:
out += (' {}'.format(str(key)))
print(out) |
s741862508 | p02288 | u112247126 | 1487817779 | Python | Python3 | py | Runtime Error | 0 | 0 | 590 | def maxHeapify(heap, i):
left = (i + 1) * 2 - 1
right = (i + 1) * 2
largest = left if heap[left] > heap[i] and left < len(heap) else i
largest = right if heap[right] > heap[largest] and right < len(heap) else largest
if largest != i:
heap[i], heap[largest] = heap[largest], heap[i]
maxHeapify(heap, largest)
def buildMaxHeap(heap):
for i in range(len(heap) // 2, -1, -1):
maxHeapify(heap, i)
n = int(input())
heap = list(map(int, input().split()))
buildMaxHeap(heap)
out = ''
for key in heap:
out += (' {}'.format(str(key)))
print(out) |
s002164390 | p02288 | u112247126 | 1487817803 | Python | Python3 | py | Runtime Error | 0 | 0 | 614 | def maxHeapify(heap, i):
left = (i + 1) * 2 - 1
right = (i + 1) * 2
largest = left if heap[left] > heap[i] and left < len(heap) else i
largest = right if heap[right] > heap[largest] and right < len(heap) else largest
if largest != i:
heap[i], heap[largest] = heap[largest], heap[i]
maxHeapify(heap, largest)
def buildMaxHeap(heap):
for i in range(len(heap) // 2, -1, -1):
maxHeapify(heap, i)
n = int(input())
heap = list(map(int, input().split()))
buildMaxHeap(heap)
print('', *heap)
'''
out = ''
for key in heap:
out += (' {}'.format(str(key)))
print(out)
''' |
s700998177 | p02288 | u112247126 | 1487818072 | Python | Python3 | py | Runtime Error | 0 | 0 | 655 | # ????????????????????????????????????
def maxHeapify(heap, i):
left = (i + 1) * 2 - 1
right = (i + 1) * 2
largest = left if heap[left] > heap[i] and left < len(heap) else i
largest = right if heap[right] > heap[largest] and right < len(heap) else largest
if largest != i:
heap[i], heap[largest] = heap[largest], heap[i]
maxHeapify(heap, largest)
def buildMaxHeap(heap):
for i in range(len(heap) // 2, -1, -1):
maxHeapify(heap, i)
n = int(input())
heap = list(map(int, input().split()))
buildMaxHeap(heap)
print('', *heap)
'''
out = ''
for key in heap:
out += (' {}'.format(str(key)))
print(out)
''' |
s090628955 | p02288 | u150984829 | 1519611334 | Python | Python3 | py | Runtime Error | 0 | 0 | 229 | input()
A=[0]+list(map(int,input().split()))
H=len(A)
def h(i):
l=2*i;r,g=l+1,[i,l][A[i]<A[l]and l<H]
if A[g]<A[r]and r<H:g=r
if g!=i:A[i],A[g]=A[g],A[i];h(g)
for i in range(H//2,0,-1):h(i)
print(' '+' '.join(map(str,A[1:])))
|
s676329062 | p02288 | u150984829 | 1519612793 | Python | Python3 | py | Runtime Error | 0 | 0 | 222 | H=int(input())+1
A=[0]+list(map(int,input().split()))
def h(i):
g=A.index(max(A[i],A[i,2*i][2*i<H],A[i,2*i+1][2*i+1<H]))
if g>i:A[i],A[g]=A[g],A[i];h(g)
for i in range(H//2,0,-1):h(i)
print(' '+' '.join(map(str,A[1:])))
|
s979642463 | p02288 | u150984829 | 1519614191 | Python | Python3 | py | Runtime Error | 0 | 0 | 258 | H=int(input())+1
A=[0]+list(map(int,input().split()))
def h(i):
l=2*i;r=l+1
g=i
if r<H and A[g]<A[r]:g=l if A[i]<A[l]else r
else:if l<H and A[i]<A[l]:g=l
if g>i:A[i],A[g]=A[g],A[i];h(g)
for i in range(H//2,0,-1):h(i)
print(' '+' '.join(map(str,A[1:])))
|
s040704980 | p02288 | u135421061 | 1523861063 | Python | Python3 | py | Runtime Error | 0 | 0 | 880 | import numpy as np
import sys
def maxHeapify(array,i):
l = 2 * i
r = 2 * i + 1
largest = i
#print("i,array[i] ==: " + str(i) + ", " + str(array[i]))
#print(array)
if( l < (len(array))):
if(array[l] > array[i]):
largest = l
else:
largest = i
if( r < (len(array))):
if(array[r] > array[largest]):
largest = r
if(largest != i):
array[i],array[largest] = array[largest],array[i]
maxHeapify(array,largest)
def buildMaxHeap(array):
for i in range( int((len(array)-1) / 2),0,-1):
maxHeapify(array,i)
return array
if __name__ == "__main__":
h = int(input())
array = [1]
array[0] = 0
array.extend(list(map(int,input().split())))
#print("original == :" + str(array))
maxheap = buildMaxHeap(array)
maxheap.pop(0)
print(maxheap)
|
s055523782 | p02288 | u135421061 | 1523861378 | Python | Python3 | py | Runtime Error | 0 | 0 | 884 | import numpy as np
import sys
def maxHeapify(array,i):
l = 2 * i
r = 2 * i + 1
largest = i
#print("i,array[i] ==: " + str(i) + ", " + str(array[i]))
#print(array)
if( l < (len(array))):
if(array[l] > array[i]):
largest = l
else:
largest = i
if( r < (len(array))):
if(array[r] > array[largest]):
largest = r
if(largest != i):
array[i],array[largest] = array[largest],array[i]
maxHeapify(array,largest)
def buildMaxHeap(array):
for i in range( int((len(array)-1) / 2),0,-1):
maxHeapify(array,i)
return array
if __name__ == "__main__":
h = int(input())
array = [1]
array[0] = 0
array.extend(list(map(int,input().split())))
#print("original == :" + str(array))
maxheap = buildMaxHeap(array)
maxheap.pop(0)
print('',*maxheap)
|
s090252665 | p02289 | u007270338 | 1535531301 | Python | Python3 | py | Runtime Error | 0 | 0 | 998 | #coding: utf-8
A = []
inf = 100000000000
def maxHeapify(A, i):
l = 2 * i
r = 2 * i + 1
H = len(A)
if l <= H and A[l] > A[i]:
largest = l
else:
largest = i
if r <= H and A[r] > A[largest]:
largest = r
if largest != i:
A[i], A[largest] = A[largest], A[i]
maxHeapify(A, largest)
def Insert(key):
A.append(key)
i = len(A)
while i > 1 and A[i // 2 - 1] < A[i-1] :
A[i-1], A[i // 2 - 1] = A[i // 2 - 1], A[i - 1]
i = i// 2
def heapExtractMax(A):
if len(A) == 0:
return
maxv = A[0]
A[0] = A[-1]
maxHeapify(A, 0)
return maxv
while True:
data = list(input().split())
if data[0] == "end":
break
elif data[0] == "insert":
Insert(int(data[1]))
else:
maxv = heapExtractMax(A)
print(maxv)
|
s205342381 | p02289 | u800534567 | 1540306919 | Python | Python3 | py | Runtime Error | 0 | 0 | 827 | #include <stdio.h>
#include <stdlib.h>
#define SIZE 2000000
int main() {
int A[SIZE];
int H=0;
int i, l, largest, tmp;
char com[20];
do {
fgets(com, 20, stdin);
if (com[0] == 'i') { // insert nn
A[++H] = atoi(com+7);
for (i=H; i>1 && A[i/2]<A[i];i/=2) {
tmp = A[i/2];
A[i/2] = A[i];
A[i] = tmp;
}
} else if (com[1]=='x') { // extract
printf("%d\n", A[1]);
A[1] = A[H];
i = 1;
while (1) {
l = i*2;
largest = i;
if (l < H && A[l] > A[i]) largest = l;
if (l+1 < H && A[l+1] > A[largest]) largest = l+1;
if (largest == i) break;
tmp = A[i];
A[i] = A[largest];
A[largest] = tmp;
i = largest;
}
H--;
}
} while (com[2]!='d');
return 0;
}
|
s517861371 | p02289 | u800534567 | 1540307931 | Python | Python3 | py | Runtime Error | 0 | 0 | 1035 | #include <stdio.h>
#define SIZE 2000000
int myatoi(const char* p)
{
int n;
while (*p!='\n') {
n = n*10+*p-'0';
p++;
}
return n;
}
void putnum(int n)
{
int i;
char buf[20];
buf[19]='\0';
for (i=18; n>0; n/=10) buf[i--]=(n%10)+'0';
puts(buf+i+1);
}javascript:void(0)
int main() {
int A[SIZE];
int H=0;
int i, l, largest, tmp;
char com[21];
do {
fgets(com, 20, stdin);
if (com[0] == 'i') {
A[++H] = myatoi(com+7);
for (i=H; i>1 && A[i/2]<A[i];i/=2) {
tmp = A[i/2];
A[i/2] = A[i];
A[i] = tmp;
}
} else if (com[1]=='x') { // extract
putnum(A[1]);
A[1] = A[H];
i = 1;
while (1) {
l = i*2;
largest = i;
if (l < H && A[l] > A[i]) largest = l;
if (l+1 < H && A[l+1] > A[largest]) largest = l+1;
if (largest == i) break;
tmp = A[i];
A[i] = A[largest];
A[largest] = tmp;
i = largest;
}
H--;
}
} while (com[2]!='d');
return 0;
}
|
s494703360 | p02289 | u800534567 | 1540307984 | Python | Python3 | py | Runtime Error | 0 | 0 | 1041 | #include <stdio.h>
#define SIZE 2000000
int myatoi(const char* p)
{
int n;
while (*p!='\n') {
n = n*10+*p-'0';
p++;
}
return n;
}
void putnum(int n)
{
int i;
char buf[20];
buf[19]='\0';
for (i=18; n>0; n/=10) buf[i--]=(n%10)+'0';
puts(buf+i+1);
}
int main() {
int A[SIZE];
int H=0;
int i, l, largest, tmp;
char com[21];
do {
fgets(com, 20, stdin);
if (com[0] == 'i') {
A[++H] = myatoi(com+7);
for (i=H; i>1 && A[i/2]<A[i];i/=2) {
tmp = A[i/2];
A[i/2] = A[i];
A[i] = tmp;
}
} else if (com[1]=='x') { // extract
printf("%d\n", A[1]); //putnum(A[1]);
A[1] = A[H];
i = 1;
while (1) {
l = i*2;
largest = i;
if (l < H && A[l] > A[i]) largest = l;
if (l+1 < H && A[l+1] > A[largest]) largest = l+1;
if (largest == i) break;
tmp = A[i];
A[i] = A[largest];
A[largest] = tmp;
i = largest;
}
H--;
}
} while (com[2]!='d');
return 0;
}
|
s600314357 | p02289 | u800534567 | 1540308472 | Python | Python3 | py | Runtime Error | 0 | 0 | 898 | #include <stdio.h>
#define SIZE 2000000
int myatoi(const char* p)
{
int n;
while (*p!='\n') {
n = n*10+*p-'0';
p++;
}
return n;
}
int main() {
int A[SIZE];
int H=0;
int i, l, largest, tmp;
char com[21];
do {
fgets(com, 20, stdin);
if (com[0] == 'i') {
A[++H] = myatoi(com+7);
for (i=H; i>1 && A[i/2]<A[i];i/=2) {
tmp = A[i/2];
A[i/2] = A[i];
A[i] = tmp;
}
} else if (com[1]=='x') { // extract
printf("%d\n", A[1]);
A[1] = A[H];
i = 1;
while (1) {
l = i*2;
largest = i;
if (l < H && A[l] > A[i]) largest = l;
if (l+1 < H && A[l+1] > A[largest]) largest = l+1;
if (largest == i) break;
tmp = A[i];
A[i] = A[largest];
A[largest] = tmp;
i = largest;
}
H--;
}
} while (com[2]!='d');
return 0;
}
|
s661590400 | p02289 | u800534567 | 1540308486 | Python | Python3 | py | Runtime Error | 0 | 0 | 916 | #include <stdio.h>
#include <stdlib.h>
#define SIZE 2000000
int myatoi(const char* p)
{
int n;
while (*p!='\n') {
n = n*10+*p-'0';
p++;
}
return n;
}
int main() {
int A[SIZE];
int H=0;
int i, l, largest, tmp;
char com[21];
do {
fgets(com, 20, stdin);
if (com[0] == 'i') {
A[++H] = atoi(com+7);
for (i=H; i>1 && A[i/2]<A[i];i/=2) {
tmp = A[i/2];
A[i/2] = A[i];
A[i] = tmp;
}
} else if (com[1]=='x') { // extract
printf("%d\n", A[1]);
A[1] = A[H];
i = 1;
while (1) {
l = i*2;
largest = i;
if (l < H && A[l] > A[i]) largest = l;
if (l+1 < H && A[l+1] > A[largest]) largest = l+1;
if (largest == i) break;
tmp = A[i];
A[i] = A[largest];
A[largest] = tmp;
i = largest;
}
H--;
}
} while (com[2]!='d');
return 0;
}
|
s984669674 | p02289 | u800534567 | 1540308575 | Python | Python3 | py | Runtime Error | 0 | 0 | 930 | #include <stdio.h>
#include <stdlib.h>
#define SIZE 2000000
int myatoi(const char* p)
{
int n;
while (*p!='\n' && *p!='\r') {
n = n*10+*p-'0';
p++;
}
return n;
}
int main() {
int A[SIZE];
int H=0;
int i, l, largest, tmp;
char com[21];
do {
fgets(com, 20, stdin);
if (com[0] == 'i') {
A[++H] = myatoi(com+7);
for (i=H; i>1 && A[i/2]<A[i];i/=2) {
tmp = A[i/2];
A[i/2] = A[i];
A[i] = tmp;
}
} else if (com[1]=='x') { // extract
printf("%d\n", A[1]);
A[1] = A[H];
i = 1;
while (1) {
l = i*2;
largest = i;
if (l < H && A[l] > A[i]) largest = l;
if (l+1 < H && A[l+1] > A[largest]) largest = l+1;
if (largest == i) break;
tmp = A[i];
A[i] = A[largest];
A[largest] = tmp;
i = largest;
}
H--;
}
} while (com[2]!='d');
return 0;
}
|
s146479281 | p02289 | u357267874 | 1555719685 | Python | Python3 | py | Runtime Error | 20 | 5608 | 1739 | def get_parent(A, i):
if i == 1:
return None
else:
return i // 2
def get_left(A, i):
if len(A) > 2 * i:
return 2 * i
else:
return None
def get_right(A, i):
if len(A) > 2 * i + 1:
return 2 * i + 1
else:
return None
A = [-1] * 10
H = 0
def insert(A, key):
global H
H += 1
A[H] = key
i = H
while i > 1:
# print(i)
parent = get_parent(A, i)
if parent is None:
break
if A[parent] < A[i]:
# print('swap', i, parent, A[i], A[parent])
tmp = A[i]
A[i] = A[parent]
A[parent] = tmp
i = parent
else:
break
def max_heapfy(A, i):
left = get_left(A, i)
right = get_right(A, i)
largest = i
if left and A[left] > A[i]:
largest = left
if right and A[right] > A[largest]:
largest = right
if largest != i:
tmp = A[i]
A[i] = A[largest]
A[largest] = tmp
max_heapfy(A, largest)
def extract_max(A):
global H
max_value = A[1]
A[1] = A[H]
A[H] = -1
H -= 1
max_heapfy(A, 1)
return max_value
# Heap heap ヒープの実装はここを参考にした
# http://ikapblg.blog.fc2.com/blog-entry-57.html
def print_heap(A):
for index, elem in enumerate(A):
if index == 0:
continue
if elem == -1:
break
print(elem)
while True:
line = input().split()
if line[0] == 'insert':
insert(A, int(line[1]))
# print(A)
elif line[0] == 'extract':
max_value = extract_max(A)
print(max_value)
else:
# print('end:')
# print_heap(A)
break
|
s220645185 | p02289 | u554503378 | 1556535403 | Python | Python3 | py | Runtime Error | 0 | 0 | 1398 | #include <bits/stdc++.h>
using namespace std;
void insert(vector<int> &p_q,int last,int val){
p_q.push_back(val);
last++;
int last_p = (last-1)/2;
while(last >= 0 && p_q[last] > p_q[last_p]){
swap(p_q[last],p_q[last_p]);
last = last_p;
last_p = ((last-1)/2);
}
}
void make_heap(vector<int> &p_q,int size,int idx){
int left = 2*idx+1;
int right = left+1;
int max_i = idx;
if(left < size && p_q[left] > p_q[idx])
max_i = left;
if(right < size && p_q[right] > p_q[max_i])
max_i = right;
if(max_i != idx){
swap(p_q[idx],p_q[max_i]);
make_heap(p_q,size,max_i);
}
}
void extract(vector<int> &p_q){
int size = p_q.size();
if(size < 1) return;
int ret = p_q[0];
p_q[0] = p_q[size-1];
p_q.pop_back();
make_heap(p_q,size,0);
cout << ret << endl;
}
void print_queue(vector<int> &p_q){
for(int i=0;i<p_q.size();i++)
cout << p_q[i] << " ";
cout << endl;
}
int main(){
string order;
int val;
vector<int> p_queue;
while(1){
cin >> order;
if(order == "insert"){
cin >> val;
insert(p_queue,p_queue.size()-1,val);
}
else if(order == "extract"){
extract(p_queue);
}
else if(order == "end")
break;
else print_queue(p_queue);
}
}
|
s993890004 | p02289 | u491071312 | 1438061581 | Python | Python3 | py | Runtime Error | 0 | 0 | 231 | import asyncio
PQ = asyncio.PriorityQueue()
while True:
line = input().split()
if line[0] == 'insert':
PQ.put_nowait( line[1] )
elif line[0] == 'extract':
print(PQ.get_nowait())
else:
break |
s826825394 | p02289 | u148091382 | 1440837296 | Python | Python | py | Runtime Error | 0 | 0 | 1185 | def insert(array, new_value)
array << new_value
current = array.size-1
parent = current / 2
while (parent > 0) do
if (array[parent] < array[current]) then
array[parent], array[current] = array[current], array[parent]
current = parent
parent = current / 2
else
break
end
end
end
def extract(array)
return nil if array.size == 1
array[1], array[-1] = array[-1], array[1]
max = array.pop
current = 1
loop do
bigger_child = get_bigger_child(array, current)
break if bigger_child == nil
break if array[current] >= bigger_child[0]
array[current], array[bigger_child[1]] = array[bigger_child[1]], array[current]
current = bigger_child[1]
end
return max
end
def get_bigger_child(array, i)
return nil if array.size <= i*2
return [array[i*2], i*2] if array.size == (i*2 + 1)
left = [array[i*2], i*2]
right = [array[i*2+1], i*2+1]
return [left, right].max_by{|x| x[0]}
end
# main
array = [nil]
while line = gets do
inputs = line.chomp.split
if (inputs[0] == 'insert') then
insert(array, inputs[1].to_i)
elsif (inputs[0] == 'extract') then
puts extract(array)
else
break
end
end |
s438932690 | p02289 | u247976584 | 1455521162 | Python | Python3 | py | Runtime Error | 0 | 0 | 1055 | from sys import stdin, exit
def max_heapify(a, i):
heap_size = a[0]
L = 2*i
R = 2*i + 1
if L <= heap_size and a[L] > a[i]:
largest = L
else:
largest = i
if R <= heap_size and a[R] > a[largest]:
largest = R
if largest != i:
a[i], a[largest] = a[largest], a[i]
max_heapify(a, largest)
def main():
ret = []
heap = [-1] * 2000001
heap[0] = 1
for cmd in stdin:
if cmd[0] == 'i':
heap[0] += 1
i = heap[0]
heap[i] = int(cmd[7:])
half = i // 2
while i > 1 and heap[half] < heap[i]:
heap[i], heap[half] = heap[half], heap[i]
i //= 2
half = i // 2
elif cmd[1] == 'x':
ret.append(heap[1])
heap[1] = heap[heap[0]]
heap[0] -= 1
max_heapify(heap, 1)
elif cmd[1] == 'n':
sys.stdout.writelines("\n".join([str(s) for s in ret]))
print()
exit(0)
main() |
s977230915 | p02289 | u247976584 | 1455521220 | Python | Python3 | py | Runtime Error | 0 | 0 | 1063 | from sys import stdin, stdout, exit
def max_heapify(a, i):
heap_size = a[0]
L = 2*i
R = 2*i + 1
if L <= heap_size and a[L] > a[i]:
largest = L
else:
largest = i
if R <= heap_size and a[R] > a[largest]:
largest = R
if largest != i:
a[i], a[largest] = a[largest], a[i]
max_heapify(a, largest)
def main():
ret = []
heap = [-1] * 2000001
heap[0] = 1
for cmd in stdin:
if cmd[0] == 'i':
heap[0] += 1
i = heap[0]
heap[i] = int(cmd[7:])
half = i // 2
while i > 1 and heap[half] < heap[i]:
heap[i], heap[half] = heap[half], heap[i]
i //= 2
half = i // 2
elif cmd[1] == 'x':
ret.append(heap[1])
heap[1] = heap[heap[0]]
heap[0] -= 1
max_heapify(heap, 1)
elif cmd[1] == 'n':
sys.stdout.writelines("\n".join([str(s) for s in ret]))
print()
exit(0)
main() |
s966999980 | p02289 | u567281053 | 1461079555 | Python | Python | py | Runtime Error | 0 | 0 | 1090 | import sys
def parent(i):
return (i + 1) / 2 - 1
def left(i):
return 2 * i + 1
def right(i):
return 2 * i + 2
def sibling(i):
if i % 2 == 0:
return i - 1
else:
return i + 1
def insert(S, k):
S.append(k)
now = len(S) - 1
while True:
p = parent(now)
if p < 0:
break
elif S[now] > S[p]:
S[now], S[p] = S[p], S[now]
else:
now = p
def extract(S):
print S[0]
S[0] = S[-1]
S.pop()
now = 0
while True:
l, r = left(now), right(now)
if l < len(S):
if r >= len(S) or S[now] < S[r] and S[l] < S[r]:
S[now], S[r] = S[r], S[now]
now = left
elif S[now] < S[l] and S[r] < S[l]:
S[now], S[r] = S[r], S[now]
now = r
else:
break
if __name__ == "__main__":
lines = sys.stdin.readlines()
lines.pop()
S = []
for line in lines:
if line[0] == "i":
insert(S, int(line[7:]))
else:
extract(S) |
s151338590 | p02289 | u567281053 | 1461249343 | Python | Python | py | Runtime Error | 0 | 0 | 1097 | import sys
def parent(i):
return (i + 1) / 2 - 1
def left(i):
return 2 * i + 1
def right(i):
return 2 * i + 2
def sibling(i):
if i % 2 == 0:
return i - 1
else:
return i + 1
def insert(S, k):
S.append(k)
idx = len(S) - 1
while True:
p = parent(idx)
if p < 0 or S[idx] <= S[p]:
break
else:
S[idx], S[p] = S[p], S[idx]
idx = p
#print S
def extract(S):
print S[0]
S[0] = S[-1]
S.pop()
size = len(S)
idx = 0
while True:
l, r = left(idx), right(idx)
if l < size and S[idx] < S[l] and (r < size and S[r] <= S[l] or r >= size:
S[idx], S[l] = S[l], S[idx]
idx = l
elif r < size and S[idx] < S[r]:
S[idx], S[r] = S[r], S[idx]
idx = r
else:
break
#print S
if __name__ == "__main__":
lines = sys.stdin.readlines()
lines.pop()
S = []
for line in lines:
if line[0] == "i":
insert(S, int(line[7:]))
else:
extract(S) |
s012245291 | p02289 | u567281053 | 1461250172 | Python | Python | py | Runtime Error | 0 | 0 | 854 | import sys
def insert(S, k):
S.append(k)
idx = len(S) - 1
while True:
p = (i + 1) / 2 - 1
if p < 0 or S[idx] <= S[p]:
break
else:
S[idx], S[p] = S[p], S[idx]
idx = p
def maxHeapify(A, i, size):
l = 2 * i + 1
r = 2 * i + 2
if l < size and A[l] > A[i]:
largest = l
else:
largest = i
if r < size and A[r] > A[largest]:
largest = r
if largest != i:
A[i], A[largest] = A[largest], A[i]
maxHeapify(A, largest, size)
def extract(S):
print S[0]
S[0] = S[-1]
S.pop()
maxHeapify(S, 0, len(S))
if __name__ == "__main__":
lines = sys.stdin.readlines()
lines.pop()
S = []
for line in lines:
if line[0] == "i":
insert(S, int(line[7:]))
else:
extract(S) |
s751697551 | p02289 | u567281053 | 1461251562 | Python | Python | py | Runtime Error | 0 | 0 | 936 | import sys
def insert(k):
global S, last
S[last] = k
idx = last
while True:
p = (idx + 1) / 2 - 1
if S[idx] <= S[p]:
break
else:
S[idx], S[p] = S[p], S[idx]
idx = p
last += 1
def maxHeapify(i):
global S, last
l = 2 * i + 1
r = 2 * i + 2
if l < last and S[l] > S[i]:
largest = l
else:
largest = i
if r < last and S[r] > S[largest]:
largest = r
if largest != i:
S[i], S[largest] = S[largest], S[i]
maxHeapify(largest)
def extract():
global S, last
print S[0]
last -= 1
S[0], S[last] = S[last], 0
maxHeapify(0)
def main():
lines = sys.stdin.readlines()
lines.pop()
S = [0] * 2000001
S[2000000] = 2000000000
last = 0
for line in lines:
if line[0] == "i":
insert(int(line[7:]))
else:
extract()
main() |
s602235413 | p02289 | u949338836 | 1464678548 | Python | Python3 | py | Runtime Error | 0 | 0 | 219 | #coding:utf-8
#1_9_C
s = set()
while True:
cmd = input().split()
if cmd[0] == "end":
break
elif cmd[0] == "insert":
l.add(int(cmd[1]))
else:
print(max(s))
l.remove(max(s)) |
s947226950 | p02289 | u027872723 | 1476634717 | Python | Python3 | py | Runtime Error | 0 | 0 | 1537 | # -*- coding: utf_8 -*-
level = False
def debug(v):
if level:
print(v)
class PriorityQueue:
def __init__(self, size):
self.queue = []
def insert(self, key):
self.queue.append(key)
self.heapIncreaseKey()
debug(self.queue)
def heapIncreaseKey(self):
h = len(self.queue) - 1
parent = get_parent(h)
while self.queue[parent] < self.queue[h]:
self.queue[parent], self.queue[h] = self.queue[h], self.queue[parent]
def extract(self):
root = self.queue.pop(0)
if len(self.queue) > 0:
self.queue = [self.queue.pop()] + self.queue
maxHeapify(self.queue)
debug(self.queue)
return root
def maxHeapify(A):
for i in range(int(len(A) / 2), 0, -1):
maxHeapify2(A, i)
def maxHeapify2(A, i):
l = 2 * i - 1
r = 2 * i
largest = i - 1
if l < len(A):
largest = largest if A[largest] > A[l] else l
if r < len(A):
largest = largest if A[largest] > A[r] else r
if largest != i - 1:
A[largest], A[i - 1] = A[i - 1], A[largest]
maxHeapify2(A, largest + 1)
def get_parent(size):
size += 1
return int(size/2) - 1
if __name__ == "__main__":
queue = PriorityQueue(2000000)
while True:
command = input().split()
if len(command) == 2:
queue.insert(int(command[1]))
if command[0] == "extract":
print(queue.extract())
if command[0] == "end":
sys.exit() |
s518606491 | p02289 | u027872723 | 1476634752 | Python | Python3 | py | Runtime Error | 0 | 0 | 1537 | # -*- coding: utf_8 -*-
level = False
def debug(v):
if level:
print(v)
class PriorityQueue:
def __init__(self, size):
self.queue = []
def insert(self, key):
self.queue.append(key)
self.heapIncreaseKey()
debug(self.queue)
def heapIncreaseKey(self):
h = len(self.queue) - 1
parent = get_parent(h)
while self.queue[parent] < self.queue[h]:
self.queue[parent], self.queue[h] = self.queue[h], self.queue[parent]
def extract(self):
root = self.queue.pop(0)
if len(self.queue) > 0:
self.queue = [self.queue.pop()] + self.queue
maxHeapify(self.queue)
debug(self.queue)
return root
def maxHeapify(A):
for i in range(int(len(A) / 2), 0, -1):
maxHeapify2(A, i)
def maxHeapify2(A, i):
l = 2 * i - 1
r = 2 * i
largest = i - 1
if l < len(A):
largest = largest if A[largest] > A[l] else l
if r < len(A):
largest = largest if A[largest] > A[r] else r
if largest != i - 1:
A[largest], A[i - 1] = A[i - 1], A[largest]
maxHeapify2(A, largest + 1)
def get_parent(size):
size += 1
return int(size/2) - 1
if __name__ == "__main__":
queue = PriorityQueue(2000000)
while True:
command = input().split()
if len(command) == 2:
queue.insert(int(command[1]))
if command[0] == "extract":
print(queue.extract())
if command[0] == "end":
sys.exit() |
s949007172 | p02289 | u027872723 | 1476636869 | Python | Python3 | py | Runtime Error | 0 | 0 | 1715 | # -*- coding: utf_8 -*-
import sys
level = False
def debug(v):
if level:
print(v)
class PriorityQueue:
def __init__(self, size):
self.queue = [-1] * size
self.tail = 0
def insert(self, key):
self.queue[tail] = key
self.tail += 1
self.heapIncreaseKey()
debug(self.queue)
def heapIncreaseKey(self):
h = self.tail - 1
parent = get_parent(h)
while parent >= 0 and self.queue[parent] < self.queue[h]:
self.queue[parent], self.queue[h] = self.queue[h], self.queue[parent]
h = parent
parent = get_parent(h)
def extract(self):
root = self.queue[0]
if len(self.queue) > 0:
self.queue[0], self.queue[self.tail - 1] = self.queue[tail - 1], -1
self.tail -=1
maxHeapify(self.queue)
debug(self.queue)
return root
def maxHeapify(A):
for i in range(int(len(A) / 2), 0, -1):
maxHeapify2(A, i)
def maxHeapify2(A, i):
l = 2 * i - 1
r = 2 * i
largest = i - 1
if l < len(A):
largest = largest if A[largest] > A[l] else l
if r < len(A):
largest = largest if A[largest] > A[r] else r
if largest != i - 1:
A[largest], A[i - 1] = A[i - 1], A[largest]
maxHeapify2(A, largest + 1)
def get_parent(size):
size += 1
return int(size/2) - 1
if __name__ == "__main__":
queue = PriorityQueue(2000000)
while True:
command = input().split()
if len(command) == 2:
queue.insert(int(command[1]))
if command[0] == "extract":
print(queue.extract())
if command[0] == "end":
sys.exit() |
s166638525 | p02289 | u027872723 | 1476637448 | Python | Python3 | py | Runtime Error | 0 | 0 | 1740 | # -*- coding: utf_8 -*-
import sys
level = False
def debug(v):
if level:
print(v)
class PriorityQueue:
def __init__(self, size):
self.queue = [-1] * size
self.tail = 0
def insert(self, key):
self.queue[self.tail] = key
self.tail += 1
self.heapIncreaseKey()
debug(self.queue)
def heapIncreaseKey(self):
h = self.tail - 1
parent = get_parent(h)
while parent >= 0 and self.queue[parent] < self.queue[h]:
self.queue[parent], self.queue[h] = self.queue[h], self.queue[parent]
h = parent
parent = get_parent(h)
def extract(self):
root = self.queue[0]
if len(self.queue) > 0:
self.queue[0], self.queue[self.tail - 1] = self.queue[self.tail - 1], -1
self.tail -=1
maxHeapify(self.queue, self.tail)
debug(self.queue)
return root
def maxHeapify(A, size):
for i in range(int(size / 2), 0, -1):
maxHeapify2(A, i, size)
def maxHeapify2(A, i, size):
l = 2 * i - 1
r = 2 * i
largest = i - 1
if l < size:
largest = largest if A[largest] > A[l] else l
if r < size:
largest = largest if A[largest] > A[r] else r
if largest != i - 1:
A[largest], A[i - 1] = A[i - 1], A[largest]
maxHeapify2(A, largest + 1)
def get_parent(size):
size += 1
return int(size/2) - 1
if __name__ == "__main__":
queue = PriorityQueue(2000000)
while True:
command = input().split()
if len(command) == 2:
queue.insert(int(command[1]))
if command[0] == "extract":
print(queue.extract())
if command[0] == "end":
sys.exit() |
s499363262 | p02289 | u022407960 | 1479465412 | Python | Python3 | py | Runtime Error | 0 | 0 | 2039 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
def max_heapify(index):
left, right, largest = 2 * index, 2 * index + 1, None
if left <= heap_length and heap_array[left] > heap_array[index]:
largest = left
else:
largest = index
if right <= heap_length and heap_array[right] > heap_array[largest]:
largest = right
if largest != index:
heap_array[index], heap_array[largest] = heap_array[largest], heap_array[index]
max_heapify(largest)
return None
def extract():
global heap_length
if heap_length < 1:
raise SystemExit('Heap underflow!')
heap_max = heap_array[1]
heap_array[1] = heap_array[heap_length]
heap_length -= 1
# print('max', heap_max, heap_length, heap_array)
print(heap_max)
max_heapify(1)
return heap_max
def insert(data):
global heap_length
heap_length += 1
heap_array.append(-1)
# print(heap_length, heap_array)
# assert len(heap_array) == heap_length + 1
insert_data(heap_length, data)
def insert_data(index, data):
if data < heap_array[index]:
raise SystemExit('Not a max-heap!')
heap_array[index] = data
while index > 1:
parent = index // 2
if heap_array[parent] >= heap_array[index]:
break
heap_array[index], heap_array[parent] = heap_array[parent], heap_array[index]
index //= 2
return None
def action(_command, _content):
if _command.startswith('in'):
insert(int(_content))
elif _command.startswith('ex'):
extract()
else:
pass
return None
if __name__ == '__main__':
_input = sys.stdin.readlines()
command_list = list(map(lambda x: x.split(), _input))
allowed_commands = ('insert', 'extract', 'end')
heap_array, heap_length = [None], 0
for each in command_list:
command, content = each[0], each[-1]
if command not in allowed_commands:
raise SystemExit('Illegal command!')
action(command, content) |
s293292893 | p02289 | u112247126 | 1487832763 | Python | Python3 | py | Runtime Error | 0 | 0 | 1108 | import sys
from numpy import inf
def insert(heap, key):
heap.append(-inf)
heapIncreaseKey(heap, key)
def parent(i):
return (i - 1) // 2
def heapIncreaseKey(heap, key):
heap[len(heap) - 1] = key
i = len(heap) - 1
while i > 0 and heap[parent(i)] < heap[i]:
heap[i], heap[parent(i)] = heap[parent(i)], heap[i]
i = parent(i)
def heapExtractMax(heap):
if len(heap) < 1:
return None
else:
MAX = heap[0]
heap[0] = heap.pop()
maxHeapify(heap, 0)
return MAX
def maxHeapify(heap, i):
left = (i + 1) * 2 - 1
right = (i + 1) * 2
largest = left if left < len(heap) and heap[left] > heap[i] else i
largest = right if right < len(heap) and heap[right] > heap[largest] else largest
if largest != i:
heap[i], heap[largest] = heap[largest], heap[i]
maxHeapify(heap, largest)
heap = []
out = ''
for line in sys.stdin:
while line[0:2] != 'en':
if line[0] == 'i':
insert(heap, int(line.split()[1]))
if line[0:2] == 'ex':
print(str(heapExtractMax(heap))) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.