def makemaze(w,h,tw):
random.seed()
size = w*h
ds = DisjointSets(size)
walls = ([(a,a+1) for a in [x for x in range(size) if (x+1)%w != 0]]
+ [(a,a+w) for a in [x for x in range(size-w)]])
while not _done(ds):
a,b = walls[random.randint(0, len(walls)-1)]
x,y = ds.find(a), ds.find(b)
if not x == y:
ds.union(x,y)
walls.remove((a,b))
tiles = ([Tile('wall',_newp(i,tw),_newp(j,tw),tw) for i in range(2*w+1) for j in range(2*h+1)
if (i == 0 or j == 0 or i == w*2 or j == h*2 or (i%2==0 and j%2==0))
and not (j == 2*h-1 and i == 2*w)]
+ [Tile('floor',_newp(i,tw),_newp(j,tw),tw)
for i in range(1,2*w+1) for j in range(1,2*h+1)
if (i%2==1 and j%2==1)
or (j == 2*h-1 and i == 2*w)]
+ [Tile('wall' if i%2==0 and
list(set([(a,a+1) for a in range(i/2-1,size,w)])
& set([(b,b+1) for b in
range(j/2*w,(j/2+1)*w-1)]))[0] in walls
or i%2==1 and
list(set([(a,a+w) for a in range(i/2,size,w)])
& set([(b,b+w) for b in
range((j/2-1)*w,j/2*w)]))[0] in walls
else 'floor'
,_newp(i,tw),_newp(j,tw),tw)
for i in range(1,2*w) for j in range(1,2*h)
if i%2 != j%2])
return tiles
class Class(object):
def __init__(self, meta=None, fields=tuple()):
if meta is None:
meta = {}
self.meta = meta
self.fields = list(fields)
self.instances = WeakCollection()
# Each set of linked subfields means that those subfields are linked and share the same instance
self.links = DisjointSets()
def __repr__(self):
return '<%s, meta=%r, fields=%r>' % (self.__class__.__name__, self.meta, len(self.fields))
def add_field(self, field):
self.fields.append(field)
for instance in self.instances:
instance.new_field(field)
def create_instance(self, **kw):
instance = Instance(self, **kw)
self.instances.add(instance)
return instance
def union(self, src_subfield_hierarchy, dst_subfield_hierarchy):
src_subfield_hierarchy = tuple(src_subfield_hierarchy)
dst_subfield_hierarchy = tuple(dst_subfield_hierarchy)
self.links.union(src_subfield_hierarchy, dst_subfield_hierarchy)
assert dst_subfield_hierarchy in self.links.set_of(src_subfield_hierarchy)
assert src_subfield_hierarchy in self.links.set_of(dst_subfield_hierarchy)
for instance in self.instances:
# Find the subfield's_instance for this instance (extract the instance from the deepest level)
src_subfield_instance = instance.get_subfield_instance(src_subfield_hierarchy, False)
# Tell the instance that the subfield has changed, it will update all internally linked fields to point
# to the new instance.
instance.subfield_linked(src_subfield_hierarchy, src_subfield_instance)
def split(self, subfield_hierarchy):
self.links.split(subfield_hierarchy)
for instance in self.instances:
instance.subfield_unlinked(subfield_hierarchy)
def kruskal(graph):
"""Find the minimum spanning tree of a graph."""
msf = set()
forest = DisjointSets()
for v in graph.keys():
forest.makeset(v)
edges = []
for u, adjlist in graph.items():
for (v, weight) in adjlist.items():
edges.append((u, v, weight))
edges.sort(key=lambda edge: edge[2])
for u, v, w in edges:
if forest.find(u) != forest.find(v):
msf.add((u, v, w))
forest.union(u, v)
return msf
def kruskal(graph):
"""Find the minimum spanning tree of a graph."""
msf = set()
forest = DisjointSets()
for v in graph.keys():
forest.makeset(v)
edges = []
for u, adjlist in graph.items():
for (v, weight) in adjlist.items():
edges.append((u, v, weight))
edges.sort(key=lambda edge: edge[2])
for u, v, w in edges:
if forest.find(u) != forest.find(v):
msf.add((u, v, w))
forest.union(u, v)
return msf
def mst(n, edges):
weight_sum, m, tree = 0, n - 1, []
edges.sort(key=lambda x: -x[2])
sets = DS()
vertices = [sets.make_set(i) for i in range(n)]
while m > 0:
edge = edges.pop()
if not sets.union(vertices[edge[0]], vertices[edge[1]]):
continue
tree.append(edge)
weight_sum += edge[2]
m -= 1
return tree, weight_sum
