def algorithm(inputfilename): routers_list = finding_most_valid_routers(inputfilename) l = lambda x: (x[0], x[2], x[3], x[4], x[5], x[6]) rows, radius, connecting_to_backbone_cost, router_cost, budget, initial_backbone = l( reading_input_data(inputfilename)) placed_routers = list() while budget - router_cost > ( rows * connecting_to_backbone_cost) / 2 and len(routers_list) > 0: current = choice(routers_list) while True: val = find_better_neighbors(routers_list, current, initial_backbone, inputfilename) if current != val: current = val else: break routers_list = [ i for i in routers_list if not (abs(i[0][0] - current[0][0]) <= radius and abs(i[0][1] - current[0][1]) <= radius) ] placed_routers.append(current) budget -= current[2] * connecting_to_backbone_cost + router_cost return placed_routers
def greedy_algorithm(inputfile): l = lambda x: (x[3], x[4], x[5]) connecting_to_backbone_cost, router_cost, budget = l( reading_input_data(inputfile)) routers_list = finding_most_valid_routers2(inputfile) print(1) sorted_routers_list = sorted(routers_list, key=lambda x: x[1] / x[2]) dots_s = set() n = 0 i = len(sorted_routers_list) - 1 sorted_routers_listt = sorted_routers_list[:] while n < budget and i != 0: if n + sorted_routers_listt[i][ 2] * connecting_to_backbone_cost + router_cost < budget: sorted_routers_listt = sorted(sorted_routers_list, key=lambda x: len(x[3] - dots_s)) dots_s = dots_s.union(sorted_routers_listt[i][3]) dots_s.add((sorted_routers_listt[i][0][0], sorted_routers_listt[i][0][1], "r")) n += sorted_routers_listt[i][ 2] * connecting_to_backbone_cost + router_cost else: i -= 1 r_list = [] dots_s = list(dots_s) for i in range(len(dots_s)): if len(dots_s[i]) == 3: r_list.append((dots_s[i][0], dots_s[i][1])) return len(dots_s), dots_s, len(r_list), r_list
def dumm_algorithm(inputfilename): routers_list = finding_most_valid_routers(inputfilename) l = lambda x: (x[3], x[4], x[5]) connecting_to_backbone_cost, router_cost, budget = l( reading_input_data(inputfilename)) total_cost = 0 score_list_ = list() for len_ in range(1, budget // router_cost + 1): for subset in combinations(routers_list, len_): for i in subset: total_cost += (i[2] * connecting_to_backbone_cost + router_cost) if total_cost < budget: total_connected_cells = sum([i[2] for i in subset]) ZAGLUSHKA_CELLS = [[i for i in range(2)] for j in range(total_connected_cells)] coordinates_of_routers = [i[0] for i in subset] creating_outputfile(total_connected_cells, ZAGLUSHKA_CELLS, len(subset), coordinates_of_routers) val = count_points("../txt/algoroutput.txt", inputfilename) score_list_.append(val) total_cost = 0 return max(score_list_)
def count_points(outputfilename, inputfilename): """ :param outputfilename:The name of our resulted file :param inputfilename:The name of our input data file :return: Our algorithms score """ l = lambda x: (x[2], x[3], x[4], x[5], x[7]) radius, connecting_to_backbone_cost, router_cost, budget, cells_list = l( reading_input_data(inputfilename)) l = lambda x: (x[1], x[2], x[3]) routers_list, connected_cells, placed_routers = l( reading_output_data(outputfilename)) placed = placing_connected_cells(routers_list, radius, cells_list)[1] return 1000 * placed + (budget - (connected_cells * connecting_to_backbone_cost + placed_routers * router_cost))
def text_connectedcells_visualization(outputfilename, inputfilename): """ :param outputfilename: Name of an output file :param inputfilename: Name of an output file :return: Returns the view of connected to network cells, which are denoted as "w" """ placed = 0 router_list = reading_output_data(outputfilename)[1] l = lambda x: (x[2], x[7]) radius, cells_list = l(reading_input_data(inputfilename)) print("Routers are placed in {} position".format(router_list)) cells_list, placed = placing_connected_cells(router_list,radius,cells_list) for i in cells_list: print("".join(i))
def dynamic_algorithm(inputfile): l = lambda x: (x[3], x[4], x[5]) connecting_to_backbone_cost, router_cost, budget = l( reading_input_data(inputfile)) routers_list = finding_most_valid_routers2(inputfile) dict_ = dict() sorted_routers_list = sorted(routers_list, key=lambda x: x[1] / x[2]) dots_s = set() dots_list = [] def recur(budget, i, dots_set): sorted_routers_listt = sorted(sorted_routers_list, key=lambda x: len(x[3] - dots_set)) dots = dots_set.copy() if budget in dict_: return dict_[budget] if i == 0 or budget == 0: dots_list.append(dots) return 0 elif sorted_routers_listt[i][ 2] * connecting_to_backbone_cost + router_cost > budget: dict_[budget] = recur(budget, i - 1, dots) return dict_[budget] else: d = dots.union(sorted_routers_listt[i][3]) d.add((sorted_routers_listt[i][0][0], sorted_routers_listt[i][0][1], "r")) val = sorted_routers_listt[i][ 2] * connecting_to_backbone_cost + router_cost g = sorted_routers_listt[i][1] + recur(budget - val, i - 1, d) gg = recur(budget, i - 1, dots) if g > gg: dict_[budget] = g else: dict_[budget] = gg return dict_[budget] asd = recur(budget, len(routers_list) - 1, dots_s) d_set = list(max(dots_list)) r_list = [] for i in range(len(d_set)): if len(d_set[i]) == 3: r_list.append((d_set[i][0], d_set[i][1])) return len(d_set), d_set, len(r_list), r_list
def text_result_visualization(outputfilename, inputfilename): """ :param outputfilename: Name of an input file :param inputfilename: Name of an output file :return: Text representation of already changed data """ l = lambda x: (x[0], x[1]) connected_cells_list, routers_list = l(reading_output_data(outputfilename)) l = lambda x: (x[7], x[6]) cells_list, initial_backbone = l(reading_input_data(inputfilename)) for i in connected_cells_list: cells_list[i[0]][i[1]] = "c" for i in routers_list: cells_list[i[0]][i[1]] = "r" cells_list[initial_backbone[0]][initial_backbone[1]] = "b" for i in cells_list: print("".join(i)) return cells_list
def finding_most_valid_routers2(inputfilename): """ :param inputfilename: The name of our input data file :return: List of possible placed routers with coordinates as a first param, coverage as second and distance to backbone as third """ def calc_dist(backbone, router): return max(abs(backbone[0] - router[0]), abs(backbone[1] - router[1])) rows, cols, radius, connecting_to_backbone_cost, router_cost, budget,\ initial_backbone, cells_list = reading_input_data(inputfilename) routers_list = list() i = 0 for X in range(rows): for Y in range(cols): distance = calc_dist(initial_backbone, (X, Y)) if distance != 0 and cells_list[X][ Y] == ".": #Adding routers that are not backbone pos and in . pos routers_list.append([(X, Y), 0, distance, set()]) #Finding the coverage of our router for x in range(-radius, radius + 1): for y in range(-radius, radius + 1): try: if x == 0 and y == 0: continue if cells_list[X + x][ Y + y] == "." and X + x >= 0 and Y + y >= 0 and nowalls( cells_list, X, Y, X + x, Y + y): routers_list[i][1] += 1 routers_list[i][3].add((X + x, Y + y)) except IndexError: pass i += 1 return routers_list
def text_input_visualization(inputfilename): """ :param inputfilename: Name of an input file :return: Text representation of input data """ rows, cols, radius, connecting_to_backbone_cost, router_cost, budget, initial_backbone, cells_list = reading_input_data( inputfilename) print("""{0} rows, {1} columns, router range radius is {2} backbone costs {3}, router costs {4}, budget is {5} the initial cell connected to backbone is {6} """ \ .format(rows, cols, radius, connecting_to_backbone_cost, router_cost, budget, initial_backbone)) for i in cells_list: print("".join(i)) return cells_list