136 lines
4.2 KiB
Python
136 lines
4.2 KiB
Python
|
|
class Route(object):
|
|
"""docstring for Route."""
|
|
def __init__(self, route_id, contract_id, load,src,dst):
|
|
super(Route, self).__init__()
|
|
self.route_id = route_id
|
|
self.contract_id = contract_id
|
|
self.load = load
|
|
self.src = src
|
|
self.dst = dst
|
|
|
|
def __eq__(self,rt):
|
|
eq = self.route_id == rt.route_id and self.contract_id == rt.contract_id
|
|
return eq
|
|
|
|
def __repr__(self):
|
|
return str(self.contract_id)+"-"+str(self.route_id)+":"+self.src+" - "+self.dst+" "+self.load
|
|
|
|
|
|
class Contract(object):
|
|
"""docstring for Contract."""
|
|
def __init__(self, contract_id, routes):
|
|
super(Contract, self).__init__()
|
|
self.contract_id = contract_id
|
|
self.routes = routes
|
|
|
|
def __repr__(self):
|
|
return "\tContract : "+str(self.contract_id)+"\n\tRoutes\n\t\t"+"\n\t\t".join(map(repr,self.routes))
|
|
|
|
class Transporter(object):
|
|
"""docstring for Transporter."""
|
|
def __init__(self, contracts):
|
|
super(Transporter, self).__init__()
|
|
self.contracts = contracts
|
|
|
|
@classmethod
|
|
def from_file(cls,c_file):
|
|
return cls(cls.read_contracts(c_file))
|
|
|
|
@staticmethod
|
|
def read_contracts(c_file):
|
|
c_lines = open(c_file,'r').readlines()
|
|
c_dict = {}
|
|
for l in c_lines:
|
|
(c_id,src,dst,load) = l.split(' ')
|
|
if c_dict.has_key(c_id):
|
|
route_id = len(c_dict[c_id])
|
|
c_dict[c_id].append(Route(route_id,int(c_id),load,src,dst))
|
|
else:
|
|
c_dict[c_id] = [Route(0,int(c_id),load,src,dst)]
|
|
contracts = [Contract(int(i),c_dict[i]) for i in sorted(c_dict.keys())]
|
|
|
|
return contracts
|
|
|
|
def contract_routes(self):
|
|
all_routes = []
|
|
for c in self.contracts:
|
|
for r in c.routes:
|
|
all_routes.append(r)
|
|
return all_routes
|
|
|
|
def contracts_required(self):
|
|
routes = self.contract_routes()
|
|
unfulfilled = rem_routes(routes)
|
|
print "No of contracts required : ",len(unfulfilled)
|
|
if len(unfulfilled) > 0:
|
|
print "Contracts from ",repr(unfulfilled)
|
|
|
|
CYCLE_LIMIT = 3
|
|
|
|
def rem_routes(routes):
|
|
loop_routes = routes
|
|
while len(loop_routes)>0:
|
|
circ,paths,loop_routes = largest_loop(loop_routes)
|
|
if not circ:
|
|
break
|
|
partial_paths = []
|
|
partial_routes = loop_routes
|
|
while len(partial_routes)>0:
|
|
lp = longest_path(partial_routes)
|
|
partial_paths.append((lp[-1].dst,lp[0].src))
|
|
partial_routes = filter(lambda x:x not in lp,partial_routes)
|
|
return partial_paths
|
|
|
|
def route_deps(routes):
|
|
routes_map = {}
|
|
for r in routes:
|
|
if routes_map.has_key(r.src):
|
|
routes_map[r.src].append(r)
|
|
else:
|
|
routes_map[r.src]= [r]
|
|
if not routes_map.has_key(r.dst):
|
|
routes_map[r.dst]= []
|
|
return routes_map
|
|
|
|
def largest_loop(routes):
|
|
deps = route_deps(routes)
|
|
circ_paths = [find_loop(r.src,r.src,deps,set(),[]) for r in routes]
|
|
circ,paths = max(circ_paths,key=lambda p:len(p[1]))
|
|
# print filter(lambda p:not p[0],circ_paths)
|
|
rem_paths = filter(lambda x:x not in paths,routes)
|
|
return (circ,paths,rem_paths)
|
|
|
|
def longest_path(routes):
|
|
def route_path(r,deps):
|
|
if not deps.has_key(r.dst) or len(deps[r.dst])==0:
|
|
return [r]
|
|
all_dep_paths = [([r]+route_path(rt,deps)) for rt in deps[r.dst]]
|
|
rp = max(all_dep_paths,key=lambda p:len(p))
|
|
return rp
|
|
deps = route_deps(routes)
|
|
all_paths = [route_path(r,deps) for r in routes]
|
|
longest = max(all_paths,key=len)
|
|
return longest
|
|
|
|
def find_loop(elem,dep_elem,deps,checked,path):
|
|
found_loop = False
|
|
if dep_elem not in checked and deps.has_key(dep_elem):
|
|
checked.add(dep_elem)
|
|
for c in deps[dep_elem]:
|
|
path.append(c)
|
|
if elem == c.dst and len(path) <= CYCLE_LIMIT:
|
|
found_loop = True
|
|
break
|
|
(loop,path) = find_loop(elem,c.dst,deps,checked,path)
|
|
if loop:
|
|
found_loop = True
|
|
break
|
|
else:
|
|
del(path[-1])
|
|
return (found_loop,path)
|
|
|
|
|
|
# Transporter.from_file('./contracts.txt').contracts_required()
|
|
Transporter.from_file('./contracts.txt').contracts_required()
|