
import numpy as np
import pandas as pd
import time
from kemeny import algorithms as alg
from kemeny import sc

rep = 1
results = np.zeros(0).reshape(0,7+rep)

##############################################################
om = np.array([
[0,259,278,248,255,269,234,282,266,294,272,275],
[242,0,252,257,217,244,226,248,239,263,240,225],
[223,249,0,256,228,225,242,264,268,281,263,260],
[253,244,245,0,243,231,226,267,271,274,269,284],
[246,284,273,258,0,242,251,274,269,269,250,240],
[232,257,276,270,259,0,249,262,269,286,270,254],
[267,275,259,275,250,252,0,302,262,282,271,266],
[219,253,237,234,227,239,199,0,249,278,246,241],
[235,262,233,230,232,232,239,252,0,257,260,223],
[207,238,220,227,232,215,219,223,244,0,222,216],
[229,261,238,232,251,231,230,255,241,279,0,254],
[226,276,241,217,261,247,235,260,278,285,247,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 1, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,259,263,250,258,235,242,245,243,272,256,244],
[242,0,241,232,243,234,229,248,247,247,249,249],
[238,260,0,233,253,249,233,238,243,254,247,241],
[251,269,268,0,248,257,239,245,259,250,266,254],
[243,258,248,253,0,240,246,247,243,260,259,254],
[266,267,252,244,261,0,255,254,250,267,255,260],
[259,272,268,262,255,246,0,259,260,275,266,256],
[256,253,263,256,254,247,242,0,241,261,254,250],
[258,254,258,242,258,251,241,260,0,268,257,252],
[229,254,247,251,241,234,226,240,233,0,254,243],
[245,252,254,235,242,246,235,247,244,247,0,248],
[257,252,260,247,247,241,245,251,249,258,253,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 2, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,247,229,236,228,211,241,224,225,231,224,221],
[254,0,237,241,251,219,246,248,235,233,229,223],
[272,264,0,251,252,240,269,270,245,250,232,234],
[265,260,250,0,240,242,250,272,245,238,247,236],
[273,250,249,261,0,234,242,248,245,237,237,245],
[290,282,261,259,267,0,286,259,264,247,262,247],
[260,255,232,251,259,215,0,248,223,235,229,238],
[277,253,231,229,253,242,253,0,241,242,245,239],
[276,266,256,256,256,237,278,260,0,253,238,250],
[270,268,251,263,264,254,266,259,248,0,249,257],
[277,272,269,254,264,239,272,256,263,252,0,249],
[280,278,267,265,256,254,263,262,251,244,252,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 3, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,266,234,275,235,284,219,265,219,263,247,246],
[235,0,236,283,257,299,224,274,232,245,263,263],
[267,265,0,291,261,313,263,268,248,277,257,269],
[226,218,210,0,237,283,215,251,216,228,256,234],
[266,244,240,264,0,288,244,232,250,215,256,231],
[217,202,188,218,213,0,198,216,221,224,194,231],
[282,277,238,286,257,303,0,272,259,261,252,266],
[236,227,233,250,269,285,229,0,202,234,235,237],
[282,269,253,285,251,280,242,299,0,275,265,259],
[238,256,224,273,286,277,240,267,226,0,255,238],
[254,238,244,245,245,307,249,266,236,246,0,256],
[255,238,232,267,270,270,235,264,242,263,245,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 4, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,191,219,198,169,179,190,155,217,164,245,265],
[310,0,227,329,266,246,261,272,287,287,261,274],
[282,274,0,258,268,211,186,237,261,229,178,302],
[303,172,243,0,209,264,150,185,243,192,238,270],
[332,235,233,292,0,250,261,295,336,213,249,294],
[322,255,290,237,251,0,244,294,241,251,316,261],
[311,240,315,351,240,257,0,244,240,303,204,350],
[346,229,264,316,206,207,257,0,258,282,237,310],
[284,214,240,258,165,260,261,243,0,262,200,302],
[337,214,272,309,288,250,198,219,239,0,220,282],
[256,240,323,263,252,185,297,264,301,281,0,339],
[236,227,199,231,207,240,151,191,199,219,162,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 5, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,275,252,277,275,281,282,239,280,255,305,329],
[226,0,240,288,262,229,294,193,309,244,286,290],
[249,261,0,267,280,260,286,205,295,203,273,277],
[224,213,234,0,244,256,232,228,248,238,263,312],
[226,239,221,257,0,201,256,227,248,253,285,267],
[220,272,241,245,300,0,287,203,258,219,283,301],
[219,207,215,269,245,214,0,219,312,254,287,268],
[262,308,296,273,274,298,282,0,337,242,311,307],
[221,192,206,253,253,243,189,164,0,179,258,306],
[246,257,298,263,248,282,247,259,322,0,291,274],
[196,215,228,238,216,218,214,190,243,210,0,239],
[172,211,224,189,234,200,233,194,195,227,262,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 6, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,241,223,213,255,249,259,232,254,230,241,264],
[260,0,241,236,263,265,272,239,279,247,263,254],
[278,260,0,250,276,244,304,256,266,262,267,284],
[288,265,251,0,267,255,265,249,248,244,269,268],
[246,238,225,234,0,253,273,252,271,244,263,266],
[252,236,257,246,248,0,251,251,271,238,258,270],
[242,229,197,236,228,250,0,214,235,236,243,264],
[269,262,245,252,249,250,287,0,258,246,254,270],
[247,222,235,253,230,230,266,243,0,216,232,241],
[271,254,239,257,257,263,265,255,285,0,290,265],
[260,238,234,232,238,243,258,247,269,211,0,254],
[237,247,217,233,235,231,237,231,260,236,247,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 7, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,234,243,240,249,237,246,246,252,250,257,255],
[267,0,254,267,253,248,264,258,254,263,259,256],
[258,247,0,251,258,263,256,251,265,254,260,265],
[261,234,250,0,241,243,264,250,247,260,249,258],
[252,248,243,260,0,253,253,258,243,253,246,264],
[264,253,238,258,248,0,266,242,263,268,240,271],
[255,237,245,237,248,235,0,243,233,256,242,260],
[255,243,250,251,243,259,258,0,249,265,264,260],
[249,247,236,254,258,238,268,252,0,257,256,263],
[251,238,247,241,248,233,245,236,244,0,244,258],
[244,242,241,252,255,261,259,237,245,257,0,259],
[246,245,236,243,237,230,241,241,238,243,242,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 8, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,246,259,252,252,249,259,284,265,248,278,251],
[255,0,259,252,249,267,262,276,279,234,271,279],
[242,242,0,240,254,257,255,263,264,240,246,249],
[249,249,261,0,241,279,243,267,253,261,263,257],
[249,252,247,260,0,255,260,270,253,262,258,268],
[252,234,244,222,246,0,250,258,261,240,264,258],
[242,239,246,258,241,251,0,265,255,253,261,269],
[217,225,238,234,231,243,236,0,252,234,243,247],
[236,222,237,248,248,240,246,249,0,243,236,245],
[253,267,261,240,239,261,248,267,258,0,240,258],
[223,230,255,238,243,237,240,258,265,261,0,245],
[250,222,252,244,233,243,232,254,256,243,256,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 9, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,251,261,223,245,237,275,220,224,243,264,242],
[250,0,260,222,243,243,274,215,229,242,261,273],
[240,241,0,231,213,225,228,252,234,239,238,258],
[278,279,270,0,283,264,295,265,246,267,271,288],
[256,258,288,218,0,236,261,233,216,251,267,269],
[264,258,276,237,265,0,275,273,253,249,262,290],
[226,227,273,206,240,226,0,214,240,230,245,250],
[281,286,249,236,268,228,287,0,276,257,245,301],
[277,272,267,255,285,248,261,225,0,271,260,280],
[258,259,262,234,250,252,271,244,230,0,251,302],
[237,240,263,230,234,239,256,256,241,250,0,266],
[259,228,243,213,232,211,251,200,221,199,235,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 10, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,263,241,241,215,238,216,270,205,258,258,242],
[238,0,245,245,239,229,232,227,215,276,229,266],
[260,256,0,275,273,239,220,259,233,269,248,257],
[260,256,226,0,249,235,223,253,228,256,269,302],
[286,262,228,252,0,235,228,264,264,270,259,277],
[263,272,262,266,266,0,224,256,248,265,242,264],
[285,269,281,278,273,277,0,275,240,266,308,318],
[231,274,242,248,237,245,226,0,216,279,244,253],
[296,286,268,273,237,253,261,285,0,286,258,309],
[243,225,232,245,231,236,235,222,215,0,262,249],
[243,272,253,232,242,259,193,257,243,239,0,278],
[259,235,244,199,224,237,183,248,192,252,223,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 11, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,227,329,294,369,243,216,235,353,255,288,277],
[274,0,314,328,392,297,321,230,332,353,319,280],
[172,187,0,216,379,238,299,171,204,228,278,241],
[207,173,285,0,438,298,365,280,234,325,313,277],
[132,109,122,63,0,168,199,128,168,224,227,154],
[258,204,263,203,333,0,301,250,291,244,326,285],
[285,180,202,136,302,200,0,224,216,294,237,230],
[266,271,330,221,373,251,277,0,300,341,283,242],
[148,169,297,267,333,210,285,201,0,211,238,189],
[246,148,273,176,277,257,207,160,290,0,282,220],
[213,182,223,188,274,175,264,218,263,219,0,208],
[224,221,260,224,347,216,271,259,312,281,293,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 12, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,261,248,278,247,248,246,265,258,234,235,242],
[240,0,253,268,258,240,252,258,271,239,252,244],
[253,248,0,264,273,252,246,280,265,262,250,251],
[223,233,237,0,251,250,246,255,247,232,232,244],
[254,243,228,250,0,242,235,261,254,243,248,245],
[253,261,249,251,259,0,247,257,250,244,246,244],
[255,249,255,255,266,254,0,269,256,248,254,235],
[236,243,221,246,240,244,232,0,253,228,214,233],
[243,230,236,254,247,251,245,248,0,244,239,236],
[267,262,239,269,258,257,253,273,257,0,251,262],
[266,249,251,269,253,255,247,287,262,250,0,244],
[259,257,250,257,256,257,266,268,265,239,257,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 13, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,243,247,249,229,244,247,245,246,231,223,272],
[258,0,238,235,232,243,259,231,224,236,236,257],
[254,263,0,259,253,258,268,267,241,267,228,278],
[252,266,242,0,255,262,264,260,248,260,258,270],
[272,269,248,246,0,248,270,264,259,257,239,260],
[257,258,243,239,253,0,252,229,244,240,223,249],
[254,242,233,237,231,249,0,247,245,272,253,271],
[256,270,234,241,237,272,254,0,244,246,245,267],
[255,277,260,253,242,257,256,257,0,247,245,257],
[270,265,234,241,244,261,229,255,254,0,240,250],
[278,265,273,243,262,278,248,256,256,261,0,268],
[229,244,223,231,241,252,230,234,244,251,233,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 14, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,258,251,277,239,227,263,230,231,253,266,259],
[243,0,258,258,238,235,240,223,245,249,247,269],
[250,243,0,255,247,214,238,241,259,236,249,252],
[224,243,246,0,227,241,240,202,226,228,229,242],
[262,263,254,274,0,253,234,232,236,238,244,271],
[274,266,287,260,248,0,267,221,249,260,283,284],
[238,261,263,261,267,234,0,248,258,251,248,275],
[271,278,260,299,269,280,253,0,247,270,284,279],
[270,256,242,275,265,252,243,254,0,254,283,253],
[248,252,265,273,263,241,250,231,247,0,270,242],
[235,254,252,272,257,218,253,217,218,231,0,263],
[242,232,249,259,230,217,226,222,248,259,238,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 15, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,301,293,246,369,267,254,241,350,231,202,252],
[200,0,213,189,263,260,151,155,312,186,253,273],
[208,288,0,243,256,274,193,255,310,225,297,313],
[255,312,258,0,330,211,199,163,306,219,228,325],
[132,238,245,171,0,193,184,93,254,115,161,222],
[234,241,227,290,308,0,189,253,277,198,205,286],
[247,350,308,302,317,312,0,265,348,257,244,253],
[260,346,246,338,408,248,236,0,403,260,296,342],
[151,189,191,195,247,224,153,98,0,122,176,151],
[270,315,276,282,386,303,244,241,379,0,214,293],
[299,248,204,273,340,296,257,205,325,287,0,199],
[249,228,188,176,279,215,248,159,350,208,302,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 16, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,220,223,218,230,220,235,230,246,235,206,233],
[281,0,220,210,225,243,211,250,224,230,188,225],
[278,281,0,223,267,251,250,271,268,248,259,261],
[283,291,278,0,262,291,271,277,270,257,246,290],
[271,276,234,239,0,280,230,235,261,250,228,267],
[281,258,250,210,221,0,231,258,247,232,252,258],
[266,290,251,230,271,270,0,279,280,258,237,273],
[271,251,230,224,266,243,222,0,255,228,183,248],
[255,277,233,231,240,254,221,246,0,233,184,262],
[266,271,253,244,251,269,243,273,268,0,254,254],
[295,313,242,255,273,249,264,318,317,247,0,283],
[268,276,240,211,234,243,228,253,239,247,218,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 17, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,233,269,273,209,223,270,272,272,263,229,237],
[268,0,237,246,245,223,278,266,258,255,230,202],
[232,264,0,298,242,269,321,224,216,214,258,199],
[228,255,203,0,221,209,301,202,242,123,205,255],
[292,256,259,280,0,237,265,277,291,298,210,230],
[278,278,232,292,264,0,234,219,301,246,280,236],
[231,223,180,200,236,267,0,213,225,237,231,220],
[229,235,277,299,224,282,288,0,267,269,197,278],
[229,243,285,259,210,200,276,234,0,209,189,249],
[238,246,287,378,203,255,264,232,292,0,230,247],
[272,271,243,296,291,221,270,304,312,271,0,264],
[264,299,302,246,271,265,281,223,252,254,237,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 18, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,219,259,296,276,232,249,277,268,257,277,314],
[282,0,203,306,290,261,283,306,279,241,288,297],
[242,298,0,280,247,232,291,303,216,228,277,265],
[205,195,221,0,225,170,205,233,193,197,196,217],
[225,211,254,276,0,226,250,254,254,207,225,264],
[269,240,269,331,275,0,284,298,266,248,298,277],
[252,218,210,296,251,217,0,257,256,198,258,249],
[224,195,198,268,247,203,244,0,213,190,237,219],
[233,222,285,308,247,235,245,288,0,183,267,275],
[244,260,273,304,294,253,303,311,318,0,278,288],
[224,213,224,305,276,203,243,264,234,223,0,236],
[187,204,236,284,237,224,252,282,226,213,265,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 19, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,232,248,245,247,231,244,236,259,223,262,267],
[269,0,257,249,256,267,272,268,259,260,265,279],
[253,244,0,261,257,262,257,246,267,252,264,274],
[256,252,240,0,248,271,262,265,262,239,249,256],
[254,245,244,253,0,260,263,240,262,240,239,254],
[270,234,239,230,241,0,251,239,260,250,241,258],
[257,229,244,239,238,250,0,244,255,242,249,245],
[265,233,255,236,261,262,257,0,263,238,245,260],
[242,242,234,239,239,241,246,238,0,236,246,251],
[278,241,249,262,261,251,259,263,265,0,261,266],
[239,236,237,252,262,260,252,256,255,240,0,245],
[234,222,227,245,247,243,256,241,250,235,256,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 20, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,245,259,252,251,242,258,258,253,254,244,240],
[256,0,247,229,244,232,238,242,263,246,244,238],
[242,254,0,241,262,244,245,240,253,246,245,244],
[249,272,260,0,258,248,243,250,258,263,270,242],
[250,257,239,243,0,234,255,251,257,248,254,239],
[259,269,257,253,267,0,261,243,252,262,265,234],
[243,263,256,258,246,240,0,260,258,255,252,251],
[243,259,261,251,250,258,241,0,256,245,257,241],
[248,238,248,243,244,249,243,245,0,263,269,232],
[247,255,255,238,253,239,246,256,238,0,246,241],
[257,257,256,231,247,236,249,244,232,255,0,240],
[261,263,257,259,262,267,250,260,269,260,261,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 21, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,244,236,236,229,250,236,241,253,237,233,236],
[257,0,240,241,246,253,243,244,258,243,264,254],
[265,261,0,248,258,254,240,249,260,252,257,256],
[265,260,253,0,253,253,244,253,264,253,250,257],
[272,255,243,248,0,263,267,262,256,259,258,261],
[251,248,247,248,238,0,236,249,262,254,248,244],
[265,258,261,257,234,265,0,269,264,251,268,255],
[260,257,252,248,239,252,232,0,255,247,250,242],
[248,243,241,237,245,239,237,246,0,252,238,238],
[264,258,249,248,242,247,250,254,249,0,260,258],
[268,237,244,251,243,253,233,251,263,241,0,249],
[265,247,245,244,240,257,246,259,263,243,252,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 22, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,264,246,281,272,246,280,278,256,277,282,257],
[237,0,239,264,249,233,253,256,277,263,256,245],
[255,262,0,258,252,236,268,276,254,289,268,257],
[220,237,243,0,254,217,255,256,231,271,267,232],
[229,252,249,247,0,255,273,289,273,279,276,268],
[255,268,265,284,246,0,289,273,281,272,277,284],
[221,248,233,246,228,212,0,247,224,265,250,217],
[223,245,225,245,212,228,254,0,237,232,232,222],
[245,224,247,270,228,220,277,264,0,266,251,227],
[224,238,212,230,222,229,236,269,235,0,250,235],
[219,245,233,234,225,224,251,269,250,251,0,205],
[244,256,244,269,233,217,284,279,274,266,296,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 23, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,232,254,274,245,255,289,269,270,232,255,258],
[269,0,275,264,248,245,255,276,251,254,254,249],
[247,226,0,242,230,267,281,251,252,242,240,258],
[227,237,259,0,236,263,272,242,240,219,239,244],
[256,253,271,265,0,264,283,256,273,232,271,256],
[246,256,234,238,237,0,255,240,218,241,259,248],
[212,246,220,229,218,246,0,228,228,221,222,239],
[232,225,250,259,245,261,273,0,248,247,275,258],
[231,250,249,261,228,283,273,253,0,242,274,245],
[269,247,259,282,269,260,280,254,259,0,250,270],
[246,247,261,262,230,242,279,226,227,251,0,257],
[243,252,243,257,245,253,262,243,256,231,244,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 24, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,217,220,223,203,228,205,244,238,206,217,223],
[284,0,215,211,237,234,246,269,250,224,251,238],
[281,286,0,234,254,253,215,255,230,225,276,263],
[278,290,267,0,258,255,246,310,222,222,245,265],
[298,264,247,243,0,253,257,268,231,239,240,253],
[273,267,248,246,248,0,224,266,233,220,265,257],
[296,255,286,255,244,277,0,280,257,261,257,252],
[257,232,246,191,233,235,221,0,229,216,229,248],
[263,251,271,279,270,268,244,272,0,218,253,272],
[295,277,276,279,262,281,240,285,283,0,266,263],
[284,250,225,256,261,236,244,272,248,235,0,256],
[278,263,238,236,248,244,249,253,229,238,245,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 25, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,242,252,205,221,228,194,243,247,209,242,210],
[259,0,255,237,217,244,221,240,264,245,273,233],
[249,246,0,218,207,236,233,247,232,219,240,235],
[296,264,283,0,270,272,269,296,301,273,258,244],
[280,284,294,231,0,254,247,289,255,239,229,262],
[273,257,265,229,247,0,226,238,241,235,239,209],
[307,280,268,232,254,275,0,294,270,264,257,239],
[258,261,254,205,212,263,207,0,251,228,232,228],
[254,237,269,200,246,260,231,250,0,222,234,209],
[292,256,282,228,262,266,237,273,279,0,251,254],
[259,228,261,243,272,262,244,269,267,250,0,272],
[291,268,266,257,239,292,262,273,292,247,229,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 26, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,220,248,202,215,243,224,199,237,262,245,234],
[281,0,282,272,243,255,238,227,273,301,295,262],
[253,219,0,202,245,221,242,232,273,254,297,243],
[299,229,299,0,240,255,239,251,306,292,277,231],
[286,258,256,261,0,292,265,256,285,292,255,239],
[258,246,280,246,209,0,239,218,250,261,264,238],
[277,263,259,262,236,262,0,231,260,261,293,240],
[302,274,269,250,245,283,270,0,264,279,283,244],
[264,228,228,195,216,251,241,237,0,273,246,217],
[239,200,247,209,209,240,240,222,228,0,257,254],
[256,206,204,224,246,237,208,218,255,244,0,256],
[267,239,258,270,262,263,261,257,284,247,245,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 27, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,290,289,219,239,286,272,257,264,233,260,263],
[211,0,251,217,201,224,251,222,212,244,262,197],
[212,250,0,214,209,259,233,225,241,213,271,205],
[282,284,287,0,238,269,272,229,257,263,274,236],
[262,300,292,263,0,250,261,251,238,236,283,229],
[215,277,242,232,251,0,229,228,216,261,265,235],
[229,250,268,229,240,272,0,231,249,238,278,247],
[244,279,276,272,250,273,270,0,272,248,275,227],
[237,289,260,244,263,285,252,229,0,266,254,231],
[268,257,288,238,265,240,263,253,235,0,274,232],
[241,239,230,227,218,236,223,226,247,227,0,224],
[238,304,296,265,272,266,254,274,270,269,277,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 28, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,174,251,282,240,260,314,240,198,287,278,290],
[327,0,205,289,266,276,282,334,191,259,359,258],
[250,296,0,245,343,266,390,298,224,184,355,320],
[219,212,256,0,268,272,248,245,227,204,313,250],
[261,235,158,233,0,202,258,220,199,147,241,205],
[241,225,235,229,299,0,277,234,272,172,260,329],
[187,219,111,253,243,224,0,205,127,199,272,243],
[261,167,203,256,281,267,296,0,210,154,248,218],
[303,310,277,274,302,229,374,291,0,266,323,345],
[214,242,317,297,354,329,302,347,235,0,354,263],
[223,142,146,188,260,241,229,253,178,147,0,176],
[211,243,181,251,296,172,258,283,156,238,325,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 29, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,251,270,270,270,259,268,241,256,269,276,264],
[250,0,243,255,253,266,242,239,232,255,268,271],
[231,258,0,254,236,240,259,243,228,254,268,246],
[231,246,247,0,248,256,246,243,235,259,258,254],
[231,248,265,253,0,255,241,248,244,260,257,257],
[242,235,261,245,246,0,240,238,244,254,256,255],
[233,259,242,255,260,261,0,246,271,264,270,239],
[260,262,258,258,253,263,255,0,246,256,266,263],
[245,269,273,266,257,257,230,255,0,267,277,258],
[232,246,247,242,241,247,237,245,234,0,253,265],
[225,233,233,243,244,245,231,235,224,248,0,254],
[237,230,255,247,244,246,262,238,243,236,247,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 30, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,271,258,275,254,254,251,262,273,264,247,259],
[230,0,233,237,219,256,221,232,223,240,244,231],
[243,268,0,267,244,266,229,240,246,271,269,242],
[226,264,234,0,270,269,256,258,239,264,256,226],
[247,282,257,231,0,262,228,271,241,276,262,244],
[247,245,235,232,239,0,258,276,254,249,248,228],
[250,280,272,245,273,243,0,274,258,271,258,243],
[239,269,261,243,230,225,227,0,253,263,241,244],
[228,278,255,262,260,247,243,248,0,262,260,237],
[237,261,230,237,225,252,230,238,239,0,254,246],
[254,257,232,245,239,253,243,260,241,247,0,247],
[242,270,259,275,257,273,258,257,264,255,254,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 31, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,244,231,273,251,278,261,270,252,239,261,272],
[257,0,233,290,244,280,261,262,252,242,262,243],
[270,268,0,283,251,277,284,255,245,256,265,265],
[228,211,218,0,211,233,226,232,210,234,210,214],
[250,257,250,290,0,299,266,275,255,249,257,263],
[223,221,224,268,202,0,224,245,230,234,223,227],
[240,240,217,275,235,277,0,261,231,231,241,225],
[231,239,246,269,226,256,240,0,230,240,237,235],
[249,249,256,291,246,271,270,271,0,261,250,268],
[262,259,245,267,252,267,270,261,240,0,236,248],
[240,239,236,291,244,278,260,264,251,265,0,260],
[229,258,236,287,238,274,276,266,233,253,241,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 32, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,253,198,227,207,223,196,208,220,229,188,202],
[248,0,244,252,241,257,240,242,260,261,221,233],
[303,257,0,243,256,244,230,259,267,276,209,221],
[274,249,258,0,239,237,235,233,228,262,255,250],
[294,260,245,262,0,258,248,266,234,258,217,214],
[278,244,257,264,243,0,225,224,253,251,193,213],
[305,261,271,266,253,276,0,265,245,244,231,248],
[293,259,242,268,235,277,236,0,249,255,223,236],
[281,241,234,273,267,248,256,252,0,276,223,242],
[272,240,225,239,243,250,257,246,225,0,227,236],
[313,280,292,246,284,308,270,278,278,274,0,275],
[299,268,280,251,287,288,253,265,259,265,226,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 33, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,267,265,260,261,273,251,272,291,246,256,261],
[234,0,267,234,258,264,241,252,257,245,239,235],
[236,234,0,249,266,225,243,263,264,255,247,253],
[241,267,252,0,270,245,247,269,293,268,268,244],
[240,243,235,231,0,268,250,235,257,231,258,255],
[228,237,276,256,233,0,235,231,238,233,235,250],
[250,260,258,254,251,266,0,266,267,255,239,256],
[229,249,238,232,266,270,235,0,252,248,253,233],
[210,244,237,208,244,263,234,249,0,235,217,236],
[255,256,246,233,270,268,246,253,266,0,268,269],
[245,262,254,233,243,266,262,248,284,233,0,268],
[240,266,248,257,246,251,245,268,265,232,233,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 34, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,253,253,246,252,256,266,260,234,245,258,265],
[248,0,255,259,258,235,251,260,234,245,240,260],
[248,246,0,255,263,238,243,259,252,245,250,258],
[255,242,246,0,267,255,249,250,250,225,257,242],
[249,243,238,234,0,242,253,253,235,235,247,264],
[245,266,263,246,259,0,246,253,228,269,255,262],
[235,250,258,252,248,255,0,259,254,257,251,245],
[241,241,242,251,248,248,242,0,238,247,248,258],
[267,267,249,251,266,273,247,263,0,247,258,253],
[256,256,256,276,266,232,244,254,254,0,261,271],
[243,261,251,244,254,246,250,253,243,240,0,255],
[236,241,243,259,237,239,256,243,248,230,246,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 35, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,246,247,240,236,256,237,246,260,279,261,238],
[255,0,262,266,264,252,217,267,252,272,268,246],
[254,239,0,255,261,271,254,244,255,270,292,252],
[261,235,246,0,249,244,242,239,274,262,249,242],
[265,237,240,252,0,285,226,255,277,251,259,266],
[245,249,230,257,216,0,234,230,235,225,258,239],
[264,284,247,259,275,267,0,258,271,302,297,234],
[255,234,257,262,246,271,243,0,250,291,278,270],
[241,249,246,227,224,266,230,251,0,264,273,232],
[222,229,231,239,250,276,199,210,237,0,234,216],
[240,233,209,252,242,243,204,223,228,267,0,228],
[263,255,249,259,235,262,267,231,269,285,273,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 36, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,232,241,229,264,264,220,227,265,221,261,194],
[269,0,282,268,260,275,301,230,255,269,285,240],
[260,219,0,217,270,243,245,226,254,213,240,217],
[272,233,284,0,284,268,267,274,269,254,246,224],
[237,241,231,217,0,235,238,199,229,210,259,183],
[237,226,258,233,266,0,237,240,210,247,248,228],
[281,200,256,234,263,264,0,189,267,257,261,210],
[274,271,275,227,302,261,312,0,271,257,300,294],
[236,246,247,232,272,291,234,230,0,268,252,232],
[280,232,288,247,291,254,244,244,233,0,272,238],
[240,216,261,255,242,253,240,201,249,229,0,216],
[307,261,284,277,318,273,291,207,269,263,285,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 37, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,236,246,263,236,248,240,257,260,244,234,273],
[265,0,246,263,264,264,256,263,264,255,243,289],
[255,255,0,268,245,250,248,242,250,251,242,264],
[238,238,233,0,252,260,243,243,251,234,234,270],
[265,237,256,249,0,253,247,242,252,238,256,266],
[253,237,251,241,248,0,240,257,229,250,247,258],
[261,245,253,258,254,261,0,261,263,257,249,269],
[244,238,259,258,259,244,240,0,263,251,242,274],
[241,237,251,250,249,272,238,238,0,240,245,255],
[257,246,250,267,263,251,244,250,261,0,255,276],
[267,258,259,267,245,254,252,259,256,246,0,286],
[228,212,237,231,235,243,232,227,246,225,215,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 38, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,260,239,247,245,236,253,247,243,237,260,265],
[241,0,229,231,237,249,259,229,238,244,266,267],
[262,272,0,261,232,241,263,264,251,262,262,263],
[254,270,240,0,258,256,268,277,246,262,278,272],
[256,264,269,243,0,252,261,265,255,272,260,267],
[265,252,260,245,249,0,271,267,251,251,263,281],
[248,242,238,233,240,230,0,229,250,254,242,257],
[254,272,237,224,236,234,272,0,233,251,263,251],
[258,263,250,255,246,250,251,268,0,250,275,264],
[264,257,239,239,229,250,247,250,251,0,270,272],
[241,235,239,223,241,238,259,238,226,231,0,258],
[236,234,238,229,234,220,244,250,237,229,243,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 39, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,230,218,231,225,259,233,245,287,232,267,218],
[271,0,247,274,262,314,275,260,274,217,295,236],
[283,254,0,284,225,310,257,250,292,252,286,215],
[270,227,217,0,210,250,225,227,243,251,278,196],
[276,239,276,291,0,304,255,254,280,261,306,209],
[242,187,191,251,197,0,196,231,258,206,218,184],
[268,226,244,276,246,305,0,236,277,247,275,232],
[256,241,251,274,247,270,265,0,290,210,278,242],
[214,227,209,258,221,243,224,211,0,196,255,236],
[269,284,249,250,240,295,254,291,305,0,288,252],
[234,206,215,223,195,283,226,223,246,213,0,224],
[283,265,286,305,292,317,269,259,265,249,277,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 40, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,281,245,257,246,267,251,279,242,251,257,246],
[220,0,231,250,224,251,253,245,226,228,222,218],
[256,270,0,264,263,262,267,253,239,236,256,241],
[244,251,237,0,236,263,275,250,235,239,241,225],
[255,277,238,265,0,248,263,253,233,259,234,255],
[234,250,239,238,253,0,242,265,236,242,249,217],
[250,248,234,226,238,259,0,263,222,267,256,212],
[222,256,248,251,248,236,238,0,219,226,256,226],
[259,275,262,266,268,265,279,282,0,254,257,246],
[250,273,265,262,242,259,234,275,247,0,256,221],
[244,279,245,260,267,252,245,245,244,245,0,204],
[255,283,260,276,246,284,289,275,255,280,297,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 41, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,256,237,238,282,230,251,250,251,257,271,256],
[245,0,222,252,218,259,228,242,228,258,251,237],
[264,279,0,256,251,263,264,235,282,266,288,264],
[263,249,245,0,256,249,248,255,262,251,283,248],
[219,283,250,245,0,251,227,217,255,248,260,243],
[271,242,238,252,250,0,227,241,264,245,262,235],
[250,273,237,253,274,274,0,267,258,260,286,276],
[251,259,266,246,284,260,234,0,276,256,283,279],
[250,273,219,239,246,237,243,225,0,236,255,237],
[244,243,235,250,253,256,241,245,265,0,270,244],
[230,250,213,218,241,239,215,218,246,231,0,263],
[245,264,237,253,258,266,225,222,264,257,238,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 42, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,270,261,288,269,268,260,271,254,227,254,253],
[231,0,243,265,259,269,260,253,228,262,240,248],
[240,258,0,270,272,278,262,286,238,266,256,242],
[213,236,231,0,243,261,240,233,251,234,236,226],
[232,242,229,258,0,267,249,238,228,242,232,216],
[233,232,223,240,234,0,221,246,206,245,209,211],
[241,241,239,261,252,280,0,255,211,261,230,239],
[230,248,215,268,263,255,246,0,227,245,239,229],
[247,273,263,250,273,295,290,274,0,264,274,248],
[274,239,235,267,259,256,240,256,237,0,238,263],
[247,261,245,265,269,292,271,262,227,263,0,249],
[248,253,259,275,285,290,262,272,253,238,252,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 43, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,254,260,268,244,245,254,263,236,251,260,234],
[247,0,267,263,247,242,236,249,229,241,242,233],
[241,234,0,244,228,238,221,251,229,231,245,231],
[233,238,257,0,233,251,241,251,239,238,249,234],
[257,254,273,268,0,256,252,263,238,255,260,247],
[256,259,263,250,245,0,238,257,236,250,261,240],
[247,265,280,260,249,263,0,273,251,257,265,253],
[238,252,250,250,238,244,228,0,229,243,232,234],
[265,272,272,262,263,265,250,272,0,261,258,256],
[250,260,270,263,246,251,244,258,240,0,260,245],
[241,259,256,252,241,240,236,269,243,241,0,230],
[267,268,270,267,254,261,248,267,245,256,271,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 44, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,240,303,317,307,277,245,262,338,218,306,247],
[261,0,278,266,314,310,219,261,275,219,272,258],
[198,223,0,279,237,237,192,243,234,213,275,213],
[184,235,222,0,236,269,197,201,245,206,228,222],
[194,187,264,265,0,306,261,237,328,257,299,260],
[224,191,264,232,195,0,179,174,252,210,225,228],
[256,282,309,304,240,322,0,279,315,262,364,261],
[239,240,258,300,264,327,222,0,285,254,262,246],
[163,226,267,256,173,249,186,216,0,267,280,173],
[283,282,288,295,244,291,239,247,234,0,291,223],
[195,229,226,273,202,276,137,239,221,210,0,225],
[254,243,288,279,241,273,240,255,328,278,276,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 45, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,340,276,362,225,300,264,225,310,236,288,255],
[161,0,192,253,182,220,201,200,242,185,260,246],
[225,309,0,270,237,286,282,268,255,290,268,272],
[139,248,231,0,177,216,181,202,185,192,193,226],
[276,319,264,324,0,290,263,238,323,295,246,263],
[201,281,215,285,211,0,248,221,254,210,227,256],
[237,300,219,320,238,253,0,222,275,227,288,234],
[276,301,233,299,263,280,279,0,314,313,339,302],
[191,259,246,316,178,247,226,187,0,214,210,220],
[265,316,211,309,206,291,274,188,287,0,247,256],
[213,241,233,308,255,274,213,162,291,254,0,257],
[246,255,229,275,238,245,267,199,281,245,244,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 46, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,226,242,217,271,227,267,225,243,277,213,267],
[275,0,251,241,270,238,246,203,242,298,229,247],
[259,250,0,225,238,231,222,196,214,244,242,242],
[284,260,276,0,261,276,225,253,242,273,254,254],
[230,231,263,240,0,272,221,228,208,259,253,214],
[274,263,270,225,229,0,197,265,250,296,261,267],
[234,255,279,276,280,304,0,269,267,277,259,261],
[276,298,305,248,273,236,232,0,210,276,256,215],
[258,259,287,259,293,251,234,291,0,287,219,225],
[224,203,257,228,242,205,224,225,214,0,210,197],
[288,272,259,247,248,240,242,245,282,291,0,252],
[234,254,259,247,287,234,240,286,276,304,249,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 47, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,248,250,222,236,236,247,244,245,240,236,246],
[253,0,224,226,253,243,255,243,235,255,258,237],
[251,277,0,247,261,267,255,256,250,254,269,232],
[279,275,254,0,257,258,302,249,270,264,266,249],
[265,248,240,244,0,238,257,232,257,261,237,223],
[265,258,234,243,263,0,277,274,270,277,295,252],
[254,246,246,199,244,224,0,231,266,241,235,224],
[257,258,245,252,269,227,270,0,237,267,243,245],
[256,266,251,231,244,231,235,264,0,228,238,231],
[261,246,247,237,240,224,260,234,273,0,255,230],
[265,243,232,235,264,206,266,258,263,246,0,219],
[255,264,269,252,278,249,277,256,270,271,282,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 48, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,244,259,255,264,255,255,261,258,257,254,254],
[257,0,242,256,274,252,257,256,271,253,227,240],
[242,259,0,244,261,252,248,252,258,235,238,238],
[246,245,257,0,259,250,250,258,273,235,253,249],
[237,227,240,242,0,248,237,258,252,227,235,244],
[246,249,249,251,253,0,274,269,271,256,228,250],
[246,244,253,251,264,227,0,257,262,240,234,250],
[240,245,249,243,243,232,244,0,265,247,231,237],
[243,230,243,228,249,230,239,236,0,255,236,234],
[244,248,266,266,274,245,261,254,246,0,239,248],
[247,274,263,248,266,273,267,270,265,262,0,248],
[247,261,263,252,257,251,251,264,267,253,253,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 49, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,260,258,254,251,226,241,267,242,260,263,284],
[241,0,210,262,239,234,231,253,217,277,247,259],
[243,291,0,275,242,213,230,251,224,261,264,239],
[247,239,226,0,217,240,205,255,236,223,249,270],
[250,262,259,284,0,227,259,255,242,277,260,284],
[275,267,288,261,274,0,240,297,234,297,294,292],
[260,270,271,296,242,261,0,277,254,290,295,272],
[234,248,250,246,246,204,224,0,220,265,240,262],
[259,284,277,265,259,267,247,281,0,281,257,297],
[241,224,240,278,224,204,211,236,220,0,268,274],
[238,254,237,252,241,207,206,261,244,233,0,286],
[217,242,262,231,217,209,229,239,204,227,215,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 50, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,265,237,246,255,270,248,261,263,257,252,267],
[236,0,241,242,244,240,238,247,254,243,251,253],
[264,260,0,253,252,260,242,262,261,272,264,266],
[255,259,248,0,264,247,248,255,257,261,258,261],
[246,257,249,237,0,256,253,265,268,248,261,271],
[231,261,241,254,245,0,249,260,244,253,259,266],
[253,263,259,253,248,252,0,264,264,251,264,268],
[240,254,239,246,236,241,237,0,242,241,268,258],
[238,247,240,244,233,257,237,259,0,243,255,261],
[244,258,229,240,253,248,250,260,258,0,265,279],
[249,250,237,243,240,242,237,233,246,236,0,264],
[234,248,235,240,230,235,233,243,240,222,237,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 51, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,265,242,272,248,240,208,244,250,249,251,215],
[236,0,250,229,229,255,236,235,268,267,244,231],
[259,251,0,239,208,213,226,251,239,248,226,217],
[229,272,262,0,236,250,238,238,270,253,239,230],
[253,272,293,265,0,261,261,266,244,295,272,259],
[261,246,288,251,240,0,262,234,235,276,267,229],
[293,265,275,263,240,239,0,227,245,305,263,224],
[257,266,250,263,235,267,274,0,267,296,280,234],
[251,233,262,231,257,266,256,234,0,278,293,224],
[252,234,253,248,206,225,196,205,223,0,240,223],
[250,257,275,262,229,234,238,221,208,261,0,212],
[286,270,284,271,242,272,277,267,277,278,289,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 52, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,254,238,260,247,224,244,269,221,239,228,251],
[247,0,237,252,234,230,228,227,213,254,211,261],
[263,264,0,243,249,251,254,269,242,253,247,247],
[241,249,258,0,252,239,259,254,226,258,227,259],
[254,267,252,249,0,249,257,261,228,262,240,253],
[277,271,250,262,252,0,280,253,230,262,231,267],
[257,273,247,242,244,221,0,256,234,261,244,263],
[232,274,232,247,240,248,245,0,252,280,230,275],
[280,288,259,275,273,271,267,249,0,272,254,255],
[262,247,248,243,239,239,240,221,229,0,218,256],
[273,290,254,274,261,270,257,271,247,283,0,283],
[250,240,254,242,248,234,238,226,246,245,218,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 53, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,225,254,236,250,241,237,259,257,227,270,245],
[276,0,269,256,282,255,250,257,257,250,269,258],
[247,232,0,242,272,229,240,262,236,238,260,249],
[265,245,259,0,274,244,250,278,258,255,266,275],
[251,219,229,227,0,230,239,248,239,240,288,245],
[260,246,272,257,271,0,265,273,248,257,285,252],
[264,251,261,251,262,236,0,257,264,220,281,247],
[242,244,239,223,253,228,244,0,234,220,275,222],
[244,244,265,243,262,253,237,267,0,227,268,244],
[274,251,263,246,261,244,281,281,274,0,289,261],
[231,232,241,235,213,216,220,226,233,212,0,252],
[256,243,252,226,256,249,254,279,257,240,249,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 54, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,251,243,263,258,250,252,241,236,240,263,261],
[250,0,245,265,258,248,253,248,243,247,266,258],
[258,256,0,275,276,245,265,255,257,247,270,261],
[238,236,226,0,247,247,259,247,235,243,248,247],
[243,243,225,254,0,249,256,244,229,245,254,265],
[251,253,256,254,252,0,257,253,244,236,243,263],
[249,248,236,242,245,244,0,233,242,243,251,250],
[260,253,246,254,257,248,268,0,249,241,241,246],
[265,258,244,266,272,257,259,252,0,266,261,258],
[261,254,254,258,256,265,258,260,235,0,253,256],
[238,235,231,253,247,258,250,260,240,248,0,263],
[240,243,240,254,236,238,251,255,243,245,238,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 55, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,253,245,266,254,258,244,265,239,253,254,297],
[248,0,245,269,248,259,249,233,245,235,231,269],
[256,256,0,277,271,278,259,227,249,244,246,268],
[235,232,224,0,251,233,245,228,230,255,226,266],
[247,253,230,250,0,254,246,253,257,227,237,276],
[243,242,223,268,247,0,247,229,240,253,223,259],
[257,252,242,256,255,254,0,236,237,243,250,283],
[236,268,274,273,248,272,265,0,240,264,246,280],
[262,256,252,271,244,261,264,261,0,240,263,273],
[248,266,257,246,274,248,258,237,261,0,235,283],
[247,270,255,275,264,278,251,255,238,266,0,288],
[204,232,233,235,225,242,218,221,228,218,213,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 56, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,237,241,236,264,274,255,250,273,250,252,272],
[264,0,249,254,258,272,258,250,291,276,240,288],
[260,252,0,246,249,253,239,243,261,277,247,276],
[265,247,255,0,240,248,261,227,283,271,252,242],
[237,243,252,261,0,248,238,238,248,261,236,256],
[227,229,248,253,253,0,231,219,261,252,223,245],
[246,243,262,240,263,270,0,260,264,253,253,263],
[251,251,258,274,263,282,241,0,281,271,249,268],
[228,210,240,218,253,240,237,220,0,256,201,232],
[251,225,224,230,240,249,248,230,245,0,232,254],
[249,261,254,249,265,278,248,252,300,269,0,270],
[229,213,225,259,245,256,238,233,269,247,231,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 57, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,240,252,264,229,249,256,263,239,251,237,242],
[261,0,251,257,243,251,250,237,257,252,253,248],
[249,250,0,238,238,246,269,243,252,262,246,243],
[237,244,263,0,236,236,252,236,244,260,243,235],
[272,258,263,265,0,267,255,254,251,253,249,253],
[252,250,255,265,234,0,263,259,254,254,254,226],
[245,251,232,249,246,238,0,245,249,247,251,235],
[238,264,258,265,247,242,256,0,269,261,250,251],
[262,244,249,257,250,247,252,232,0,243,244,229],
[250,249,239,241,248,247,254,240,258,0,244,225],
[264,248,255,258,252,247,250,251,257,257,0,247],
[259,253,258,266,248,275,266,250,272,276,254,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 58, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,253,244,249,250,248,244,232,235,258,247,248],
[248,0,245,230,240,236,254,246,229,260,250,247],
[257,256,0,243,258,240,253,237,250,253,237,253],
[252,271,258,0,260,255,250,240,259,258,246,250],
[251,261,243,241,0,244,249,233,235,242,250,242],
[253,265,261,246,257,0,262,247,247,260,266,235],
[257,247,248,251,252,239,0,231,243,248,252,266],
[269,255,264,261,268,254,270,0,246,271,263,263],
[266,272,251,242,266,254,258,255,0,276,256,257],
[243,241,248,243,259,241,253,230,225,0,237,253],
[254,251,264,255,251,235,249,238,245,264,0,250],
[253,254,248,251,259,266,235,238,244,248,251,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 59, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,235,218,239,242,227,245,261,249,263,236,225],
[266,0,222,286,275,274,253,274,270,263,282,257],
[283,279,0,270,257,259,270,275,281,266,271,250],
[262,215,231,0,243,274,244,270,281,271,237,245],
[259,226,244,258,0,258,275,273,276,272,262,250],
[274,227,242,227,243,0,291,251,263,273,259,267],
[256,248,231,257,226,210,0,247,245,245,248,226],
[240,227,226,231,228,250,254,0,240,247,262,210],
[252,231,220,220,225,238,256,261,0,251,251,220],
[238,238,235,230,229,228,256,254,250,0,264,248],
[265,219,230,264,239,242,253,239,250,237,0,248],
[276,244,251,256,251,234,275,291,281,253,253,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 60, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,246,240,274,267,244,258,250,258,251,264,234],
[255,0,248,254,244,250,242,250,255,253,250,261],
[261,253,0,267,244,242,257,238,241,242,224,220],
[227,247,234,0,245,224,248,213,225,247,224,235],
[234,257,257,256,0,249,263,244,261,241,253,243],
[257,251,259,277,252,0,242,218,235,258,264,228],
[243,259,244,253,238,259,0,230,253,248,230,229],
[251,251,263,288,257,283,271,0,265,257,245,239],
[243,246,260,276,240,266,248,236,0,263,242,254],
[250,248,259,254,260,243,253,244,238,0,248,242],
[237,251,277,277,248,237,271,256,259,253,0,244],
[267,240,281,266,258,273,272,262,247,259,257,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 61, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,249,259,256,247,253,262,249,266,248,267,242],
[252,0,241,246,248,232,253,259,245,237,258,241],
[242,260,0,242,245,232,252,253,255,242,259,250],
[245,255,259,0,252,253,248,240,252,246,249,238],
[254,253,256,249,0,249,247,259,262,245,255,242],
[248,269,269,248,252,0,275,273,262,250,271,240],
[239,248,249,253,254,226,0,251,248,245,254,233],
[252,242,248,261,242,228,250,0,237,259,237,254],
[235,256,246,249,239,239,253,264,0,235,247,237],
[253,264,259,255,256,251,256,242,266,0,251,243],
[234,243,242,252,246,230,247,264,254,250,0,238],
[259,260,251,263,259,261,268,247,264,258,263,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 62, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,259,247,262,253,242,219,241,266,252,259,263],
[242,0,241,250,245,246,246,242,249,254,248,232],
[254,260,0,245,266,252,271,253,259,245,274,260],
[239,251,256,0,216,241,237,225,240,237,239,235],
[248,256,235,285,0,253,244,236,250,243,266,250],
[259,255,249,260,248,0,249,227,254,262,252,249],
[282,255,230,264,257,252,0,265,272,268,270,264],
[260,259,248,276,265,274,236,0,265,253,245,247],
[235,252,242,261,251,247,229,236,0,251,238,243],
[249,247,256,264,258,239,233,248,250,0,255,254],
[242,253,227,262,235,249,231,256,263,246,0,243],
[238,269,241,266,251,252,237,254,258,247,258,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 63, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,268,311,301,240,262,298,258,227,299,260,275],
[233,0,299,264,247,277,241,256,238,292,253,287],
[190,202,0,277,234,234,259,224,205,234,201,276],
[200,237,224,0,198,214,252,229,224,231,229,224],
[261,254,267,303,0,278,267,235,258,263,211,269],
[239,224,267,287,223,0,279,221,210,251,241,269],
[203,260,242,249,234,222,0,250,216,226,266,253],
[243,245,277,272,266,280,251,0,262,285,244,272],
[274,263,296,277,243,291,285,239,0,253,261,293],
[202,209,267,270,238,250,275,216,248,0,221,259],
[241,248,300,272,290,260,235,257,240,280,0,268],
[226,214,225,277,232,232,248,229,208,242,233,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 64, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,267,240,243,246,260,256,246,245,269,268,244],
[234,0,248,249,248,271,245,241,248,262,242,244],
[261,253,0,253,262,247,226,252,259,258,253,239],
[258,252,248,0,234,262,239,244,239,281,240,258],
[255,253,239,267,0,261,250,247,228,272,251,239],
[241,230,254,239,240,0,237,221,231,258,237,245],
[245,256,275,262,251,264,0,234,249,268,269,257],
[255,260,249,257,254,280,267,0,255,258,253,264],
[256,253,242,262,273,270,252,246,0,263,263,260],
[232,239,243,220,229,243,233,243,238,0,263,240],
[233,259,248,261,250,264,232,248,238,238,0,251],
[257,257,262,243,262,256,244,237,241,261,250,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 65, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,241,243,242,256,246,238,246,249,249,244,242],
[260,0,234,239,237,266,223,238,255,249,244,244],
[258,267,0,249,253,272,274,249,234,259,258,262],
[259,262,252,0,257,283,247,254,256,264,251,274],
[245,264,248,244,0,262,257,236,258,249,256,237],
[255,235,229,218,239,0,227,227,235,239,228,243],
[263,278,227,254,244,274,0,239,253,274,258,256],
[255,263,252,247,265,274,262,0,247,270,256,242],
[252,246,267,245,243,266,248,254,0,267,244,245],
[252,252,242,237,252,262,227,231,234,0,264,255],
[257,257,243,250,245,273,243,245,257,237,0,268],
[259,257,239,227,264,258,245,259,256,246,233,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 66, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,231,234,235,216,198,245,216,252,267,253,229],
[270,0,265,254,247,236,273,242,262,259,280,257],
[267,236,0,228,267,270,275,285,241,229,280,250],
[266,247,273,0,248,248,241,235,265,267,262,284],
[285,254,234,253,0,251,249,239,239,266,260,241],
[303,265,231,253,250,0,263,250,266,269,291,247],
[256,228,226,260,252,238,0,244,236,256,289,240],
[285,259,216,266,262,251,257,0,267,274,271,233],
[249,239,260,236,262,235,265,234,0,248,254,244],
[234,242,272,234,235,232,245,227,253,0,252,224],
[248,221,221,239,241,210,212,230,247,249,0,228],
[272,244,251,217,260,254,261,268,257,277,273,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 67, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,287,286,342,281,245,232,294,340,267,321,226],
[214,0,271,267,269,201,212,261,234,196,228,164],
[215,230,0,264,214,248,208,260,207,198,194,135],
[159,234,237,0,236,180,206,238,307,241,238,187],
[220,232,287,265,0,262,253,254,251,231,308,263],
[256,300,253,321,239,0,231,249,239,267,296,244],
[269,289,293,295,248,270,0,234,298,187,268,249],
[207,240,241,263,247,252,267,0,190,208,211,178],
[161,267,294,194,250,262,203,311,0,241,290,231],
[234,305,303,260,270,234,314,293,260,0,278,191],
[180,273,307,263,193,205,233,290,211,223,0,216],
[275,337,366,314,238,257,252,323,270,310,285,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 68, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,255,247,272,244,257,256,246,260,278,247,253],
[246,0,266,263,241,253,244,243,261,283,239,239],
[254,235,0,267,248,247,265,244,248,287,230,243],
[229,238,234,0,229,226,245,215,239,279,219,225],
[257,260,253,272,0,244,263,243,263,295,254,258],
[244,248,254,275,257,0,270,254,266,283,228,264],
[245,257,236,256,238,231,0,243,263,272,233,229],
[255,258,257,286,258,247,258,0,279,290,259,260],
[241,240,253,262,238,235,238,222,0,255,219,230],
[223,218,214,222,206,218,229,211,246,0,222,237],
[254,262,271,282,247,273,268,242,282,279,0,258],
[248,262,258,276,243,237,272,241,271,264,243,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 69, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,219,318,222,290,252,305,219,344,304,261,346],
[282,0,384,198,313,249,290,299,366,295,320,308],
[183,117,0,220,205,167,149,154,256,192,229,201],
[279,303,281,0,344,217,280,304,299,250,282,347],
[211,188,296,157,0,252,215,223,309,234,237,284],
[249,252,334,284,249,0,245,207,324,221,241,278],
[196,211,352,221,286,256,0,286,310,209,247,271],
[282,202,347,197,278,294,215,0,368,310,279,285],
[157,135,245,202,192,177,191,133,0,221,145,256],
[197,206,309,251,267,280,292,191,280,0,234,321],
[240,181,272,219,264,260,254,222,356,267,0,293],
[155,193,300,154,217,223,230,216,245,180,208,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 70, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,245,224,243,207,324,286,257,247,318,233,239],
[256,0,250,205,240,363,275,289,303,358,285,266],
[277,251,0,191,286,301,238,255,258,325,275,281],
[258,296,310,0,295,322,318,249,270,376,311,282],
[294,261,215,206,0,271,285,227,273,351,283,250],
[177,138,200,179,230,0,227,174,218,260,188,219],
[215,226,263,183,216,274,0,172,208,277,204,218],
[244,212,246,252,274,327,329,0,271,283,272,269],
[254,198,243,231,228,283,293,230,0,297,273,216],
[183,143,176,125,150,241,224,218,204,0,194,152],
[268,216,226,190,218,313,297,229,228,307,0,272],
[262,235,220,219,251,282,283,232,285,349,229,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 71, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,246,243,206,277,216,252,242,233,256,247,227],
[255,0,240,258,298,255,262,267,267,293,240,219],
[258,261,0,238,320,279,282,266,266,275,240,262],
[295,243,263,0,282,246,273,319,250,257,251,266],
[224,203,181,219,0,207,226,236,235,234,215,231],
[285,246,222,255,294,0,267,257,249,295,249,257],
[249,239,219,228,275,234,0,251,247,271,240,215],
[259,234,235,182,265,244,250,0,259,243,263,232],
[268,234,235,251,266,252,254,242,0,266,235,237],
[245,208,226,244,267,206,230,258,235,0,234,218],
[254,261,261,250,286,252,261,238,266,267,0,241],
[274,282,239,235,270,244,286,269,264,283,260,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 72, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,262,259,245,221,264,223,242,260,244,240,245],
[239,0,260,273,261,272,233,230,239,233,270,253],
[242,241,0,236,254,267,222,235,254,245,254,249],
[256,228,265,0,248,258,219,236,263,248,251,249],
[280,240,247,253,0,278,229,254,262,238,261,247],
[237,229,234,243,223,0,224,230,252,220,248,230],
[278,268,279,282,272,277,0,239,263,257,284,263],
[259,271,266,265,247,271,262,0,268,246,268,258],
[241,262,247,238,239,249,238,233,0,257,262,282],
[257,268,256,253,263,281,244,255,244,0,263,261],
[261,231,247,250,240,253,217,233,239,238,0,243],
[256,248,252,252,254,271,238,243,219,240,258,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 73, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,285,277,247,266,257,250,256,262,259,268,282],
[216,0,243,219,200,220,217,235,231,232,231,233],
[224,258,0,222,224,238,202,247,233,231,246,245],
[254,282,279,0,237,253,238,267,263,249,258,260],
[235,301,277,264,0,255,255,272,276,252,262,260],
[244,281,263,248,246,0,253,258,256,233,269,248],
[251,284,299,263,246,248,0,284,251,259,277,266],
[245,266,254,234,229,243,217,0,244,239,243,235],
[239,270,268,238,225,245,250,257,0,239,250,258],
[242,269,270,252,249,268,242,262,262,0,240,262],
[233,270,255,243,239,232,224,258,251,261,0,252],
[219,268,256,241,241,253,235,266,243,239,249,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 74, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,244,238,263,263,267,222,240,246,233,260,248],
[257,0,248,273,252,271,242,275,247,230,262,245],
[263,253,0,258,251,260,232,259,259,236,234,245],
[238,228,243,0,247,242,239,252,255,223,235,237],
[238,249,250,254,0,261,245,243,256,238,245,244],
[234,230,241,259,240,0,219,247,262,224,241,235],
[279,259,269,262,256,282,0,272,274,258,264,245],
[261,226,242,249,258,254,229,0,265,244,245,234],
[255,254,242,246,245,239,227,236,0,216,239,223],
[268,271,265,278,263,277,243,257,285,0,267,251],
[241,239,267,266,256,260,237,256,262,234,0,245],
[253,256,256,264,257,266,256,267,278,250,256,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 75, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,270,246,256,245,260,234,254,256,263,225,260],
[231,0,253,243,231,253,239,254,261,246,243,226],
[255,248,0,256,230,274,247,247,270,240,248,256],
[245,258,245,0,233,257,250,241,264,263,232,280],
[256,270,271,268,0,272,275,250,285,256,248,277],
[241,248,227,244,229,0,229,234,248,243,223,230],
[267,262,254,251,226,272,0,238,264,278,241,255],
[247,247,254,260,251,267,263,0,253,274,259,242],
[245,240,231,237,216,253,237,248,0,258,230,229],
[238,255,261,238,245,258,223,227,243,0,216,256],
[276,258,253,269,253,278,260,242,271,285,0,255],
[241,275,245,221,224,271,246,259,272,245,246,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 76, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,187,205,265,221,301,211,170,215,193,230,243],
[314,0,294,313,250,316,263,207,294,270,271,237],
[296,207,0,272,223,277,232,248,299,205,244,239],
[236,188,229,0,266,240,183,169,259,210,245,217],
[280,251,278,235,0,265,196,250,298,267,277,235],
[200,185,224,261,236,0,208,223,231,254,248,224],
[290,238,269,318,305,293,0,307,291,303,319,321],
[331,294,253,332,251,278,194,0,302,282,245,214],
[286,207,202,242,203,270,210,199,0,256,241,195],
[308,231,296,291,234,247,198,219,245,0,238,240],
[271,230,257,256,224,253,182,256,260,263,0,255],
[258,264,262,284,266,277,180,287,306,261,246,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 77, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,254,275,290,281,257,287,256,275,277,286,242],
[247,0,278,270,262,220,276,248,265,267,253,268],
[226,223,0,257,256,232,254,221,231,250,254,237],
[211,231,244,0,229,231,224,240,239,255,240,247],
[220,239,245,272,0,228,261,236,246,266,261,242],
[244,281,269,270,273,0,277,246,262,286,262,270],
[214,225,247,277,240,224,0,245,239,244,232,240],
[245,253,280,261,265,255,256,0,261,260,262,248],
[226,236,270,262,255,239,262,240,0,261,267,244],
[224,234,251,246,235,215,257,241,240,0,241,247],
[215,248,247,261,240,239,269,239,234,260,0,237],
[259,233,264,254,259,231,261,253,257,254,264,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 78, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,254,229,258,252,240,259,246,260,263,269,246],
[247,0,252,263,261,256,267,256,258,274,249,253],
[272,249,0,266,263,245,273,262,267,260,267,254],
[243,238,235,0,273,236,270,247,234,269,250,236],
[249,240,238,228,0,245,264,242,241,264,239,219],
[261,245,256,265,256,0,273,264,279,268,265,245],
[242,234,228,231,237,228,0,235,245,260,234,221],
[255,245,239,254,259,237,266,0,252,267,255,239],
[241,243,234,267,260,222,256,249,0,266,261,239],
[238,227,241,232,237,233,241,234,235,0,233,234],
[232,252,234,251,262,236,267,246,240,268,0,225],
[255,248,247,265,282,256,280,262,262,267,276,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 79, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,264,269,241,252,268,275,245,253,249,252,281],
[237,0,247,262,255,264,270,239,249,257,249,265],
[232,254,0,236,224,226,253,223,232,247,247,252],
[260,239,265,0,259,264,271,258,268,262,255,277],
[249,246,277,242,0,250,262,248,249,242,252,262],
[233,237,275,237,251,0,254,244,222,240,245,264],
[226,231,248,230,239,247,0,236,238,258,235,250],
[256,262,278,243,253,257,265,0,257,260,270,284],
[248,252,269,233,252,279,263,244,0,258,264,262],
[252,244,254,239,259,261,243,241,243,0,252,274],
[249,252,254,246,249,256,266,231,237,249,0,272],
[220,236,249,224,239,237,251,217,239,227,229,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 80, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,258,253,245,271,210,236,222,209,205,233,232],
[243,0,292,351,313,285,218,311,259,262,270,279],
[248,209,0,235,209,190,206,218,185,172,189,179],
[256,150,266,0,274,229,215,209,206,172,272,213],
[230,188,292,227,0,265,224,171,182,168,261,238],
[291,216,311,272,236,0,268,221,245,211,274,216],
[265,283,295,286,277,233,0,244,243,258,268,283],
[279,190,283,292,330,280,257,0,208,230,268,264],
[292,242,316,295,319,256,258,293,0,280,254,272],
[296,239,329,329,333,290,243,271,221,0,293,264],
[268,231,312,229,240,227,233,233,247,208,0,284],
[269,222,322,288,263,285,218,237,229,237,217,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 81, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,269,243,258,277,260,260,249,271,250,255,254],
[232,0,243,224,229,256,241,240,272,232,235,251],
[258,258,0,243,236,263,252,248,240,238,236,282],
[243,277,258,0,238,273,250,242,261,260,260,269],
[224,272,265,263,0,269,271,251,276,238,256,257],
[241,245,238,228,232,0,244,221,218,229,233,253],
[241,260,249,251,230,257,0,224,261,239,259,260],
[252,261,253,259,250,280,277,0,273,269,246,269],
[230,229,261,240,225,283,240,228,0,244,260,251],
[251,269,263,241,263,272,262,232,257,0,242,265],
[246,266,265,241,245,268,242,255,241,259,0,262],
[247,250,219,232,244,248,241,232,250,236,239,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 82, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,254,252,248,245,253,239,253,245,246,253,252],
[247,0,245,237,240,243,243,260,239,250,241,236],
[249,256,0,253,240,248,250,259,236,255,227,237],
[253,264,248,0,268,259,264,262,243,247,251,248],
[256,261,261,233,0,259,244,253,261,255,234,246],
[248,258,253,242,242,0,240,259,243,259,233,239],
[262,258,251,237,257,261,0,252,244,270,255,250],
[248,241,242,239,248,242,249,0,232,264,231,248],
[256,262,265,258,240,258,257,269,0,255,256,235],
[255,251,246,254,246,242,231,237,246,0,241,246],
[248,260,274,250,267,268,246,270,245,260,0,249],
[249,265,264,253,255,262,251,253,266,255,252,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 83, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,254,273,257,255,248,250,251,254,266,261,256],
[247,0,270,254,245,273,265,255,253,254,262,251],
[228,231,0,223,227,236,253,224,227,234,237,195],
[244,247,278,0,233,265,246,250,264,246,227,233],
[246,256,274,268,0,266,248,266,263,257,266,263],
[253,228,265,236,235,0,254,246,278,242,222,250],
[251,236,248,255,253,247,0,253,268,246,257,239],
[250,246,277,251,235,255,248,0,273,257,265,246],
[247,248,274,237,238,223,233,228,0,261,232,210],
[235,247,267,255,244,259,255,244,240,0,232,210],
[240,239,264,274,235,279,244,236,269,269,0,230],
[245,250,306,268,238,251,262,255,291,291,271,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 84, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,147,226,263,272,250,243,259,236,224,252,175],
[354,0,206,276,302,275,282,232,254,233,304,261],
[275,295,0,289,294,290,250,242,263,240,287,251],
[238,225,212,0,254,266,240,218,275,219,247,185],
[229,199,207,247,0,199,226,178,238,201,266,254],
[251,226,211,235,302,0,235,225,189,229,252,238],
[258,219,251,261,275,266,0,228,264,225,301,226],
[242,269,259,283,323,276,273,0,267,292,278,287],
[265,247,238,226,263,312,237,234,0,242,335,284],
[277,268,261,282,300,272,276,209,259,0,306,267],
[249,197,214,254,235,249,200,223,166,195,0,202],
[326,240,250,316,247,263,275,214,217,234,299,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 85, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,264,283,254,253,279,257,295,242,263,236,258],
[237,0,261,253,257,274,251,260,262,264,237,245],
[218,240,0,242,259,255,227,262,258,236,241,235],
[247,248,259,0,247,269,233,284,276,278,254,236],
[248,244,242,254,0,258,245,266,254,266,227,225],
[222,227,246,232,243,0,220,278,260,245,234,228],
[244,250,274,268,256,281,0,281,255,261,240,252],
[206,241,239,217,235,223,220,0,247,242,233,214],
[259,239,243,225,247,241,246,254,0,242,239,236],
[238,237,265,223,235,256,240,259,259,0,246,243],
[265,264,260,247,274,267,261,268,262,255,0,250],
[243,256,266,265,276,273,249,287,265,258,251,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 86, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,262,260,259,258,276,266,260,268,273,250,270],
[239,0,240,241,226,264,270,248,239,257,245,260],
[241,261,0,251,238,256,259,250,250,259,251,242],
[242,260,250,0,236,259,272,256,257,267,255,253],
[243,275,263,265,0,281,275,260,271,267,277,260],
[225,237,245,242,220,0,245,236,238,245,247,247],
[235,231,242,229,226,256,0,241,235,249,259,253],
[241,253,251,245,241,265,260,0,262,253,259,247],
[233,262,251,244,230,263,266,239,0,273,259,242],
[228,244,242,234,234,256,252,248,228,0,245,251],
[251,256,250,246,224,254,242,242,242,256,0,244],
[231,241,259,248,241,254,248,254,259,250,257,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 87, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,243,257,267,242,271,253,246,277,291,273,264],
[258,0,235,246,248,265,268,282,291,297,283,259],
[244,266,0,270,256,275,264,258,304,300,307,263],
[234,255,231,0,227,272,233,239,259,285,268,251],
[259,253,245,274,0,279,264,246,268,285,271,284],
[230,236,226,229,222,0,241,240,253,280,247,239],
[248,233,237,268,237,260,0,262,285,276,259,278],
[255,219,243,262,255,261,239,0,284,278,282,251],
[224,210,197,242,233,248,216,217,0,270,263,232],
[210,204,201,216,216,221,225,223,231,0,231,218],
[228,218,194,233,230,254,242,219,238,270,0,248],
[237,242,238,250,217,262,223,250,269,283,253,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 88, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,212,245,204,237,233,198,237,232,240,154,238],
[289,0,242,287,269,255,284,318,228,240,240,254],
[256,259,0,264,253,256,262,259,261,236,210,267],
[297,214,237,0,289,254,238,228,260,266,239,261],
[264,232,248,212,0,252,229,250,251,233,251,252],
[268,246,245,247,249,0,250,264,244,244,208,275],
[303,217,239,263,272,251,0,266,258,279,214,270],
[264,183,242,273,251,237,235,0,262,231,220,239],
[269,273,240,241,250,257,243,239,0,268,221,257],
[261,261,265,235,268,257,222,270,233,0,235,285],
[347,261,291,262,250,293,287,281,280,266,0,250],
[263,247,234,240,249,226,231,262,244,216,251,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 89, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,195,253,193,167,162,211,172,254,170,212,247],
[306,0,183,264,234,180,277,213,211,154,219,248],
[248,318,0,311,186,230,241,229,218,251,249,282],
[308,237,190,0,146,217,206,185,214,189,289,216],
[334,267,315,355,0,303,283,229,271,295,309,272],
[339,321,271,284,198,0,213,264,204,232,229,290],
[290,224,260,295,218,288,0,210,245,225,240,318],
[329,288,272,316,272,237,291,0,268,321,312,303],
[247,290,283,287,230,297,256,233,0,240,217,273],
[331,347,250,312,206,269,276,180,261,0,345,268],
[289,282,252,212,192,272,261,189,284,156,0,285],
[254,253,219,285,229,211,183,198,228,233,216,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 90, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,259,260,244,253,244,247,249,259,248,267,251],
[242,0,243,264,244,228,243,241,245,247,264,251],
[241,258,0,258,252,232,242,252,255,247,279,246],
[257,237,243,0,270,256,246,256,257,250,268,253],
[248,257,249,231,0,220,245,248,261,243,258,246],
[257,273,269,245,281,0,261,255,255,257,278,268],
[254,258,259,255,256,240,0,243,267,251,277,235],
[252,260,249,245,253,246,258,0,260,248,268,259],
[242,256,246,244,240,246,234,241,0,245,297,239],
[253,254,254,251,258,244,250,253,256,0,266,271],
[234,237,222,233,243,223,224,233,204,235,0,238],
[250,250,255,248,255,233,266,242,262,230,263,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 91, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,242,264,269,275,314,279,288,255,274,252,278],
[259,0,288,296,293,315,325,315,243,302,267,292],
[237,213,0,241,232,253,302,289,200,277,214,262],
[232,205,260,0,224,241,221,248,201,225,185,256],
[226,208,269,277,0,281,304,290,219,258,211,255],
[187,186,248,260,220,0,292,233,237,270,189,242],
[222,176,199,280,197,209,0,246,256,235,179,249],
[213,186,212,253,211,268,255,0,203,234,169,245],
[246,258,301,300,282,264,245,298,0,265,291,298],
[227,199,224,276,243,231,266,267,236,0,197,239],
[249,234,287,316,290,312,322,332,210,304,0,310],
[223,209,239,245,246,259,252,256,203,262,191,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 92, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,241,212,262,245,195,185,246,214,220,231,212],
[260,0,252,233,250,260,197,233,253,268,254,229],
[289,249,0,239,278,278,211,268,281,251,258,247],
[239,268,262,0,266,266,224,272,274,250,220,219],
[256,251,223,235,0,244,222,233,239,245,251,227],
[306,241,223,235,257,0,220,250,240,249,229,244],
[316,304,290,277,279,281,0,247,297,308,283,273],
[255,268,233,229,268,251,254,0,244,278,285,252],
[287,248,220,227,262,261,204,257,0,237,256,262],
[281,233,250,251,256,252,193,223,264,0,227,249],
[270,247,243,281,250,272,218,216,245,274,0,232],
[289,272,254,282,274,257,228,249,239,252,269,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 93, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,238,247,239,260,262,253,295,254,234,245,252],
[263,0,260,242,270,249,255,283,244,234,252,251],
[254,241,0,230,243,248,265,274,254,244,239,243],
[262,259,271,0,261,261,262,267,263,238,259,253],
[241,231,258,240,0,255,239,269,241,223,245,243],
[239,252,253,240,246,0,253,274,253,245,249,244],
[248,246,236,239,262,248,0,289,258,257,246,248],
[206,218,227,234,232,227,212,0,212,196,221,206],
[247,257,247,238,260,248,243,289,0,233,245,236],
[267,267,257,263,278,256,244,305,268,0,254,260],
[256,249,262,242,256,252,255,280,256,247,0,260],
[249,250,258,248,258,257,253,295,265,241,241,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 94, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,242,240,236,254,227,249,240,242,229,235,239],
[259,0,248,258,240,237,248,249,239,230,232,262],
[261,253,0,246,253,236,234,248,247,240,241,259],
[265,243,255,0,240,226,250,253,232,235,238,237],
[247,261,248,261,0,237,262,249,261,234,234,248],
[274,264,265,275,264,0,265,261,252,240,274,255],
[252,253,267,251,239,236,0,259,253,253,248,249],
[261,252,253,248,252,240,242,0,246,236,237,250],
[259,262,254,269,240,249,248,255,0,250,260,259],
[272,271,261,266,267,261,248,265,251,0,261,255],
[266,269,260,263,267,227,253,264,241,240,0,261],
[262,239,242,264,253,246,252,251,242,246,240,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 95, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,268,258,267,261,249,259,267,248,244,263,260],
[233,0,242,257,244,229,237,244,259,237,239,249],
[243,259,0,268,257,225,272,261,277,252,258,267],
[234,244,233,0,261,228,252,251,250,219,235,255],
[240,257,244,240,0,238,248,263,245,230,235,277],
[252,272,276,273,263,0,250,249,304,243,259,281],
[242,264,229,249,253,251,0,259,254,245,250,274],
[234,257,240,250,238,252,242,0,244,236,253,250],
[253,242,224,251,256,197,247,257,0,237,245,260],
[257,264,249,282,271,258,256,265,264,0,247,255],
[238,262,243,266,266,242,251,248,256,254,0,269],
[241,252,234,246,224,220,227,251,241,246,232,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 96, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,240,221,227,190,194,241,203,225,189,186,207],
[261,0,250,222,161,229,231,234,259,247,241,230],
[280,251,0,258,235,233,223,229,266,259,215,208],
[274,279,243,0,203,235,217,224,200,223,233,197],
[311,340,266,298,0,285,284,272,259,233,262,257],
[307,272,268,266,216,0,284,280,283,225,229,224],
[260,270,278,284,217,217,0,263,265,214,245,240],
[298,267,272,277,229,221,238,0,285,227,247,229],
[276,242,235,301,242,218,236,216,0,240,196,193],
[312,254,242,278,268,276,287,274,261,0,270,216],
[315,260,286,268,239,272,256,254,305,231,0,225],
[294,271,293,304,244,277,261,272,308,285,276,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 97, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,262,252,262,259,252,266,242,267,252,251,253],
[239,0,242,253,257,240,234,253,253,252,240,245],
[249,259,0,264,251,228,245,257,250,246,241,251],
[239,248,237,0,239,227,229,250,240,230,226,238],
[242,244,250,262,0,240,240,246,258,240,240,254],
[249,261,273,274,261,0,243,243,254,242,255,259],
[235,267,256,272,261,258,0,261,255,260,263,268],
[259,248,244,251,255,258,240,0,266,237,260,238],
[234,248,251,261,243,247,246,235,0,240,245,239],
[249,249,255,271,261,259,241,264,261,0,246,258],
[250,261,260,275,261,246,238,241,256,255,0,250],
[248,256,250,263,247,242,233,263,262,243,251,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 98, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,213,234,275,214,245,228,201,209,247,234,227],
[288,0,264,304,250,272,276,245,253,282,261,256],
[267,237,0,285,229,244,258,225,250,252,234,238],
[226,197,216,0,205,239,249,219,206,228,213,236],
[287,251,272,296,0,248,263,239,243,261,253,263],
[256,229,257,262,253,0,241,252,222,238,233,245],
[273,225,243,252,238,260,0,246,208,241,251,242],
[300,256,276,282,262,249,255,0,248,273,245,283],
[292,248,251,295,258,279,293,253,0,267,289,285],
[254,219,249,273,240,263,260,228,234,0,249,260],
[267,240,267,288,248,268,250,256,212,252,0,246],
[274,245,263,265,238,256,259,218,216,241,255,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 99, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,235,238,238,262,260,259,253,259,240,261,260],
[266,0,282,242,288,261,261,295,255,260,288,260],
[263,219,0,232,252,252,249,260,242,246,251,238],
[263,259,269,0,263,245,279,261,258,286,276,269],
[239,213,249,238,0,251,255,269,237,251,255,252],
[241,240,249,256,250,0,249,275,258,265,278,247],
[242,240,252,222,246,252,0,261,255,258,267,247],
[248,206,241,240,232,226,240,0,260,236,253,231],
[242,246,259,243,264,243,246,241,0,256,245,264],
[261,241,255,215,250,236,243,265,245,0,259,256],
[240,213,250,225,246,223,234,248,256,242,0,234],
[241,241,263,232,249,254,254,270,237,245,267,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 100, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,245,278,280,240,220,244,277,270,255,277,253],
[256,0,228,277,236,281,220,267,279,284,244,242],
[223,273,0,267,209,283,249,262,286,226,263,213],
[221,224,234,0,225,221,241,249,255,242,263,189],
[261,265,292,276,0,246,248,274,273,221,270,282],
[281,220,218,280,255,0,264,269,271,260,279,226],
[257,281,252,260,253,237,0,252,294,251,239,236],
[224,234,239,252,227,232,249,0,268,238,271,205],
[231,222,215,246,228,230,207,233,0,270,245,225],
[246,217,275,259,280,241,250,263,231,0,248,235],
[224,257,238,238,231,222,262,230,256,253,0,223],
[248,259,288,312,219,275,265,296,276,266,278,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 101, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,228,229,216,237,235,225,220,240,254,210,239],
[273,0,258,264,239,241,256,263,268,245,263,277],
[272,243,0,236,229,221,210,247,233,241,195,262],
[285,237,265,0,238,235,249,263,243,268,233,270],
[264,262,272,263,0,243,245,257,262,271,240,259],
[266,260,280,266,258,0,264,258,245,303,280,287],
[276,245,291,252,256,237,0,249,268,255,251,256],
[281,238,254,238,244,243,252,0,230,268,256,255],
[261,233,268,258,239,256,233,271,0,260,253,264],
[247,256,260,233,230,198,246,233,241,0,228,248],
[291,238,306,268,261,221,250,245,248,273,0,296],
[262,224,239,231,242,214,245,246,237,253,205,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 102, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,256,251,259,247,247,252,242,249,242,254,268],
[245,0,247,254,254,242,241,221,241,248,248,253],
[250,254,0,266,269,275,256,264,254,254,261,267],
[242,247,235,0,235,249,254,232,229,243,246,258],
[254,247,232,266,0,246,255,261,239,240,244,263],
[254,259,226,252,255,0,245,245,241,245,259,258],
[249,260,245,247,246,256,0,256,256,250,248,261],
[259,280,237,269,240,256,245,0,245,255,245,259],
[252,260,247,272,262,260,245,256,0,257,267,271],
[259,253,247,258,261,256,251,246,244,0,246,254],
[247,253,240,255,257,242,253,256,234,255,0,253],
[233,248,234,243,238,243,240,242,230,247,248,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 103, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,248,259,262,243,256,261,255,273,239,272,260],
[253,0,249,257,244,250,262,247,275,262,277,268],
[242,252,0,257,242,254,264,249,265,254,259,264],
[239,244,244,0,247,252,244,244,272,255,260,252],
[258,257,259,254,0,244,253,250,261,243,259,256],
[245,251,247,249,257,0,255,253,273,255,269,256],
[240,239,237,257,248,246,0,255,263,251,272,255],
[246,254,252,257,251,248,246,0,260,250,276,256],
[228,226,236,229,240,228,238,241,0,245,250,251],
[262,239,247,246,258,246,250,251,256,0,253,244],
[229,224,242,241,242,232,229,225,251,248,0,245],
[241,233,237,249,245,245,246,245,250,257,256,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 104, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,242,254,219,236,227,247,264,230,280,239,249],
[259,0,230,259,269,283,269,278,256,278,250,254],
[247,271,0,211,259,238,260,278,220,243,248,237],
[282,242,290,0,278,253,270,276,258,291,272,285],
[265,232,242,223,0,249,247,258,200,240,231,245],
[274,218,263,248,252,0,288,285,241,287,259,270],
[254,232,241,231,254,213,0,251,214,270,223,260],
[237,223,223,225,243,216,250,0,191,250,228,231],
[271,245,281,243,301,260,287,310,0,282,266,280],
[221,223,258,210,261,214,231,251,219,0,250,262],
[262,251,253,229,270,242,278,273,235,251,0,284],
[252,247,264,216,256,231,241,270,221,239,217,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 105, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,249,247,229,260,244,242,240,246,254,244,241],
[252,0,265,259,258,251,246,232,246,262,257,258],
[254,236,0,235,252,230,227,222,235,249,234,227],
[272,242,266,0,272,264,245,234,236,258,243,256],
[241,243,249,229,0,229,224,223,219,245,223,234],
[257,250,271,237,272,0,247,243,267,240,246,246],
[259,255,274,256,277,254,0,235,257,258,270,241],
[261,269,279,267,278,258,266,0,250,280,267,257],
[255,255,266,265,282,234,244,251,0,262,259,256],
[247,239,252,243,256,261,243,221,239,0,248,243],
[257,244,267,258,278,255,231,234,242,253,0,266],
[260,243,274,245,267,255,260,244,245,258,235,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 106, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,224,216,254,240,226,245,243,227,245,235,234],
[277,0,269,268,251,264,269,267,253,258,247,249],
[285,232,0,251,247,259,274,249,254,256,247,247],
[247,233,250,0,241,252,268,242,242,255,270,237],
[261,250,254,260,0,258,274,258,254,275,250,234],
[275,237,242,249,243,0,271,264,248,256,246,249],
[256,232,227,233,227,230,0,222,213,231,231,211],
[258,234,252,259,243,237,279,0,244,279,225,258],
[274,248,247,259,247,253,288,257,0,262,253,248],
[256,243,245,246,226,245,270,222,239,0,250,235],
[266,254,254,231,251,255,270,276,248,251,0,260],
[267,252,254,264,267,252,290,243,253,266,241,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 107, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,251,226,234,242,235,249,229,243,258,242,246],
[250,0,226,261,234,254,229,258,242,234,230,278],
[275,275,0,260,242,283,251,261,247,253,251,302],
[267,240,241,0,239,254,261,251,269,252,244,273],
[259,267,259,262,0,242,253,267,264,276,259,288],
[266,247,218,247,259,0,233,239,210,251,261,270],
[252,272,250,240,248,268,0,263,252,240,260,270],
[272,243,240,250,234,262,238,0,252,246,254,265],
[258,259,254,232,237,291,249,249,0,243,254,266],
[243,267,248,249,225,250,261,255,258,0,244,284],
[259,271,250,257,242,240,241,247,247,257,0,253],
[255,223,199,228,213,231,231,236,235,217,248,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 108, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,265,156,392,353,234,323,340,347,376,285,304],
[236,0,326,314,236,308,335,316,370,277,204,258],
[345,175,0,345,247,203,485,347,326,386,238,408],
[109,187,156,0,306,165,382,235,297,306,143,129],
[148,265,254,195,0,184,344,256,238,314,197,261],
[267,193,298,336,317,0,407,397,385,335,238,358],
[178,166,16,119,157,94,0,241,137,157,141,160],
[161,185,154,266,245,104,260,0,166,245,238,233],
[154,131,175,204,263,116,364,335,0,222,184,226],
[125,224,115,195,187,166,344,256,279,0,156,308],
[216,297,263,358,304,263,360,263,317,345,0,365],
[197,243,93,372,240,143,341,268,275,193,136,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 109, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,248,268,242,261,252,261,225,257,247,239,258],
[253,0,266,271,286,271,270,255,275,264,249,263],
[233,235,0,240,255,255,267,236,236,242,237,240],
[259,230,261,0,275,257,278,249,230,258,236,223],
[240,215,246,226,0,245,252,220,241,237,206,234],
[249,230,246,244,256,0,292,228,249,228,242,226],
[240,231,234,223,249,209,0,218,230,230,212,221],
[276,246,265,252,281,273,283,0,262,272,256,257],
[244,226,265,271,260,252,271,239,0,250,242,267],
[254,237,259,243,264,273,271,229,251,0,228,258],
[262,252,264,265,295,259,289,245,259,273,0,254],
[243,238,261,278,267,275,280,244,234,243,247,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 110, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,292,220,239,220,209,243,225,221,269,214,220],
[209,0,239,191,225,225,222,248,212,222,180,212],
[281,262,0,319,228,313,266,285,263,224,282,260],
[262,310,182,0,264,318,303,296,220,229,194,236],
[281,276,273,237,0,280,333,246,222,233,272,247],
[292,276,188,183,221,0,261,249,251,225,239,231],
[258,279,235,198,168,240,0,248,240,243,266,216],
[276,253,216,205,255,252,253,0,210,243,225,213],
[280,289,238,281,279,250,261,291,0,243,230,237],
[232,279,277,272,268,276,258,258,258,0,220,170],
[287,321,219,307,229,262,235,276,271,281,0,267],
[281,289,241,265,254,270,285,288,264,331,234,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 111, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,277,250,263,266,291,268,262,264,262,255,271],
[224,0,224,241,245,263,230,242,247,237,229,243],
[251,277,0,260,260,249,241,267,269,264,240,250],
[238,260,241,0,249,243,253,259,250,228,251,240],
[235,256,241,252,0,236,242,247,253,241,229,243],
[210,238,252,258,265,0,233,245,234,234,218,254],
[233,271,260,248,259,268,0,261,257,244,265,269],
[239,259,234,242,254,256,240,0,252,257,252,241],
[237,254,232,251,248,267,244,249,0,244,231,259],
[239,264,237,273,260,267,257,244,257,0,252,242],
[246,272,261,250,272,283,236,249,270,249,0,254],
[230,258,251,261,258,247,232,260,242,259,247,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 112, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,252,267,254,246,243,275,252,257,254,230,264],
[249,0,275,232,259,245,278,261,280,232,242,231],
[234,226,0,214,239,226,240,223,258,223,230,228],
[247,269,287,0,244,241,270,270,265,246,263,259],
[255,242,262,257,0,238,253,250,259,253,238,240],
[258,256,275,260,263,0,275,258,261,261,251,243],
[226,223,261,231,248,226,0,250,252,221,239,223],
[249,240,278,231,251,243,251,0,260,216,237,240],
[244,221,243,236,242,240,249,241,0,231,251,241],
[247,269,278,255,248,240,280,285,270,0,283,256],
[271,259,271,238,263,250,262,264,250,218,0,244],
[237,270,273,242,261,258,278,261,260,245,257,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 113, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,322,322,267,363,285,289,297,329,249,302,276],
[179,0,242,253,249,256,280,310,375,256,294,235],
[179,259,0,177,278,275,230,235,272,235,223,184],
[234,248,324,0,243,283,361,254,339,294,268,196],
[138,252,223,258,0,274,237,260,285,254,298,212],
[216,245,226,218,227,0,300,231,359,280,293,196],
[212,221,271,140,264,201,0,249,291,244,254,175],
[204,191,266,247,241,270,252,0,288,263,236,153],
[172,126,229,162,216,142,210,213,0,202,194,166],
[252,245,266,207,247,221,257,238,299,0,202,199],
[199,207,278,233,203,208,247,265,307,299,0,146],
[225,266,317,305,289,305,326,348,335,302,355,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 114, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,257,275,253,262,246,270,242,242,263,258,242],
[244,0,264,234,250,241,245,254,240,250,238,239],
[226,237,0,239,225,245,236,229,241,244,251,229],
[248,267,262,0,261,253,272,260,234,271,260,249],
[239,251,276,240,0,260,249,248,237,259,251,235],
[255,260,256,248,241,0,262,244,235,259,234,255],
[231,256,265,229,252,239,0,250,239,250,242,239],
[259,247,272,241,253,257,251,0,249,279,257,270],
[259,261,260,267,264,266,262,252,0,284,242,244],
[238,251,257,230,242,242,251,222,217,0,236,248],
[243,263,250,241,250,267,259,244,259,265,0,227],
[259,262,272,252,266,246,262,231,257,253,274,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 115, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,235,254,243,280,266,251,261,286,318,253,290],
[266,0,251,256,306,308,278,230,283,303,270,324],
[247,250,0,227,277,326,256,225,255,280,237,272],
[258,245,274,0,302,295,269,254,282,283,265,297],
[221,195,224,199,0,266,232,224,231,242,234,302],
[235,193,175,206,235,0,200,245,227,260,199,233],
[250,223,245,232,269,301,0,241,204,261,247,247],
[240,271,276,247,277,256,260,0,226,260,242,326],
[215,218,246,219,270,274,297,275,0,272,235,263],
[183,198,221,218,259,241,240,241,229,0,249,249],
[248,231,264,236,267,302,254,259,266,252,0,277],
[211,177,229,204,199,268,254,175,238,252,224,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 116, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,235,282,264,277,255,279,314,307,285,311,260],
[266,0,277,237,238,241,260,275,291,284,305,274],
[219,224,0,207,247,252,205,267,290,259,295,231],
[237,264,294,0,225,280,303,261,283,316,299,275],
[224,263,254,276,0,265,268,302,285,279,290,264],
[246,260,249,221,236,0,280,297,293,272,306,264],
[222,241,296,198,233,221,0,282,303,264,258,252],
[187,226,234,240,199,204,219,0,274,194,272,230],
[194,210,211,218,216,208,198,227,0,224,262,238],
[216,217,242,185,222,229,237,307,277,0,256,233],
[190,196,206,202,211,195,243,229,239,245,0,218],
[241,227,270,226,237,237,249,271,263,268,283,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 117, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,242,253,253,254,246,271,240,246,237,276,260],
[259,0,259,241,273,255,257,266,257,264,254,260],
[248,242,0,242,271,243,246,254,249,228,268,251],
[248,260,259,0,269,242,265,259,239,240,273,257],
[247,228,230,232,0,201,235,209,225,209,244,216],
[255,246,258,259,300,0,271,268,235,240,267,254],
[230,244,255,236,266,230,0,232,241,235,257,234],
[261,235,247,242,292,233,269,0,237,239,263,265],
[255,244,252,262,276,266,260,264,0,250,282,261],
[264,237,273,261,292,261,266,262,251,0,264,270],
[225,247,233,228,257,234,244,238,219,237,0,229],
[241,241,250,244,285,247,267,236,240,231,272,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 118, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,206,180,187,207,226,307,335,145,149,195,186],
[295,0,260,219,280,269,321,318,240,274,267,273],
[321,241,0,284,267,325,340,337,197,242,271,255],
[314,282,217,0,244,253,292,265,206,232,245,268],
[294,221,234,257,0,270,293,341,230,192,221,229],
[275,232,176,248,231,0,307,248,178,236,232,234],
[194,180,161,209,208,194,0,200,144,125,213,180],
[166,183,164,236,160,253,301,0,166,155,209,218],
[356,261,304,295,271,323,357,335,0,241,208,292],
[352,227,259,269,309,265,376,346,260,0,277,277],
[306,234,230,256,280,269,288,292,293,224,0,274],
[315,228,246,233,272,267,321,283,209,224,227,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 119, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,267,249,252,264,260,228,280,206,256,280,254],
[234,0,298,266,303,290,317,271,275,285,274,308],
[252,203,0,220,286,298,291,265,225,255,269,269],
[249,235,281,0,292,256,267,284,252,244,269,291],
[237,198,215,209,0,238,188,240,270,221,239,266],
[241,211,203,245,263,0,226,233,235,199,245,259],
[273,184,210,234,313,275,0,226,239,245,254,286],
[221,230,236,217,261,268,275,0,216,245,229,257],
[295,226,276,249,231,266,262,285,0,256,272,292],
[245,216,246,257,280,302,256,256,245,0,287,264],
[221,227,232,232,262,256,247,272,229,214,0,262],
[247,193,232,210,235,242,215,244,209,237,239,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 120, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,255,217,217,255,222,211,208,237,240,224,219],
[246,0,225,228,238,215,246,242,251,243,206,257],
[284,276,0,250,263,261,264,264,269,252,260,262],
[284,273,251,0,268,276,246,266,276,261,268,259],
[246,263,238,233,0,239,209,221,262,227,249,242],
[279,286,240,225,262,0,254,244,276,265,240,241],
[290,255,237,255,292,247,0,229,269,253,257,248],
[293,259,237,235,280,257,272,0,288,260,245,246],
[264,250,232,225,239,225,232,213,0,248,236,225],
[261,258,249,240,274,236,248,241,253,0,261,256],
[277,295,241,233,252,261,244,256,265,240,0,252],
[282,244,239,242,259,260,253,255,276,245,249,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 121, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,262,278,270,286,244,301,253,251,274,254,283],
[239,0,283,272,323,261,239,272,257,296,235,230],
[223,218,0,264,254,207,241,223,230,259,232,229],
[231,229,237,0,255,207,233,223,189,249,224,195],
[215,178,247,246,0,221,263,243,232,257,227,207],
[257,240,294,294,280,0,293,266,263,309,272,285],
[200,262,260,268,238,208,0,276,215,283,240,251],
[248,229,278,278,258,235,225,0,228,256,248,252],
[250,244,271,312,269,238,286,273,0,257,238,282],
[227,205,242,252,244,192,218,245,244,0,243,269],
[247,266,269,277,274,229,261,253,263,258,0,276],
[218,271,272,306,294,216,250,249,219,232,225,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 122, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,214,241,249,213,251,241,258,248,237,253,231],
[287,0,280,259,254,254,245,266,261,258,250,274],
[260,221,0,240,227,250,237,245,267,249,257,217],
[252,242,261,0,236,248,243,242,243,251,251,223],
[288,247,274,265,0,261,252,264,266,258,259,240],
[250,247,251,253,240,0,246,243,254,254,252,238],
[260,256,264,258,249,255,0,247,269,257,248,254],
[243,235,256,259,237,258,254,0,255,241,253,244],
[253,240,234,258,235,247,232,246,0,239,255,245],
[264,243,252,250,243,247,244,260,262,0,263,278],
[248,251,244,250,242,249,253,248,246,238,0,245],
[270,227,284,278,261,263,247,257,256,223,256,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 123, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,241,214,295,251,197,252,222,272,238,219,221],
[260,0,233,299,328,337,280,255,319,299,286,254],
[287,268,0,257,268,241,294,212,287,278,297,256],
[206,202,244,0,215,185,270,186,245,267,253,208],
[250,173,233,286,0,273,285,231,265,265,253,208],
[304,164,260,316,228,0,258,224,217,265,251,235],
[249,221,207,231,216,243,0,211,229,236,243,225],
[279,246,289,315,270,277,290,0,232,261,261,238],
[229,182,214,256,236,284,272,269,0,288,230,230],
[263,202,223,234,236,236,265,240,213,0,242,258],
[282,215,204,248,248,250,258,240,271,259,0,203],
[280,247,245,293,293,266,276,263,271,243,298,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 124, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,270,251,240,268,262,258,275,270,273,259,258],
[231,0,245,242,260,252,245,257,260,253,262,264],
[250,256,0,264,237,242,254,244,250,259,261,260],
[261,259,237,0,243,254,255,264,251,264,252,263],
[233,241,264,258,0,247,249,252,245,249,251,268],
[239,249,259,247,254,0,254,266,259,263,272,259],
[243,256,247,246,252,247,0,267,259,267,247,257],
[226,244,257,237,249,235,234,0,238,253,256,253],
[231,241,251,250,256,242,242,263,0,254,264,261],
[228,248,242,237,252,238,234,248,247,0,255,248],
[242,239,240,249,250,229,254,245,237,246,0,251],
[243,237,241,238,233,242,244,248,240,253,250,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 125, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,217,223,225,268,250,230,261,234,265,236,210],
[284,0,230,276,225,208,260,260,244,244,229,239],
[278,271,0,274,260,238,271,299,264,263,227,254],
[276,225,227,0,239,242,237,239,258,223,220,225],
[233,276,241,262,0,260,237,258,265,291,252,225],
[251,293,263,259,241,0,262,246,248,277,249,213],
[271,241,230,264,264,239,0,285,251,257,222,234],
[240,241,202,262,243,255,216,0,223,256,236,197],
[267,257,237,243,236,253,250,278,0,255,278,214],
[236,257,238,278,210,224,244,245,246,0,232,206],
[265,272,274,281,249,252,279,265,223,269,0,227],
[291,262,247,276,276,288,267,304,287,295,274,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 126, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,243,256,246,227,243,240,257,243,240,238,245],
[258,0,256,265,250,252,259,268,261,251,259,260],
[245,245,0,266,253,236,241,274,257,239,257,248],
[255,236,235,0,244,241,245,266,252,242,232,234],
[274,251,248,257,0,251,252,266,264,244,253,256],
[258,249,265,260,250,0,247,268,263,239,256,267],
[261,242,260,256,249,254,0,271,264,240,255,250],
[244,233,227,235,235,233,230,0,256,233,222,236],
[258,240,244,249,237,238,237,245,0,237,232,254],
[261,250,262,259,257,262,261,268,264,0,254,259],
[263,242,244,269,248,245,246,279,269,247,0,260],
[256,241,253,267,245,234,251,265,247,242,241,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 127, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,277,288,245,252,254,265,240,252,272,253,250],
[224,0,248,234,232,253,244,242,266,255,218,244],
[213,253,0,246,232,240,245,253,252,280,248,239],
[256,267,255,0,254,235,273,259,253,273,231,236],
[249,269,269,247,0,255,269,242,265,275,269,261],
[247,248,261,266,246,0,246,251,276,260,242,252],
[236,257,256,228,232,255,0,251,233,252,225,235],
[261,259,248,242,259,250,250,0,250,274,250,233],
[249,235,249,248,236,225,268,251,0,268,232,237],
[229,246,221,228,226,241,249,227,233,0,222,227],
[248,283,253,270,232,259,276,251,269,279,0,269],
[251,257,262,265,240,249,266,268,264,274,232,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 128, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,201,317,215,295,248,271,246,264,255,252,256],
[300,0,305,317,266,306,204,317,250,238,287,255],
[184,196,0,182,234,280,189,169,216,172,160,197],
[286,184,319,0,297,332,263,185,241,294,212,136],
[206,235,267,204,0,303,184,254,218,282,241,132],
[253,195,221,169,198,0,265,190,239,211,202,110],
[230,297,312,238,317,236,0,260,270,290,210,197],
[255,184,332,316,247,311,241,0,274,232,247,151],
[237,251,285,260,283,262,231,227,0,295,173,192],
[246,263,329,207,219,290,211,269,206,0,209,149],
[249,214,341,289,260,299,291,254,328,292,0,219],
[245,246,304,365,369,391,304,350,309,352,282,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 129, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,268,231,267,280,289,265,288,271,278,249,253],
[233,0,218,227,301,250,233,251,255,266,256,256],
[270,283,0,269,277,277,248,255,265,312,283,282],
[234,274,232,0,298,279,274,326,265,259,278,301],
[221,200,224,203,0,268,246,266,207,220,254,201],
[212,251,224,222,233,0,208,261,218,219,214,266],
[236,268,253,227,255,293,0,274,237,243,268,275],
[213,250,246,175,235,240,227,0,196,226,239,238],
[230,246,236,236,294,283,264,305,0,261,278,233],
[223,235,189,242,281,282,258,275,240,0,242,225],
[252,245,218,223,247,287,233,262,223,259,0,233],
[248,245,219,200,300,235,226,263,268,276,268,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 130, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,223,210,215,244,217,258,234,216,252,216,234],
[278,0,254,236,221,284,275,261,275,241,267,238],
[291,247,0,196,257,246,240,268,256,260,282,274],
[286,265,305,0,258,256,275,291,277,279,294,247],
[257,280,244,243,0,207,261,276,258,239,288,268],
[284,217,255,245,294,0,250,257,227,283,267,265],
[243,226,261,226,240,251,0,277,228,258,247,249],
[267,240,233,210,225,244,224,0,226,273,232,187],
[285,226,245,224,243,274,273,275,0,222,270,257],
[249,260,241,222,262,218,243,228,279,0,241,189],
[285,234,219,207,213,234,254,269,231,260,0,226],
[267,263,227,254,233,236,252,314,244,312,275,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 131, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,239,245,256,256,223,261,228,220,206,273,241],
[262,0,280,298,258,253,270,238,255,246,281,222],
[256,221,0,267,273,220,254,231,253,235,260,246],
[245,203,234,0,241,215,216,223,220,215,230,242],
[245,243,228,260,0,224,206,218,235,203,234,222],
[278,248,281,286,277,0,280,255,247,230,245,248],
[240,231,247,285,295,221,0,251,226,237,236,207],
[273,263,270,278,283,246,250,0,240,247,254,241],
[281,246,248,281,266,254,275,261,0,244,254,263],
[295,255,266,286,298,271,264,254,257,0,276,238],
[228,220,241,271,267,256,265,247,247,225,0,243],
[260,279,255,259,279,253,294,260,238,263,258,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 132, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,216,276,228,273,295,247,276,211,256,264,294],
[285,0,289,278,322,327,273,281,297,288,246,335],
[225,212,0,218,241,273,203,232,218,251,230,283],
[273,223,283,0,282,275,251,240,219,264,261,258],
[228,179,260,219,0,242,196,241,189,240,215,219],
[206,174,228,226,259,0,198,234,195,222,225,231],
[254,228,298,250,305,303,0,277,278,294,254,277],
[225,220,269,261,260,267,224,0,197,245,263,222],
[290,204,283,282,312,306,223,304,0,275,242,274],
[245,213,250,237,261,279,207,256,226,0,244,257],
[237,255,271,240,286,276,247,238,259,257,0,277],
[207,166,218,243,282,270,224,279,227,244,224,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 133, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,341,283,289,314,223,279,278,305,221,277,249],
[160,0,167,236,271,200,228,210,251,164,210,257],
[218,334,0,240,273,285,250,324,301,255,253,264],
[212,265,261,0,276,247,253,272,269,228,227,251],
[187,230,228,225,0,213,277,240,244,193,232,271],
[278,301,216,254,288,0,310,295,277,202,285,274],
[222,273,251,248,224,191,0,306,267,209,228,241],
[223,291,177,229,261,206,195,0,278,242,249,184],
[196,250,200,232,257,224,234,223,0,167,197,241],
[280,337,246,273,308,299,292,259,334,0,320,300],
[224,291,248,274,269,216,273,252,304,181,0,294],
[252,244,237,250,230,227,260,317,260,201,207,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 134, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,258,261,250,231,259,266,202,253,191,198,267],
[243,0,268,273,265,240,253,273,270,257,269,265],
[240,233,0,206,193,232,216,223,197,162,214,217],
[251,228,295,0,245,308,250,232,293,191,276,221],
[270,236,308,256,0,265,290,231,252,284,324,257],
[242,261,269,193,236,0,284,274,264,255,289,263],
[235,248,285,251,211,217,0,208,257,198,311,247],
[299,228,278,269,270,227,293,0,298,224,251,291],
[248,231,304,208,249,237,244,203,0,210,248,203],
[310,244,339,310,217,246,303,277,291,0,317,250],
[303,232,287,225,177,212,190,250,253,184,0,239],
[234,236,284,280,244,238,254,210,298,251,262,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 135, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,273,236,275,266,261,252,259,264,253,269,242],
[228,0,244,269,254,240,238,250,247,237,247,233],
[265,257,0,262,257,255,248,276,250,247,244,243],
[226,232,239,0,248,231,238,256,240,248,243,225],
[235,247,244,253,0,241,247,265,260,242,260,236],
[240,261,246,270,260,0,240,257,260,250,254,251],
[249,263,253,263,254,261,0,259,269,245,257,239],
[242,251,225,245,236,244,242,0,249,238,245,223],
[237,254,251,261,241,241,232,252,0,234,255,240],
[248,264,254,253,259,251,256,263,267,0,258,237],
[232,254,257,258,241,247,244,256,246,243,0,235],
[259,268,258,276,265,250,262,278,261,264,266,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 136, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,217,223,236,265,284,227,253,266,269,256,275],
[284,0,246,272,296,284,325,296,287,307,285,285],
[278,255,0,272,295,239,267,288,276,281,292,290],
[265,229,229,0,252,244,271,267,259,297,270,293],
[236,205,206,249,0,233,224,278,219,248,266,255],
[217,217,262,257,268,0,263,282,247,263,279,287],
[274,176,234,230,277,238,0,267,254,279,276,271],
[248,205,213,234,223,219,234,0,228,263,255,238],
[235,214,225,242,282,254,247,273,0,278,280,266],
[232,194,220,204,253,238,222,238,223,0,234,248],
[245,216,209,231,235,222,225,246,221,267,0,264],
[226,216,211,208,246,214,230,263,235,253,237,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 137, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,225,234,235,244,253,248,264,252,230,237,223],
[276,0,260,259,273,266,273,295,269,235,264,268],
[267,241,0,250,244,257,248,261,249,228,237,239],
[266,242,251,0,249,264,247,295,274,247,243,259],
[257,228,257,252,0,269,248,287,260,228,255,231],
[248,235,244,237,232,0,239,255,237,231,233,222],
[253,228,253,254,253,262,0,286,274,246,236,246],
[237,206,240,206,214,246,215,0,230,224,212,229],
[249,232,252,227,241,264,227,271,0,239,220,240],
[271,266,273,254,273,270,255,277,262,0,236,260],
[264,237,264,258,246,268,265,289,281,265,0,248],
[278,233,262,242,270,279,255,272,261,241,253,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 138, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,295,282,264,304,264,265,261,291,250,270,286],
[206,0,219,243,217,246,193,218,224,202,242,231],
[219,282,0,278,282,252,193,257,265,234,256,263],
[237,258,223,0,263,239,230,244,247,206,243,257],
[197,284,219,238,0,211,212,233,244,200,233,235],
[237,255,249,262,290,0,228,249,246,241,258,276],
[236,308,308,271,289,273,0,252,262,261,272,267],
[240,283,244,257,268,252,249,0,267,232,249,267],
[210,277,236,254,257,255,239,234,0,217,252,245],
[251,299,267,295,301,260,240,269,284,0,269,285],
[231,259,245,258,268,243,229,252,249,232,0,246],
[215,270,238,244,266,225,234,234,256,216,255,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 139, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,254,260,251,248,240,216,263,269,241,246,263],
[247,0,254,224,256,242,237,261,266,245,236,260],
[241,247,0,233,261,232,233,260,246,241,251,267],
[250,277,268,0,258,258,253,269,287,272,257,305],
[253,245,240,243,0,227,230,252,280,255,233,270],
[261,259,269,243,274,0,247,265,291,255,273,274],
[285,264,268,248,271,254,0,268,293,287,265,290],
[238,240,241,232,249,236,233,0,258,254,245,273],
[232,235,255,214,221,210,208,243,0,217,244,263],
[260,256,260,229,246,246,214,247,284,0,264,259],
[255,265,250,244,268,228,236,256,257,237,0,257],
[238,241,234,196,231,227,211,228,238,242,244,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 140, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,249,265,268,283,256,248,258,243,276,266,269],
[252,0,261,277,264,251,271,255,261,280,274,245],
[236,240,0,245,250,237,230,238,243,240,248,248],
[233,224,256,0,250,245,244,238,246,253,249,241],
[218,237,251,251,0,243,255,255,254,258,231,257],
[245,250,264,256,258,0,260,258,254,263,265,250],
[253,230,271,257,246,241,0,238,241,255,258,229],
[243,246,263,263,246,243,263,0,244,261,259,254],
[258,240,258,255,247,247,260,257,0,261,265,259],
[225,221,261,248,243,238,246,240,240,0,240,225],
[235,227,253,252,270,236,243,242,236,261,0,247],
[232,256,253,260,244,251,272,247,242,276,254,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 141, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,169,181,135,252,237,272,233,181,195,164,235],
[332,0,288,276,293,286,334,278,188,244,279,262],
[320,213,0,217,304,336,382,304,232,274,226,300],
[366,225,284,0,216,366,336,272,344,222,281,284],
[249,208,197,285,0,271,268,209,261,140,207,207],
[264,215,165,135,230,0,262,209,188,184,233,167],
[229,167,119,165,233,239,0,234,241,186,184,188],
[268,223,197,229,292,292,267,0,246,204,215,303],
[320,313,269,157,240,313,260,255,0,253,183,231],
[306,257,227,279,361,317,315,297,248,0,283,320],
[337,222,275,220,294,268,317,286,318,218,0,294],
[266,239,201,217,294,334,313,198,270,181,207,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 142, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,235,268,257,259,259,245,284,255,274,267,260],
[266,0,260,257,266,270,244,282,255,276,279,259],
[233,241,0,248,256,235,234,273,240,259,267,236],
[244,244,253,0,251,264,235,263,242,259,244,252],
[242,235,245,250,0,258,240,258,230,257,259,252],
[242,231,266,237,243,0,255,278,250,277,264,256],
[256,257,267,266,261,246,0,291,252,277,278,272],
[217,219,228,238,243,223,210,0,207,228,237,232],
[246,246,261,259,271,251,249,294,0,265,267,251],
[227,225,242,242,244,224,224,273,236,0,259,237],
[234,222,234,257,242,237,223,264,234,242,0,245],
[241,242,265,249,249,245,229,269,250,264,256,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 143, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,245,243,227,258,259,242,236,232,243,248,247],
[256,0,247,271,262,256,274,258,251,252,270,249],
[258,254,0,256,262,267,262,247,265,268,277,262],
[274,230,245,0,270,260,271,260,260,254,279,267],
[243,239,239,231,0,248,251,238,233,241,256,250],
[242,245,234,241,253,0,262,237,240,245,255,249],
[259,227,239,230,250,239,0,251,238,250,261,255],
[265,243,254,241,263,264,250,0,251,242,254,254],
[269,250,236,241,268,261,263,250,0,264,262,264],
[258,249,233,247,260,256,251,259,237,0,261,229],
[253,231,224,222,245,246,240,247,239,240,0,244],
[254,252,239,234,251,252,246,247,237,272,257,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 144, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,246,274,260,263,258,258,258,242,255,253,266],
[255,0,250,249,249,256,265,251,252,247,261,254],
[227,251,0,240,259,247,266,231,231,257,256,241],
[241,252,261,0,271,260,281,245,260,253,254,255],
[238,252,242,230,0,225,254,236,243,238,240,221],
[243,245,254,241,276,0,262,256,259,267,261,249],
[243,236,235,220,247,239,0,223,212,237,233,230],
[243,250,270,256,265,245,278,0,264,252,256,248],
[259,249,270,241,258,242,289,237,0,264,247,256],
[246,254,244,248,263,234,264,249,237,0,261,255],
[248,240,245,247,261,240,268,245,254,240,0,240],
[235,247,260,246,280,252,271,253,245,246,261,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 145, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,271,288,231,262,251,263,260,280,262,214,245],
[230,0,281,231,263,256,253,237,271,245,229,228],
[213,220,0,193,205,226,220,201,234,233,216,210],
[270,270,308,0,279,281,248,273,291,254,245,261],
[239,238,296,222,0,250,249,222,247,229,215,221],
[250,245,275,220,251,0,240,240,276,213,220,236],
[238,248,281,253,252,261,0,261,259,239,231,238],
[241,264,300,228,279,261,240,0,274,250,263,237],
[221,230,267,210,254,225,242,227,0,233,191,207],
[239,256,268,247,272,288,262,251,268,0,240,231],
[287,272,285,256,286,281,270,238,310,261,0,256],
[256,273,291,240,280,265,263,264,294,270,245,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 146, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,240,211,249,253,203,252,239,225,258,271,275],
[261,0,243,246,267,246,220,242,234,283,302,261],
[290,258,0,257,233,233,274,262,272,282,300,294],
[252,255,244,0,244,210,251,229,197,286,308,279],
[248,234,268,257,0,229,260,238,260,307,320,289],
[298,255,268,291,272,0,256,233,226,263,278,292],
[249,281,227,250,241,245,0,228,234,291,289,260],
[262,259,239,272,263,268,273,0,241,290,323,296],
[276,267,229,304,241,275,267,260,0,264,329,299],
[243,218,219,215,194,238,210,211,237,0,280,236],
[230,199,201,193,181,223,212,178,172,221,0,234],
[226,240,207,222,212,209,241,205,202,265,267,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 147, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,245,235,249,236,253,253,249,253,224,241,241],
[256,0,253,269,248,251,250,283,266,255,257,268],
[266,248,0,258,241,252,248,271,259,251,239,245],
[252,232,243,0,234,246,250,252,257,217,234,254],
[265,253,260,267,0,255,248,270,275,243,256,257],
[248,250,249,255,246,0,254,252,253,226,251,252],
[248,251,253,251,253,247,0,265,253,245,264,269],
[252,218,230,249,231,249,236,0,245,245,246,240],
[248,235,242,244,226,248,248,256,0,234,252,246],
[277,246,250,284,258,275,256,256,267,0,274,256],
[260,244,262,267,245,250,237,255,249,227,0,255],
[260,233,256,247,244,249,232,261,255,245,246,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 148, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,282,168,181,167,308,263,211,240,237,218,214],
[219,0,207,194,129,294,253,135,261,237,172,200],
[333,294,0,211,263,340,319,255,291,267,230,240],
[320,307,290,0,228,308,281,250,331,312,316,237],
[334,372,238,273,0,403,286,322,339,325,285,301],
[193,207,161,193,98,0,186,159,228,238,218,126],
[238,248,182,220,215,315,0,220,245,223,235,289],
[290,366,246,251,179,342,281,0,286,277,262,255],
[261,240,210,170,162,273,256,215,0,239,268,242],
[264,264,234,189,176,263,278,224,262,0,214,236],
[283,329,271,185,216,283,266,239,233,287,0,214],
[287,301,261,264,200,375,212,246,259,265,287,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 149, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,247,280,289,263,243,289,285,272,277,291,276],
[254,0,231,296,224,217,248,269,264,220,274,269],
[221,270,0,243,210,231,246,234,238,273,262,226],
[212,205,258,0,190,206,236,216,213,217,222,229],
[238,277,291,311,0,278,286,287,280,248,308,300],
[258,284,270,295,223,0,267,240,301,270,270,268],
[212,253,255,265,215,234,0,235,247,228,288,233],
[216,232,267,285,214,261,266,0,239,237,281,261],
[229,237,263,288,221,200,254,262,0,208,253,225],
[224,281,228,284,253,231,273,264,293,0,273,260],
[210,227,239,279,193,231,213,220,248,228,0,265],
[225,232,275,272,201,233,268,240,276,241,236,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 150, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,253,268,253,288,248,266,246,278,288,256,259],
[248,0,237,232,254,226,219,250,252,251,233,230],
[233,264,0,252,242,263,251,257,260,274,252,257],
[248,269,249,0,274,243,250,255,269,280,250,245],
[213,247,259,227,0,232,238,237,235,238,260,212],
[253,275,238,258,269,0,232,253,268,276,256,253],
[235,282,250,251,263,269,0,234,275,262,267,264],
[255,251,244,246,264,248,267,0,254,271,250,253],
[223,249,241,232,266,233,226,247,0,254,262,234],
[213,250,227,221,263,225,239,230,247,0,224,218],
[245,268,249,251,241,245,234,251,239,277,0,229],
[242,271,244,256,289,248,237,248,267,283,272,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 151, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,264,253,256,264,266,240,255,263,248,255,259],
[237,0,236,230,239,234,235,235,240,217,230,234],
[248,265,0,258,281,258,256,246,271,261,263,259],
[245,271,243,0,259,244,254,240,254,248,251,243],
[237,262,220,242,0,229,239,244,239,231,255,250],
[235,267,243,257,272,0,255,242,254,242,269,252],
[261,266,245,247,262,246,0,243,251,259,257,266],
[246,266,255,261,257,259,258,0,263,269,271,258],
[238,261,230,247,262,247,250,238,0,245,248,256],
[253,284,240,253,270,259,242,232,256,0,267,265],
[246,271,238,250,246,232,244,230,253,234,0,233],
[242,267,242,258,251,249,235,243,245,236,268,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 152, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,272,244,268,254,267,264,279,282,280,253,242],
[229,0,225,240,224,239,257,262,270,262,246,252],
[257,276,0,261,247,260,282,270,280,296,252,268],
[233,261,240,0,228,252,263,249,255,254,237,252],
[247,277,254,273,0,261,291,291,280,272,268,249],
[234,262,241,249,240,0,264,248,271,254,250,240],
[237,244,219,238,210,237,0,239,250,247,229,227],
[222,239,231,252,210,253,262,0,275,252,272,235],
[219,231,221,246,221,230,251,226,0,246,222,250],
[221,239,205,247,229,247,254,249,255,0,240,228],
[248,255,249,264,233,251,272,229,279,261,0,253],
[259,249,233,249,252,261,274,266,251,273,248,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 153, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,226,214,221,224,219,229,225,234,245,219,253],
[275,0,267,223,241,250,246,234,263,278,278,271],
[287,234,0,249,250,241,274,228,247,277,248,264],
[280,278,252,0,249,270,243,255,285,288,265,289],
[277,260,251,252,0,252,263,244,257,284,254,263],
[282,251,260,231,249,0,266,262,263,294,258,245],
[272,255,227,258,238,235,0,236,252,255,250,249],
[276,267,273,246,257,239,265,0,249,288,238,252],
[267,238,254,216,244,238,249,252,0,286,250,259],
[256,223,224,213,217,207,246,213,215,0,213,219],
[282,223,253,236,247,243,251,263,251,288,0,266],
[248,230,237,212,238,256,252,249,242,282,235,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 154, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,267,273,242,256,252,287,236,267,287,242,225],
[234,0,225,191,231,218,231,251,251,255,214,198],
[228,276,0,196,216,250,268,269,249,261,233,220],
[259,310,305,0,231,284,278,274,302,267,272,275],
[245,270,285,270,0,283,260,276,274,264,260,236],
[249,283,251,217,218,0,244,264,253,254,254,240],
[214,270,233,223,241,257,0,232,240,279,197,202],
[265,250,232,227,225,237,269,0,253,265,243,204],
[234,250,252,199,227,248,261,248,0,272,235,206],
[214,246,240,234,237,247,222,236,229,0,208,218],
[259,287,268,229,241,247,304,258,266,293,0,238],
[276,303,281,226,265,261,299,297,295,283,263,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 155, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,278,250,296,254,278,258,260,258,244,262,248],
[223,0,238,253,222,237,241,181,252,218,236,217],
[251,263,0,263,217,259,246,171,248,213,253,239],
[205,248,238,0,229,231,248,214,217,190,223,244],
[247,279,284,272,0,288,299,187,249,218,262,238],
[223,264,242,270,213,0,257,202,257,212,201,255],
[243,260,255,253,202,244,0,183,264,215,208,198],
[241,320,330,287,314,299,318,0,273,302,293,324],
[243,249,253,284,252,244,237,228,0,228,246,265],
[257,283,288,311,283,289,286,199,273,0,290,262],
[239,265,248,278,239,300,293,208,255,211,0,275],
[253,284,262,257,263,246,303,177,236,239,226,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 156, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,254,262,242,244,242,264,245,261,238,246,249],
[247,0,263,254,250,255,266,264,260,241,273,241],
[239,238,0,236,222,235,250,241,255,228,253,234],
[259,247,265,0,235,259,263,251,258,253,265,260],
[257,251,279,266,0,247,273,262,257,251,270,250],
[259,246,266,242,254,0,255,257,268,244,264,254],
[237,235,251,238,228,246,0,232,242,228,265,241],
[256,237,260,250,239,244,269,0,253,247,261,248],
[240,241,246,243,244,233,259,248,0,229,250,233],
[263,260,273,248,250,257,273,254,272,0,250,252],
[255,228,248,236,231,237,236,240,251,251,0,229],
[252,260,267,241,251,247,260,253,268,249,272,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 157, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,281,247,303,292,223,290,319,291,252,276,289],
[220,0,246,233,243,235,268,263,263,252,260,267],
[254,255,0,260,246,237,288,299,240,248,244,270],
[198,268,241,0,269,220,253,291,261,252,227,223],
[209,258,255,232,0,215,288,296,255,244,265,248],
[278,266,264,281,286,0,322,318,249,253,309,257],
[211,233,213,248,213,179,0,278,227,189,220,214],
[182,238,202,210,205,183,223,0,213,227,227,188],
[210,238,261,240,246,252,274,288,0,251,272,256],
[249,249,253,249,257,248,312,274,250,0,265,255],
[225,241,257,274,236,192,281,274,229,236,0,243],
[212,234,231,278,253,244,287,313,245,246,258,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 158, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,233,252,293,302,227,234,257,282,260,196,319],
[268,0,272,295,328,240,288,286,277,323,251,305],
[249,229,0,250,237,207,228,228,251,240,214,277],
[208,206,251,0,282,208,200,231,250,251,193,234],
[199,173,264,219,0,192,206,210,239,238,215,248],
[274,261,294,293,309,0,229,259,323,278,233,278],
[267,213,273,301,295,272,0,240,245,264,197,242],
[244,215,273,270,291,242,261,0,244,242,225,291],
[219,224,250,251,262,178,256,257,0,254,222,274],
[241,178,261,250,263,223,237,259,247,0,248,277],
[305,250,287,308,286,268,304,276,279,253,0,277],
[182,196,224,267,253,223,259,210,227,224,224,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 159, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,210,230,257,250,187,391,268,214,215,302,277],
[291,0,202,236,214,282,390,313,235,186,285,249],
[271,299,0,299,202,305,314,242,212,258,339,307],
[244,265,202,0,217,281,418,303,253,275,273,298],
[251,287,299,284,0,369,372,295,358,206,332,280],
[314,219,196,220,132,0,354,281,241,221,257,260],
[110,111,187,83,129,147,0,185,150,118,147,113],
[233,188,259,198,206,220,316,0,298,196,286,287],
[287,266,289,248,143,260,351,203,0,192,287,191],
[286,315,243,226,295,280,383,305,309,0,315,334],
[199,216,162,228,169,244,354,215,214,186,0,265],
[224,252,194,203,221,241,388,214,310,167,236,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 160, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,247,239,236,258,259,258,254,261,248,255,245],
[254,0,240,241,241,248,243,250,254,259,251,236],
[262,261,0,239,269,263,244,249,282,257,250,240],
[265,260,262,0,266,260,260,257,263,246,259,241],
[243,260,232,235,0,259,247,266,246,245,247,247],
[242,253,238,241,242,0,236,240,252,273,262,242],
[243,258,257,241,254,265,0,251,252,247,257,240],
[247,251,252,244,235,261,250,0,257,242,264,255],
[240,247,219,238,255,249,249,244,0,246,251,228],
[253,242,244,255,256,228,254,259,255,0,239,244],
[246,250,251,242,254,239,244,237,250,262,0,241],
[256,265,261,260,254,259,261,246,273,257,260,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 161, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,253,232,263,238,248,230,237,264,245,234,277],
[248,0,249,244,248,252,240,247,265,248,240,260],
[269,252,0,266,248,243,233,243,284,266,260,254],
[238,257,235,0,268,248,228,237,253,256,242,250],
[263,253,253,233,0,248,254,256,253,254,240,262],
[253,249,258,253,253,0,244,243,252,266,248,262],
[271,261,268,273,247,257,0,253,287,268,248,264],
[264,254,258,264,245,258,248,0,256,251,260,266],
[237,236,217,248,248,249,214,245,0,259,234,239],
[256,253,235,245,247,235,233,250,242,0,250,251],
[267,261,241,259,261,253,253,241,267,251,0,237],
[224,241,247,251,239,239,237,235,262,250,264,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 162, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,261,230,222,227,231,244,261,227,247,235,243],
[240,0,213,231,239,222,225,244,227,246,233,234],
[271,288,0,238,277,275,250,272,248,276,254,264],
[279,270,263,0,247,255,248,273,269,271,256,271],
[274,262,224,254,0,252,226,244,261,266,260,264],
[270,279,226,246,249,0,251,272,264,256,267,272],
[257,276,251,253,275,250,0,278,254,260,265,264],
[240,257,229,228,257,229,223,0,240,272,243,255],
[274,274,253,232,240,237,247,261,0,263,251,257],
[254,255,225,230,235,245,241,229,238,0,238,255],
[266,268,247,245,241,234,236,258,250,263,0,277],
[258,267,237,230,237,229,237,246,244,246,224,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 163, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,242,261,218,245,242,270,224,241,219,258,246],
[259,0,264,242,240,269,259,275,258,264,245,265],
[240,237,0,224,233,262,254,252,257,258,252,259],
[283,259,277,0,248,259,287,246,265,260,245,289],
[256,261,268,253,0,246,284,252,262,261,269,264],
[259,232,239,242,255,0,256,255,245,258,235,227],
[231,242,247,214,217,245,0,251,219,252,253,247],
[277,226,249,255,249,246,250,0,257,265,261,254],
[260,243,244,236,239,256,282,244,0,261,245,252],
[282,237,243,241,240,243,249,236,240,0,257,261],
[243,256,249,256,232,266,248,240,256,244,0,255],
[255,236,242,212,237,274,254,247,249,240,246,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 164, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,221,255,246,236,230,246,282,276,225,210,270],
[280,0,287,290,265,268,250,267,273,283,248,307],
[246,214,0,299,261,304,253,272,256,286,229,248],
[255,211,202,0,261,222,164,250,272,263,234,241],
[265,236,240,240,0,271,191,241,271,272,204,249],
[271,233,197,279,230,0,198,227,275,207,206,236],
[255,251,248,337,310,303,0,269,275,253,263,310],
[219,234,229,251,260,274,232,0,278,270,224,242],
[225,228,245,229,230,226,226,223,0,203,180,212],
[276,218,215,238,229,294,248,231,298,0,234,272],
[291,253,272,267,297,295,238,277,321,267,0,277],
[231,194,253,260,252,265,191,259,289,229,224,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 165, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,227,215,221,247,220,242,259,243,230,236,232],
[274,0,234,259,260,228,261,265,263,229,234,276],
[286,267,0,244,266,255,268,262,262,235,244,271],
[280,242,257,0,258,249,263,249,275,256,239,246],
[254,241,235,243,0,230,249,235,258,245,221,251],
[281,273,246,252,271,0,269,259,265,241,244,275],
[259,240,233,238,252,232,0,278,252,240,238,222],
[242,236,239,252,266,242,223,0,274,246,229,259],
[258,238,239,226,243,236,249,227,0,233,212,255],
[271,272,266,245,256,260,261,255,268,0,254,289],
[265,267,257,262,280,257,263,272,289,247,0,265],
[269,225,230,255,250,226,279,242,246,212,236,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 166, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,231,318,252,298,292,298,296,282,232,256,294],
[270,0,325,291,258,276,343,291,313,332,257,248],
[183,176,0,218,250,227,259,292,311,231,205,259],
[249,210,283,0,206,295,316,263,268,252,233,233],
[203,243,251,295,0,291,370,259,299,253,275,217],
[209,225,274,206,210,0,292,251,274,284,200,196],
[203,158,242,185,131,209,0,229,243,223,153,132],
[205,210,209,238,242,250,272,0,223,249,245,223],
[219,188,190,233,202,227,258,278,0,216,191,183],
[269,169,270,249,248,217,278,252,285,0,173,255],
[245,244,296,268,226,301,348,256,310,328,0,252],
[207,253,242,268,284,305,369,278,318,246,249,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 167, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,227,274,240,225,288,297,270,225,301,283,292],
[274,0,283,273,284,293,310,238,251,321,312,256],
[227,218,0,260,261,248,260,226,224,260,249,271],
[261,228,241,0,234,286,310,252,231,282,279,276],
[276,217,240,267,0,238,264,297,230,293,253,303],
[213,208,253,215,263,0,256,222,212,264,234,268],
[204,191,241,191,237,245,0,229,204,272,208,233],
[231,263,275,249,204,279,272,0,248,260,232,273],
[276,250,277,270,271,289,297,253,0,314,253,274],
[200,180,241,219,208,237,229,241,187,0,215,221],
[218,189,252,222,248,267,293,269,248,286,0,268],
[209,245,230,225,198,233,268,228,227,280,233,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 168, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,274,269,244,264,243,265,267,244,239,252,256],
[227,0,250,252,261,222,245,241,230,244,244,240],
[232,251,0,231,248,238,244,255,221,225,209,234],
[257,249,270,0,253,249,254,264,243,244,249,255],
[237,240,253,248,0,250,242,266,223,238,220,229],
[258,279,263,252,251,0,273,261,249,240,245,237],
[236,256,257,247,259,228,0,239,231,241,228,241],
[234,260,246,237,235,240,262,0,228,229,226,245],
[257,271,280,258,278,252,270,273,0,252,254,247],
[262,257,276,257,263,261,260,272,249,0,259,266],
[249,257,292,252,281,256,273,275,247,242,0,260],
[245,261,267,246,272,264,260,256,254,235,241,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 169, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,231,234,254,255,254,246,232,242,258,252,274],
[270,0,260,275,256,255,267,266,247,260,256,261],
[267,241,0,240,261,253,248,245,246,251,261,261],
[247,226,261,0,241,264,249,220,236,247,239,253],
[246,245,240,260,0,245,263,246,262,257,245,278],
[247,246,248,237,256,0,246,246,237,243,250,260],
[255,234,253,252,238,255,0,227,253,241,238,262],
[269,235,256,281,255,255,274,0,252,280,273,274],
[259,254,255,265,239,264,248,249,0,250,255,278],
[243,241,250,254,244,258,260,221,251,0,241,271],
[249,245,240,262,256,251,263,228,246,260,0,262],
[227,240,240,248,223,241,239,227,223,230,239,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 170, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,268,263,218,257,274,247,262,273,247,270,242],
[233,0,235,259,228,244,229,237,248,234,256,253],
[238,266,0,230,241,248,238,238,274,234,250,248],
[283,242,271,0,276,277,264,274,264,269,283,268],
[244,273,260,225,0,238,254,239,241,235,267,276],
[227,257,253,224,263,0,237,242,231,236,269,243],
[254,272,263,237,247,264,0,274,277,247,270,267],
[239,264,263,227,262,259,227,0,238,243,262,265],
[228,253,227,237,260,270,224,263,0,251,260,254],
[254,267,267,232,266,265,254,258,250,0,277,262],
[231,245,251,218,234,232,231,239,241,224,0,222],
[259,248,253,233,225,258,234,236,247,239,279,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 171, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,256,245,255,256,230,254,217,258,253,236,246],
[245,0,249,263,253,243,233,219,256,264,237,249],
[256,252,0,242,276,252,258,236,267,255,249,260],
[246,238,259,0,254,248,265,214,236,254,239,222],
[245,248,225,247,0,229,239,224,262,249,244,247],
[271,258,249,253,272,0,270,233,270,284,268,264],
[247,268,243,236,262,231,0,224,247,253,242,255],
[284,282,265,287,277,268,277,0,271,289,267,246],
[243,245,234,265,239,231,254,230,0,255,236,237],
[248,237,246,247,252,217,248,212,246,0,240,251],
[265,264,252,262,257,233,259,234,265,261,0,268],
[255,252,241,279,254,237,246,255,264,250,233,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 172, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,266,283,243,256,255,254,253,262,283,249,232],
[235,0,243,222,245,272,230,240,251,324,263,226],
[218,258,0,228,227,219,209,234,262,252,228,186],
[258,279,273,0,262,271,206,259,290,298,298,291],
[245,256,274,239,0,239,210,247,284,271,237,196],
[246,229,282,230,262,0,195,189,247,261,259,221],
[247,271,292,295,291,306,0,290,225,304,284,240],
[248,261,267,242,254,312,211,0,303,285,251,230],
[239,250,239,211,217,254,276,198,0,267,230,227],
[218,177,249,203,230,240,197,216,234,0,234,210],
[252,238,273,203,264,242,217,250,271,267,0,246],
[269,275,315,210,305,280,261,271,274,291,255,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 173, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,181,182,192,249,236,186,189,238,258,233,210],
[320,0,283,277,321,330,236,307,302,256,275,245],
[319,218,0,213,267,281,236,282,318,245,283,237],
[309,224,288,0,351,266,266,365,305,216,301,309],
[252,180,234,150,0,219,154,271,285,209,221,222],
[265,171,220,235,282,0,227,294,272,211,267,263],
[315,265,265,235,347,274,0,307,310,298,321,280],
[312,194,219,136,230,207,194,0,246,195,269,265],
[263,199,183,196,216,229,191,255,0,176,185,191],
[243,245,256,285,292,290,203,306,325,0,228,234],
[268,226,218,200,280,234,180,232,316,273,0,234],
[291,256,264,192,279,238,221,236,310,267,267,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 174, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,271,236,234,261,239,231,235,247,233,235,250],
[230,0,242,233,246,254,232,238,246,238,234,236],
[265,259,0,249,247,247,240,229,254,230,232,238],
[267,268,252,0,248,245,257,254,259,253,255,261],
[240,255,254,253,0,240,237,252,251,234,237,254],
[262,247,254,256,261,0,252,276,253,245,255,265],
[270,269,261,244,264,249,0,267,259,259,244,263],
[266,263,272,247,249,225,234,0,240,246,233,245],
[254,255,247,242,250,248,242,261,0,242,232,240],
[268,263,271,248,267,256,242,255,259,0,240,250],
[266,267,269,246,264,246,257,268,269,261,0,247],
[251,265,263,240,247,236,238,256,261,251,254,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 175, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,225,254,250,234,246,247,248,237,228,246,256],
[276,0,262,266,249,239,255,256,253,250,263,277],
[247,239,0,249,252,246,255,263,246,249,228,259],
[251,235,252,0,224,260,269,251,239,233,238,266],
[267,252,249,277,0,264,253,249,262,248,263,264],
[255,262,255,241,237,0,254,248,259,252,258,296],
[254,246,246,232,248,247,0,260,246,250,234,245],
[253,245,238,250,252,253,241,0,275,247,239,263],
[264,248,255,262,239,242,255,226,0,230,224,255],
[273,251,252,268,253,249,251,254,271,0,253,268],
[255,238,273,263,238,243,267,262,277,248,0,271],
[245,224,242,235,237,205,256,238,246,233,230,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 176, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,256,264,235,248,256,251,264,273,292,272,260],
[245,0,230,235,232,236,250,253,285,259,253,244],
[237,271,0,252,244,259,255,265,261,274,259,255],
[266,266,249,0,252,261,266,264,256,292,249,262],
[253,269,257,249,0,266,238,255,264,280,249,263],
[245,265,242,240,235,0,232,264,257,275,264,255],
[250,251,246,235,263,269,0,257,267,274,269,288],
[237,248,236,237,246,237,244,0,256,275,261,246],
[228,216,240,245,237,244,234,245,0,257,265,270],
[209,242,227,209,221,226,227,226,244,0,257,231],
[229,248,242,252,252,237,232,240,236,244,0,247],
[241,257,246,239,238,246,213,255,231,270,254,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 177, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,253,231,265,271,272,275,270,274,275,246,282],
[248,0,244,269,295,272,254,254,252,272,284,272],
[270,257,0,254,284,288,266,252,235,272,270,274],
[236,232,247,0,249,247,250,252,232,242,246,246],
[230,206,217,252,0,265,241,250,238,248,245,260],
[229,229,213,254,236,0,234,244,252,252,226,259],
[226,247,235,251,260,267,0,238,238,251,248,256],
[231,247,249,249,251,257,263,0,258,265,254,262],
[227,249,266,269,263,249,263,243,0,252,248,268],
[226,229,229,259,253,249,250,236,249,0,229,252],
[255,217,231,255,256,275,253,247,253,272,0,262],
[219,229,227,255,241,242,245,239,233,249,239,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 178, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,231,241,224,235,231,237,257,230,227,239,226],
[270,0,273,242,269,243,253,261,253,251,269,246],
[260,228,0,235,241,245,237,255,233,240,254,231],
[277,259,266,0,249,245,238,267,265,242,258,242],
[266,232,260,252,0,244,259,259,248,239,264,250],
[270,258,256,256,257,0,255,268,262,243,259,234],
[264,248,264,263,242,246,0,262,263,254,253,235],
[244,240,246,234,242,233,239,0,242,234,234,236],
[271,248,268,236,253,239,238,259,0,238,276,256],
[274,250,261,259,262,258,247,267,263,0,268,252],
[262,232,247,243,237,242,248,267,225,233,0,231],
[275,255,270,259,251,267,266,265,245,249,270,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 179, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,243,256,243,261,275,267,277,286,279,270,252],
[258,0,263,242,266,239,240,285,306,244,280,249],
[245,238,0,240,256,236,248,290,268,238,264,231],
[258,259,261,0,253,269,236,268,305,259,292,220],
[240,235,245,248,0,236,251,270,279,266,253,249],
[226,262,265,232,265,0,262,296,261,236,296,244],
[234,261,253,265,250,239,0,293,294,241,269,244],
[224,216,211,233,231,205,208,0,236,208,241,203],
[215,195,233,196,222,240,207,265,0,211,271,208],
[222,257,263,242,235,265,260,293,290,0,288,206],
[231,221,237,209,248,205,232,260,230,213,0,236],
[249,252,270,281,252,257,257,298,293,295,265,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 180, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,264,244,279,249,254,247,262,257,252,274,249],
[237,0,229,231,240,245,254,261,233,218,259,234],
[257,272,0,268,243,274,260,267,249,249,292,264],
[222,270,233,0,217,233,240,240,231,220,259,232],
[252,261,258,284,0,262,267,286,241,239,276,233],
[247,256,227,268,239,0,259,250,222,225,262,232],
[254,247,241,261,234,242,0,263,206,217,249,245],
[239,240,234,261,215,251,238,0,194,225,248,231],
[244,268,252,270,260,279,295,307,0,262,283,263],
[249,283,252,281,262,276,284,276,239,0,276,270],
[227,242,209,242,225,239,252,253,218,225,0,223],
[252,267,237,269,268,269,256,270,238,231,278,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 181, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,196,326,256,236,276,296,240,262,250,254,280],
[305,0,290,257,252,254,305,228,255,258,284,282],
[175,211,0,216,245,243,304,220,266,193,238,271],
[245,244,285,0,214,276,324,221,230,249,256,306],
[265,249,256,287,0,282,267,229,280,267,283,271],
[225,247,258,225,219,0,306,190,259,213,264,274],
[205,196,197,177,234,195,0,182,196,199,231,288],
[261,273,281,280,272,311,319,0,276,250,260,302],
[239,246,235,271,221,242,305,225,0,232,254,258],
[251,243,308,252,234,288,302,251,269,0,258,272],
[247,217,263,245,218,237,270,241,247,243,0,265],
[221,219,230,195,230,227,213,199,243,229,236,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 182, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,241,250,241,249,234,243,241,253,251,257,260],
[260,0,242,245,266,239,257,252,257,246,246,266],
[251,259,0,258,271,244,236,254,267,266,266,273],
[260,256,243,0,274,257,245,254,259,257,245,264],
[252,235,230,227,0,228,228,253,240,255,244,248],
[267,262,257,244,273,0,265,273,271,264,268,264],
[258,244,265,256,273,236,0,252,266,264,251,248],
[260,249,247,247,248,228,249,0,252,258,253,253],
[248,244,234,242,261,230,235,249,0,257,250,249],
[250,255,235,244,246,237,237,243,244,0,258,256],
[244,255,235,256,257,233,250,248,251,243,0,241],
[241,235,228,237,253,237,253,248,252,245,260,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 183, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,314,263,300,270,247,281,313,214,298,299,288],
[187,0,169,202,226,205,238,275,205,262,255,208],
[238,332,0,284,330,292,242,292,231,288,285,271],
[201,299,217,0,294,213,269,313,230,297,276,263],
[231,275,171,207,0,201,249,243,230,250,254,251],
[254,296,209,288,300,0,245,254,271,245,293,275],
[220,263,259,232,252,256,0,338,246,280,314,295],
[188,226,209,188,258,247,163,0,154,238,270,234],
[287,296,270,271,271,230,255,347,0,288,323,301],
[203,239,213,204,251,256,221,263,213,0,280,253],
[202,246,216,225,247,208,187,231,178,221,0,298],
[213,293,230,238,250,226,206,267,200,248,203,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 184, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,252,237,240,245,258,245,237,240,240,245,251],
[249,0,257,243,246,247,253,240,234,244,241,250],
[264,244,0,264,262,252,252,262,253,252,246,250],
[261,258,237,0,254,248,253,251,256,240,243,251],
[256,255,239,247,0,241,255,242,239,251,225,274],
[243,254,249,253,260,0,248,266,267,256,247,266],
[256,248,249,248,246,253,0,243,251,248,251,258],
[264,261,239,250,259,235,258,0,250,262,251,264],
[261,267,248,245,262,234,250,251,0,251,248,275],
[261,257,249,261,250,245,253,239,250,0,249,265],
[256,260,255,258,276,254,250,250,253,252,0,245],
[250,251,251,250,227,235,243,237,226,236,256,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 185, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,252,218,253,248,254,246,232,258,249,268,268],
[249,0,224,236,257,255,228,242,243,256,270,232],
[283,277,0,260,266,270,265,235,264,227,273,256],
[248,265,241,0,235,247,233,234,238,248,236,232],
[253,244,235,266,0,257,258,248,243,262,257,252],
[247,246,231,254,244,0,234,219,223,243,258,237],
[255,273,236,268,243,267,0,259,247,257,260,220],
[269,259,266,267,253,282,242,0,266,254,280,238],
[243,258,237,263,258,278,254,235,0,242,276,230],
[252,245,274,253,239,258,244,247,259,0,289,220],
[233,231,228,265,244,243,241,221,225,212,0,209],
[233,269,245,269,249,264,281,263,271,281,292,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 186, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,245,259,240,243,251,253,246,273,248,267,239],
[256,0,264,261,275,254,268,259,275,255,259,247],
[242,237,0,241,252,231,253,224,245,238,235,241],
[261,240,260,0,257,241,257,239,253,249,248,251],
[258,226,249,244,0,253,250,237,253,241,241,240],
[250,247,270,260,248,0,252,261,246,240,254,231],
[248,233,248,244,251,249,0,238,255,228,238,240],
[255,242,277,262,264,240,263,0,266,247,268,241],
[228,226,256,248,248,255,246,235,0,246,264,257],
[253,246,263,252,260,261,273,254,255,0,263,265],
[234,242,266,253,260,247,263,233,237,238,0,249],
[262,254,260,250,261,270,261,260,244,236,252,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 187, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,138,264,269,158,252,162,130,165,154,130,182],
[363,0,283,309,188,321,279,169,348,300,291,341],
[237,218,0,264,248,334,278,171,292,173,236,281],
[232,192,237,0,115,228,203,183,206,228,261,202],
[343,313,253,386,0,347,269,266,322,248,337,264],
[249,180,167,273,154,0,184,201,248,199,142,244],
[339,222,223,298,232,317,0,177,256,240,307,218],
[371,332,330,318,235,300,324,0,243,267,268,252],
[336,153,209,295,179,253,245,258,0,177,253,265],
[347,201,328,273,253,302,261,234,324,0,315,220],
[371,210,265,240,164,359,194,233,248,186,0,254],
[319,160,220,299,237,257,283,249,236,281,247,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 188, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,247,294,275,271,252,286,271,239,232,265,275],
[254,0,253,208,225,232,240,231,267,262,235,225],
[207,248,0,240,242,204,222,207,253,241,207,240],
[226,293,261,0,253,285,260,211,280,245,253,256],
[230,276,259,248,0,283,231,229,285,243,237,233],
[249,269,297,216,218,0,251,220,258,251,232,267],
[215,261,279,241,270,250,0,248,292,292,262,259],
[230,270,294,290,272,281,253,0,255,283,270,308],
[262,234,248,221,216,243,209,246,0,228,214,233],
[269,239,260,256,258,250,209,218,273,0,263,227],
[236,266,294,248,264,269,239,231,287,238,0,258],
[226,276,261,245,268,234,242,193,268,274,243,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 189, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,256,256,246,258,246,250,247,246,247,253,259],
[245,0,254,246,265,252,242,240,257,248,253,247],
[245,247,0,233,257,253,245,242,255,250,238,252],
[255,255,268,0,266,249,255,247,256,253,259,251],
[243,236,244,235,0,232,262,243,245,241,242,250],
[255,249,248,252,269,0,261,250,265,259,248,251],
[251,259,256,246,239,240,0,258,245,246,266,249],
[254,261,259,254,258,251,243,0,255,249,254,248],
[255,244,246,245,256,236,256,246,0,259,247,251],
[254,253,251,248,260,242,255,252,242,0,261,249],
[248,248,263,242,259,253,235,247,254,240,0,257],
[242,254,249,250,251,250,252,253,250,252,244,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 190, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,264,257,244,241,258,284,266,255,245,260,247],
[237,0,237,219,223,225,259,253,250,228,237,241],
[244,264,0,235,230,242,261,250,245,241,241,243],
[257,282,266,0,233,253,271,260,261,260,253,254],
[260,278,271,268,0,270,273,262,256,241,256,255],
[243,276,259,248,231,0,270,257,252,246,257,241],
[217,242,240,230,228,231,0,245,241,233,243,247],
[235,248,251,241,239,244,256,0,246,232,249,265],
[246,251,256,240,245,249,260,255,0,235,243,253],
[256,273,260,241,260,255,268,269,266,0,254,269],
[241,264,260,248,245,244,258,252,258,247,0,265],
[254,260,258,247,246,260,254,236,248,232,236,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 191, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,256,305,277,309,294,273,247,259,263,238,318],
[245,0,256,305,318,305,300,294,257,265,259,260],
[196,245,0,249,281,290,254,263,226,251,225,276],
[224,196,252,0,315,292,263,243,261,279,225,264],
[192,183,220,186,0,228,206,194,228,206,205,224],
[207,196,211,209,273,0,246,240,211,204,167,221],
[228,201,247,238,295,255,0,283,187,202,186,242],
[254,207,238,258,307,261,218,0,217,253,199,262],
[242,244,275,240,273,290,314,284,0,249,194,259],
[238,236,250,222,295,297,299,248,252,0,222,277],
[263,242,276,276,296,334,315,302,307,279,0,318],
[183,241,225,237,277,280,259,239,242,224,183,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 192, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,258,254,251,272,265,260,240,250,258,271,257],
[243,0,246,232,269,247,249,247,250,236,264,265],
[247,255,0,247,269,267,263,256,245,242,284,273],
[250,269,254,0,290,260,267,261,277,249,287,280],
[229,232,232,211,0,217,236,232,231,219,245,239],
[236,254,234,241,284,0,257,247,247,239,264,263],
[241,252,238,234,265,244,0,241,246,241,257,259],
[261,254,245,240,269,254,260,0,250,244,284,265],
[251,251,256,224,270,254,255,251,0,239,269,257],
[243,265,259,252,282,262,260,257,262,0,280,269],
[230,237,217,214,256,237,244,217,232,221,0,244],
[244,236,228,221,262,238,242,236,244,232,257,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 193, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,312,258,254,267,317,283,217,351,297,275,224],
[189,0,229,160,220,244,205,171,234,166,242,220],
[243,272,0,234,261,315,167,264,292,310,277,260],
[247,341,267,0,295,326,226,162,262,231,243,263],
[234,281,240,206,0,191,138,215,244,228,250,259],
[184,257,186,175,310,0,152,114,264,127,150,254],
[218,296,334,275,363,349,0,270,303,255,269,315],
[284,330,237,339,286,387,231,0,351,293,233,322],
[150,267,209,239,257,237,198,150,0,165,200,221],
[204,335,191,270,273,374,246,208,336,0,228,219],
[226,259,224,258,251,351,232,268,301,273,0,288],
[277,281,241,238,242,247,186,179,280,282,213,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 194, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,219,214,256,244,236,261,242,240,250,249,220],
[282,0,264,258,236,279,263,271,236,287,273,249],
[287,237,0,263,248,269,275,273,224,272,270,255],
[245,243,238,0,257,279,270,251,237,277,274,246],
[257,265,253,244,0,285,280,266,267,284,284,259],
[265,222,232,222,216,0,272,242,234,269,277,228],
[240,238,226,231,221,229,0,237,229,249,258,247],
[259,230,228,250,235,259,264,0,245,269,261,249],
[261,265,277,264,234,267,272,256,0,279,265,264],
[251,214,229,224,217,232,252,232,222,0,246,239],
[252,228,231,227,217,224,243,240,236,255,0,224],
[281,252,246,255,242,273,254,252,237,262,277,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 195, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,254,238,261,255,263,244,266,257,241,257,246],
[247,0,255,268,239,264,242,253,247,243,256,226],
[263,246,0,265,263,254,240,259,246,251,262,239],
[240,233,236,0,238,257,242,252,245,228,237,257],
[246,262,238,263,0,256,265,249,239,237,240,252],
[238,237,247,244,245,0,230,260,259,241,243,244],
[257,259,261,259,236,271,0,276,254,249,253,245],
[235,248,242,249,252,241,225,0,247,249,249,225],
[244,254,255,256,262,242,247,254,0,243,244,265],
[260,258,250,273,264,260,252,252,258,0,262,251],
[244,245,239,264,261,258,248,252,257,239,0,231],
[255,275,262,244,249,257,256,276,236,250,270,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 196, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,240,285,247,212,236,226,231,250,236,222,250],
[261,0,276,244,229,244,230,242,264,256,243,252],
[216,225,0,219,220,214,213,219,236,231,237,223],
[254,257,282,0,235,258,292,269,276,258,242,262],
[289,272,281,266,0,261,269,259,287,250,270,292],
[265,257,287,243,240,0,237,217,269,260,263,265],
[275,271,288,209,232,264,0,251,241,214,223,265],
[270,259,282,232,242,284,250,0,258,281,257,292],
[251,237,265,225,214,232,260,243,0,245,232,266],
[265,245,270,243,251,241,287,220,256,0,232,264],
[279,258,264,259,231,238,278,244,269,269,0,259],
[251,249,278,239,209,236,236,209,235,237,242,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 197, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,246,216,202,248,226,206,252,263,230,247,244],
[255,0,246,260,269,261,242,247,241,274,273,262],
[285,255,0,235,270,223,225,281,268,244,260,284],
[299,241,266,0,275,264,251,257,249,279,254,276],
[253,232,231,226,0,227,219,233,229,257,261,251],
[275,240,278,237,274,0,246,282,257,254,269,261],
[295,259,276,250,282,255,0,300,290,269,276,272],
[249,254,220,244,268,219,201,0,262,241,234,258],
[238,260,233,252,272,244,211,239,0,247,265,263],
[271,227,257,222,244,247,232,260,254,0,266,267],
[254,228,241,247,240,232,225,267,236,235,0,241],
[257,239,217,225,250,240,229,243,238,234,260,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 198, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,256,287,251,247,283,299,284,248,287,308,195],
[245,0,260,239,254,300,285,241,277,276,311,246],
[214,241,0,240,220,280,256,278,264,271,254,223],
[250,262,261,0,219,325,274,289,289,228,283,269],
[254,247,281,282,0,293,324,249,290,317,284,208],
[218,201,221,176,208,0,260,243,231,213,257,194],
[202,216,245,227,177,241,0,220,223,252,251,179],
[217,260,223,212,252,258,281,0,269,252,255,247],
[253,224,237,212,211,270,278,232,0,244,278,236],
[214,225,230,273,184,288,249,249,257,0,281,238],
[193,190,247,218,217,244,250,246,223,220,0,203],
[306,255,278,232,293,307,322,254,265,263,298,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 199, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,244,238,253,250,235,231,241,239,228,244,212],
[257,0,266,259,258,245,247,253,260,251,256,247],
[263,235,0,235,243,240,232,235,246,254,237,230],
[248,242,266,0,249,237,241,229,244,234,251,237],
[251,243,258,252,0,242,241,230,245,259,244,231],
[266,256,261,264,259,0,249,247,262,269,253,245],
[270,254,269,260,260,252,0,247,273,256,276,243],
[260,248,266,272,271,254,254,0,268,248,265,255],
[262,241,255,257,256,239,228,233,0,250,254,248],
[273,250,247,267,242,232,245,253,251,0,245,230],
[257,245,264,250,257,248,225,236,247,256,0,230],
[289,254,271,264,270,256,258,246,253,271,271,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 200, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

 
pd.DataFrame(results).to_csv("/Users/noeliarico/Desktop/folder-kemeny/2021EJOR/results/mebbd/mebbd_12_501.csv", index=False, header=False)
3ca527cdf02b1991f3a669941060813ee2beb079
<mask token>

<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
<mask token>
print(result[:7])
<mask token>
pd.DataFrame(results).to_csv(
    '/Users/noeliarico/Desktop/folder-kemeny/2021EJOR/results/mebbd/mebbd_12_501.csv'
    , index=False, header=False)

<mask token>
rep = 1
results = np.zeros(0).reshape(0, 7 + rep)
om = np.array([[0, 259, 278, 248, 255, 269, 234, 282, 266, 294, 272, 275],
    [242, 0, 252, 257, 217, 244, 226, 248, 239, 263, 240, 225], [223, 249, 
    0, 256, 228, 225, 242, 264, 268, 281, 263, 260], [253, 244, 245, 0, 243,
    231, 226, 267, 271, 274, 269, 284], [246, 284, 273, 258, 0, 242, 251, 
    274, 269, 269, 250, 240], [232, 257, 276, 270, 259, 0, 249, 262, 269, 
    286, 270, 254], [267, 275, 259, 275, 250, 252, 0, 302, 262, 282, 271, 
    266], [219, 253, 237, 234, 227, 239, 199, 0, 249, 278, 246, 241], [235,
    262, 233, 230, 232, 232, 239, 252, 0, 257, 260, 223], [207, 238, 220, 
    227, 232, 215, 219, 223, 244, 0, 222, 216], [229, 261, 238, 232, 251, 
    231, 230, 255, 241, 279, 0, 254], [226, 276, 241, 217, 261, 247, 235, 
    260, 278, 285, 247, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 1, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 259, 263, 250, 258, 235, 242, 245, 243, 272, 256, 244],
    [242, 0, 241, 232, 243, 234, 229, 248, 247, 247, 249, 249], [238, 260, 
    0, 233, 253, 249, 233, 238, 243, 254, 247, 241], [251, 269, 268, 0, 248,
    257, 239, 245, 259, 250, 266, 254], [243, 258, 248, 253, 0, 240, 246, 
    247, 243, 260, 259, 254], [266, 267, 252, 244, 261, 0, 255, 254, 250, 
    267, 255, 260], [259, 272, 268, 262, 255, 246, 0, 259, 260, 275, 266, 
    256], [256, 253, 263, 256, 254, 247, 242, 0, 241, 261, 254, 250], [258,
    254, 258, 242, 258, 251, 241, 260, 0, 268, 257, 252], [229, 254, 247, 
    251, 241, 234, 226, 240, 233, 0, 254, 243], [245, 252, 254, 235, 242, 
    246, 235, 247, 244, 247, 0, 248], [257, 252, 260, 247, 247, 241, 245, 
    251, 249, 258, 253, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 2, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 247, 229, 236, 228, 211, 241, 224, 225, 231, 224, 221],
    [254, 0, 237, 241, 251, 219, 246, 248, 235, 233, 229, 223], [272, 264, 
    0, 251, 252, 240, 269, 270, 245, 250, 232, 234], [265, 260, 250, 0, 240,
    242, 250, 272, 245, 238, 247, 236], [273, 250, 249, 261, 0, 234, 242, 
    248, 245, 237, 237, 245], [290, 282, 261, 259, 267, 0, 286, 259, 264, 
    247, 262, 247], [260, 255, 232, 251, 259, 215, 0, 248, 223, 235, 229, 
    238], [277, 253, 231, 229, 253, 242, 253, 0, 241, 242, 245, 239], [276,
    266, 256, 256, 256, 237, 278, 260, 0, 253, 238, 250], [270, 268, 251, 
    263, 264, 254, 266, 259, 248, 0, 249, 257], [277, 272, 269, 254, 264, 
    239, 272, 256, 263, 252, 0, 249], [280, 278, 267, 265, 256, 254, 263, 
    262, 251, 244, 252, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 3, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 266, 234, 275, 235, 284, 219, 265, 219, 263, 247, 246],
    [235, 0, 236, 283, 257, 299, 224, 274, 232, 245, 263, 263], [267, 265, 
    0, 291, 261, 313, 263, 268, 248, 277, 257, 269], [226, 218, 210, 0, 237,
    283, 215, 251, 216, 228, 256, 234], [266, 244, 240, 264, 0, 288, 244, 
    232, 250, 215, 256, 231], [217, 202, 188, 218, 213, 0, 198, 216, 221, 
    224, 194, 231], [282, 277, 238, 286, 257, 303, 0, 272, 259, 261, 252, 
    266], [236, 227, 233, 250, 269, 285, 229, 0, 202, 234, 235, 237], [282,
    269, 253, 285, 251, 280, 242, 299, 0, 275, 265, 259], [238, 256, 224, 
    273, 286, 277, 240, 267, 226, 0, 255, 238], [254, 238, 244, 245, 245, 
    307, 249, 266, 236, 246, 0, 256], [255, 238, 232, 267, 270, 270, 235, 
    264, 242, 263, 245, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 4, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 191, 219, 198, 169, 179, 190, 155, 217, 164, 245, 265],
    [310, 0, 227, 329, 266, 246, 261, 272, 287, 287, 261, 274], [282, 274, 
    0, 258, 268, 211, 186, 237, 261, 229, 178, 302], [303, 172, 243, 0, 209,
    264, 150, 185, 243, 192, 238, 270], [332, 235, 233, 292, 0, 250, 261, 
    295, 336, 213, 249, 294], [322, 255, 290, 237, 251, 0, 244, 294, 241, 
    251, 316, 261], [311, 240, 315, 351, 240, 257, 0, 244, 240, 303, 204, 
    350], [346, 229, 264, 316, 206, 207, 257, 0, 258, 282, 237, 310], [284,
    214, 240, 258, 165, 260, 261, 243, 0, 262, 200, 302], [337, 214, 272, 
    309, 288, 250, 198, 219, 239, 0, 220, 282], [256, 240, 323, 263, 252, 
    185, 297, 264, 301, 281, 0, 339], [236, 227, 199, 231, 207, 240, 151, 
    191, 199, 219, 162, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 5, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 275, 252, 277, 275, 281, 282, 239, 280, 255, 305, 329],
    [226, 0, 240, 288, 262, 229, 294, 193, 309, 244, 286, 290], [249, 261, 
    0, 267, 280, 260, 286, 205, 295, 203, 273, 277], [224, 213, 234, 0, 244,
    256, 232, 228, 248, 238, 263, 312], [226, 239, 221, 257, 0, 201, 256, 
    227, 248, 253, 285, 267], [220, 272, 241, 245, 300, 0, 287, 203, 258, 
    219, 283, 301], [219, 207, 215, 269, 245, 214, 0, 219, 312, 254, 287, 
    268], [262, 308, 296, 273, 274, 298, 282, 0, 337, 242, 311, 307], [221,
    192, 206, 253, 253, 243, 189, 164, 0, 179, 258, 306], [246, 257, 298, 
    263, 248, 282, 247, 259, 322, 0, 291, 274], [196, 215, 228, 238, 216, 
    218, 214, 190, 243, 210, 0, 239], [172, 211, 224, 189, 234, 200, 233, 
    194, 195, 227, 262, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 6, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 241, 223, 213, 255, 249, 259, 232, 254, 230, 241, 264],
    [260, 0, 241, 236, 263, 265, 272, 239, 279, 247, 263, 254], [278, 260, 
    0, 250, 276, 244, 304, 256, 266, 262, 267, 284], [288, 265, 251, 0, 267,
    255, 265, 249, 248, 244, 269, 268], [246, 238, 225, 234, 0, 253, 273, 
    252, 271, 244, 263, 266], [252, 236, 257, 246, 248, 0, 251, 251, 271, 
    238, 258, 270], [242, 229, 197, 236, 228, 250, 0, 214, 235, 236, 243, 
    264], [269, 262, 245, 252, 249, 250, 287, 0, 258, 246, 254, 270], [247,
    222, 235, 253, 230, 230, 266, 243, 0, 216, 232, 241], [271, 254, 239, 
    257, 257, 263, 265, 255, 285, 0, 290, 265], [260, 238, 234, 232, 238, 
    243, 258, 247, 269, 211, 0, 254], [237, 247, 217, 233, 235, 231, 237, 
    231, 260, 236, 247, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 7, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 234, 243, 240, 249, 237, 246, 246, 252, 250, 257, 255],
    [267, 0, 254, 267, 253, 248, 264, 258, 254, 263, 259, 256], [258, 247, 
    0, 251, 258, 263, 256, 251, 265, 254, 260, 265], [261, 234, 250, 0, 241,
    243, 264, 250, 247, 260, 249, 258], [252, 248, 243, 260, 0, 253, 253, 
    258, 243, 253, 246, 264], [264, 253, 238, 258, 248, 0, 266, 242, 263, 
    268, 240, 271], [255, 237, 245, 237, 248, 235, 0, 243, 233, 256, 242, 
    260], [255, 243, 250, 251, 243, 259, 258, 0, 249, 265, 264, 260], [249,
    247, 236, 254, 258, 238, 268, 252, 0, 257, 256, 263], [251, 238, 247, 
    241, 248, 233, 245, 236, 244, 0, 244, 258], [244, 242, 241, 252, 255, 
    261, 259, 237, 245, 257, 0, 259], [246, 245, 236, 243, 237, 230, 241, 
    241, 238, 243, 242, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 8, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 246, 259, 252, 252, 249, 259, 284, 265, 248, 278, 251],
    [255, 0, 259, 252, 249, 267, 262, 276, 279, 234, 271, 279], [242, 242, 
    0, 240, 254, 257, 255, 263, 264, 240, 246, 249], [249, 249, 261, 0, 241,
    279, 243, 267, 253, 261, 263, 257], [249, 252, 247, 260, 0, 255, 260, 
    270, 253, 262, 258, 268], [252, 234, 244, 222, 246, 0, 250, 258, 261, 
    240, 264, 258], [242, 239, 246, 258, 241, 251, 0, 265, 255, 253, 261, 
    269], [217, 225, 238, 234, 231, 243, 236, 0, 252, 234, 243, 247], [236,
    222, 237, 248, 248, 240, 246, 249, 0, 243, 236, 245], [253, 267, 261, 
    240, 239, 261, 248, 267, 258, 0, 240, 258], [223, 230, 255, 238, 243, 
    237, 240, 258, 265, 261, 0, 245], [250, 222, 252, 244, 233, 243, 232, 
    254, 256, 243, 256, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 9, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 251, 261, 223, 245, 237, 275, 220, 224, 243, 264, 242],
    [250, 0, 260, 222, 243, 243, 274, 215, 229, 242, 261, 273], [240, 241, 
    0, 231, 213, 225, 228, 252, 234, 239, 238, 258], [278, 279, 270, 0, 283,
    264, 295, 265, 246, 267, 271, 288], [256, 258, 288, 218, 0, 236, 261, 
    233, 216, 251, 267, 269], [264, 258, 276, 237, 265, 0, 275, 273, 253, 
    249, 262, 290], [226, 227, 273, 206, 240, 226, 0, 214, 240, 230, 245, 
    250], [281, 286, 249, 236, 268, 228, 287, 0, 276, 257, 245, 301], [277,
    272, 267, 255, 285, 248, 261, 225, 0, 271, 260, 280], [258, 259, 262, 
    234, 250, 252, 271, 244, 230, 0, 251, 302], [237, 240, 263, 230, 234, 
    239, 256, 256, 241, 250, 0, 266], [259, 228, 243, 213, 232, 211, 251, 
    200, 221, 199, 235, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 10, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 263, 241, 241, 215, 238, 216, 270, 205, 258, 258, 242],
    [238, 0, 245, 245, 239, 229, 232, 227, 215, 276, 229, 266], [260, 256, 
    0, 275, 273, 239, 220, 259, 233, 269, 248, 257], [260, 256, 226, 0, 249,
    235, 223, 253, 228, 256, 269, 302], [286, 262, 228, 252, 0, 235, 228, 
    264, 264, 270, 259, 277], [263, 272, 262, 266, 266, 0, 224, 256, 248, 
    265, 242, 264], [285, 269, 281, 278, 273, 277, 0, 275, 240, 266, 308, 
    318], [231, 274, 242, 248, 237, 245, 226, 0, 216, 279, 244, 253], [296,
    286, 268, 273, 237, 253, 261, 285, 0, 286, 258, 309], [243, 225, 232, 
    245, 231, 236, 235, 222, 215, 0, 262, 249], [243, 272, 253, 232, 242, 
    259, 193, 257, 243, 239, 0, 278], [259, 235, 244, 199, 224, 237, 183, 
    248, 192, 252, 223, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 11, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 227, 329, 294, 369, 243, 216, 235, 353, 255, 288, 277],
    [274, 0, 314, 328, 392, 297, 321, 230, 332, 353, 319, 280], [172, 187, 
    0, 216, 379, 238, 299, 171, 204, 228, 278, 241], [207, 173, 285, 0, 438,
    298, 365, 280, 234, 325, 313, 277], [132, 109, 122, 63, 0, 168, 199, 
    128, 168, 224, 227, 154], [258, 204, 263, 203, 333, 0, 301, 250, 291, 
    244, 326, 285], [285, 180, 202, 136, 302, 200, 0, 224, 216, 294, 237, 
    230], [266, 271, 330, 221, 373, 251, 277, 0, 300, 341, 283, 242], [148,
    169, 297, 267, 333, 210, 285, 201, 0, 211, 238, 189], [246, 148, 273, 
    176, 277, 257, 207, 160, 290, 0, 282, 220], [213, 182, 223, 188, 274, 
    175, 264, 218, 263, 219, 0, 208], [224, 221, 260, 224, 347, 216, 271, 
    259, 312, 281, 293, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 12, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 261, 248, 278, 247, 248, 246, 265, 258, 234, 235, 242],
    [240, 0, 253, 268, 258, 240, 252, 258, 271, 239, 252, 244], [253, 248, 
    0, 264, 273, 252, 246, 280, 265, 262, 250, 251], [223, 233, 237, 0, 251,
    250, 246, 255, 247, 232, 232, 244], [254, 243, 228, 250, 0, 242, 235, 
    261, 254, 243, 248, 245], [253, 261, 249, 251, 259, 0, 247, 257, 250, 
    244, 246, 244], [255, 249, 255, 255, 266, 254, 0, 269, 256, 248, 254, 
    235], [236, 243, 221, 246, 240, 244, 232, 0, 253, 228, 214, 233], [243,
    230, 236, 254, 247, 251, 245, 248, 0, 244, 239, 236], [267, 262, 239, 
    269, 258, 257, 253, 273, 257, 0, 251, 262], [266, 249, 251, 269, 253, 
    255, 247, 287, 262, 250, 0, 244], [259, 257, 250, 257, 256, 257, 266, 
    268, 265, 239, 257, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 13, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 243, 247, 249, 229, 244, 247, 245, 246, 231, 223, 272],
    [258, 0, 238, 235, 232, 243, 259, 231, 224, 236, 236, 257], [254, 263, 
    0, 259, 253, 258, 268, 267, 241, 267, 228, 278], [252, 266, 242, 0, 255,
    262, 264, 260, 248, 260, 258, 270], [272, 269, 248, 246, 0, 248, 270, 
    264, 259, 257, 239, 260], [257, 258, 243, 239, 253, 0, 252, 229, 244, 
    240, 223, 249], [254, 242, 233, 237, 231, 249, 0, 247, 245, 272, 253, 
    271], [256, 270, 234, 241, 237, 272, 254, 0, 244, 246, 245, 267], [255,
    277, 260, 253, 242, 257, 256, 257, 0, 247, 245, 257], [270, 265, 234, 
    241, 244, 261, 229, 255, 254, 0, 240, 250], [278, 265, 273, 243, 262, 
    278, 248, 256, 256, 261, 0, 268], [229, 244, 223, 231, 241, 252, 230, 
    234, 244, 251, 233, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 14, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 258, 251, 277, 239, 227, 263, 230, 231, 253, 266, 259],
    [243, 0, 258, 258, 238, 235, 240, 223, 245, 249, 247, 269], [250, 243, 
    0, 255, 247, 214, 238, 241, 259, 236, 249, 252], [224, 243, 246, 0, 227,
    241, 240, 202, 226, 228, 229, 242], [262, 263, 254, 274, 0, 253, 234, 
    232, 236, 238, 244, 271], [274, 266, 287, 260, 248, 0, 267, 221, 249, 
    260, 283, 284], [238, 261, 263, 261, 267, 234, 0, 248, 258, 251, 248, 
    275], [271, 278, 260, 299, 269, 280, 253, 0, 247, 270, 284, 279], [270,
    256, 242, 275, 265, 252, 243, 254, 0, 254, 283, 253], [248, 252, 265, 
    273, 263, 241, 250, 231, 247, 0, 270, 242], [235, 254, 252, 272, 257, 
    218, 253, 217, 218, 231, 0, 263], [242, 232, 249, 259, 230, 217, 226, 
    222, 248, 259, 238, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 15, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 301, 293, 246, 369, 267, 254, 241, 350, 231, 202, 252],
    [200, 0, 213, 189, 263, 260, 151, 155, 312, 186, 253, 273], [208, 288, 
    0, 243, 256, 274, 193, 255, 310, 225, 297, 313], [255, 312, 258, 0, 330,
    211, 199, 163, 306, 219, 228, 325], [132, 238, 245, 171, 0, 193, 184, 
    93, 254, 115, 161, 222], [234, 241, 227, 290, 308, 0, 189, 253, 277, 
    198, 205, 286], [247, 350, 308, 302, 317, 312, 0, 265, 348, 257, 244, 
    253], [260, 346, 246, 338, 408, 248, 236, 0, 403, 260, 296, 342], [151,
    189, 191, 195, 247, 224, 153, 98, 0, 122, 176, 151], [270, 315, 276, 
    282, 386, 303, 244, 241, 379, 0, 214, 293], [299, 248, 204, 273, 340, 
    296, 257, 205, 325, 287, 0, 199], [249, 228, 188, 176, 279, 215, 248, 
    159, 350, 208, 302, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 16, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 220, 223, 218, 230, 220, 235, 230, 246, 235, 206, 233],
    [281, 0, 220, 210, 225, 243, 211, 250, 224, 230, 188, 225], [278, 281, 
    0, 223, 267, 251, 250, 271, 268, 248, 259, 261], [283, 291, 278, 0, 262,
    291, 271, 277, 270, 257, 246, 290], [271, 276, 234, 239, 0, 280, 230, 
    235, 261, 250, 228, 267], [281, 258, 250, 210, 221, 0, 231, 258, 247, 
    232, 252, 258], [266, 290, 251, 230, 271, 270, 0, 279, 280, 258, 237, 
    273], [271, 251, 230, 224, 266, 243, 222, 0, 255, 228, 183, 248], [255,
    277, 233, 231, 240, 254, 221, 246, 0, 233, 184, 262], [266, 271, 253, 
    244, 251, 269, 243, 273, 268, 0, 254, 254], [295, 313, 242, 255, 273, 
    249, 264, 318, 317, 247, 0, 283], [268, 276, 240, 211, 234, 243, 228, 
    253, 239, 247, 218, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 17, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 233, 269, 273, 209, 223, 270, 272, 272, 263, 229, 237],
    [268, 0, 237, 246, 245, 223, 278, 266, 258, 255, 230, 202], [232, 264, 
    0, 298, 242, 269, 321, 224, 216, 214, 258, 199], [228, 255, 203, 0, 221,
    209, 301, 202, 242, 123, 205, 255], [292, 256, 259, 280, 0, 237, 265, 
    277, 291, 298, 210, 230], [278, 278, 232, 292, 264, 0, 234, 219, 301, 
    246, 280, 236], [231, 223, 180, 200, 236, 267, 0, 213, 225, 237, 231, 
    220], [229, 235, 277, 299, 224, 282, 288, 0, 267, 269, 197, 278], [229,
    243, 285, 259, 210, 200, 276, 234, 0, 209, 189, 249], [238, 246, 287, 
    378, 203, 255, 264, 232, 292, 0, 230, 247], [272, 271, 243, 296, 291, 
    221, 270, 304, 312, 271, 0, 264], [264, 299, 302, 246, 271, 265, 281, 
    223, 252, 254, 237, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 18, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 219, 259, 296, 276, 232, 249, 277, 268, 257, 277, 314],
    [282, 0, 203, 306, 290, 261, 283, 306, 279, 241, 288, 297], [242, 298, 
    0, 280, 247, 232, 291, 303, 216, 228, 277, 265], [205, 195, 221, 0, 225,
    170, 205, 233, 193, 197, 196, 217], [225, 211, 254, 276, 0, 226, 250, 
    254, 254, 207, 225, 264], [269, 240, 269, 331, 275, 0, 284, 298, 266, 
    248, 298, 277], [252, 218, 210, 296, 251, 217, 0, 257, 256, 198, 258, 
    249], [224, 195, 198, 268, 247, 203, 244, 0, 213, 190, 237, 219], [233,
    222, 285, 308, 247, 235, 245, 288, 0, 183, 267, 275], [244, 260, 273, 
    304, 294, 253, 303, 311, 318, 0, 278, 288], [224, 213, 224, 305, 276, 
    203, 243, 264, 234, 223, 0, 236], [187, 204, 236, 284, 237, 224, 252, 
    282, 226, 213, 265, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 19, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 232, 248, 245, 247, 231, 244, 236, 259, 223, 262, 267],
    [269, 0, 257, 249, 256, 267, 272, 268, 259, 260, 265, 279], [253, 244, 
    0, 261, 257, 262, 257, 246, 267, 252, 264, 274], [256, 252, 240, 0, 248,
    271, 262, 265, 262, 239, 249, 256], [254, 245, 244, 253, 0, 260, 263, 
    240, 262, 240, 239, 254], [270, 234, 239, 230, 241, 0, 251, 239, 260, 
    250, 241, 258], [257, 229, 244, 239, 238, 250, 0, 244, 255, 242, 249, 
    245], [265, 233, 255, 236, 261, 262, 257, 0, 263, 238, 245, 260], [242,
    242, 234, 239, 239, 241, 246, 238, 0, 236, 246, 251], [278, 241, 249, 
    262, 261, 251, 259, 263, 265, 0, 261, 266], [239, 236, 237, 252, 262, 
    260, 252, 256, 255, 240, 0, 245], [234, 222, 227, 245, 247, 243, 256, 
    241, 250, 235, 256, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 20, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 245, 259, 252, 251, 242, 258, 258, 253, 254, 244, 240],
    [256, 0, 247, 229, 244, 232, 238, 242, 263, 246, 244, 238], [242, 254, 
    0, 241, 262, 244, 245, 240, 253, 246, 245, 244], [249, 272, 260, 0, 258,
    248, 243, 250, 258, 263, 270, 242], [250, 257, 239, 243, 0, 234, 255, 
    251, 257, 248, 254, 239], [259, 269, 257, 253, 267, 0, 261, 243, 252, 
    262, 265, 234], [243, 263, 256, 258, 246, 240, 0, 260, 258, 255, 252, 
    251], [243, 259, 261, 251, 250, 258, 241, 0, 256, 245, 257, 241], [248,
    238, 248, 243, 244, 249, 243, 245, 0, 263, 269, 232], [247, 255, 255, 
    238, 253, 239, 246, 256, 238, 0, 246, 241], [257, 257, 256, 231, 247, 
    236, 249, 244, 232, 255, 0, 240], [261, 263, 257, 259, 262, 267, 250, 
    260, 269, 260, 261, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 21, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 244, 236, 236, 229, 250, 236, 241, 253, 237, 233, 236],
    [257, 0, 240, 241, 246, 253, 243, 244, 258, 243, 264, 254], [265, 261, 
    0, 248, 258, 254, 240, 249, 260, 252, 257, 256], [265, 260, 253, 0, 253,
    253, 244, 253, 264, 253, 250, 257], [272, 255, 243, 248, 0, 263, 267, 
    262, 256, 259, 258, 261], [251, 248, 247, 248, 238, 0, 236, 249, 262, 
    254, 248, 244], [265, 258, 261, 257, 234, 265, 0, 269, 264, 251, 268, 
    255], [260, 257, 252, 248, 239, 252, 232, 0, 255, 247, 250, 242], [248,
    243, 241, 237, 245, 239, 237, 246, 0, 252, 238, 238], [264, 258, 249, 
    248, 242, 247, 250, 254, 249, 0, 260, 258], [268, 237, 244, 251, 243, 
    253, 233, 251, 263, 241, 0, 249], [265, 247, 245, 244, 240, 257, 246, 
    259, 263, 243, 252, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 22, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 264, 246, 281, 272, 246, 280, 278, 256, 277, 282, 257],
    [237, 0, 239, 264, 249, 233, 253, 256, 277, 263, 256, 245], [255, 262, 
    0, 258, 252, 236, 268, 276, 254, 289, 268, 257], [220, 237, 243, 0, 254,
    217, 255, 256, 231, 271, 267, 232], [229, 252, 249, 247, 0, 255, 273, 
    289, 273, 279, 276, 268], [255, 268, 265, 284, 246, 0, 289, 273, 281, 
    272, 277, 284], [221, 248, 233, 246, 228, 212, 0, 247, 224, 265, 250, 
    217], [223, 245, 225, 245, 212, 228, 254, 0, 237, 232, 232, 222], [245,
    224, 247, 270, 228, 220, 277, 264, 0, 266, 251, 227], [224, 238, 212, 
    230, 222, 229, 236, 269, 235, 0, 250, 235], [219, 245, 233, 234, 225, 
    224, 251, 269, 250, 251, 0, 205], [244, 256, 244, 269, 233, 217, 284, 
    279, 274, 266, 296, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 23, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 232, 254, 274, 245, 255, 289, 269, 270, 232, 255, 258],
    [269, 0, 275, 264, 248, 245, 255, 276, 251, 254, 254, 249], [247, 226, 
    0, 242, 230, 267, 281, 251, 252, 242, 240, 258], [227, 237, 259, 0, 236,
    263, 272, 242, 240, 219, 239, 244], [256, 253, 271, 265, 0, 264, 283, 
    256, 273, 232, 271, 256], [246, 256, 234, 238, 237, 0, 255, 240, 218, 
    241, 259, 248], [212, 246, 220, 229, 218, 246, 0, 228, 228, 221, 222, 
    239], [232, 225, 250, 259, 245, 261, 273, 0, 248, 247, 275, 258], [231,
    250, 249, 261, 228, 283, 273, 253, 0, 242, 274, 245], [269, 247, 259, 
    282, 269, 260, 280, 254, 259, 0, 250, 270], [246, 247, 261, 262, 230, 
    242, 279, 226, 227, 251, 0, 257], [243, 252, 243, 257, 245, 253, 262, 
    243, 256, 231, 244, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 24, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 217, 220, 223, 203, 228, 205, 244, 238, 206, 217, 223],
    [284, 0, 215, 211, 237, 234, 246, 269, 250, 224, 251, 238], [281, 286, 
    0, 234, 254, 253, 215, 255, 230, 225, 276, 263], [278, 290, 267, 0, 258,
    255, 246, 310, 222, 222, 245, 265], [298, 264, 247, 243, 0, 253, 257, 
    268, 231, 239, 240, 253], [273, 267, 248, 246, 248, 0, 224, 266, 233, 
    220, 265, 257], [296, 255, 286, 255, 244, 277, 0, 280, 257, 261, 257, 
    252], [257, 232, 246, 191, 233, 235, 221, 0, 229, 216, 229, 248], [263,
    251, 271, 279, 270, 268, 244, 272, 0, 218, 253, 272], [295, 277, 276, 
    279, 262, 281, 240, 285, 283, 0, 266, 263], [284, 250, 225, 256, 261, 
    236, 244, 272, 248, 235, 0, 256], [278, 263, 238, 236, 248, 244, 249, 
    253, 229, 238, 245, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 25, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 242, 252, 205, 221, 228, 194, 243, 247, 209, 242, 210],
    [259, 0, 255, 237, 217, 244, 221, 240, 264, 245, 273, 233], [249, 246, 
    0, 218, 207, 236, 233, 247, 232, 219, 240, 235], [296, 264, 283, 0, 270,
    272, 269, 296, 301, 273, 258, 244], [280, 284, 294, 231, 0, 254, 247, 
    289, 255, 239, 229, 262], [273, 257, 265, 229, 247, 0, 226, 238, 241, 
    235, 239, 209], [307, 280, 268, 232, 254, 275, 0, 294, 270, 264, 257, 
    239], [258, 261, 254, 205, 212, 263, 207, 0, 251, 228, 232, 228], [254,
    237, 269, 200, 246, 260, 231, 250, 0, 222, 234, 209], [292, 256, 282, 
    228, 262, 266, 237, 273, 279, 0, 251, 254], [259, 228, 261, 243, 272, 
    262, 244, 269, 267, 250, 0, 272], [291, 268, 266, 257, 239, 292, 262, 
    273, 292, 247, 229, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 26, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 220, 248, 202, 215, 243, 224, 199, 237, 262, 245, 234],
    [281, 0, 282, 272, 243, 255, 238, 227, 273, 301, 295, 262], [253, 219, 
    0, 202, 245, 221, 242, 232, 273, 254, 297, 243], [299, 229, 299, 0, 240,
    255, 239, 251, 306, 292, 277, 231], [286, 258, 256, 261, 0, 292, 265, 
    256, 285, 292, 255, 239], [258, 246, 280, 246, 209, 0, 239, 218, 250, 
    261, 264, 238], [277, 263, 259, 262, 236, 262, 0, 231, 260, 261, 293, 
    240], [302, 274, 269, 250, 245, 283, 270, 0, 264, 279, 283, 244], [264,
    228, 228, 195, 216, 251, 241, 237, 0, 273, 246, 217], [239, 200, 247, 
    209, 209, 240, 240, 222, 228, 0, 257, 254], [256, 206, 204, 224, 246, 
    237, 208, 218, 255, 244, 0, 256], [267, 239, 258, 270, 262, 263, 261, 
    257, 284, 247, 245, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 27, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 290, 289, 219, 239, 286, 272, 257, 264, 233, 260, 263],
    [211, 0, 251, 217, 201, 224, 251, 222, 212, 244, 262, 197], [212, 250, 
    0, 214, 209, 259, 233, 225, 241, 213, 271, 205], [282, 284, 287, 0, 238,
    269, 272, 229, 257, 263, 274, 236], [262, 300, 292, 263, 0, 250, 261, 
    251, 238, 236, 283, 229], [215, 277, 242, 232, 251, 0, 229, 228, 216, 
    261, 265, 235], [229, 250, 268, 229, 240, 272, 0, 231, 249, 238, 278, 
    247], [244, 279, 276, 272, 250, 273, 270, 0, 272, 248, 275, 227], [237,
    289, 260, 244, 263, 285, 252, 229, 0, 266, 254, 231], [268, 257, 288, 
    238, 265, 240, 263, 253, 235, 0, 274, 232], [241, 239, 230, 227, 218, 
    236, 223, 226, 247, 227, 0, 224], [238, 304, 296, 265, 272, 266, 254, 
    274, 270, 269, 277, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 28, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 174, 251, 282, 240, 260, 314, 240, 198, 287, 278, 290],
    [327, 0, 205, 289, 266, 276, 282, 334, 191, 259, 359, 258], [250, 296, 
    0, 245, 343, 266, 390, 298, 224, 184, 355, 320], [219, 212, 256, 0, 268,
    272, 248, 245, 227, 204, 313, 250], [261, 235, 158, 233, 0, 202, 258, 
    220, 199, 147, 241, 205], [241, 225, 235, 229, 299, 0, 277, 234, 272, 
    172, 260, 329], [187, 219, 111, 253, 243, 224, 0, 205, 127, 199, 272, 
    243], [261, 167, 203, 256, 281, 267, 296, 0, 210, 154, 248, 218], [303,
    310, 277, 274, 302, 229, 374, 291, 0, 266, 323, 345], [214, 242, 317, 
    297, 354, 329, 302, 347, 235, 0, 354, 263], [223, 142, 146, 188, 260, 
    241, 229, 253, 178, 147, 0, 176], [211, 243, 181, 251, 296, 172, 258, 
    283, 156, 238, 325, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 29, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 251, 270, 270, 270, 259, 268, 241, 256, 269, 276, 264],
    [250, 0, 243, 255, 253, 266, 242, 239, 232, 255, 268, 271], [231, 258, 
    0, 254, 236, 240, 259, 243, 228, 254, 268, 246], [231, 246, 247, 0, 248,
    256, 246, 243, 235, 259, 258, 254], [231, 248, 265, 253, 0, 255, 241, 
    248, 244, 260, 257, 257], [242, 235, 261, 245, 246, 0, 240, 238, 244, 
    254, 256, 255], [233, 259, 242, 255, 260, 261, 0, 246, 271, 264, 270, 
    239], [260, 262, 258, 258, 253, 263, 255, 0, 246, 256, 266, 263], [245,
    269, 273, 266, 257, 257, 230, 255, 0, 267, 277, 258], [232, 246, 247, 
    242, 241, 247, 237, 245, 234, 0, 253, 265], [225, 233, 233, 243, 244, 
    245, 231, 235, 224, 248, 0, 254], [237, 230, 255, 247, 244, 246, 262, 
    238, 243, 236, 247, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 30, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 271, 258, 275, 254, 254, 251, 262, 273, 264, 247, 259],
    [230, 0, 233, 237, 219, 256, 221, 232, 223, 240, 244, 231], [243, 268, 
    0, 267, 244, 266, 229, 240, 246, 271, 269, 242], [226, 264, 234, 0, 270,
    269, 256, 258, 239, 264, 256, 226], [247, 282, 257, 231, 0, 262, 228, 
    271, 241, 276, 262, 244], [247, 245, 235, 232, 239, 0, 258, 276, 254, 
    249, 248, 228], [250, 280, 272, 245, 273, 243, 0, 274, 258, 271, 258, 
    243], [239, 269, 261, 243, 230, 225, 227, 0, 253, 263, 241, 244], [228,
    278, 255, 262, 260, 247, 243, 248, 0, 262, 260, 237], [237, 261, 230, 
    237, 225, 252, 230, 238, 239, 0, 254, 246], [254, 257, 232, 245, 239, 
    253, 243, 260, 241, 247, 0, 247], [242, 270, 259, 275, 257, 273, 258, 
    257, 264, 255, 254, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 31, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 244, 231, 273, 251, 278, 261, 270, 252, 239, 261, 272],
    [257, 0, 233, 290, 244, 280, 261, 262, 252, 242, 262, 243], [270, 268, 
    0, 283, 251, 277, 284, 255, 245, 256, 265, 265], [228, 211, 218, 0, 211,
    233, 226, 232, 210, 234, 210, 214], [250, 257, 250, 290, 0, 299, 266, 
    275, 255, 249, 257, 263], [223, 221, 224, 268, 202, 0, 224, 245, 230, 
    234, 223, 227], [240, 240, 217, 275, 235, 277, 0, 261, 231, 231, 241, 
    225], [231, 239, 246, 269, 226, 256, 240, 0, 230, 240, 237, 235], [249,
    249, 256, 291, 246, 271, 270, 271, 0, 261, 250, 268], [262, 259, 245, 
    267, 252, 267, 270, 261, 240, 0, 236, 248], [240, 239, 236, 291, 244, 
    278, 260, 264, 251, 265, 0, 260], [229, 258, 236, 287, 238, 274, 276, 
    266, 233, 253, 241, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 32, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 253, 198, 227, 207, 223, 196, 208, 220, 229, 188, 202],
    [248, 0, 244, 252, 241, 257, 240, 242, 260, 261, 221, 233], [303, 257, 
    0, 243, 256, 244, 230, 259, 267, 276, 209, 221], [274, 249, 258, 0, 239,
    237, 235, 233, 228, 262, 255, 250], [294, 260, 245, 262, 0, 258, 248, 
    266, 234, 258, 217, 214], [278, 244, 257, 264, 243, 0, 225, 224, 253, 
    251, 193, 213], [305, 261, 271, 266, 253, 276, 0, 265, 245, 244, 231, 
    248], [293, 259, 242, 268, 235, 277, 236, 0, 249, 255, 223, 236], [281,
    241, 234, 273, 267, 248, 256, 252, 0, 276, 223, 242], [272, 240, 225, 
    239, 243, 250, 257, 246, 225, 0, 227, 236], [313, 280, 292, 246, 284, 
    308, 270, 278, 278, 274, 0, 275], [299, 268, 280, 251, 287, 288, 253, 
    265, 259, 265, 226, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 33, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 267, 265, 260, 261, 273, 251, 272, 291, 246, 256, 261],
    [234, 0, 267, 234, 258, 264, 241, 252, 257, 245, 239, 235], [236, 234, 
    0, 249, 266, 225, 243, 263, 264, 255, 247, 253], [241, 267, 252, 0, 270,
    245, 247, 269, 293, 268, 268, 244], [240, 243, 235, 231, 0, 268, 250, 
    235, 257, 231, 258, 255], [228, 237, 276, 256, 233, 0, 235, 231, 238, 
    233, 235, 250], [250, 260, 258, 254, 251, 266, 0, 266, 267, 255, 239, 
    256], [229, 249, 238, 232, 266, 270, 235, 0, 252, 248, 253, 233], [210,
    244, 237, 208, 244, 263, 234, 249, 0, 235, 217, 236], [255, 256, 246, 
    233, 270, 268, 246, 253, 266, 0, 268, 269], [245, 262, 254, 233, 243, 
    266, 262, 248, 284, 233, 0, 268], [240, 266, 248, 257, 246, 251, 245, 
    268, 265, 232, 233, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 34, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 253, 253, 246, 252, 256, 266, 260, 234, 245, 258, 265],
    [248, 0, 255, 259, 258, 235, 251, 260, 234, 245, 240, 260], [248, 246, 
    0, 255, 263, 238, 243, 259, 252, 245, 250, 258], [255, 242, 246, 0, 267,
    255, 249, 250, 250, 225, 257, 242], [249, 243, 238, 234, 0, 242, 253, 
    253, 235, 235, 247, 264], [245, 266, 263, 246, 259, 0, 246, 253, 228, 
    269, 255, 262], [235, 250, 258, 252, 248, 255, 0, 259, 254, 257, 251, 
    245], [241, 241, 242, 251, 248, 248, 242, 0, 238, 247, 248, 258], [267,
    267, 249, 251, 266, 273, 247, 263, 0, 247, 258, 253], [256, 256, 256, 
    276, 266, 232, 244, 254, 254, 0, 261, 271], [243, 261, 251, 244, 254, 
    246, 250, 253, 243, 240, 0, 255], [236, 241, 243, 259, 237, 239, 256, 
    243, 248, 230, 246, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 35, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 246, 247, 240, 236, 256, 237, 246, 260, 279, 261, 238],
    [255, 0, 262, 266, 264, 252, 217, 267, 252, 272, 268, 246], [254, 239, 
    0, 255, 261, 271, 254, 244, 255, 270, 292, 252], [261, 235, 246, 0, 249,
    244, 242, 239, 274, 262, 249, 242], [265, 237, 240, 252, 0, 285, 226, 
    255, 277, 251, 259, 266], [245, 249, 230, 257, 216, 0, 234, 230, 235, 
    225, 258, 239], [264, 284, 247, 259, 275, 267, 0, 258, 271, 302, 297, 
    234], [255, 234, 257, 262, 246, 271, 243, 0, 250, 291, 278, 270], [241,
    249, 246, 227, 224, 266, 230, 251, 0, 264, 273, 232], [222, 229, 231, 
    239, 250, 276, 199, 210, 237, 0, 234, 216], [240, 233, 209, 252, 242, 
    243, 204, 223, 228, 267, 0, 228], [263, 255, 249, 259, 235, 262, 267, 
    231, 269, 285, 273, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 36, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 232, 241, 229, 264, 264, 220, 227, 265, 221, 261, 194],
    [269, 0, 282, 268, 260, 275, 301, 230, 255, 269, 285, 240], [260, 219, 
    0, 217, 270, 243, 245, 226, 254, 213, 240, 217], [272, 233, 284, 0, 284,
    268, 267, 274, 269, 254, 246, 224], [237, 241, 231, 217, 0, 235, 238, 
    199, 229, 210, 259, 183], [237, 226, 258, 233, 266, 0, 237, 240, 210, 
    247, 248, 228], [281, 200, 256, 234, 263, 264, 0, 189, 267, 257, 261, 
    210], [274, 271, 275, 227, 302, 261, 312, 0, 271, 257, 300, 294], [236,
    246, 247, 232, 272, 291, 234, 230, 0, 268, 252, 232], [280, 232, 288, 
    247, 291, 254, 244, 244, 233, 0, 272, 238], [240, 216, 261, 255, 242, 
    253, 240, 201, 249, 229, 0, 216], [307, 261, 284, 277, 318, 273, 291, 
    207, 269, 263, 285, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 37, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 236, 246, 263, 236, 248, 240, 257, 260, 244, 234, 273],
    [265, 0, 246, 263, 264, 264, 256, 263, 264, 255, 243, 289], [255, 255, 
    0, 268, 245, 250, 248, 242, 250, 251, 242, 264], [238, 238, 233, 0, 252,
    260, 243, 243, 251, 234, 234, 270], [265, 237, 256, 249, 0, 253, 247, 
    242, 252, 238, 256, 266], [253, 237, 251, 241, 248, 0, 240, 257, 229, 
    250, 247, 258], [261, 245, 253, 258, 254, 261, 0, 261, 263, 257, 249, 
    269], [244, 238, 259, 258, 259, 244, 240, 0, 263, 251, 242, 274], [241,
    237, 251, 250, 249, 272, 238, 238, 0, 240, 245, 255], [257, 246, 250, 
    267, 263, 251, 244, 250, 261, 0, 255, 276], [267, 258, 259, 267, 245, 
    254, 252, 259, 256, 246, 0, 286], [228, 212, 237, 231, 235, 243, 232, 
    227, 246, 225, 215, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 38, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 260, 239, 247, 245, 236, 253, 247, 243, 237, 260, 265],
    [241, 0, 229, 231, 237, 249, 259, 229, 238, 244, 266, 267], [262, 272, 
    0, 261, 232, 241, 263, 264, 251, 262, 262, 263], [254, 270, 240, 0, 258,
    256, 268, 277, 246, 262, 278, 272], [256, 264, 269, 243, 0, 252, 261, 
    265, 255, 272, 260, 267], [265, 252, 260, 245, 249, 0, 271, 267, 251, 
    251, 263, 281], [248, 242, 238, 233, 240, 230, 0, 229, 250, 254, 242, 
    257], [254, 272, 237, 224, 236, 234, 272, 0, 233, 251, 263, 251], [258,
    263, 250, 255, 246, 250, 251, 268, 0, 250, 275, 264], [264, 257, 239, 
    239, 229, 250, 247, 250, 251, 0, 270, 272], [241, 235, 239, 223, 241, 
    238, 259, 238, 226, 231, 0, 258], [236, 234, 238, 229, 234, 220, 244, 
    250, 237, 229, 243, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 39, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 230, 218, 231, 225, 259, 233, 245, 287, 232, 267, 218],
    [271, 0, 247, 274, 262, 314, 275, 260, 274, 217, 295, 236], [283, 254, 
    0, 284, 225, 310, 257, 250, 292, 252, 286, 215], [270, 227, 217, 0, 210,
    250, 225, 227, 243, 251, 278, 196], [276, 239, 276, 291, 0, 304, 255, 
    254, 280, 261, 306, 209], [242, 187, 191, 251, 197, 0, 196, 231, 258, 
    206, 218, 184], [268, 226, 244, 276, 246, 305, 0, 236, 277, 247, 275, 
    232], [256, 241, 251, 274, 247, 270, 265, 0, 290, 210, 278, 242], [214,
    227, 209, 258, 221, 243, 224, 211, 0, 196, 255, 236], [269, 284, 249, 
    250, 240, 295, 254, 291, 305, 0, 288, 252], [234, 206, 215, 223, 195, 
    283, 226, 223, 246, 213, 0, 224], [283, 265, 286, 305, 292, 317, 269, 
    259, 265, 249, 277, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 40, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 281, 245, 257, 246, 267, 251, 279, 242, 251, 257, 246],
    [220, 0, 231, 250, 224, 251, 253, 245, 226, 228, 222, 218], [256, 270, 
    0, 264, 263, 262, 267, 253, 239, 236, 256, 241], [244, 251, 237, 0, 236,
    263, 275, 250, 235, 239, 241, 225], [255, 277, 238, 265, 0, 248, 263, 
    253, 233, 259, 234, 255], [234, 250, 239, 238, 253, 0, 242, 265, 236, 
    242, 249, 217], [250, 248, 234, 226, 238, 259, 0, 263, 222, 267, 256, 
    212], [222, 256, 248, 251, 248, 236, 238, 0, 219, 226, 256, 226], [259,
    275, 262, 266, 268, 265, 279, 282, 0, 254, 257, 246], [250, 273, 265, 
    262, 242, 259, 234, 275, 247, 0, 256, 221], [244, 279, 245, 260, 267, 
    252, 245, 245, 244, 245, 0, 204], [255, 283, 260, 276, 246, 284, 289, 
    275, 255, 280, 297, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 41, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 256, 237, 238, 282, 230, 251, 250, 251, 257, 271, 256],
    [245, 0, 222, 252, 218, 259, 228, 242, 228, 258, 251, 237], [264, 279, 
    0, 256, 251, 263, 264, 235, 282, 266, 288, 264], [263, 249, 245, 0, 256,
    249, 248, 255, 262, 251, 283, 248], [219, 283, 250, 245, 0, 251, 227, 
    217, 255, 248, 260, 243], [271, 242, 238, 252, 250, 0, 227, 241, 264, 
    245, 262, 235], [250, 273, 237, 253, 274, 274, 0, 267, 258, 260, 286, 
    276], [251, 259, 266, 246, 284, 260, 234, 0, 276, 256, 283, 279], [250,
    273, 219, 239, 246, 237, 243, 225, 0, 236, 255, 237], [244, 243, 235, 
    250, 253, 256, 241, 245, 265, 0, 270, 244], [230, 250, 213, 218, 241, 
    239, 215, 218, 246, 231, 0, 263], [245, 264, 237, 253, 258, 266, 225, 
    222, 264, 257, 238, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 42, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 270, 261, 288, 269, 268, 260, 271, 254, 227, 254, 253],
    [231, 0, 243, 265, 259, 269, 260, 253, 228, 262, 240, 248], [240, 258, 
    0, 270, 272, 278, 262, 286, 238, 266, 256, 242], [213, 236, 231, 0, 243,
    261, 240, 233, 251, 234, 236, 226], [232, 242, 229, 258, 0, 267, 249, 
    238, 228, 242, 232, 216], [233, 232, 223, 240, 234, 0, 221, 246, 206, 
    245, 209, 211], [241, 241, 239, 261, 252, 280, 0, 255, 211, 261, 230, 
    239], [230, 248, 215, 268, 263, 255, 246, 0, 227, 245, 239, 229], [247,
    273, 263, 250, 273, 295, 290, 274, 0, 264, 274, 248], [274, 239, 235, 
    267, 259, 256, 240, 256, 237, 0, 238, 263], [247, 261, 245, 265, 269, 
    292, 271, 262, 227, 263, 0, 249], [248, 253, 259, 275, 285, 290, 262, 
    272, 253, 238, 252, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 43, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 254, 260, 268, 244, 245, 254, 263, 236, 251, 260, 234],
    [247, 0, 267, 263, 247, 242, 236, 249, 229, 241, 242, 233], [241, 234, 
    0, 244, 228, 238, 221, 251, 229, 231, 245, 231], [233, 238, 257, 0, 233,
    251, 241, 251, 239, 238, 249, 234], [257, 254, 273, 268, 0, 256, 252, 
    263, 238, 255, 260, 247], [256, 259, 263, 250, 245, 0, 238, 257, 236, 
    250, 261, 240], [247, 265, 280, 260, 249, 263, 0, 273, 251, 257, 265, 
    253], [238, 252, 250, 250, 238, 244, 228, 0, 229, 243, 232, 234], [265,
    272, 272, 262, 263, 265, 250, 272, 0, 261, 258, 256], [250, 260, 270, 
    263, 246, 251, 244, 258, 240, 0, 260, 245], [241, 259, 256, 252, 241, 
    240, 236, 269, 243, 241, 0, 230], [267, 268, 270, 267, 254, 261, 248, 
    267, 245, 256, 271, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 44, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 240, 303, 317, 307, 277, 245, 262, 338, 218, 306, 247],
    [261, 0, 278, 266, 314, 310, 219, 261, 275, 219, 272, 258], [198, 223, 
    0, 279, 237, 237, 192, 243, 234, 213, 275, 213], [184, 235, 222, 0, 236,
    269, 197, 201, 245, 206, 228, 222], [194, 187, 264, 265, 0, 306, 261, 
    237, 328, 257, 299, 260], [224, 191, 264, 232, 195, 0, 179, 174, 252, 
    210, 225, 228], [256, 282, 309, 304, 240, 322, 0, 279, 315, 262, 364, 
    261], [239, 240, 258, 300, 264, 327, 222, 0, 285, 254, 262, 246], [163,
    226, 267, 256, 173, 249, 186, 216, 0, 267, 280, 173], [283, 282, 288, 
    295, 244, 291, 239, 247, 234, 0, 291, 223], [195, 229, 226, 273, 202, 
    276, 137, 239, 221, 210, 0, 225], [254, 243, 288, 279, 241, 273, 240, 
    255, 328, 278, 276, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 45, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 340, 276, 362, 225, 300, 264, 225, 310, 236, 288, 255],
    [161, 0, 192, 253, 182, 220, 201, 200, 242, 185, 260, 246], [225, 309, 
    0, 270, 237, 286, 282, 268, 255, 290, 268, 272], [139, 248, 231, 0, 177,
    216, 181, 202, 185, 192, 193, 226], [276, 319, 264, 324, 0, 290, 263, 
    238, 323, 295, 246, 263], [201, 281, 215, 285, 211, 0, 248, 221, 254, 
    210, 227, 256], [237, 300, 219, 320, 238, 253, 0, 222, 275, 227, 288, 
    234], [276, 301, 233, 299, 263, 280, 279, 0, 314, 313, 339, 302], [191,
    259, 246, 316, 178, 247, 226, 187, 0, 214, 210, 220], [265, 316, 211, 
    309, 206, 291, 274, 188, 287, 0, 247, 256], [213, 241, 233, 308, 255, 
    274, 213, 162, 291, 254, 0, 257], [246, 255, 229, 275, 238, 245, 267, 
    199, 281, 245, 244, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 46, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 226, 242, 217, 271, 227, 267, 225, 243, 277, 213, 267],
    [275, 0, 251, 241, 270, 238, 246, 203, 242, 298, 229, 247], [259, 250, 
    0, 225, 238, 231, 222, 196, 214, 244, 242, 242], [284, 260, 276, 0, 261,
    276, 225, 253, 242, 273, 254, 254], [230, 231, 263, 240, 0, 272, 221, 
    228, 208, 259, 253, 214], [274, 263, 270, 225, 229, 0, 197, 265, 250, 
    296, 261, 267], [234, 255, 279, 276, 280, 304, 0, 269, 267, 277, 259, 
    261], [276, 298, 305, 248, 273, 236, 232, 0, 210, 276, 256, 215], [258,
    259, 287, 259, 293, 251, 234, 291, 0, 287, 219, 225], [224, 203, 257, 
    228, 242, 205, 224, 225, 214, 0, 210, 197], [288, 272, 259, 247, 248, 
    240, 242, 245, 282, 291, 0, 252], [234, 254, 259, 247, 287, 234, 240, 
    286, 276, 304, 249, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 47, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 248, 250, 222, 236, 236, 247, 244, 245, 240, 236, 246],
    [253, 0, 224, 226, 253, 243, 255, 243, 235, 255, 258, 237], [251, 277, 
    0, 247, 261, 267, 255, 256, 250, 254, 269, 232], [279, 275, 254, 0, 257,
    258, 302, 249, 270, 264, 266, 249], [265, 248, 240, 244, 0, 238, 257, 
    232, 257, 261, 237, 223], [265, 258, 234, 243, 263, 0, 277, 274, 270, 
    277, 295, 252], [254, 246, 246, 199, 244, 224, 0, 231, 266, 241, 235, 
    224], [257, 258, 245, 252, 269, 227, 270, 0, 237, 267, 243, 245], [256,
    266, 251, 231, 244, 231, 235, 264, 0, 228, 238, 231], [261, 246, 247, 
    237, 240, 224, 260, 234, 273, 0, 255, 230], [265, 243, 232, 235, 264, 
    206, 266, 258, 263, 246, 0, 219], [255, 264, 269, 252, 278, 249, 277, 
    256, 270, 271, 282, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 48, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 244, 259, 255, 264, 255, 255, 261, 258, 257, 254, 254],
    [257, 0, 242, 256, 274, 252, 257, 256, 271, 253, 227, 240], [242, 259, 
    0, 244, 261, 252, 248, 252, 258, 235, 238, 238], [246, 245, 257, 0, 259,
    250, 250, 258, 273, 235, 253, 249], [237, 227, 240, 242, 0, 248, 237, 
    258, 252, 227, 235, 244], [246, 249, 249, 251, 253, 0, 274, 269, 271, 
    256, 228, 250], [246, 244, 253, 251, 264, 227, 0, 257, 262, 240, 234, 
    250], [240, 245, 249, 243, 243, 232, 244, 0, 265, 247, 231, 237], [243,
    230, 243, 228, 249, 230, 239, 236, 0, 255, 236, 234], [244, 248, 266, 
    266, 274, 245, 261, 254, 246, 0, 239, 248], [247, 274, 263, 248, 266, 
    273, 267, 270, 265, 262, 0, 248], [247, 261, 263, 252, 257, 251, 251, 
    264, 267, 253, 253, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 49, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 260, 258, 254, 251, 226, 241, 267, 242, 260, 263, 284],
    [241, 0, 210, 262, 239, 234, 231, 253, 217, 277, 247, 259], [243, 291, 
    0, 275, 242, 213, 230, 251, 224, 261, 264, 239], [247, 239, 226, 0, 217,
    240, 205, 255, 236, 223, 249, 270], [250, 262, 259, 284, 0, 227, 259, 
    255, 242, 277, 260, 284], [275, 267, 288, 261, 274, 0, 240, 297, 234, 
    297, 294, 292], [260, 270, 271, 296, 242, 261, 0, 277, 254, 290, 295, 
    272], [234, 248, 250, 246, 246, 204, 224, 0, 220, 265, 240, 262], [259,
    284, 277, 265, 259, 267, 247, 281, 0, 281, 257, 297], [241, 224, 240, 
    278, 224, 204, 211, 236, 220, 0, 268, 274], [238, 254, 237, 252, 241, 
    207, 206, 261, 244, 233, 0, 286], [217, 242, 262, 231, 217, 209, 229, 
    239, 204, 227, 215, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 50, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 265, 237, 246, 255, 270, 248, 261, 263, 257, 252, 267],
    [236, 0, 241, 242, 244, 240, 238, 247, 254, 243, 251, 253], [264, 260, 
    0, 253, 252, 260, 242, 262, 261, 272, 264, 266], [255, 259, 248, 0, 264,
    247, 248, 255, 257, 261, 258, 261], [246, 257, 249, 237, 0, 256, 253, 
    265, 268, 248, 261, 271], [231, 261, 241, 254, 245, 0, 249, 260, 244, 
    253, 259, 266], [253, 263, 259, 253, 248, 252, 0, 264, 264, 251, 264, 
    268], [240, 254, 239, 246, 236, 241, 237, 0, 242, 241, 268, 258], [238,
    247, 240, 244, 233, 257, 237, 259, 0, 243, 255, 261], [244, 258, 229, 
    240, 253, 248, 250, 260, 258, 0, 265, 279], [249, 250, 237, 243, 240, 
    242, 237, 233, 246, 236, 0, 264], [234, 248, 235, 240, 230, 235, 233, 
    243, 240, 222, 237, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 51, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 265, 242, 272, 248, 240, 208, 244, 250, 249, 251, 215],
    [236, 0, 250, 229, 229, 255, 236, 235, 268, 267, 244, 231], [259, 251, 
    0, 239, 208, 213, 226, 251, 239, 248, 226, 217], [229, 272, 262, 0, 236,
    250, 238, 238, 270, 253, 239, 230], [253, 272, 293, 265, 0, 261, 261, 
    266, 244, 295, 272, 259], [261, 246, 288, 251, 240, 0, 262, 234, 235, 
    276, 267, 229], [293, 265, 275, 263, 240, 239, 0, 227, 245, 305, 263, 
    224], [257, 266, 250, 263, 235, 267, 274, 0, 267, 296, 280, 234], [251,
    233, 262, 231, 257, 266, 256, 234, 0, 278, 293, 224], [252, 234, 253, 
    248, 206, 225, 196, 205, 223, 0, 240, 223], [250, 257, 275, 262, 229, 
    234, 238, 221, 208, 261, 0, 212], [286, 270, 284, 271, 242, 272, 277, 
    267, 277, 278, 289, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 52, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 254, 238, 260, 247, 224, 244, 269, 221, 239, 228, 251],
    [247, 0, 237, 252, 234, 230, 228, 227, 213, 254, 211, 261], [263, 264, 
    0, 243, 249, 251, 254, 269, 242, 253, 247, 247], [241, 249, 258, 0, 252,
    239, 259, 254, 226, 258, 227, 259], [254, 267, 252, 249, 0, 249, 257, 
    261, 228, 262, 240, 253], [277, 271, 250, 262, 252, 0, 280, 253, 230, 
    262, 231, 267], [257, 273, 247, 242, 244, 221, 0, 256, 234, 261, 244, 
    263], [232, 274, 232, 247, 240, 248, 245, 0, 252, 280, 230, 275], [280,
    288, 259, 275, 273, 271, 267, 249, 0, 272, 254, 255], [262, 247, 248, 
    243, 239, 239, 240, 221, 229, 0, 218, 256], [273, 290, 254, 274, 261, 
    270, 257, 271, 247, 283, 0, 283], [250, 240, 254, 242, 248, 234, 238, 
    226, 246, 245, 218, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 53, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 225, 254, 236, 250, 241, 237, 259, 257, 227, 270, 245],
    [276, 0, 269, 256, 282, 255, 250, 257, 257, 250, 269, 258], [247, 232, 
    0, 242, 272, 229, 240, 262, 236, 238, 260, 249], [265, 245, 259, 0, 274,
    244, 250, 278, 258, 255, 266, 275], [251, 219, 229, 227, 0, 230, 239, 
    248, 239, 240, 288, 245], [260, 246, 272, 257, 271, 0, 265, 273, 248, 
    257, 285, 252], [264, 251, 261, 251, 262, 236, 0, 257, 264, 220, 281, 
    247], [242, 244, 239, 223, 253, 228, 244, 0, 234, 220, 275, 222], [244,
    244, 265, 243, 262, 253, 237, 267, 0, 227, 268, 244], [274, 251, 263, 
    246, 261, 244, 281, 281, 274, 0, 289, 261], [231, 232, 241, 235, 213, 
    216, 220, 226, 233, 212, 0, 252], [256, 243, 252, 226, 256, 249, 254, 
    279, 257, 240, 249, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 54, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 251, 243, 263, 258, 250, 252, 241, 236, 240, 263, 261],
    [250, 0, 245, 265, 258, 248, 253, 248, 243, 247, 266, 258], [258, 256, 
    0, 275, 276, 245, 265, 255, 257, 247, 270, 261], [238, 236, 226, 0, 247,
    247, 259, 247, 235, 243, 248, 247], [243, 243, 225, 254, 0, 249, 256, 
    244, 229, 245, 254, 265], [251, 253, 256, 254, 252, 0, 257, 253, 244, 
    236, 243, 263], [249, 248, 236, 242, 245, 244, 0, 233, 242, 243, 251, 
    250], [260, 253, 246, 254, 257, 248, 268, 0, 249, 241, 241, 246], [265,
    258, 244, 266, 272, 257, 259, 252, 0, 266, 261, 258], [261, 254, 254, 
    258, 256, 265, 258, 260, 235, 0, 253, 256], [238, 235, 231, 253, 247, 
    258, 250, 260, 240, 248, 0, 263], [240, 243, 240, 254, 236, 238, 251, 
    255, 243, 245, 238, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 55, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 253, 245, 266, 254, 258, 244, 265, 239, 253, 254, 297],
    [248, 0, 245, 269, 248, 259, 249, 233, 245, 235, 231, 269], [256, 256, 
    0, 277, 271, 278, 259, 227, 249, 244, 246, 268], [235, 232, 224, 0, 251,
    233, 245, 228, 230, 255, 226, 266], [247, 253, 230, 250, 0, 254, 246, 
    253, 257, 227, 237, 276], [243, 242, 223, 268, 247, 0, 247, 229, 240, 
    253, 223, 259], [257, 252, 242, 256, 255, 254, 0, 236, 237, 243, 250, 
    283], [236, 268, 274, 273, 248, 272, 265, 0, 240, 264, 246, 280], [262,
    256, 252, 271, 244, 261, 264, 261, 0, 240, 263, 273], [248, 266, 257, 
    246, 274, 248, 258, 237, 261, 0, 235, 283], [247, 270, 255, 275, 264, 
    278, 251, 255, 238, 266, 0, 288], [204, 232, 233, 235, 225, 242, 218, 
    221, 228, 218, 213, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 56, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 237, 241, 236, 264, 274, 255, 250, 273, 250, 252, 272],
    [264, 0, 249, 254, 258, 272, 258, 250, 291, 276, 240, 288], [260, 252, 
    0, 246, 249, 253, 239, 243, 261, 277, 247, 276], [265, 247, 255, 0, 240,
    248, 261, 227, 283, 271, 252, 242], [237, 243, 252, 261, 0, 248, 238, 
    238, 248, 261, 236, 256], [227, 229, 248, 253, 253, 0, 231, 219, 261, 
    252, 223, 245], [246, 243, 262, 240, 263, 270, 0, 260, 264, 253, 253, 
    263], [251, 251, 258, 274, 263, 282, 241, 0, 281, 271, 249, 268], [228,
    210, 240, 218, 253, 240, 237, 220, 0, 256, 201, 232], [251, 225, 224, 
    230, 240, 249, 248, 230, 245, 0, 232, 254], [249, 261, 254, 249, 265, 
    278, 248, 252, 300, 269, 0, 270], [229, 213, 225, 259, 245, 256, 238, 
    233, 269, 247, 231, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 57, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 240, 252, 264, 229, 249, 256, 263, 239, 251, 237, 242],
    [261, 0, 251, 257, 243, 251, 250, 237, 257, 252, 253, 248], [249, 250, 
    0, 238, 238, 246, 269, 243, 252, 262, 246, 243], [237, 244, 263, 0, 236,
    236, 252, 236, 244, 260, 243, 235], [272, 258, 263, 265, 0, 267, 255, 
    254, 251, 253, 249, 253], [252, 250, 255, 265, 234, 0, 263, 259, 254, 
    254, 254, 226], [245, 251, 232, 249, 246, 238, 0, 245, 249, 247, 251, 
    235], [238, 264, 258, 265, 247, 242, 256, 0, 269, 261, 250, 251], [262,
    244, 249, 257, 250, 247, 252, 232, 0, 243, 244, 229], [250, 249, 239, 
    241, 248, 247, 254, 240, 258, 0, 244, 225], [264, 248, 255, 258, 252, 
    247, 250, 251, 257, 257, 0, 247], [259, 253, 258, 266, 248, 275, 266, 
    250, 272, 276, 254, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 58, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 253, 244, 249, 250, 248, 244, 232, 235, 258, 247, 248],
    [248, 0, 245, 230, 240, 236, 254, 246, 229, 260, 250, 247], [257, 256, 
    0, 243, 258, 240, 253, 237, 250, 253, 237, 253], [252, 271, 258, 0, 260,
    255, 250, 240, 259, 258, 246, 250], [251, 261, 243, 241, 0, 244, 249, 
    233, 235, 242, 250, 242], [253, 265, 261, 246, 257, 0, 262, 247, 247, 
    260, 266, 235], [257, 247, 248, 251, 252, 239, 0, 231, 243, 248, 252, 
    266], [269, 255, 264, 261, 268, 254, 270, 0, 246, 271, 263, 263], [266,
    272, 251, 242, 266, 254, 258, 255, 0, 276, 256, 257], [243, 241, 248, 
    243, 259, 241, 253, 230, 225, 0, 237, 253], [254, 251, 264, 255, 251, 
    235, 249, 238, 245, 264, 0, 250], [253, 254, 248, 251, 259, 266, 235, 
    238, 244, 248, 251, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 59, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 235, 218, 239, 242, 227, 245, 261, 249, 263, 236, 225],
    [266, 0, 222, 286, 275, 274, 253, 274, 270, 263, 282, 257], [283, 279, 
    0, 270, 257, 259, 270, 275, 281, 266, 271, 250], [262, 215, 231, 0, 243,
    274, 244, 270, 281, 271, 237, 245], [259, 226, 244, 258, 0, 258, 275, 
    273, 276, 272, 262, 250], [274, 227, 242, 227, 243, 0, 291, 251, 263, 
    273, 259, 267], [256, 248, 231, 257, 226, 210, 0, 247, 245, 245, 248, 
    226], [240, 227, 226, 231, 228, 250, 254, 0, 240, 247, 262, 210], [252,
    231, 220, 220, 225, 238, 256, 261, 0, 251, 251, 220], [238, 238, 235, 
    230, 229, 228, 256, 254, 250, 0, 264, 248], [265, 219, 230, 264, 239, 
    242, 253, 239, 250, 237, 0, 248], [276, 244, 251, 256, 251, 234, 275, 
    291, 281, 253, 253, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 60, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 246, 240, 274, 267, 244, 258, 250, 258, 251, 264, 234],
    [255, 0, 248, 254, 244, 250, 242, 250, 255, 253, 250, 261], [261, 253, 
    0, 267, 244, 242, 257, 238, 241, 242, 224, 220], [227, 247, 234, 0, 245,
    224, 248, 213, 225, 247, 224, 235], [234, 257, 257, 256, 0, 249, 263, 
    244, 261, 241, 253, 243], [257, 251, 259, 277, 252, 0, 242, 218, 235, 
    258, 264, 228], [243, 259, 244, 253, 238, 259, 0, 230, 253, 248, 230, 
    229], [251, 251, 263, 288, 257, 283, 271, 0, 265, 257, 245, 239], [243,
    246, 260, 276, 240, 266, 248, 236, 0, 263, 242, 254], [250, 248, 259, 
    254, 260, 243, 253, 244, 238, 0, 248, 242], [237, 251, 277, 277, 248, 
    237, 271, 256, 259, 253, 0, 244], [267, 240, 281, 266, 258, 273, 272, 
    262, 247, 259, 257, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 61, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 249, 259, 256, 247, 253, 262, 249, 266, 248, 267, 242],
    [252, 0, 241, 246, 248, 232, 253, 259, 245, 237, 258, 241], [242, 260, 
    0, 242, 245, 232, 252, 253, 255, 242, 259, 250], [245, 255, 259, 0, 252,
    253, 248, 240, 252, 246, 249, 238], [254, 253, 256, 249, 0, 249, 247, 
    259, 262, 245, 255, 242], [248, 269, 269, 248, 252, 0, 275, 273, 262, 
    250, 271, 240], [239, 248, 249, 253, 254, 226, 0, 251, 248, 245, 254, 
    233], [252, 242, 248, 261, 242, 228, 250, 0, 237, 259, 237, 254], [235,
    256, 246, 249, 239, 239, 253, 264, 0, 235, 247, 237], [253, 264, 259, 
    255, 256, 251, 256, 242, 266, 0, 251, 243], [234, 243, 242, 252, 246, 
    230, 247, 264, 254, 250, 0, 238], [259, 260, 251, 263, 259, 261, 268, 
    247, 264, 258, 263, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 62, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 259, 247, 262, 253, 242, 219, 241, 266, 252, 259, 263],
    [242, 0, 241, 250, 245, 246, 246, 242, 249, 254, 248, 232], [254, 260, 
    0, 245, 266, 252, 271, 253, 259, 245, 274, 260], [239, 251, 256, 0, 216,
    241, 237, 225, 240, 237, 239, 235], [248, 256, 235, 285, 0, 253, 244, 
    236, 250, 243, 266, 250], [259, 255, 249, 260, 248, 0, 249, 227, 254, 
    262, 252, 249], [282, 255, 230, 264, 257, 252, 0, 265, 272, 268, 270, 
    264], [260, 259, 248, 276, 265, 274, 236, 0, 265, 253, 245, 247], [235,
    252, 242, 261, 251, 247, 229, 236, 0, 251, 238, 243], [249, 247, 256, 
    264, 258, 239, 233, 248, 250, 0, 255, 254], [242, 253, 227, 262, 235, 
    249, 231, 256, 263, 246, 0, 243], [238, 269, 241, 266, 251, 252, 237, 
    254, 258, 247, 258, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 63, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 268, 311, 301, 240, 262, 298, 258, 227, 299, 260, 275],
    [233, 0, 299, 264, 247, 277, 241, 256, 238, 292, 253, 287], [190, 202, 
    0, 277, 234, 234, 259, 224, 205, 234, 201, 276], [200, 237, 224, 0, 198,
    214, 252, 229, 224, 231, 229, 224], [261, 254, 267, 303, 0, 278, 267, 
    235, 258, 263, 211, 269], [239, 224, 267, 287, 223, 0, 279, 221, 210, 
    251, 241, 269], [203, 260, 242, 249, 234, 222, 0, 250, 216, 226, 266, 
    253], [243, 245, 277, 272, 266, 280, 251, 0, 262, 285, 244, 272], [274,
    263, 296, 277, 243, 291, 285, 239, 0, 253, 261, 293], [202, 209, 267, 
    270, 238, 250, 275, 216, 248, 0, 221, 259], [241, 248, 300, 272, 290, 
    260, 235, 257, 240, 280, 0, 268], [226, 214, 225, 277, 232, 232, 248, 
    229, 208, 242, 233, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 64, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 267, 240, 243, 246, 260, 256, 246, 245, 269, 268, 244],
    [234, 0, 248, 249, 248, 271, 245, 241, 248, 262, 242, 244], [261, 253, 
    0, 253, 262, 247, 226, 252, 259, 258, 253, 239], [258, 252, 248, 0, 234,
    262, 239, 244, 239, 281, 240, 258], [255, 253, 239, 267, 0, 261, 250, 
    247, 228, 272, 251, 239], [241, 230, 254, 239, 240, 0, 237, 221, 231, 
    258, 237, 245], [245, 256, 275, 262, 251, 264, 0, 234, 249, 268, 269, 
    257], [255, 260, 249, 257, 254, 280, 267, 0, 255, 258, 253, 264], [256,
    253, 242, 262, 273, 270, 252, 246, 0, 263, 263, 260], [232, 239, 243, 
    220, 229, 243, 233, 243, 238, 0, 263, 240], [233, 259, 248, 261, 250, 
    264, 232, 248, 238, 238, 0, 251], [257, 257, 262, 243, 262, 256, 244, 
    237, 241, 261, 250, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 65, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 241, 243, 242, 256, 246, 238, 246, 249, 249, 244, 242],
    [260, 0, 234, 239, 237, 266, 223, 238, 255, 249, 244, 244], [258, 267, 
    0, 249, 253, 272, 274, 249, 234, 259, 258, 262], [259, 262, 252, 0, 257,
    283, 247, 254, 256, 264, 251, 274], [245, 264, 248, 244, 0, 262, 257, 
    236, 258, 249, 256, 237], [255, 235, 229, 218, 239, 0, 227, 227, 235, 
    239, 228, 243], [263, 278, 227, 254, 244, 274, 0, 239, 253, 274, 258, 
    256], [255, 263, 252, 247, 265, 274, 262, 0, 247, 270, 256, 242], [252,
    246, 267, 245, 243, 266, 248, 254, 0, 267, 244, 245], [252, 252, 242, 
    237, 252, 262, 227, 231, 234, 0, 264, 255], [257, 257, 243, 250, 245, 
    273, 243, 245, 257, 237, 0, 268], [259, 257, 239, 227, 264, 258, 245, 
    259, 256, 246, 233, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 66, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 231, 234, 235, 216, 198, 245, 216, 252, 267, 253, 229],
    [270, 0, 265, 254, 247, 236, 273, 242, 262, 259, 280, 257], [267, 236, 
    0, 228, 267, 270, 275, 285, 241, 229, 280, 250], [266, 247, 273, 0, 248,
    248, 241, 235, 265, 267, 262, 284], [285, 254, 234, 253, 0, 251, 249, 
    239, 239, 266, 260, 241], [303, 265, 231, 253, 250, 0, 263, 250, 266, 
    269, 291, 247], [256, 228, 226, 260, 252, 238, 0, 244, 236, 256, 289, 
    240], [285, 259, 216, 266, 262, 251, 257, 0, 267, 274, 271, 233], [249,
    239, 260, 236, 262, 235, 265, 234, 0, 248, 254, 244], [234, 242, 272, 
    234, 235, 232, 245, 227, 253, 0, 252, 224], [248, 221, 221, 239, 241, 
    210, 212, 230, 247, 249, 0, 228], [272, 244, 251, 217, 260, 254, 261, 
    268, 257, 277, 273, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 67, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 287, 286, 342, 281, 245, 232, 294, 340, 267, 321, 226],
    [214, 0, 271, 267, 269, 201, 212, 261, 234, 196, 228, 164], [215, 230, 
    0, 264, 214, 248, 208, 260, 207, 198, 194, 135], [159, 234, 237, 0, 236,
    180, 206, 238, 307, 241, 238, 187], [220, 232, 287, 265, 0, 262, 253, 
    254, 251, 231, 308, 263], [256, 300, 253, 321, 239, 0, 231, 249, 239, 
    267, 296, 244], [269, 289, 293, 295, 248, 270, 0, 234, 298, 187, 268, 
    249], [207, 240, 241, 263, 247, 252, 267, 0, 190, 208, 211, 178], [161,
    267, 294, 194, 250, 262, 203, 311, 0, 241, 290, 231], [234, 305, 303, 
    260, 270, 234, 314, 293, 260, 0, 278, 191], [180, 273, 307, 263, 193, 
    205, 233, 290, 211, 223, 0, 216], [275, 337, 366, 314, 238, 257, 252, 
    323, 270, 310, 285, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 68, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 255, 247, 272, 244, 257, 256, 246, 260, 278, 247, 253],
    [246, 0, 266, 263, 241, 253, 244, 243, 261, 283, 239, 239], [254, 235, 
    0, 267, 248, 247, 265, 244, 248, 287, 230, 243], [229, 238, 234, 0, 229,
    226, 245, 215, 239, 279, 219, 225], [257, 260, 253, 272, 0, 244, 263, 
    243, 263, 295, 254, 258], [244, 248, 254, 275, 257, 0, 270, 254, 266, 
    283, 228, 264], [245, 257, 236, 256, 238, 231, 0, 243, 263, 272, 233, 
    229], [255, 258, 257, 286, 258, 247, 258, 0, 279, 290, 259, 260], [241,
    240, 253, 262, 238, 235, 238, 222, 0, 255, 219, 230], [223, 218, 214, 
    222, 206, 218, 229, 211, 246, 0, 222, 237], [254, 262, 271, 282, 247, 
    273, 268, 242, 282, 279, 0, 258], [248, 262, 258, 276, 243, 237, 272, 
    241, 271, 264, 243, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 69, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 219, 318, 222, 290, 252, 305, 219, 344, 304, 261, 346],
    [282, 0, 384, 198, 313, 249, 290, 299, 366, 295, 320, 308], [183, 117, 
    0, 220, 205, 167, 149, 154, 256, 192, 229, 201], [279, 303, 281, 0, 344,
    217, 280, 304, 299, 250, 282, 347], [211, 188, 296, 157, 0, 252, 215, 
    223, 309, 234, 237, 284], [249, 252, 334, 284, 249, 0, 245, 207, 324, 
    221, 241, 278], [196, 211, 352, 221, 286, 256, 0, 286, 310, 209, 247, 
    271], [282, 202, 347, 197, 278, 294, 215, 0, 368, 310, 279, 285], [157,
    135, 245, 202, 192, 177, 191, 133, 0, 221, 145, 256], [197, 206, 309, 
    251, 267, 280, 292, 191, 280, 0, 234, 321], [240, 181, 272, 219, 264, 
    260, 254, 222, 356, 267, 0, 293], [155, 193, 300, 154, 217, 223, 230, 
    216, 245, 180, 208, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 70, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 245, 224, 243, 207, 324, 286, 257, 247, 318, 233, 239],
    [256, 0, 250, 205, 240, 363, 275, 289, 303, 358, 285, 266], [277, 251, 
    0, 191, 286, 301, 238, 255, 258, 325, 275, 281], [258, 296, 310, 0, 295,
    322, 318, 249, 270, 376, 311, 282], [294, 261, 215, 206, 0, 271, 285, 
    227, 273, 351, 283, 250], [177, 138, 200, 179, 230, 0, 227, 174, 218, 
    260, 188, 219], [215, 226, 263, 183, 216, 274, 0, 172, 208, 277, 204, 
    218], [244, 212, 246, 252, 274, 327, 329, 0, 271, 283, 272, 269], [254,
    198, 243, 231, 228, 283, 293, 230, 0, 297, 273, 216], [183, 143, 176, 
    125, 150, 241, 224, 218, 204, 0, 194, 152], [268, 216, 226, 190, 218, 
    313, 297, 229, 228, 307, 0, 272], [262, 235, 220, 219, 251, 282, 283, 
    232, 285, 349, 229, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 71, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 246, 243, 206, 277, 216, 252, 242, 233, 256, 247, 227],
    [255, 0, 240, 258, 298, 255, 262, 267, 267, 293, 240, 219], [258, 261, 
    0, 238, 320, 279, 282, 266, 266, 275, 240, 262], [295, 243, 263, 0, 282,
    246, 273, 319, 250, 257, 251, 266], [224, 203, 181, 219, 0, 207, 226, 
    236, 235, 234, 215, 231], [285, 246, 222, 255, 294, 0, 267, 257, 249, 
    295, 249, 257], [249, 239, 219, 228, 275, 234, 0, 251, 247, 271, 240, 
    215], [259, 234, 235, 182, 265, 244, 250, 0, 259, 243, 263, 232], [268,
    234, 235, 251, 266, 252, 254, 242, 0, 266, 235, 237], [245, 208, 226, 
    244, 267, 206, 230, 258, 235, 0, 234, 218], [254, 261, 261, 250, 286, 
    252, 261, 238, 266, 267, 0, 241], [274, 282, 239, 235, 270, 244, 286, 
    269, 264, 283, 260, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 72, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 262, 259, 245, 221, 264, 223, 242, 260, 244, 240, 245],
    [239, 0, 260, 273, 261, 272, 233, 230, 239, 233, 270, 253], [242, 241, 
    0, 236, 254, 267, 222, 235, 254, 245, 254, 249], [256, 228, 265, 0, 248,
    258, 219, 236, 263, 248, 251, 249], [280, 240, 247, 253, 0, 278, 229, 
    254, 262, 238, 261, 247], [237, 229, 234, 243, 223, 0, 224, 230, 252, 
    220, 248, 230], [278, 268, 279, 282, 272, 277, 0, 239, 263, 257, 284, 
    263], [259, 271, 266, 265, 247, 271, 262, 0, 268, 246, 268, 258], [241,
    262, 247, 238, 239, 249, 238, 233, 0, 257, 262, 282], [257, 268, 256, 
    253, 263, 281, 244, 255, 244, 0, 263, 261], [261, 231, 247, 250, 240, 
    253, 217, 233, 239, 238, 0, 243], [256, 248, 252, 252, 254, 271, 238, 
    243, 219, 240, 258, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 73, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 285, 277, 247, 266, 257, 250, 256, 262, 259, 268, 282],
    [216, 0, 243, 219, 200, 220, 217, 235, 231, 232, 231, 233], [224, 258, 
    0, 222, 224, 238, 202, 247, 233, 231, 246, 245], [254, 282, 279, 0, 237,
    253, 238, 267, 263, 249, 258, 260], [235, 301, 277, 264, 0, 255, 255, 
    272, 276, 252, 262, 260], [244, 281, 263, 248, 246, 0, 253, 258, 256, 
    233, 269, 248], [251, 284, 299, 263, 246, 248, 0, 284, 251, 259, 277, 
    266], [245, 266, 254, 234, 229, 243, 217, 0, 244, 239, 243, 235], [239,
    270, 268, 238, 225, 245, 250, 257, 0, 239, 250, 258], [242, 269, 270, 
    252, 249, 268, 242, 262, 262, 0, 240, 262], [233, 270, 255, 243, 239, 
    232, 224, 258, 251, 261, 0, 252], [219, 268, 256, 241, 241, 253, 235, 
    266, 243, 239, 249, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 74, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 244, 238, 263, 263, 267, 222, 240, 246, 233, 260, 248],
    [257, 0, 248, 273, 252, 271, 242, 275, 247, 230, 262, 245], [263, 253, 
    0, 258, 251, 260, 232, 259, 259, 236, 234, 245], [238, 228, 243, 0, 247,
    242, 239, 252, 255, 223, 235, 237], [238, 249, 250, 254, 0, 261, 245, 
    243, 256, 238, 245, 244], [234, 230, 241, 259, 240, 0, 219, 247, 262, 
    224, 241, 235], [279, 259, 269, 262, 256, 282, 0, 272, 274, 258, 264, 
    245], [261, 226, 242, 249, 258, 254, 229, 0, 265, 244, 245, 234], [255,
    254, 242, 246, 245, 239, 227, 236, 0, 216, 239, 223], [268, 271, 265, 
    278, 263, 277, 243, 257, 285, 0, 267, 251], [241, 239, 267, 266, 256, 
    260, 237, 256, 262, 234, 0, 245], [253, 256, 256, 264, 257, 266, 256, 
    267, 278, 250, 256, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 75, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 270, 246, 256, 245, 260, 234, 254, 256, 263, 225, 260],
    [231, 0, 253, 243, 231, 253, 239, 254, 261, 246, 243, 226], [255, 248, 
    0, 256, 230, 274, 247, 247, 270, 240, 248, 256], [245, 258, 245, 0, 233,
    257, 250, 241, 264, 263, 232, 280], [256, 270, 271, 268, 0, 272, 275, 
    250, 285, 256, 248, 277], [241, 248, 227, 244, 229, 0, 229, 234, 248, 
    243, 223, 230], [267, 262, 254, 251, 226, 272, 0, 238, 264, 278, 241, 
    255], [247, 247, 254, 260, 251, 267, 263, 0, 253, 274, 259, 242], [245,
    240, 231, 237, 216, 253, 237, 248, 0, 258, 230, 229], [238, 255, 261, 
    238, 245, 258, 223, 227, 243, 0, 216, 256], [276, 258, 253, 269, 253, 
    278, 260, 242, 271, 285, 0, 255], [241, 275, 245, 221, 224, 271, 246, 
    259, 272, 245, 246, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 76, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 187, 205, 265, 221, 301, 211, 170, 215, 193, 230, 243],
    [314, 0, 294, 313, 250, 316, 263, 207, 294, 270, 271, 237], [296, 207, 
    0, 272, 223, 277, 232, 248, 299, 205, 244, 239], [236, 188, 229, 0, 266,
    240, 183, 169, 259, 210, 245, 217], [280, 251, 278, 235, 0, 265, 196, 
    250, 298, 267, 277, 235], [200, 185, 224, 261, 236, 0, 208, 223, 231, 
    254, 248, 224], [290, 238, 269, 318, 305, 293, 0, 307, 291, 303, 319, 
    321], [331, 294, 253, 332, 251, 278, 194, 0, 302, 282, 245, 214], [286,
    207, 202, 242, 203, 270, 210, 199, 0, 256, 241, 195], [308, 231, 296, 
    291, 234, 247, 198, 219, 245, 0, 238, 240], [271, 230, 257, 256, 224, 
    253, 182, 256, 260, 263, 0, 255], [258, 264, 262, 284, 266, 277, 180, 
    287, 306, 261, 246, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 77, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 254, 275, 290, 281, 257, 287, 256, 275, 277, 286, 242],
    [247, 0, 278, 270, 262, 220, 276, 248, 265, 267, 253, 268], [226, 223, 
    0, 257, 256, 232, 254, 221, 231, 250, 254, 237], [211, 231, 244, 0, 229,
    231, 224, 240, 239, 255, 240, 247], [220, 239, 245, 272, 0, 228, 261, 
    236, 246, 266, 261, 242], [244, 281, 269, 270, 273, 0, 277, 246, 262, 
    286, 262, 270], [214, 225, 247, 277, 240, 224, 0, 245, 239, 244, 232, 
    240], [245, 253, 280, 261, 265, 255, 256, 0, 261, 260, 262, 248], [226,
    236, 270, 262, 255, 239, 262, 240, 0, 261, 267, 244], [224, 234, 251, 
    246, 235, 215, 257, 241, 240, 0, 241, 247], [215, 248, 247, 261, 240, 
    239, 269, 239, 234, 260, 0, 237], [259, 233, 264, 254, 259, 231, 261, 
    253, 257, 254, 264, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 78, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 254, 229, 258, 252, 240, 259, 246, 260, 263, 269, 246],
    [247, 0, 252, 263, 261, 256, 267, 256, 258, 274, 249, 253], [272, 249, 
    0, 266, 263, 245, 273, 262, 267, 260, 267, 254], [243, 238, 235, 0, 273,
    236, 270, 247, 234, 269, 250, 236], [249, 240, 238, 228, 0, 245, 264, 
    242, 241, 264, 239, 219], [261, 245, 256, 265, 256, 0, 273, 264, 279, 
    268, 265, 245], [242, 234, 228, 231, 237, 228, 0, 235, 245, 260, 234, 
    221], [255, 245, 239, 254, 259, 237, 266, 0, 252, 267, 255, 239], [241,
    243, 234, 267, 260, 222, 256, 249, 0, 266, 261, 239], [238, 227, 241, 
    232, 237, 233, 241, 234, 235, 0, 233, 234], [232, 252, 234, 251, 262, 
    236, 267, 246, 240, 268, 0, 225], [255, 248, 247, 265, 282, 256, 280, 
    262, 262, 267, 276, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 79, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 264, 269, 241, 252, 268, 275, 245, 253, 249, 252, 281],
    [237, 0, 247, 262, 255, 264, 270, 239, 249, 257, 249, 265], [232, 254, 
    0, 236, 224, 226, 253, 223, 232, 247, 247, 252], [260, 239, 265, 0, 259,
    264, 271, 258, 268, 262, 255, 277], [249, 246, 277, 242, 0, 250, 262, 
    248, 249, 242, 252, 262], [233, 237, 275, 237, 251, 0, 254, 244, 222, 
    240, 245, 264], [226, 231, 248, 230, 239, 247, 0, 236, 238, 258, 235, 
    250], [256, 262, 278, 243, 253, 257, 265, 0, 257, 260, 270, 284], [248,
    252, 269, 233, 252, 279, 263, 244, 0, 258, 264, 262], [252, 244, 254, 
    239, 259, 261, 243, 241, 243, 0, 252, 274], [249, 252, 254, 246, 249, 
    256, 266, 231, 237, 249, 0, 272], [220, 236, 249, 224, 239, 237, 251, 
    217, 239, 227, 229, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 80, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 258, 253, 245, 271, 210, 236, 222, 209, 205, 233, 232],
    [243, 0, 292, 351, 313, 285, 218, 311, 259, 262, 270, 279], [248, 209, 
    0, 235, 209, 190, 206, 218, 185, 172, 189, 179], [256, 150, 266, 0, 274,
    229, 215, 209, 206, 172, 272, 213], [230, 188, 292, 227, 0, 265, 224, 
    171, 182, 168, 261, 238], [291, 216, 311, 272, 236, 0, 268, 221, 245, 
    211, 274, 216], [265, 283, 295, 286, 277, 233, 0, 244, 243, 258, 268, 
    283], [279, 190, 283, 292, 330, 280, 257, 0, 208, 230, 268, 264], [292,
    242, 316, 295, 319, 256, 258, 293, 0, 280, 254, 272], [296, 239, 329, 
    329, 333, 290, 243, 271, 221, 0, 293, 264], [268, 231, 312, 229, 240, 
    227, 233, 233, 247, 208, 0, 284], [269, 222, 322, 288, 263, 285, 218, 
    237, 229, 237, 217, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 81, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 269, 243, 258, 277, 260, 260, 249, 271, 250, 255, 254],
    [232, 0, 243, 224, 229, 256, 241, 240, 272, 232, 235, 251], [258, 258, 
    0, 243, 236, 263, 252, 248, 240, 238, 236, 282], [243, 277, 258, 0, 238,
    273, 250, 242, 261, 260, 260, 269], [224, 272, 265, 263, 0, 269, 271, 
    251, 276, 238, 256, 257], [241, 245, 238, 228, 232, 0, 244, 221, 218, 
    229, 233, 253], [241, 260, 249, 251, 230, 257, 0, 224, 261, 239, 259, 
    260], [252, 261, 253, 259, 250, 280, 277, 0, 273, 269, 246, 269], [230,
    229, 261, 240, 225, 283, 240, 228, 0, 244, 260, 251], [251, 269, 263, 
    241, 263, 272, 262, 232, 257, 0, 242, 265], [246, 266, 265, 241, 245, 
    268, 242, 255, 241, 259, 0, 262], [247, 250, 219, 232, 244, 248, 241, 
    232, 250, 236, 239, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 82, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 254, 252, 248, 245, 253, 239, 253, 245, 246, 253, 252],
    [247, 0, 245, 237, 240, 243, 243, 260, 239, 250, 241, 236], [249, 256, 
    0, 253, 240, 248, 250, 259, 236, 255, 227, 237], [253, 264, 248, 0, 268,
    259, 264, 262, 243, 247, 251, 248], [256, 261, 261, 233, 0, 259, 244, 
    253, 261, 255, 234, 246], [248, 258, 253, 242, 242, 0, 240, 259, 243, 
    259, 233, 239], [262, 258, 251, 237, 257, 261, 0, 252, 244, 270, 255, 
    250], [248, 241, 242, 239, 248, 242, 249, 0, 232, 264, 231, 248], [256,
    262, 265, 258, 240, 258, 257, 269, 0, 255, 256, 235], [255, 251, 246, 
    254, 246, 242, 231, 237, 246, 0, 241, 246], [248, 260, 274, 250, 267, 
    268, 246, 270, 245, 260, 0, 249], [249, 265, 264, 253, 255, 262, 251, 
    253, 266, 255, 252, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 83, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 254, 273, 257, 255, 248, 250, 251, 254, 266, 261, 256],
    [247, 0, 270, 254, 245, 273, 265, 255, 253, 254, 262, 251], [228, 231, 
    0, 223, 227, 236, 253, 224, 227, 234, 237, 195], [244, 247, 278, 0, 233,
    265, 246, 250, 264, 246, 227, 233], [246, 256, 274, 268, 0, 266, 248, 
    266, 263, 257, 266, 263], [253, 228, 265, 236, 235, 0, 254, 246, 278, 
    242, 222, 250], [251, 236, 248, 255, 253, 247, 0, 253, 268, 246, 257, 
    239], [250, 246, 277, 251, 235, 255, 248, 0, 273, 257, 265, 246], [247,
    248, 274, 237, 238, 223, 233, 228, 0, 261, 232, 210], [235, 247, 267, 
    255, 244, 259, 255, 244, 240, 0, 232, 210], [240, 239, 264, 274, 235, 
    279, 244, 236, 269, 269, 0, 230], [245, 250, 306, 268, 238, 251, 262, 
    255, 291, 291, 271, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 84, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 147, 226, 263, 272, 250, 243, 259, 236, 224, 252, 175],
    [354, 0, 206, 276, 302, 275, 282, 232, 254, 233, 304, 261], [275, 295, 
    0, 289, 294, 290, 250, 242, 263, 240, 287, 251], [238, 225, 212, 0, 254,
    266, 240, 218, 275, 219, 247, 185], [229, 199, 207, 247, 0, 199, 226, 
    178, 238, 201, 266, 254], [251, 226, 211, 235, 302, 0, 235, 225, 189, 
    229, 252, 238], [258, 219, 251, 261, 275, 266, 0, 228, 264, 225, 301, 
    226], [242, 269, 259, 283, 323, 276, 273, 0, 267, 292, 278, 287], [265,
    247, 238, 226, 263, 312, 237, 234, 0, 242, 335, 284], [277, 268, 261, 
    282, 300, 272, 276, 209, 259, 0, 306, 267], [249, 197, 214, 254, 235, 
    249, 200, 223, 166, 195, 0, 202], [326, 240, 250, 316, 247, 263, 275, 
    214, 217, 234, 299, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 85, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 264, 283, 254, 253, 279, 257, 295, 242, 263, 236, 258],
    [237, 0, 261, 253, 257, 274, 251, 260, 262, 264, 237, 245], [218, 240, 
    0, 242, 259, 255, 227, 262, 258, 236, 241, 235], [247, 248, 259, 0, 247,
    269, 233, 284, 276, 278, 254, 236], [248, 244, 242, 254, 0, 258, 245, 
    266, 254, 266, 227, 225], [222, 227, 246, 232, 243, 0, 220, 278, 260, 
    245, 234, 228], [244, 250, 274, 268, 256, 281, 0, 281, 255, 261, 240, 
    252], [206, 241, 239, 217, 235, 223, 220, 0, 247, 242, 233, 214], [259,
    239, 243, 225, 247, 241, 246, 254, 0, 242, 239, 236], [238, 237, 265, 
    223, 235, 256, 240, 259, 259, 0, 246, 243], [265, 264, 260, 247, 274, 
    267, 261, 268, 262, 255, 0, 250], [243, 256, 266, 265, 276, 273, 249, 
    287, 265, 258, 251, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 86, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 262, 260, 259, 258, 276, 266, 260, 268, 273, 250, 270],
    [239, 0, 240, 241, 226, 264, 270, 248, 239, 257, 245, 260], [241, 261, 
    0, 251, 238, 256, 259, 250, 250, 259, 251, 242], [242, 260, 250, 0, 236,
    259, 272, 256, 257, 267, 255, 253], [243, 275, 263, 265, 0, 281, 275, 
    260, 271, 267, 277, 260], [225, 237, 245, 242, 220, 0, 245, 236, 238, 
    245, 247, 247], [235, 231, 242, 229, 226, 256, 0, 241, 235, 249, 259, 
    253], [241, 253, 251, 245, 241, 265, 260, 0, 262, 253, 259, 247], [233,
    262, 251, 244, 230, 263, 266, 239, 0, 273, 259, 242], [228, 244, 242, 
    234, 234, 256, 252, 248, 228, 0, 245, 251], [251, 256, 250, 246, 224, 
    254, 242, 242, 242, 256, 0, 244], [231, 241, 259, 248, 241, 254, 248, 
    254, 259, 250, 257, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 87, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 243, 257, 267, 242, 271, 253, 246, 277, 291, 273, 264],
    [258, 0, 235, 246, 248, 265, 268, 282, 291, 297, 283, 259], [244, 266, 
    0, 270, 256, 275, 264, 258, 304, 300, 307, 263], [234, 255, 231, 0, 227,
    272, 233, 239, 259, 285, 268, 251], [259, 253, 245, 274, 0, 279, 264, 
    246, 268, 285, 271, 284], [230, 236, 226, 229, 222, 0, 241, 240, 253, 
    280, 247, 239], [248, 233, 237, 268, 237, 260, 0, 262, 285, 276, 259, 
    278], [255, 219, 243, 262, 255, 261, 239, 0, 284, 278, 282, 251], [224,
    210, 197, 242, 233, 248, 216, 217, 0, 270, 263, 232], [210, 204, 201, 
    216, 216, 221, 225, 223, 231, 0, 231, 218], [228, 218, 194, 233, 230, 
    254, 242, 219, 238, 270, 0, 248], [237, 242, 238, 250, 217, 262, 223, 
    250, 269, 283, 253, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 88, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 212, 245, 204, 237, 233, 198, 237, 232, 240, 154, 238],
    [289, 0, 242, 287, 269, 255, 284, 318, 228, 240, 240, 254], [256, 259, 
    0, 264, 253, 256, 262, 259, 261, 236, 210, 267], [297, 214, 237, 0, 289,
    254, 238, 228, 260, 266, 239, 261], [264, 232, 248, 212, 0, 252, 229, 
    250, 251, 233, 251, 252], [268, 246, 245, 247, 249, 0, 250, 264, 244, 
    244, 208, 275], [303, 217, 239, 263, 272, 251, 0, 266, 258, 279, 214, 
    270], [264, 183, 242, 273, 251, 237, 235, 0, 262, 231, 220, 239], [269,
    273, 240, 241, 250, 257, 243, 239, 0, 268, 221, 257], [261, 261, 265, 
    235, 268, 257, 222, 270, 233, 0, 235, 285], [347, 261, 291, 262, 250, 
    293, 287, 281, 280, 266, 0, 250], [263, 247, 234, 240, 249, 226, 231, 
    262, 244, 216, 251, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 89, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 195, 253, 193, 167, 162, 211, 172, 254, 170, 212, 247],
    [306, 0, 183, 264, 234, 180, 277, 213, 211, 154, 219, 248], [248, 318, 
    0, 311, 186, 230, 241, 229, 218, 251, 249, 282], [308, 237, 190, 0, 146,
    217, 206, 185, 214, 189, 289, 216], [334, 267, 315, 355, 0, 303, 283, 
    229, 271, 295, 309, 272], [339, 321, 271, 284, 198, 0, 213, 264, 204, 
    232, 229, 290], [290, 224, 260, 295, 218, 288, 0, 210, 245, 225, 240, 
    318], [329, 288, 272, 316, 272, 237, 291, 0, 268, 321, 312, 303], [247,
    290, 283, 287, 230, 297, 256, 233, 0, 240, 217, 273], [331, 347, 250, 
    312, 206, 269, 276, 180, 261, 0, 345, 268], [289, 282, 252, 212, 192, 
    272, 261, 189, 284, 156, 0, 285], [254, 253, 219, 285, 229, 211, 183, 
    198, 228, 233, 216, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 90, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 259, 260, 244, 253, 244, 247, 249, 259, 248, 267, 251],
    [242, 0, 243, 264, 244, 228, 243, 241, 245, 247, 264, 251], [241, 258, 
    0, 258, 252, 232, 242, 252, 255, 247, 279, 246], [257, 237, 243, 0, 270,
    256, 246, 256, 257, 250, 268, 253], [248, 257, 249, 231, 0, 220, 245, 
    248, 261, 243, 258, 246], [257, 273, 269, 245, 281, 0, 261, 255, 255, 
    257, 278, 268], [254, 258, 259, 255, 256, 240, 0, 243, 267, 251, 277, 
    235], [252, 260, 249, 245, 253, 246, 258, 0, 260, 248, 268, 259], [242,
    256, 246, 244, 240, 246, 234, 241, 0, 245, 297, 239], [253, 254, 254, 
    251, 258, 244, 250, 253, 256, 0, 266, 271], [234, 237, 222, 233, 243, 
    223, 224, 233, 204, 235, 0, 238], [250, 250, 255, 248, 255, 233, 266, 
    242, 262, 230, 263, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 91, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 242, 264, 269, 275, 314, 279, 288, 255, 274, 252, 278],
    [259, 0, 288, 296, 293, 315, 325, 315, 243, 302, 267, 292], [237, 213, 
    0, 241, 232, 253, 302, 289, 200, 277, 214, 262], [232, 205, 260, 0, 224,
    241, 221, 248, 201, 225, 185, 256], [226, 208, 269, 277, 0, 281, 304, 
    290, 219, 258, 211, 255], [187, 186, 248, 260, 220, 0, 292, 233, 237, 
    270, 189, 242], [222, 176, 199, 280, 197, 209, 0, 246, 256, 235, 179, 
    249], [213, 186, 212, 253, 211, 268, 255, 0, 203, 234, 169, 245], [246,
    258, 301, 300, 282, 264, 245, 298, 0, 265, 291, 298], [227, 199, 224, 
    276, 243, 231, 266, 267, 236, 0, 197, 239], [249, 234, 287, 316, 290, 
    312, 322, 332, 210, 304, 0, 310], [223, 209, 239, 245, 246, 259, 252, 
    256, 203, 262, 191, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 92, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 241, 212, 262, 245, 195, 185, 246, 214, 220, 231, 212],
    [260, 0, 252, 233, 250, 260, 197, 233, 253, 268, 254, 229], [289, 249, 
    0, 239, 278, 278, 211, 268, 281, 251, 258, 247], [239, 268, 262, 0, 266,
    266, 224, 272, 274, 250, 220, 219], [256, 251, 223, 235, 0, 244, 222, 
    233, 239, 245, 251, 227], [306, 241, 223, 235, 257, 0, 220, 250, 240, 
    249, 229, 244], [316, 304, 290, 277, 279, 281, 0, 247, 297, 308, 283, 
    273], [255, 268, 233, 229, 268, 251, 254, 0, 244, 278, 285, 252], [287,
    248, 220, 227, 262, 261, 204, 257, 0, 237, 256, 262], [281, 233, 250, 
    251, 256, 252, 193, 223, 264, 0, 227, 249], [270, 247, 243, 281, 250, 
    272, 218, 216, 245, 274, 0, 232], [289, 272, 254, 282, 274, 257, 228, 
    249, 239, 252, 269, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 93, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 238, 247, 239, 260, 262, 253, 295, 254, 234, 245, 252],
    [263, 0, 260, 242, 270, 249, 255, 283, 244, 234, 252, 251], [254, 241, 
    0, 230, 243, 248, 265, 274, 254, 244, 239, 243], [262, 259, 271, 0, 261,
    261, 262, 267, 263, 238, 259, 253], [241, 231, 258, 240, 0, 255, 239, 
    269, 241, 223, 245, 243], [239, 252, 253, 240, 246, 0, 253, 274, 253, 
    245, 249, 244], [248, 246, 236, 239, 262, 248, 0, 289, 258, 257, 246, 
    248], [206, 218, 227, 234, 232, 227, 212, 0, 212, 196, 221, 206], [247,
    257, 247, 238, 260, 248, 243, 289, 0, 233, 245, 236], [267, 267, 257, 
    263, 278, 256, 244, 305, 268, 0, 254, 260], [256, 249, 262, 242, 256, 
    252, 255, 280, 256, 247, 0, 260], [249, 250, 258, 248, 258, 257, 253, 
    295, 265, 241, 241, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 94, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 242, 240, 236, 254, 227, 249, 240, 242, 229, 235, 239],
    [259, 0, 248, 258, 240, 237, 248, 249, 239, 230, 232, 262], [261, 253, 
    0, 246, 253, 236, 234, 248, 247, 240, 241, 259], [265, 243, 255, 0, 240,
    226, 250, 253, 232, 235, 238, 237], [247, 261, 248, 261, 0, 237, 262, 
    249, 261, 234, 234, 248], [274, 264, 265, 275, 264, 0, 265, 261, 252, 
    240, 274, 255], [252, 253, 267, 251, 239, 236, 0, 259, 253, 253, 248, 
    249], [261, 252, 253, 248, 252, 240, 242, 0, 246, 236, 237, 250], [259,
    262, 254, 269, 240, 249, 248, 255, 0, 250, 260, 259], [272, 271, 261, 
    266, 267, 261, 248, 265, 251, 0, 261, 255], [266, 269, 260, 263, 267, 
    227, 253, 264, 241, 240, 0, 261], [262, 239, 242, 264, 253, 246, 252, 
    251, 242, 246, 240, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 95, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 268, 258, 267, 261, 249, 259, 267, 248, 244, 263, 260],
    [233, 0, 242, 257, 244, 229, 237, 244, 259, 237, 239, 249], [243, 259, 
    0, 268, 257, 225, 272, 261, 277, 252, 258, 267], [234, 244, 233, 0, 261,
    228, 252, 251, 250, 219, 235, 255], [240, 257, 244, 240, 0, 238, 248, 
    263, 245, 230, 235, 277], [252, 272, 276, 273, 263, 0, 250, 249, 304, 
    243, 259, 281], [242, 264, 229, 249, 253, 251, 0, 259, 254, 245, 250, 
    274], [234, 257, 240, 250, 238, 252, 242, 0, 244, 236, 253, 250], [253,
    242, 224, 251, 256, 197, 247, 257, 0, 237, 245, 260], [257, 264, 249, 
    282, 271, 258, 256, 265, 264, 0, 247, 255], [238, 262, 243, 266, 266, 
    242, 251, 248, 256, 254, 0, 269], [241, 252, 234, 246, 224, 220, 227, 
    251, 241, 246, 232, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 96, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 240, 221, 227, 190, 194, 241, 203, 225, 189, 186, 207],
    [261, 0, 250, 222, 161, 229, 231, 234, 259, 247, 241, 230], [280, 251, 
    0, 258, 235, 233, 223, 229, 266, 259, 215, 208], [274, 279, 243, 0, 203,
    235, 217, 224, 200, 223, 233, 197], [311, 340, 266, 298, 0, 285, 284, 
    272, 259, 233, 262, 257], [307, 272, 268, 266, 216, 0, 284, 280, 283, 
    225, 229, 224], [260, 270, 278, 284, 217, 217, 0, 263, 265, 214, 245, 
    240], [298, 267, 272, 277, 229, 221, 238, 0, 285, 227, 247, 229], [276,
    242, 235, 301, 242, 218, 236, 216, 0, 240, 196, 193], [312, 254, 242, 
    278, 268, 276, 287, 274, 261, 0, 270, 216], [315, 260, 286, 268, 239, 
    272, 256, 254, 305, 231, 0, 225], [294, 271, 293, 304, 244, 277, 261, 
    272, 308, 285, 276, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 97, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 262, 252, 262, 259, 252, 266, 242, 267, 252, 251, 253],
    [239, 0, 242, 253, 257, 240, 234, 253, 253, 252, 240, 245], [249, 259, 
    0, 264, 251, 228, 245, 257, 250, 246, 241, 251], [239, 248, 237, 0, 239,
    227, 229, 250, 240, 230, 226, 238], [242, 244, 250, 262, 0, 240, 240, 
    246, 258, 240, 240, 254], [249, 261, 273, 274, 261, 0, 243, 243, 254, 
    242, 255, 259], [235, 267, 256, 272, 261, 258, 0, 261, 255, 260, 263, 
    268], [259, 248, 244, 251, 255, 258, 240, 0, 266, 237, 260, 238], [234,
    248, 251, 261, 243, 247, 246, 235, 0, 240, 245, 239], [249, 249, 255, 
    271, 261, 259, 241, 264, 261, 0, 246, 258], [250, 261, 260, 275, 261, 
    246, 238, 241, 256, 255, 0, 250], [248, 256, 250, 263, 247, 242, 233, 
    263, 262, 243, 251, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 98, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 213, 234, 275, 214, 245, 228, 201, 209, 247, 234, 227],
    [288, 0, 264, 304, 250, 272, 276, 245, 253, 282, 261, 256], [267, 237, 
    0, 285, 229, 244, 258, 225, 250, 252, 234, 238], [226, 197, 216, 0, 205,
    239, 249, 219, 206, 228, 213, 236], [287, 251, 272, 296, 0, 248, 263, 
    239, 243, 261, 253, 263], [256, 229, 257, 262, 253, 0, 241, 252, 222, 
    238, 233, 245], [273, 225, 243, 252, 238, 260, 0, 246, 208, 241, 251, 
    242], [300, 256, 276, 282, 262, 249, 255, 0, 248, 273, 245, 283], [292,
    248, 251, 295, 258, 279, 293, 253, 0, 267, 289, 285], [254, 219, 249, 
    273, 240, 263, 260, 228, 234, 0, 249, 260], [267, 240, 267, 288, 248, 
    268, 250, 256, 212, 252, 0, 246], [274, 245, 263, 265, 238, 256, 259, 
    218, 216, 241, 255, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 99, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 235, 238, 238, 262, 260, 259, 253, 259, 240, 261, 260],
    [266, 0, 282, 242, 288, 261, 261, 295, 255, 260, 288, 260], [263, 219, 
    0, 232, 252, 252, 249, 260, 242, 246, 251, 238], [263, 259, 269, 0, 263,
    245, 279, 261, 258, 286, 276, 269], [239, 213, 249, 238, 0, 251, 255, 
    269, 237, 251, 255, 252], [241, 240, 249, 256, 250, 0, 249, 275, 258, 
    265, 278, 247], [242, 240, 252, 222, 246, 252, 0, 261, 255, 258, 267, 
    247], [248, 206, 241, 240, 232, 226, 240, 0, 260, 236, 253, 231], [242,
    246, 259, 243, 264, 243, 246, 241, 0, 256, 245, 264], [261, 241, 255, 
    215, 250, 236, 243, 265, 245, 0, 259, 256], [240, 213, 250, 225, 246, 
    223, 234, 248, 256, 242, 0, 234], [241, 241, 263, 232, 249, 254, 254, 
    270, 237, 245, 267, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 100, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 245, 278, 280, 240, 220, 244, 277, 270, 255, 277, 253],
    [256, 0, 228, 277, 236, 281, 220, 267, 279, 284, 244, 242], [223, 273, 
    0, 267, 209, 283, 249, 262, 286, 226, 263, 213], [221, 224, 234, 0, 225,
    221, 241, 249, 255, 242, 263, 189], [261, 265, 292, 276, 0, 246, 248, 
    274, 273, 221, 270, 282], [281, 220, 218, 280, 255, 0, 264, 269, 271, 
    260, 279, 226], [257, 281, 252, 260, 253, 237, 0, 252, 294, 251, 239, 
    236], [224, 234, 239, 252, 227, 232, 249, 0, 268, 238, 271, 205], [231,
    222, 215, 246, 228, 230, 207, 233, 0, 270, 245, 225], [246, 217, 275, 
    259, 280, 241, 250, 263, 231, 0, 248, 235], [224, 257, 238, 238, 231, 
    222, 262, 230, 256, 253, 0, 223], [248, 259, 288, 312, 219, 275, 265, 
    296, 276, 266, 278, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 101, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 228, 229, 216, 237, 235, 225, 220, 240, 254, 210, 239],
    [273, 0, 258, 264, 239, 241, 256, 263, 268, 245, 263, 277], [272, 243, 
    0, 236, 229, 221, 210, 247, 233, 241, 195, 262], [285, 237, 265, 0, 238,
    235, 249, 263, 243, 268, 233, 270], [264, 262, 272, 263, 0, 243, 245, 
    257, 262, 271, 240, 259], [266, 260, 280, 266, 258, 0, 264, 258, 245, 
    303, 280, 287], [276, 245, 291, 252, 256, 237, 0, 249, 268, 255, 251, 
    256], [281, 238, 254, 238, 244, 243, 252, 0, 230, 268, 256, 255], [261,
    233, 268, 258, 239, 256, 233, 271, 0, 260, 253, 264], [247, 256, 260, 
    233, 230, 198, 246, 233, 241, 0, 228, 248], [291, 238, 306, 268, 261, 
    221, 250, 245, 248, 273, 0, 296], [262, 224, 239, 231, 242, 214, 245, 
    246, 237, 253, 205, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 102, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 256, 251, 259, 247, 247, 252, 242, 249, 242, 254, 268],
    [245, 0, 247, 254, 254, 242, 241, 221, 241, 248, 248, 253], [250, 254, 
    0, 266, 269, 275, 256, 264, 254, 254, 261, 267], [242, 247, 235, 0, 235,
    249, 254, 232, 229, 243, 246, 258], [254, 247, 232, 266, 0, 246, 255, 
    261, 239, 240, 244, 263], [254, 259, 226, 252, 255, 0, 245, 245, 241, 
    245, 259, 258], [249, 260, 245, 247, 246, 256, 0, 256, 256, 250, 248, 
    261], [259, 280, 237, 269, 240, 256, 245, 0, 245, 255, 245, 259], [252,
    260, 247, 272, 262, 260, 245, 256, 0, 257, 267, 271], [259, 253, 247, 
    258, 261, 256, 251, 246, 244, 0, 246, 254], [247, 253, 240, 255, 257, 
    242, 253, 256, 234, 255, 0, 253], [233, 248, 234, 243, 238, 243, 240, 
    242, 230, 247, 248, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 103, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 248, 259, 262, 243, 256, 261, 255, 273, 239, 272, 260],
    [253, 0, 249, 257, 244, 250, 262, 247, 275, 262, 277, 268], [242, 252, 
    0, 257, 242, 254, 264, 249, 265, 254, 259, 264], [239, 244, 244, 0, 247,
    252, 244, 244, 272, 255, 260, 252], [258, 257, 259, 254, 0, 244, 253, 
    250, 261, 243, 259, 256], [245, 251, 247, 249, 257, 0, 255, 253, 273, 
    255, 269, 256], [240, 239, 237, 257, 248, 246, 0, 255, 263, 251, 272, 
    255], [246, 254, 252, 257, 251, 248, 246, 0, 260, 250, 276, 256], [228,
    226, 236, 229, 240, 228, 238, 241, 0, 245, 250, 251], [262, 239, 247, 
    246, 258, 246, 250, 251, 256, 0, 253, 244], [229, 224, 242, 241, 242, 
    232, 229, 225, 251, 248, 0, 245], [241, 233, 237, 249, 245, 245, 246, 
    245, 250, 257, 256, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 104, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 242, 254, 219, 236, 227, 247, 264, 230, 280, 239, 249],
    [259, 0, 230, 259, 269, 283, 269, 278, 256, 278, 250, 254], [247, 271, 
    0, 211, 259, 238, 260, 278, 220, 243, 248, 237], [282, 242, 290, 0, 278,
    253, 270, 276, 258, 291, 272, 285], [265, 232, 242, 223, 0, 249, 247, 
    258, 200, 240, 231, 245], [274, 218, 263, 248, 252, 0, 288, 285, 241, 
    287, 259, 270], [254, 232, 241, 231, 254, 213, 0, 251, 214, 270, 223, 
    260], [237, 223, 223, 225, 243, 216, 250, 0, 191, 250, 228, 231], [271,
    245, 281, 243, 301, 260, 287, 310, 0, 282, 266, 280], [221, 223, 258, 
    210, 261, 214, 231, 251, 219, 0, 250, 262], [262, 251, 253, 229, 270, 
    242, 278, 273, 235, 251, 0, 284], [252, 247, 264, 216, 256, 231, 241, 
    270, 221, 239, 217, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 105, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 249, 247, 229, 260, 244, 242, 240, 246, 254, 244, 241],
    [252, 0, 265, 259, 258, 251, 246, 232, 246, 262, 257, 258], [254, 236, 
    0, 235, 252, 230, 227, 222, 235, 249, 234, 227], [272, 242, 266, 0, 272,
    264, 245, 234, 236, 258, 243, 256], [241, 243, 249, 229, 0, 229, 224, 
    223, 219, 245, 223, 234], [257, 250, 271, 237, 272, 0, 247, 243, 267, 
    240, 246, 246], [259, 255, 274, 256, 277, 254, 0, 235, 257, 258, 270, 
    241], [261, 269, 279, 267, 278, 258, 266, 0, 250, 280, 267, 257], [255,
    255, 266, 265, 282, 234, 244, 251, 0, 262, 259, 256], [247, 239, 252, 
    243, 256, 261, 243, 221, 239, 0, 248, 243], [257, 244, 267, 258, 278, 
    255, 231, 234, 242, 253, 0, 266], [260, 243, 274, 245, 267, 255, 260, 
    244, 245, 258, 235, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 106, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 224, 216, 254, 240, 226, 245, 243, 227, 245, 235, 234],
    [277, 0, 269, 268, 251, 264, 269, 267, 253, 258, 247, 249], [285, 232, 
    0, 251, 247, 259, 274, 249, 254, 256, 247, 247], [247, 233, 250, 0, 241,
    252, 268, 242, 242, 255, 270, 237], [261, 250, 254, 260, 0, 258, 274, 
    258, 254, 275, 250, 234], [275, 237, 242, 249, 243, 0, 271, 264, 248, 
    256, 246, 249], [256, 232, 227, 233, 227, 230, 0, 222, 213, 231, 231, 
    211], [258, 234, 252, 259, 243, 237, 279, 0, 244, 279, 225, 258], [274,
    248, 247, 259, 247, 253, 288, 257, 0, 262, 253, 248], [256, 243, 245, 
    246, 226, 245, 270, 222, 239, 0, 250, 235], [266, 254, 254, 231, 251, 
    255, 270, 276, 248, 251, 0, 260], [267, 252, 254, 264, 267, 252, 290, 
    243, 253, 266, 241, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 107, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 251, 226, 234, 242, 235, 249, 229, 243, 258, 242, 246],
    [250, 0, 226, 261, 234, 254, 229, 258, 242, 234, 230, 278], [275, 275, 
    0, 260, 242, 283, 251, 261, 247, 253, 251, 302], [267, 240, 241, 0, 239,
    254, 261, 251, 269, 252, 244, 273], [259, 267, 259, 262, 0, 242, 253, 
    267, 264, 276, 259, 288], [266, 247, 218, 247, 259, 0, 233, 239, 210, 
    251, 261, 270], [252, 272, 250, 240, 248, 268, 0, 263, 252, 240, 260, 
    270], [272, 243, 240, 250, 234, 262, 238, 0, 252, 246, 254, 265], [258,
    259, 254, 232, 237, 291, 249, 249, 0, 243, 254, 266], [243, 267, 248, 
    249, 225, 250, 261, 255, 258, 0, 244, 284], [259, 271, 250, 257, 242, 
    240, 241, 247, 247, 257, 0, 253], [255, 223, 199, 228, 213, 231, 231, 
    236, 235, 217, 248, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 108, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 265, 156, 392, 353, 234, 323, 340, 347, 376, 285, 304],
    [236, 0, 326, 314, 236, 308, 335, 316, 370, 277, 204, 258], [345, 175, 
    0, 345, 247, 203, 485, 347, 326, 386, 238, 408], [109, 187, 156, 0, 306,
    165, 382, 235, 297, 306, 143, 129], [148, 265, 254, 195, 0, 184, 344, 
    256, 238, 314, 197, 261], [267, 193, 298, 336, 317, 0, 407, 397, 385, 
    335, 238, 358], [178, 166, 16, 119, 157, 94, 0, 241, 137, 157, 141, 160
    ], [161, 185, 154, 266, 245, 104, 260, 0, 166, 245, 238, 233], [154, 
    131, 175, 204, 263, 116, 364, 335, 0, 222, 184, 226], [125, 224, 115, 
    195, 187, 166, 344, 256, 279, 0, 156, 308], [216, 297, 263, 358, 304, 
    263, 360, 263, 317, 345, 0, 365], [197, 243, 93, 372, 240, 143, 341, 
    268, 275, 193, 136, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 109, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 248, 268, 242, 261, 252, 261, 225, 257, 247, 239, 258],
    [253, 0, 266, 271, 286, 271, 270, 255, 275, 264, 249, 263], [233, 235, 
    0, 240, 255, 255, 267, 236, 236, 242, 237, 240], [259, 230, 261, 0, 275,
    257, 278, 249, 230, 258, 236, 223], [240, 215, 246, 226, 0, 245, 252, 
    220, 241, 237, 206, 234], [249, 230, 246, 244, 256, 0, 292, 228, 249, 
    228, 242, 226], [240, 231, 234, 223, 249, 209, 0, 218, 230, 230, 212, 
    221], [276, 246, 265, 252, 281, 273, 283, 0, 262, 272, 256, 257], [244,
    226, 265, 271, 260, 252, 271, 239, 0, 250, 242, 267], [254, 237, 259, 
    243, 264, 273, 271, 229, 251, 0, 228, 258], [262, 252, 264, 265, 295, 
    259, 289, 245, 259, 273, 0, 254], [243, 238, 261, 278, 267, 275, 280, 
    244, 234, 243, 247, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 110, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 292, 220, 239, 220, 209, 243, 225, 221, 269, 214, 220],
    [209, 0, 239, 191, 225, 225, 222, 248, 212, 222, 180, 212], [281, 262, 
    0, 319, 228, 313, 266, 285, 263, 224, 282, 260], [262, 310, 182, 0, 264,
    318, 303, 296, 220, 229, 194, 236], [281, 276, 273, 237, 0, 280, 333, 
    246, 222, 233, 272, 247], [292, 276, 188, 183, 221, 0, 261, 249, 251, 
    225, 239, 231], [258, 279, 235, 198, 168, 240, 0, 248, 240, 243, 266, 
    216], [276, 253, 216, 205, 255, 252, 253, 0, 210, 243, 225, 213], [280,
    289, 238, 281, 279, 250, 261, 291, 0, 243, 230, 237], [232, 279, 277, 
    272, 268, 276, 258, 258, 258, 0, 220, 170], [287, 321, 219, 307, 229, 
    262, 235, 276, 271, 281, 0, 267], [281, 289, 241, 265, 254, 270, 285, 
    288, 264, 331, 234, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 111, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 277, 250, 263, 266, 291, 268, 262, 264, 262, 255, 271],
    [224, 0, 224, 241, 245, 263, 230, 242, 247, 237, 229, 243], [251, 277, 
    0, 260, 260, 249, 241, 267, 269, 264, 240, 250], [238, 260, 241, 0, 249,
    243, 253, 259, 250, 228, 251, 240], [235, 256, 241, 252, 0, 236, 242, 
    247, 253, 241, 229, 243], [210, 238, 252, 258, 265, 0, 233, 245, 234, 
    234, 218, 254], [233, 271, 260, 248, 259, 268, 0, 261, 257, 244, 265, 
    269], [239, 259, 234, 242, 254, 256, 240, 0, 252, 257, 252, 241], [237,
    254, 232, 251, 248, 267, 244, 249, 0, 244, 231, 259], [239, 264, 237, 
    273, 260, 267, 257, 244, 257, 0, 252, 242], [246, 272, 261, 250, 272, 
    283, 236, 249, 270, 249, 0, 254], [230, 258, 251, 261, 258, 247, 232, 
    260, 242, 259, 247, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 112, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 252, 267, 254, 246, 243, 275, 252, 257, 254, 230, 264],
    [249, 0, 275, 232, 259, 245, 278, 261, 280, 232, 242, 231], [234, 226, 
    0, 214, 239, 226, 240, 223, 258, 223, 230, 228], [247, 269, 287, 0, 244,
    241, 270, 270, 265, 246, 263, 259], [255, 242, 262, 257, 0, 238, 253, 
    250, 259, 253, 238, 240], [258, 256, 275, 260, 263, 0, 275, 258, 261, 
    261, 251, 243], [226, 223, 261, 231, 248, 226, 0, 250, 252, 221, 239, 
    223], [249, 240, 278, 231, 251, 243, 251, 0, 260, 216, 237, 240], [244,
    221, 243, 236, 242, 240, 249, 241, 0, 231, 251, 241], [247, 269, 278, 
    255, 248, 240, 280, 285, 270, 0, 283, 256], [271, 259, 271, 238, 263, 
    250, 262, 264, 250, 218, 0, 244], [237, 270, 273, 242, 261, 258, 278, 
    261, 260, 245, 257, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 113, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 322, 322, 267, 363, 285, 289, 297, 329, 249, 302, 276],
    [179, 0, 242, 253, 249, 256, 280, 310, 375, 256, 294, 235], [179, 259, 
    0, 177, 278, 275, 230, 235, 272, 235, 223, 184], [234, 248, 324, 0, 243,
    283, 361, 254, 339, 294, 268, 196], [138, 252, 223, 258, 0, 274, 237, 
    260, 285, 254, 298, 212], [216, 245, 226, 218, 227, 0, 300, 231, 359, 
    280, 293, 196], [212, 221, 271, 140, 264, 201, 0, 249, 291, 244, 254, 
    175], [204, 191, 266, 247, 241, 270, 252, 0, 288, 263, 236, 153], [172,
    126, 229, 162, 216, 142, 210, 213, 0, 202, 194, 166], [252, 245, 266, 
    207, 247, 221, 257, 238, 299, 0, 202, 199], [199, 207, 278, 233, 203, 
    208, 247, 265, 307, 299, 0, 146], [225, 266, 317, 305, 289, 305, 326, 
    348, 335, 302, 355, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 114, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 257, 275, 253, 262, 246, 270, 242, 242, 263, 258, 242],
    [244, 0, 264, 234, 250, 241, 245, 254, 240, 250, 238, 239], [226, 237, 
    0, 239, 225, 245, 236, 229, 241, 244, 251, 229], [248, 267, 262, 0, 261,
    253, 272, 260, 234, 271, 260, 249], [239, 251, 276, 240, 0, 260, 249, 
    248, 237, 259, 251, 235], [255, 260, 256, 248, 241, 0, 262, 244, 235, 
    259, 234, 255], [231, 256, 265, 229, 252, 239, 0, 250, 239, 250, 242, 
    239], [259, 247, 272, 241, 253, 257, 251, 0, 249, 279, 257, 270], [259,
    261, 260, 267, 264, 266, 262, 252, 0, 284, 242, 244], [238, 251, 257, 
    230, 242, 242, 251, 222, 217, 0, 236, 248], [243, 263, 250, 241, 250, 
    267, 259, 244, 259, 265, 0, 227], [259, 262, 272, 252, 266, 246, 262, 
    231, 257, 253, 274, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 115, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 235, 254, 243, 280, 266, 251, 261, 286, 318, 253, 290],
    [266, 0, 251, 256, 306, 308, 278, 230, 283, 303, 270, 324], [247, 250, 
    0, 227, 277, 326, 256, 225, 255, 280, 237, 272], [258, 245, 274, 0, 302,
    295, 269, 254, 282, 283, 265, 297], [221, 195, 224, 199, 0, 266, 232, 
    224, 231, 242, 234, 302], [235, 193, 175, 206, 235, 0, 200, 245, 227, 
    260, 199, 233], [250, 223, 245, 232, 269, 301, 0, 241, 204, 261, 247, 
    247], [240, 271, 276, 247, 277, 256, 260, 0, 226, 260, 242, 326], [215,
    218, 246, 219, 270, 274, 297, 275, 0, 272, 235, 263], [183, 198, 221, 
    218, 259, 241, 240, 241, 229, 0, 249, 249], [248, 231, 264, 236, 267, 
    302, 254, 259, 266, 252, 0, 277], [211, 177, 229, 204, 199, 268, 254, 
    175, 238, 252, 224, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 116, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 235, 282, 264, 277, 255, 279, 314, 307, 285, 311, 260],
    [266, 0, 277, 237, 238, 241, 260, 275, 291, 284, 305, 274], [219, 224, 
    0, 207, 247, 252, 205, 267, 290, 259, 295, 231], [237, 264, 294, 0, 225,
    280, 303, 261, 283, 316, 299, 275], [224, 263, 254, 276, 0, 265, 268, 
    302, 285, 279, 290, 264], [246, 260, 249, 221, 236, 0, 280, 297, 293, 
    272, 306, 264], [222, 241, 296, 198, 233, 221, 0, 282, 303, 264, 258, 
    252], [187, 226, 234, 240, 199, 204, 219, 0, 274, 194, 272, 230], [194,
    210, 211, 218, 216, 208, 198, 227, 0, 224, 262, 238], [216, 217, 242, 
    185, 222, 229, 237, 307, 277, 0, 256, 233], [190, 196, 206, 202, 211, 
    195, 243, 229, 239, 245, 0, 218], [241, 227, 270, 226, 237, 237, 249, 
    271, 263, 268, 283, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 117, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 242, 253, 253, 254, 246, 271, 240, 246, 237, 276, 260],
    [259, 0, 259, 241, 273, 255, 257, 266, 257, 264, 254, 260], [248, 242, 
    0, 242, 271, 243, 246, 254, 249, 228, 268, 251], [248, 260, 259, 0, 269,
    242, 265, 259, 239, 240, 273, 257], [247, 228, 230, 232, 0, 201, 235, 
    209, 225, 209, 244, 216], [255, 246, 258, 259, 300, 0, 271, 268, 235, 
    240, 267, 254], [230, 244, 255, 236, 266, 230, 0, 232, 241, 235, 257, 
    234], [261, 235, 247, 242, 292, 233, 269, 0, 237, 239, 263, 265], [255,
    244, 252, 262, 276, 266, 260, 264, 0, 250, 282, 261], [264, 237, 273, 
    261, 292, 261, 266, 262, 251, 0, 264, 270], [225, 247, 233, 228, 257, 
    234, 244, 238, 219, 237, 0, 229], [241, 241, 250, 244, 285, 247, 267, 
    236, 240, 231, 272, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 118, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 206, 180, 187, 207, 226, 307, 335, 145, 149, 195, 186],
    [295, 0, 260, 219, 280, 269, 321, 318, 240, 274, 267, 273], [321, 241, 
    0, 284, 267, 325, 340, 337, 197, 242, 271, 255], [314, 282, 217, 0, 244,
    253, 292, 265, 206, 232, 245, 268], [294, 221, 234, 257, 0, 270, 293, 
    341, 230, 192, 221, 229], [275, 232, 176, 248, 231, 0, 307, 248, 178, 
    236, 232, 234], [194, 180, 161, 209, 208, 194, 0, 200, 144, 125, 213, 
    180], [166, 183, 164, 236, 160, 253, 301, 0, 166, 155, 209, 218], [356,
    261, 304, 295, 271, 323, 357, 335, 0, 241, 208, 292], [352, 227, 259, 
    269, 309, 265, 376, 346, 260, 0, 277, 277], [306, 234, 230, 256, 280, 
    269, 288, 292, 293, 224, 0, 274], [315, 228, 246, 233, 272, 267, 321, 
    283, 209, 224, 227, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 119, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 267, 249, 252, 264, 260, 228, 280, 206, 256, 280, 254],
    [234, 0, 298, 266, 303, 290, 317, 271, 275, 285, 274, 308], [252, 203, 
    0, 220, 286, 298, 291, 265, 225, 255, 269, 269], [249, 235, 281, 0, 292,
    256, 267, 284, 252, 244, 269, 291], [237, 198, 215, 209, 0, 238, 188, 
    240, 270, 221, 239, 266], [241, 211, 203, 245, 263, 0, 226, 233, 235, 
    199, 245, 259], [273, 184, 210, 234, 313, 275, 0, 226, 239, 245, 254, 
    286], [221, 230, 236, 217, 261, 268, 275, 0, 216, 245, 229, 257], [295,
    226, 276, 249, 231, 266, 262, 285, 0, 256, 272, 292], [245, 216, 246, 
    257, 280, 302, 256, 256, 245, 0, 287, 264], [221, 227, 232, 232, 262, 
    256, 247, 272, 229, 214, 0, 262], [247, 193, 232, 210, 235, 242, 215, 
    244, 209, 237, 239, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 120, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 255, 217, 217, 255, 222, 211, 208, 237, 240, 224, 219],
    [246, 0, 225, 228, 238, 215, 246, 242, 251, 243, 206, 257], [284, 276, 
    0, 250, 263, 261, 264, 264, 269, 252, 260, 262], [284, 273, 251, 0, 268,
    276, 246, 266, 276, 261, 268, 259], [246, 263, 238, 233, 0, 239, 209, 
    221, 262, 227, 249, 242], [279, 286, 240, 225, 262, 0, 254, 244, 276, 
    265, 240, 241], [290, 255, 237, 255, 292, 247, 0, 229, 269, 253, 257, 
    248], [293, 259, 237, 235, 280, 257, 272, 0, 288, 260, 245, 246], [264,
    250, 232, 225, 239, 225, 232, 213, 0, 248, 236, 225], [261, 258, 249, 
    240, 274, 236, 248, 241, 253, 0, 261, 256], [277, 295, 241, 233, 252, 
    261, 244, 256, 265, 240, 0, 252], [282, 244, 239, 242, 259, 260, 253, 
    255, 276, 245, 249, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 121, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 262, 278, 270, 286, 244, 301, 253, 251, 274, 254, 283],
    [239, 0, 283, 272, 323, 261, 239, 272, 257, 296, 235, 230], [223, 218, 
    0, 264, 254, 207, 241, 223, 230, 259, 232, 229], [231, 229, 237, 0, 255,
    207, 233, 223, 189, 249, 224, 195], [215, 178, 247, 246, 0, 221, 263, 
    243, 232, 257, 227, 207], [257, 240, 294, 294, 280, 0, 293, 266, 263, 
    309, 272, 285], [200, 262, 260, 268, 238, 208, 0, 276, 215, 283, 240, 
    251], [248, 229, 278, 278, 258, 235, 225, 0, 228, 256, 248, 252], [250,
    244, 271, 312, 269, 238, 286, 273, 0, 257, 238, 282], [227, 205, 242, 
    252, 244, 192, 218, 245, 244, 0, 243, 269], [247, 266, 269, 277, 274, 
    229, 261, 253, 263, 258, 0, 276], [218, 271, 272, 306, 294, 216, 250, 
    249, 219, 232, 225, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 122, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 214, 241, 249, 213, 251, 241, 258, 248, 237, 253, 231],
    [287, 0, 280, 259, 254, 254, 245, 266, 261, 258, 250, 274], [260, 221, 
    0, 240, 227, 250, 237, 245, 267, 249, 257, 217], [252, 242, 261, 0, 236,
    248, 243, 242, 243, 251, 251, 223], [288, 247, 274, 265, 0, 261, 252, 
    264, 266, 258, 259, 240], [250, 247, 251, 253, 240, 0, 246, 243, 254, 
    254, 252, 238], [260, 256, 264, 258, 249, 255, 0, 247, 269, 257, 248, 
    254], [243, 235, 256, 259, 237, 258, 254, 0, 255, 241, 253, 244], [253,
    240, 234, 258, 235, 247, 232, 246, 0, 239, 255, 245], [264, 243, 252, 
    250, 243, 247, 244, 260, 262, 0, 263, 278], [248, 251, 244, 250, 242, 
    249, 253, 248, 246, 238, 0, 245], [270, 227, 284, 278, 261, 263, 247, 
    257, 256, 223, 256, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 123, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 241, 214, 295, 251, 197, 252, 222, 272, 238, 219, 221],
    [260, 0, 233, 299, 328, 337, 280, 255, 319, 299, 286, 254], [287, 268, 
    0, 257, 268, 241, 294, 212, 287, 278, 297, 256], [206, 202, 244, 0, 215,
    185, 270, 186, 245, 267, 253, 208], [250, 173, 233, 286, 0, 273, 285, 
    231, 265, 265, 253, 208], [304, 164, 260, 316, 228, 0, 258, 224, 217, 
    265, 251, 235], [249, 221, 207, 231, 216, 243, 0, 211, 229, 236, 243, 
    225], [279, 246, 289, 315, 270, 277, 290, 0, 232, 261, 261, 238], [229,
    182, 214, 256, 236, 284, 272, 269, 0, 288, 230, 230], [263, 202, 223, 
    234, 236, 236, 265, 240, 213, 0, 242, 258], [282, 215, 204, 248, 248, 
    250, 258, 240, 271, 259, 0, 203], [280, 247, 245, 293, 293, 266, 276, 
    263, 271, 243, 298, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 124, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 270, 251, 240, 268, 262, 258, 275, 270, 273, 259, 258],
    [231, 0, 245, 242, 260, 252, 245, 257, 260, 253, 262, 264], [250, 256, 
    0, 264, 237, 242, 254, 244, 250, 259, 261, 260], [261, 259, 237, 0, 243,
    254, 255, 264, 251, 264, 252, 263], [233, 241, 264, 258, 0, 247, 249, 
    252, 245, 249, 251, 268], [239, 249, 259, 247, 254, 0, 254, 266, 259, 
    263, 272, 259], [243, 256, 247, 246, 252, 247, 0, 267, 259, 267, 247, 
    257], [226, 244, 257, 237, 249, 235, 234, 0, 238, 253, 256, 253], [231,
    241, 251, 250, 256, 242, 242, 263, 0, 254, 264, 261], [228, 248, 242, 
    237, 252, 238, 234, 248, 247, 0, 255, 248], [242, 239, 240, 249, 250, 
    229, 254, 245, 237, 246, 0, 251], [243, 237, 241, 238, 233, 242, 244, 
    248, 240, 253, 250, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 125, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 217, 223, 225, 268, 250, 230, 261, 234, 265, 236, 210],
    [284, 0, 230, 276, 225, 208, 260, 260, 244, 244, 229, 239], [278, 271, 
    0, 274, 260, 238, 271, 299, 264, 263, 227, 254], [276, 225, 227, 0, 239,
    242, 237, 239, 258, 223, 220, 225], [233, 276, 241, 262, 0, 260, 237, 
    258, 265, 291, 252, 225], [251, 293, 263, 259, 241, 0, 262, 246, 248, 
    277, 249, 213], [271, 241, 230, 264, 264, 239, 0, 285, 251, 257, 222, 
    234], [240, 241, 202, 262, 243, 255, 216, 0, 223, 256, 236, 197], [267,
    257, 237, 243, 236, 253, 250, 278, 0, 255, 278, 214], [236, 257, 238, 
    278, 210, 224, 244, 245, 246, 0, 232, 206], [265, 272, 274, 281, 249, 
    252, 279, 265, 223, 269, 0, 227], [291, 262, 247, 276, 276, 288, 267, 
    304, 287, 295, 274, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 126, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 243, 256, 246, 227, 243, 240, 257, 243, 240, 238, 245],
    [258, 0, 256, 265, 250, 252, 259, 268, 261, 251, 259, 260], [245, 245, 
    0, 266, 253, 236, 241, 274, 257, 239, 257, 248], [255, 236, 235, 0, 244,
    241, 245, 266, 252, 242, 232, 234], [274, 251, 248, 257, 0, 251, 252, 
    266, 264, 244, 253, 256], [258, 249, 265, 260, 250, 0, 247, 268, 263, 
    239, 256, 267], [261, 242, 260, 256, 249, 254, 0, 271, 264, 240, 255, 
    250], [244, 233, 227, 235, 235, 233, 230, 0, 256, 233, 222, 236], [258,
    240, 244, 249, 237, 238, 237, 245, 0, 237, 232, 254], [261, 250, 262, 
    259, 257, 262, 261, 268, 264, 0, 254, 259], [263, 242, 244, 269, 248, 
    245, 246, 279, 269, 247, 0, 260], [256, 241, 253, 267, 245, 234, 251, 
    265, 247, 242, 241, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 127, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 277, 288, 245, 252, 254, 265, 240, 252, 272, 253, 250],
    [224, 0, 248, 234, 232, 253, 244, 242, 266, 255, 218, 244], [213, 253, 
    0, 246, 232, 240, 245, 253, 252, 280, 248, 239], [256, 267, 255, 0, 254,
    235, 273, 259, 253, 273, 231, 236], [249, 269, 269, 247, 0, 255, 269, 
    242, 265, 275, 269, 261], [247, 248, 261, 266, 246, 0, 246, 251, 276, 
    260, 242, 252], [236, 257, 256, 228, 232, 255, 0, 251, 233, 252, 225, 
    235], [261, 259, 248, 242, 259, 250, 250, 0, 250, 274, 250, 233], [249,
    235, 249, 248, 236, 225, 268, 251, 0, 268, 232, 237], [229, 246, 221, 
    228, 226, 241, 249, 227, 233, 0, 222, 227], [248, 283, 253, 270, 232, 
    259, 276, 251, 269, 279, 0, 269], [251, 257, 262, 265, 240, 249, 266, 
    268, 264, 274, 232, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 128, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 201, 317, 215, 295, 248, 271, 246, 264, 255, 252, 256],
    [300, 0, 305, 317, 266, 306, 204, 317, 250, 238, 287, 255], [184, 196, 
    0, 182, 234, 280, 189, 169, 216, 172, 160, 197], [286, 184, 319, 0, 297,
    332, 263, 185, 241, 294, 212, 136], [206, 235, 267, 204, 0, 303, 184, 
    254, 218, 282, 241, 132], [253, 195, 221, 169, 198, 0, 265, 190, 239, 
    211, 202, 110], [230, 297, 312, 238, 317, 236, 0, 260, 270, 290, 210, 
    197], [255, 184, 332, 316, 247, 311, 241, 0, 274, 232, 247, 151], [237,
    251, 285, 260, 283, 262, 231, 227, 0, 295, 173, 192], [246, 263, 329, 
    207, 219, 290, 211, 269, 206, 0, 209, 149], [249, 214, 341, 289, 260, 
    299, 291, 254, 328, 292, 0, 219], [245, 246, 304, 365, 369, 391, 304, 
    350, 309, 352, 282, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 129, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 268, 231, 267, 280, 289, 265, 288, 271, 278, 249, 253],
    [233, 0, 218, 227, 301, 250, 233, 251, 255, 266, 256, 256], [270, 283, 
    0, 269, 277, 277, 248, 255, 265, 312, 283, 282], [234, 274, 232, 0, 298,
    279, 274, 326, 265, 259, 278, 301], [221, 200, 224, 203, 0, 268, 246, 
    266, 207, 220, 254, 201], [212, 251, 224, 222, 233, 0, 208, 261, 218, 
    219, 214, 266], [236, 268, 253, 227, 255, 293, 0, 274, 237, 243, 268, 
    275], [213, 250, 246, 175, 235, 240, 227, 0, 196, 226, 239, 238], [230,
    246, 236, 236, 294, 283, 264, 305, 0, 261, 278, 233], [223, 235, 189, 
    242, 281, 282, 258, 275, 240, 0, 242, 225], [252, 245, 218, 223, 247, 
    287, 233, 262, 223, 259, 0, 233], [248, 245, 219, 200, 300, 235, 226, 
    263, 268, 276, 268, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 130, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 223, 210, 215, 244, 217, 258, 234, 216, 252, 216, 234],
    [278, 0, 254, 236, 221, 284, 275, 261, 275, 241, 267, 238], [291, 247, 
    0, 196, 257, 246, 240, 268, 256, 260, 282, 274], [286, 265, 305, 0, 258,
    256, 275, 291, 277, 279, 294, 247], [257, 280, 244, 243, 0, 207, 261, 
    276, 258, 239, 288, 268], [284, 217, 255, 245, 294, 0, 250, 257, 227, 
    283, 267, 265], [243, 226, 261, 226, 240, 251, 0, 277, 228, 258, 247, 
    249], [267, 240, 233, 210, 225, 244, 224, 0, 226, 273, 232, 187], [285,
    226, 245, 224, 243, 274, 273, 275, 0, 222, 270, 257], [249, 260, 241, 
    222, 262, 218, 243, 228, 279, 0, 241, 189], [285, 234, 219, 207, 213, 
    234, 254, 269, 231, 260, 0, 226], [267, 263, 227, 254, 233, 236, 252, 
    314, 244, 312, 275, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 131, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 239, 245, 256, 256, 223, 261, 228, 220, 206, 273, 241],
    [262, 0, 280, 298, 258, 253, 270, 238, 255, 246, 281, 222], [256, 221, 
    0, 267, 273, 220, 254, 231, 253, 235, 260, 246], [245, 203, 234, 0, 241,
    215, 216, 223, 220, 215, 230, 242], [245, 243, 228, 260, 0, 224, 206, 
    218, 235, 203, 234, 222], [278, 248, 281, 286, 277, 0, 280, 255, 247, 
    230, 245, 248], [240, 231, 247, 285, 295, 221, 0, 251, 226, 237, 236, 
    207], [273, 263, 270, 278, 283, 246, 250, 0, 240, 247, 254, 241], [281,
    246, 248, 281, 266, 254, 275, 261, 0, 244, 254, 263], [295, 255, 266, 
    286, 298, 271, 264, 254, 257, 0, 276, 238], [228, 220, 241, 271, 267, 
    256, 265, 247, 247, 225, 0, 243], [260, 279, 255, 259, 279, 253, 294, 
    260, 238, 263, 258, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 132, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 216, 276, 228, 273, 295, 247, 276, 211, 256, 264, 294],
    [285, 0, 289, 278, 322, 327, 273, 281, 297, 288, 246, 335], [225, 212, 
    0, 218, 241, 273, 203, 232, 218, 251, 230, 283], [273, 223, 283, 0, 282,
    275, 251, 240, 219, 264, 261, 258], [228, 179, 260, 219, 0, 242, 196, 
    241, 189, 240, 215, 219], [206, 174, 228, 226, 259, 0, 198, 234, 195, 
    222, 225, 231], [254, 228, 298, 250, 305, 303, 0, 277, 278, 294, 254, 
    277], [225, 220, 269, 261, 260, 267, 224, 0, 197, 245, 263, 222], [290,
    204, 283, 282, 312, 306, 223, 304, 0, 275, 242, 274], [245, 213, 250, 
    237, 261, 279, 207, 256, 226, 0, 244, 257], [237, 255, 271, 240, 286, 
    276, 247, 238, 259, 257, 0, 277], [207, 166, 218, 243, 282, 270, 224, 
    279, 227, 244, 224, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 133, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 341, 283, 289, 314, 223, 279, 278, 305, 221, 277, 249],
    [160, 0, 167, 236, 271, 200, 228, 210, 251, 164, 210, 257], [218, 334, 
    0, 240, 273, 285, 250, 324, 301, 255, 253, 264], [212, 265, 261, 0, 276,
    247, 253, 272, 269, 228, 227, 251], [187, 230, 228, 225, 0, 213, 277, 
    240, 244, 193, 232, 271], [278, 301, 216, 254, 288, 0, 310, 295, 277, 
    202, 285, 274], [222, 273, 251, 248, 224, 191, 0, 306, 267, 209, 228, 
    241], [223, 291, 177, 229, 261, 206, 195, 0, 278, 242, 249, 184], [196,
    250, 200, 232, 257, 224, 234, 223, 0, 167, 197, 241], [280, 337, 246, 
    273, 308, 299, 292, 259, 334, 0, 320, 300], [224, 291, 248, 274, 269, 
    216, 273, 252, 304, 181, 0, 294], [252, 244, 237, 250, 230, 227, 260, 
    317, 260, 201, 207, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 134, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 258, 261, 250, 231, 259, 266, 202, 253, 191, 198, 267],
    [243, 0, 268, 273, 265, 240, 253, 273, 270, 257, 269, 265], [240, 233, 
    0, 206, 193, 232, 216, 223, 197, 162, 214, 217], [251, 228, 295, 0, 245,
    308, 250, 232, 293, 191, 276, 221], [270, 236, 308, 256, 0, 265, 290, 
    231, 252, 284, 324, 257], [242, 261, 269, 193, 236, 0, 284, 274, 264, 
    255, 289, 263], [235, 248, 285, 251, 211, 217, 0, 208, 257, 198, 311, 
    247], [299, 228, 278, 269, 270, 227, 293, 0, 298, 224, 251, 291], [248,
    231, 304, 208, 249, 237, 244, 203, 0, 210, 248, 203], [310, 244, 339, 
    310, 217, 246, 303, 277, 291, 0, 317, 250], [303, 232, 287, 225, 177, 
    212, 190, 250, 253, 184, 0, 239], [234, 236, 284, 280, 244, 238, 254, 
    210, 298, 251, 262, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 135, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 273, 236, 275, 266, 261, 252, 259, 264, 253, 269, 242],
    [228, 0, 244, 269, 254, 240, 238, 250, 247, 237, 247, 233], [265, 257, 
    0, 262, 257, 255, 248, 276, 250, 247, 244, 243], [226, 232, 239, 0, 248,
    231, 238, 256, 240, 248, 243, 225], [235, 247, 244, 253, 0, 241, 247, 
    265, 260, 242, 260, 236], [240, 261, 246, 270, 260, 0, 240, 257, 260, 
    250, 254, 251], [249, 263, 253, 263, 254, 261, 0, 259, 269, 245, 257, 
    239], [242, 251, 225, 245, 236, 244, 242, 0, 249, 238, 245, 223], [237,
    254, 251, 261, 241, 241, 232, 252, 0, 234, 255, 240], [248, 264, 254, 
    253, 259, 251, 256, 263, 267, 0, 258, 237], [232, 254, 257, 258, 241, 
    247, 244, 256, 246, 243, 0, 235], [259, 268, 258, 276, 265, 250, 262, 
    278, 261, 264, 266, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 136, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 217, 223, 236, 265, 284, 227, 253, 266, 269, 256, 275],
    [284, 0, 246, 272, 296, 284, 325, 296, 287, 307, 285, 285], [278, 255, 
    0, 272, 295, 239, 267, 288, 276, 281, 292, 290], [265, 229, 229, 0, 252,
    244, 271, 267, 259, 297, 270, 293], [236, 205, 206, 249, 0, 233, 224, 
    278, 219, 248, 266, 255], [217, 217, 262, 257, 268, 0, 263, 282, 247, 
    263, 279, 287], [274, 176, 234, 230, 277, 238, 0, 267, 254, 279, 276, 
    271], [248, 205, 213, 234, 223, 219, 234, 0, 228, 263, 255, 238], [235,
    214, 225, 242, 282, 254, 247, 273, 0, 278, 280, 266], [232, 194, 220, 
    204, 253, 238, 222, 238, 223, 0, 234, 248], [245, 216, 209, 231, 235, 
    222, 225, 246, 221, 267, 0, 264], [226, 216, 211, 208, 246, 214, 230, 
    263, 235, 253, 237, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 137, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 225, 234, 235, 244, 253, 248, 264, 252, 230, 237, 223],
    [276, 0, 260, 259, 273, 266, 273, 295, 269, 235, 264, 268], [267, 241, 
    0, 250, 244, 257, 248, 261, 249, 228, 237, 239], [266, 242, 251, 0, 249,
    264, 247, 295, 274, 247, 243, 259], [257, 228, 257, 252, 0, 269, 248, 
    287, 260, 228, 255, 231], [248, 235, 244, 237, 232, 0, 239, 255, 237, 
    231, 233, 222], [253, 228, 253, 254, 253, 262, 0, 286, 274, 246, 236, 
    246], [237, 206, 240, 206, 214, 246, 215, 0, 230, 224, 212, 229], [249,
    232, 252, 227, 241, 264, 227, 271, 0, 239, 220, 240], [271, 266, 273, 
    254, 273, 270, 255, 277, 262, 0, 236, 260], [264, 237, 264, 258, 246, 
    268, 265, 289, 281, 265, 0, 248], [278, 233, 262, 242, 270, 279, 255, 
    272, 261, 241, 253, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 138, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 295, 282, 264, 304, 264, 265, 261, 291, 250, 270, 286],
    [206, 0, 219, 243, 217, 246, 193, 218, 224, 202, 242, 231], [219, 282, 
    0, 278, 282, 252, 193, 257, 265, 234, 256, 263], [237, 258, 223, 0, 263,
    239, 230, 244, 247, 206, 243, 257], [197, 284, 219, 238, 0, 211, 212, 
    233, 244, 200, 233, 235], [237, 255, 249, 262, 290, 0, 228, 249, 246, 
    241, 258, 276], [236, 308, 308, 271, 289, 273, 0, 252, 262, 261, 272, 
    267], [240, 283, 244, 257, 268, 252, 249, 0, 267, 232, 249, 267], [210,
    277, 236, 254, 257, 255, 239, 234, 0, 217, 252, 245], [251, 299, 267, 
    295, 301, 260, 240, 269, 284, 0, 269, 285], [231, 259, 245, 258, 268, 
    243, 229, 252, 249, 232, 0, 246], [215, 270, 238, 244, 266, 225, 234, 
    234, 256, 216, 255, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 139, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 254, 260, 251, 248, 240, 216, 263, 269, 241, 246, 263],
    [247, 0, 254, 224, 256, 242, 237, 261, 266, 245, 236, 260], [241, 247, 
    0, 233, 261, 232, 233, 260, 246, 241, 251, 267], [250, 277, 268, 0, 258,
    258, 253, 269, 287, 272, 257, 305], [253, 245, 240, 243, 0, 227, 230, 
    252, 280, 255, 233, 270], [261, 259, 269, 243, 274, 0, 247, 265, 291, 
    255, 273, 274], [285, 264, 268, 248, 271, 254, 0, 268, 293, 287, 265, 
    290], [238, 240, 241, 232, 249, 236, 233, 0, 258, 254, 245, 273], [232,
    235, 255, 214, 221, 210, 208, 243, 0, 217, 244, 263], [260, 256, 260, 
    229, 246, 246, 214, 247, 284, 0, 264, 259], [255, 265, 250, 244, 268, 
    228, 236, 256, 257, 237, 0, 257], [238, 241, 234, 196, 231, 227, 211, 
    228, 238, 242, 244, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 140, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 249, 265, 268, 283, 256, 248, 258, 243, 276, 266, 269],
    [252, 0, 261, 277, 264, 251, 271, 255, 261, 280, 274, 245], [236, 240, 
    0, 245, 250, 237, 230, 238, 243, 240, 248, 248], [233, 224, 256, 0, 250,
    245, 244, 238, 246, 253, 249, 241], [218, 237, 251, 251, 0, 243, 255, 
    255, 254, 258, 231, 257], [245, 250, 264, 256, 258, 0, 260, 258, 254, 
    263, 265, 250], [253, 230, 271, 257, 246, 241, 0, 238, 241, 255, 258, 
    229], [243, 246, 263, 263, 246, 243, 263, 0, 244, 261, 259, 254], [258,
    240, 258, 255, 247, 247, 260, 257, 0, 261, 265, 259], [225, 221, 261, 
    248, 243, 238, 246, 240, 240, 0, 240, 225], [235, 227, 253, 252, 270, 
    236, 243, 242, 236, 261, 0, 247], [232, 256, 253, 260, 244, 251, 272, 
    247, 242, 276, 254, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 141, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 169, 181, 135, 252, 237, 272, 233, 181, 195, 164, 235],
    [332, 0, 288, 276, 293, 286, 334, 278, 188, 244, 279, 262], [320, 213, 
    0, 217, 304, 336, 382, 304, 232, 274, 226, 300], [366, 225, 284, 0, 216,
    366, 336, 272, 344, 222, 281, 284], [249, 208, 197, 285, 0, 271, 268, 
    209, 261, 140, 207, 207], [264, 215, 165, 135, 230, 0, 262, 209, 188, 
    184, 233, 167], [229, 167, 119, 165, 233, 239, 0, 234, 241, 186, 184, 
    188], [268, 223, 197, 229, 292, 292, 267, 0, 246, 204, 215, 303], [320,
    313, 269, 157, 240, 313, 260, 255, 0, 253, 183, 231], [306, 257, 227, 
    279, 361, 317, 315, 297, 248, 0, 283, 320], [337, 222, 275, 220, 294, 
    268, 317, 286, 318, 218, 0, 294], [266, 239, 201, 217, 294, 334, 313, 
    198, 270, 181, 207, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 142, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 235, 268, 257, 259, 259, 245, 284, 255, 274, 267, 260],
    [266, 0, 260, 257, 266, 270, 244, 282, 255, 276, 279, 259], [233, 241, 
    0, 248, 256, 235, 234, 273, 240, 259, 267, 236], [244, 244, 253, 0, 251,
    264, 235, 263, 242, 259, 244, 252], [242, 235, 245, 250, 0, 258, 240, 
    258, 230, 257, 259, 252], [242, 231, 266, 237, 243, 0, 255, 278, 250, 
    277, 264, 256], [256, 257, 267, 266, 261, 246, 0, 291, 252, 277, 278, 
    272], [217, 219, 228, 238, 243, 223, 210, 0, 207, 228, 237, 232], [246,
    246, 261, 259, 271, 251, 249, 294, 0, 265, 267, 251], [227, 225, 242, 
    242, 244, 224, 224, 273, 236, 0, 259, 237], [234, 222, 234, 257, 242, 
    237, 223, 264, 234, 242, 0, 245], [241, 242, 265, 249, 249, 245, 229, 
    269, 250, 264, 256, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 143, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 245, 243, 227, 258, 259, 242, 236, 232, 243, 248, 247],
    [256, 0, 247, 271, 262, 256, 274, 258, 251, 252, 270, 249], [258, 254, 
    0, 256, 262, 267, 262, 247, 265, 268, 277, 262], [274, 230, 245, 0, 270,
    260, 271, 260, 260, 254, 279, 267], [243, 239, 239, 231, 0, 248, 251, 
    238, 233, 241, 256, 250], [242, 245, 234, 241, 253, 0, 262, 237, 240, 
    245, 255, 249], [259, 227, 239, 230, 250, 239, 0, 251, 238, 250, 261, 
    255], [265, 243, 254, 241, 263, 264, 250, 0, 251, 242, 254, 254], [269,
    250, 236, 241, 268, 261, 263, 250, 0, 264, 262, 264], [258, 249, 233, 
    247, 260, 256, 251, 259, 237, 0, 261, 229], [253, 231, 224, 222, 245, 
    246, 240, 247, 239, 240, 0, 244], [254, 252, 239, 234, 251, 252, 246, 
    247, 237, 272, 257, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 144, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 246, 274, 260, 263, 258, 258, 258, 242, 255, 253, 266],
    [255, 0, 250, 249, 249, 256, 265, 251, 252, 247, 261, 254], [227, 251, 
    0, 240, 259, 247, 266, 231, 231, 257, 256, 241], [241, 252, 261, 0, 271,
    260, 281, 245, 260, 253, 254, 255], [238, 252, 242, 230, 0, 225, 254, 
    236, 243, 238, 240, 221], [243, 245, 254, 241, 276, 0, 262, 256, 259, 
    267, 261, 249], [243, 236, 235, 220, 247, 239, 0, 223, 212, 237, 233, 
    230], [243, 250, 270, 256, 265, 245, 278, 0, 264, 252, 256, 248], [259,
    249, 270, 241, 258, 242, 289, 237, 0, 264, 247, 256], [246, 254, 244, 
    248, 263, 234, 264, 249, 237, 0, 261, 255], [248, 240, 245, 247, 261, 
    240, 268, 245, 254, 240, 0, 240], [235, 247, 260, 246, 280, 252, 271, 
    253, 245, 246, 261, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 145, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 271, 288, 231, 262, 251, 263, 260, 280, 262, 214, 245],
    [230, 0, 281, 231, 263, 256, 253, 237, 271, 245, 229, 228], [213, 220, 
    0, 193, 205, 226, 220, 201, 234, 233, 216, 210], [270, 270, 308, 0, 279,
    281, 248, 273, 291, 254, 245, 261], [239, 238, 296, 222, 0, 250, 249, 
    222, 247, 229, 215, 221], [250, 245, 275, 220, 251, 0, 240, 240, 276, 
    213, 220, 236], [238, 248, 281, 253, 252, 261, 0, 261, 259, 239, 231, 
    238], [241, 264, 300, 228, 279, 261, 240, 0, 274, 250, 263, 237], [221,
    230, 267, 210, 254, 225, 242, 227, 0, 233, 191, 207], [239, 256, 268, 
    247, 272, 288, 262, 251, 268, 0, 240, 231], [287, 272, 285, 256, 286, 
    281, 270, 238, 310, 261, 0, 256], [256, 273, 291, 240, 280, 265, 263, 
    264, 294, 270, 245, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 146, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 240, 211, 249, 253, 203, 252, 239, 225, 258, 271, 275],
    [261, 0, 243, 246, 267, 246, 220, 242, 234, 283, 302, 261], [290, 258, 
    0, 257, 233, 233, 274, 262, 272, 282, 300, 294], [252, 255, 244, 0, 244,
    210, 251, 229, 197, 286, 308, 279], [248, 234, 268, 257, 0, 229, 260, 
    238, 260, 307, 320, 289], [298, 255, 268, 291, 272, 0, 256, 233, 226, 
    263, 278, 292], [249, 281, 227, 250, 241, 245, 0, 228, 234, 291, 289, 
    260], [262, 259, 239, 272, 263, 268, 273, 0, 241, 290, 323, 296], [276,
    267, 229, 304, 241, 275, 267, 260, 0, 264, 329, 299], [243, 218, 219, 
    215, 194, 238, 210, 211, 237, 0, 280, 236], [230, 199, 201, 193, 181, 
    223, 212, 178, 172, 221, 0, 234], [226, 240, 207, 222, 212, 209, 241, 
    205, 202, 265, 267, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 147, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 245, 235, 249, 236, 253, 253, 249, 253, 224, 241, 241],
    [256, 0, 253, 269, 248, 251, 250, 283, 266, 255, 257, 268], [266, 248, 
    0, 258, 241, 252, 248, 271, 259, 251, 239, 245], [252, 232, 243, 0, 234,
    246, 250, 252, 257, 217, 234, 254], [265, 253, 260, 267, 0, 255, 248, 
    270, 275, 243, 256, 257], [248, 250, 249, 255, 246, 0, 254, 252, 253, 
    226, 251, 252], [248, 251, 253, 251, 253, 247, 0, 265, 253, 245, 264, 
    269], [252, 218, 230, 249, 231, 249, 236, 0, 245, 245, 246, 240], [248,
    235, 242, 244, 226, 248, 248, 256, 0, 234, 252, 246], [277, 246, 250, 
    284, 258, 275, 256, 256, 267, 0, 274, 256], [260, 244, 262, 267, 245, 
    250, 237, 255, 249, 227, 0, 255], [260, 233, 256, 247, 244, 249, 232, 
    261, 255, 245, 246, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 148, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 282, 168, 181, 167, 308, 263, 211, 240, 237, 218, 214],
    [219, 0, 207, 194, 129, 294, 253, 135, 261, 237, 172, 200], [333, 294, 
    0, 211, 263, 340, 319, 255, 291, 267, 230, 240], [320, 307, 290, 0, 228,
    308, 281, 250, 331, 312, 316, 237], [334, 372, 238, 273, 0, 403, 286, 
    322, 339, 325, 285, 301], [193, 207, 161, 193, 98, 0, 186, 159, 228, 
    238, 218, 126], [238, 248, 182, 220, 215, 315, 0, 220, 245, 223, 235, 
    289], [290, 366, 246, 251, 179, 342, 281, 0, 286, 277, 262, 255], [261,
    240, 210, 170, 162, 273, 256, 215, 0, 239, 268, 242], [264, 264, 234, 
    189, 176, 263, 278, 224, 262, 0, 214, 236], [283, 329, 271, 185, 216, 
    283, 266, 239, 233, 287, 0, 214], [287, 301, 261, 264, 200, 375, 212, 
    246, 259, 265, 287, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 149, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 247, 280, 289, 263, 243, 289, 285, 272, 277, 291, 276],
    [254, 0, 231, 296, 224, 217, 248, 269, 264, 220, 274, 269], [221, 270, 
    0, 243, 210, 231, 246, 234, 238, 273, 262, 226], [212, 205, 258, 0, 190,
    206, 236, 216, 213, 217, 222, 229], [238, 277, 291, 311, 0, 278, 286, 
    287, 280, 248, 308, 300], [258, 284, 270, 295, 223, 0, 267, 240, 301, 
    270, 270, 268], [212, 253, 255, 265, 215, 234, 0, 235, 247, 228, 288, 
    233], [216, 232, 267, 285, 214, 261, 266, 0, 239, 237, 281, 261], [229,
    237, 263, 288, 221, 200, 254, 262, 0, 208, 253, 225], [224, 281, 228, 
    284, 253, 231, 273, 264, 293, 0, 273, 260], [210, 227, 239, 279, 193, 
    231, 213, 220, 248, 228, 0, 265], [225, 232, 275, 272, 201, 233, 268, 
    240, 276, 241, 236, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 150, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 253, 268, 253, 288, 248, 266, 246, 278, 288, 256, 259],
    [248, 0, 237, 232, 254, 226, 219, 250, 252, 251, 233, 230], [233, 264, 
    0, 252, 242, 263, 251, 257, 260, 274, 252, 257], [248, 269, 249, 0, 274,
    243, 250, 255, 269, 280, 250, 245], [213, 247, 259, 227, 0, 232, 238, 
    237, 235, 238, 260, 212], [253, 275, 238, 258, 269, 0, 232, 253, 268, 
    276, 256, 253], [235, 282, 250, 251, 263, 269, 0, 234, 275, 262, 267, 
    264], [255, 251, 244, 246, 264, 248, 267, 0, 254, 271, 250, 253], [223,
    249, 241, 232, 266, 233, 226, 247, 0, 254, 262, 234], [213, 250, 227, 
    221, 263, 225, 239, 230, 247, 0, 224, 218], [245, 268, 249, 251, 241, 
    245, 234, 251, 239, 277, 0, 229], [242, 271, 244, 256, 289, 248, 237, 
    248, 267, 283, 272, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 151, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 264, 253, 256, 264, 266, 240, 255, 263, 248, 255, 259],
    [237, 0, 236, 230, 239, 234, 235, 235, 240, 217, 230, 234], [248, 265, 
    0, 258, 281, 258, 256, 246, 271, 261, 263, 259], [245, 271, 243, 0, 259,
    244, 254, 240, 254, 248, 251, 243], [237, 262, 220, 242, 0, 229, 239, 
    244, 239, 231, 255, 250], [235, 267, 243, 257, 272, 0, 255, 242, 254, 
    242, 269, 252], [261, 266, 245, 247, 262, 246, 0, 243, 251, 259, 257, 
    266], [246, 266, 255, 261, 257, 259, 258, 0, 263, 269, 271, 258], [238,
    261, 230, 247, 262, 247, 250, 238, 0, 245, 248, 256], [253, 284, 240, 
    253, 270, 259, 242, 232, 256, 0, 267, 265], [246, 271, 238, 250, 246, 
    232, 244, 230, 253, 234, 0, 233], [242, 267, 242, 258, 251, 249, 235, 
    243, 245, 236, 268, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 152, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 272, 244, 268, 254, 267, 264, 279, 282, 280, 253, 242],
    [229, 0, 225, 240, 224, 239, 257, 262, 270, 262, 246, 252], [257, 276, 
    0, 261, 247, 260, 282, 270, 280, 296, 252, 268], [233, 261, 240, 0, 228,
    252, 263, 249, 255, 254, 237, 252], [247, 277, 254, 273, 0, 261, 291, 
    291, 280, 272, 268, 249], [234, 262, 241, 249, 240, 0, 264, 248, 271, 
    254, 250, 240], [237, 244, 219, 238, 210, 237, 0, 239, 250, 247, 229, 
    227], [222, 239, 231, 252, 210, 253, 262, 0, 275, 252, 272, 235], [219,
    231, 221, 246, 221, 230, 251, 226, 0, 246, 222, 250], [221, 239, 205, 
    247, 229, 247, 254, 249, 255, 0, 240, 228], [248, 255, 249, 264, 233, 
    251, 272, 229, 279, 261, 0, 253], [259, 249, 233, 249, 252, 261, 274, 
    266, 251, 273, 248, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 153, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 226, 214, 221, 224, 219, 229, 225, 234, 245, 219, 253],
    [275, 0, 267, 223, 241, 250, 246, 234, 263, 278, 278, 271], [287, 234, 
    0, 249, 250, 241, 274, 228, 247, 277, 248, 264], [280, 278, 252, 0, 249,
    270, 243, 255, 285, 288, 265, 289], [277, 260, 251, 252, 0, 252, 263, 
    244, 257, 284, 254, 263], [282, 251, 260, 231, 249, 0, 266, 262, 263, 
    294, 258, 245], [272, 255, 227, 258, 238, 235, 0, 236, 252, 255, 250, 
    249], [276, 267, 273, 246, 257, 239, 265, 0, 249, 288, 238, 252], [267,
    238, 254, 216, 244, 238, 249, 252, 0, 286, 250, 259], [256, 223, 224, 
    213, 217, 207, 246, 213, 215, 0, 213, 219], [282, 223, 253, 236, 247, 
    243, 251, 263, 251, 288, 0, 266], [248, 230, 237, 212, 238, 256, 252, 
    249, 242, 282, 235, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 154, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 267, 273, 242, 256, 252, 287, 236, 267, 287, 242, 225],
    [234, 0, 225, 191, 231, 218, 231, 251, 251, 255, 214, 198], [228, 276, 
    0, 196, 216, 250, 268, 269, 249, 261, 233, 220], [259, 310, 305, 0, 231,
    284, 278, 274, 302, 267, 272, 275], [245, 270, 285, 270, 0, 283, 260, 
    276, 274, 264, 260, 236], [249, 283, 251, 217, 218, 0, 244, 264, 253, 
    254, 254, 240], [214, 270, 233, 223, 241, 257, 0, 232, 240, 279, 197, 
    202], [265, 250, 232, 227, 225, 237, 269, 0, 253, 265, 243, 204], [234,
    250, 252, 199, 227, 248, 261, 248, 0, 272, 235, 206], [214, 246, 240, 
    234, 237, 247, 222, 236, 229, 0, 208, 218], [259, 287, 268, 229, 241, 
    247, 304, 258, 266, 293, 0, 238], [276, 303, 281, 226, 265, 261, 299, 
    297, 295, 283, 263, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 155, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 278, 250, 296, 254, 278, 258, 260, 258, 244, 262, 248],
    [223, 0, 238, 253, 222, 237, 241, 181, 252, 218, 236, 217], [251, 263, 
    0, 263, 217, 259, 246, 171, 248, 213, 253, 239], [205, 248, 238, 0, 229,
    231, 248, 214, 217, 190, 223, 244], [247, 279, 284, 272, 0, 288, 299, 
    187, 249, 218, 262, 238], [223, 264, 242, 270, 213, 0, 257, 202, 257, 
    212, 201, 255], [243, 260, 255, 253, 202, 244, 0, 183, 264, 215, 208, 
    198], [241, 320, 330, 287, 314, 299, 318, 0, 273, 302, 293, 324], [243,
    249, 253, 284, 252, 244, 237, 228, 0, 228, 246, 265], [257, 283, 288, 
    311, 283, 289, 286, 199, 273, 0, 290, 262], [239, 265, 248, 278, 239, 
    300, 293, 208, 255, 211, 0, 275], [253, 284, 262, 257, 263, 246, 303, 
    177, 236, 239, 226, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 156, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 254, 262, 242, 244, 242, 264, 245, 261, 238, 246, 249],
    [247, 0, 263, 254, 250, 255, 266, 264, 260, 241, 273, 241], [239, 238, 
    0, 236, 222, 235, 250, 241, 255, 228, 253, 234], [259, 247, 265, 0, 235,
    259, 263, 251, 258, 253, 265, 260], [257, 251, 279, 266, 0, 247, 273, 
    262, 257, 251, 270, 250], [259, 246, 266, 242, 254, 0, 255, 257, 268, 
    244, 264, 254], [237, 235, 251, 238, 228, 246, 0, 232, 242, 228, 265, 
    241], [256, 237, 260, 250, 239, 244, 269, 0, 253, 247, 261, 248], [240,
    241, 246, 243, 244, 233, 259, 248, 0, 229, 250, 233], [263, 260, 273, 
    248, 250, 257, 273, 254, 272, 0, 250, 252], [255, 228, 248, 236, 231, 
    237, 236, 240, 251, 251, 0, 229], [252, 260, 267, 241, 251, 247, 260, 
    253, 268, 249, 272, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 157, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 281, 247, 303, 292, 223, 290, 319, 291, 252, 276, 289],
    [220, 0, 246, 233, 243, 235, 268, 263, 263, 252, 260, 267], [254, 255, 
    0, 260, 246, 237, 288, 299, 240, 248, 244, 270], [198, 268, 241, 0, 269,
    220, 253, 291, 261, 252, 227, 223], [209, 258, 255, 232, 0, 215, 288, 
    296, 255, 244, 265, 248], [278, 266, 264, 281, 286, 0, 322, 318, 249, 
    253, 309, 257], [211, 233, 213, 248, 213, 179, 0, 278, 227, 189, 220, 
    214], [182, 238, 202, 210, 205, 183, 223, 0, 213, 227, 227, 188], [210,
    238, 261, 240, 246, 252, 274, 288, 0, 251, 272, 256], [249, 249, 253, 
    249, 257, 248, 312, 274, 250, 0, 265, 255], [225, 241, 257, 274, 236, 
    192, 281, 274, 229, 236, 0, 243], [212, 234, 231, 278, 253, 244, 287, 
    313, 245, 246, 258, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 158, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 233, 252, 293, 302, 227, 234, 257, 282, 260, 196, 319],
    [268, 0, 272, 295, 328, 240, 288, 286, 277, 323, 251, 305], [249, 229, 
    0, 250, 237, 207, 228, 228, 251, 240, 214, 277], [208, 206, 251, 0, 282,
    208, 200, 231, 250, 251, 193, 234], [199, 173, 264, 219, 0, 192, 206, 
    210, 239, 238, 215, 248], [274, 261, 294, 293, 309, 0, 229, 259, 323, 
    278, 233, 278], [267, 213, 273, 301, 295, 272, 0, 240, 245, 264, 197, 
    242], [244, 215, 273, 270, 291, 242, 261, 0, 244, 242, 225, 291], [219,
    224, 250, 251, 262, 178, 256, 257, 0, 254, 222, 274], [241, 178, 261, 
    250, 263, 223, 237, 259, 247, 0, 248, 277], [305, 250, 287, 308, 286, 
    268, 304, 276, 279, 253, 0, 277], [182, 196, 224, 267, 253, 223, 259, 
    210, 227, 224, 224, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 159, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 210, 230, 257, 250, 187, 391, 268, 214, 215, 302, 277],
    [291, 0, 202, 236, 214, 282, 390, 313, 235, 186, 285, 249], [271, 299, 
    0, 299, 202, 305, 314, 242, 212, 258, 339, 307], [244, 265, 202, 0, 217,
    281, 418, 303, 253, 275, 273, 298], [251, 287, 299, 284, 0, 369, 372, 
    295, 358, 206, 332, 280], [314, 219, 196, 220, 132, 0, 354, 281, 241, 
    221, 257, 260], [110, 111, 187, 83, 129, 147, 0, 185, 150, 118, 147, 
    113], [233, 188, 259, 198, 206, 220, 316, 0, 298, 196, 286, 287], [287,
    266, 289, 248, 143, 260, 351, 203, 0, 192, 287, 191], [286, 315, 243, 
    226, 295, 280, 383, 305, 309, 0, 315, 334], [199, 216, 162, 228, 169, 
    244, 354, 215, 214, 186, 0, 265], [224, 252, 194, 203, 221, 241, 388, 
    214, 310, 167, 236, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 160, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 247, 239, 236, 258, 259, 258, 254, 261, 248, 255, 245],
    [254, 0, 240, 241, 241, 248, 243, 250, 254, 259, 251, 236], [262, 261, 
    0, 239, 269, 263, 244, 249, 282, 257, 250, 240], [265, 260, 262, 0, 266,
    260, 260, 257, 263, 246, 259, 241], [243, 260, 232, 235, 0, 259, 247, 
    266, 246, 245, 247, 247], [242, 253, 238, 241, 242, 0, 236, 240, 252, 
    273, 262, 242], [243, 258, 257, 241, 254, 265, 0, 251, 252, 247, 257, 
    240], [247, 251, 252, 244, 235, 261, 250, 0, 257, 242, 264, 255], [240,
    247, 219, 238, 255, 249, 249, 244, 0, 246, 251, 228], [253, 242, 244, 
    255, 256, 228, 254, 259, 255, 0, 239, 244], [246, 250, 251, 242, 254, 
    239, 244, 237, 250, 262, 0, 241], [256, 265, 261, 260, 254, 259, 261, 
    246, 273, 257, 260, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 161, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 253, 232, 263, 238, 248, 230, 237, 264, 245, 234, 277],
    [248, 0, 249, 244, 248, 252, 240, 247, 265, 248, 240, 260], [269, 252, 
    0, 266, 248, 243, 233, 243, 284, 266, 260, 254], [238, 257, 235, 0, 268,
    248, 228, 237, 253, 256, 242, 250], [263, 253, 253, 233, 0, 248, 254, 
    256, 253, 254, 240, 262], [253, 249, 258, 253, 253, 0, 244, 243, 252, 
    266, 248, 262], [271, 261, 268, 273, 247, 257, 0, 253, 287, 268, 248, 
    264], [264, 254, 258, 264, 245, 258, 248, 0, 256, 251, 260, 266], [237,
    236, 217, 248, 248, 249, 214, 245, 0, 259, 234, 239], [256, 253, 235, 
    245, 247, 235, 233, 250, 242, 0, 250, 251], [267, 261, 241, 259, 261, 
    253, 253, 241, 267, 251, 0, 237], [224, 241, 247, 251, 239, 239, 237, 
    235, 262, 250, 264, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 162, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 261, 230, 222, 227, 231, 244, 261, 227, 247, 235, 243],
    [240, 0, 213, 231, 239, 222, 225, 244, 227, 246, 233, 234], [271, 288, 
    0, 238, 277, 275, 250, 272, 248, 276, 254, 264], [279, 270, 263, 0, 247,
    255, 248, 273, 269, 271, 256, 271], [274, 262, 224, 254, 0, 252, 226, 
    244, 261, 266, 260, 264], [270, 279, 226, 246, 249, 0, 251, 272, 264, 
    256, 267, 272], [257, 276, 251, 253, 275, 250, 0, 278, 254, 260, 265, 
    264], [240, 257, 229, 228, 257, 229, 223, 0, 240, 272, 243, 255], [274,
    274, 253, 232, 240, 237, 247, 261, 0, 263, 251, 257], [254, 255, 225, 
    230, 235, 245, 241, 229, 238, 0, 238, 255], [266, 268, 247, 245, 241, 
    234, 236, 258, 250, 263, 0, 277], [258, 267, 237, 230, 237, 229, 237, 
    246, 244, 246, 224, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 163, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 242, 261, 218, 245, 242, 270, 224, 241, 219, 258, 246],
    [259, 0, 264, 242, 240, 269, 259, 275, 258, 264, 245, 265], [240, 237, 
    0, 224, 233, 262, 254, 252, 257, 258, 252, 259], [283, 259, 277, 0, 248,
    259, 287, 246, 265, 260, 245, 289], [256, 261, 268, 253, 0, 246, 284, 
    252, 262, 261, 269, 264], [259, 232, 239, 242, 255, 0, 256, 255, 245, 
    258, 235, 227], [231, 242, 247, 214, 217, 245, 0, 251, 219, 252, 253, 
    247], [277, 226, 249, 255, 249, 246, 250, 0, 257, 265, 261, 254], [260,
    243, 244, 236, 239, 256, 282, 244, 0, 261, 245, 252], [282, 237, 243, 
    241, 240, 243, 249, 236, 240, 0, 257, 261], [243, 256, 249, 256, 232, 
    266, 248, 240, 256, 244, 0, 255], [255, 236, 242, 212, 237, 274, 254, 
    247, 249, 240, 246, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 164, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 221, 255, 246, 236, 230, 246, 282, 276, 225, 210, 270],
    [280, 0, 287, 290, 265, 268, 250, 267, 273, 283, 248, 307], [246, 214, 
    0, 299, 261, 304, 253, 272, 256, 286, 229, 248], [255, 211, 202, 0, 261,
    222, 164, 250, 272, 263, 234, 241], [265, 236, 240, 240, 0, 271, 191, 
    241, 271, 272, 204, 249], [271, 233, 197, 279, 230, 0, 198, 227, 275, 
    207, 206, 236], [255, 251, 248, 337, 310, 303, 0, 269, 275, 253, 263, 
    310], [219, 234, 229, 251, 260, 274, 232, 0, 278, 270, 224, 242], [225,
    228, 245, 229, 230, 226, 226, 223, 0, 203, 180, 212], [276, 218, 215, 
    238, 229, 294, 248, 231, 298, 0, 234, 272], [291, 253, 272, 267, 297, 
    295, 238, 277, 321, 267, 0, 277], [231, 194, 253, 260, 252, 265, 191, 
    259, 289, 229, 224, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 165, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 227, 215, 221, 247, 220, 242, 259, 243, 230, 236, 232],
    [274, 0, 234, 259, 260, 228, 261, 265, 263, 229, 234, 276], [286, 267, 
    0, 244, 266, 255, 268, 262, 262, 235, 244, 271], [280, 242, 257, 0, 258,
    249, 263, 249, 275, 256, 239, 246], [254, 241, 235, 243, 0, 230, 249, 
    235, 258, 245, 221, 251], [281, 273, 246, 252, 271, 0, 269, 259, 265, 
    241, 244, 275], [259, 240, 233, 238, 252, 232, 0, 278, 252, 240, 238, 
    222], [242, 236, 239, 252, 266, 242, 223, 0, 274, 246, 229, 259], [258,
    238, 239, 226, 243, 236, 249, 227, 0, 233, 212, 255], [271, 272, 266, 
    245, 256, 260, 261, 255, 268, 0, 254, 289], [265, 267, 257, 262, 280, 
    257, 263, 272, 289, 247, 0, 265], [269, 225, 230, 255, 250, 226, 279, 
    242, 246, 212, 236, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 166, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 231, 318, 252, 298, 292, 298, 296, 282, 232, 256, 294],
    [270, 0, 325, 291, 258, 276, 343, 291, 313, 332, 257, 248], [183, 176, 
    0, 218, 250, 227, 259, 292, 311, 231, 205, 259], [249, 210, 283, 0, 206,
    295, 316, 263, 268, 252, 233, 233], [203, 243, 251, 295, 0, 291, 370, 
    259, 299, 253, 275, 217], [209, 225, 274, 206, 210, 0, 292, 251, 274, 
    284, 200, 196], [203, 158, 242, 185, 131, 209, 0, 229, 243, 223, 153, 
    132], [205, 210, 209, 238, 242, 250, 272, 0, 223, 249, 245, 223], [219,
    188, 190, 233, 202, 227, 258, 278, 0, 216, 191, 183], [269, 169, 270, 
    249, 248, 217, 278, 252, 285, 0, 173, 255], [245, 244, 296, 268, 226, 
    301, 348, 256, 310, 328, 0, 252], [207, 253, 242, 268, 284, 305, 369, 
    278, 318, 246, 249, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 167, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 227, 274, 240, 225, 288, 297, 270, 225, 301, 283, 292],
    [274, 0, 283, 273, 284, 293, 310, 238, 251, 321, 312, 256], [227, 218, 
    0, 260, 261, 248, 260, 226, 224, 260, 249, 271], [261, 228, 241, 0, 234,
    286, 310, 252, 231, 282, 279, 276], [276, 217, 240, 267, 0, 238, 264, 
    297, 230, 293, 253, 303], [213, 208, 253, 215, 263, 0, 256, 222, 212, 
    264, 234, 268], [204, 191, 241, 191, 237, 245, 0, 229, 204, 272, 208, 
    233], [231, 263, 275, 249, 204, 279, 272, 0, 248, 260, 232, 273], [276,
    250, 277, 270, 271, 289, 297, 253, 0, 314, 253, 274], [200, 180, 241, 
    219, 208, 237, 229, 241, 187, 0, 215, 221], [218, 189, 252, 222, 248, 
    267, 293, 269, 248, 286, 0, 268], [209, 245, 230, 225, 198, 233, 268, 
    228, 227, 280, 233, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 168, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 274, 269, 244, 264, 243, 265, 267, 244, 239, 252, 256],
    [227, 0, 250, 252, 261, 222, 245, 241, 230, 244, 244, 240], [232, 251, 
    0, 231, 248, 238, 244, 255, 221, 225, 209, 234], [257, 249, 270, 0, 253,
    249, 254, 264, 243, 244, 249, 255], [237, 240, 253, 248, 0, 250, 242, 
    266, 223, 238, 220, 229], [258, 279, 263, 252, 251, 0, 273, 261, 249, 
    240, 245, 237], [236, 256, 257, 247, 259, 228, 0, 239, 231, 241, 228, 
    241], [234, 260, 246, 237, 235, 240, 262, 0, 228, 229, 226, 245], [257,
    271, 280, 258, 278, 252, 270, 273, 0, 252, 254, 247], [262, 257, 276, 
    257, 263, 261, 260, 272, 249, 0, 259, 266], [249, 257, 292, 252, 281, 
    256, 273, 275, 247, 242, 0, 260], [245, 261, 267, 246, 272, 264, 260, 
    256, 254, 235, 241, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 169, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 231, 234, 254, 255, 254, 246, 232, 242, 258, 252, 274],
    [270, 0, 260, 275, 256, 255, 267, 266, 247, 260, 256, 261], [267, 241, 
    0, 240, 261, 253, 248, 245, 246, 251, 261, 261], [247, 226, 261, 0, 241,
    264, 249, 220, 236, 247, 239, 253], [246, 245, 240, 260, 0, 245, 263, 
    246, 262, 257, 245, 278], [247, 246, 248, 237, 256, 0, 246, 246, 237, 
    243, 250, 260], [255, 234, 253, 252, 238, 255, 0, 227, 253, 241, 238, 
    262], [269, 235, 256, 281, 255, 255, 274, 0, 252, 280, 273, 274], [259,
    254, 255, 265, 239, 264, 248, 249, 0, 250, 255, 278], [243, 241, 250, 
    254, 244, 258, 260, 221, 251, 0, 241, 271], [249, 245, 240, 262, 256, 
    251, 263, 228, 246, 260, 0, 262], [227, 240, 240, 248, 223, 241, 239, 
    227, 223, 230, 239, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 170, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 268, 263, 218, 257, 274, 247, 262, 273, 247, 270, 242],
    [233, 0, 235, 259, 228, 244, 229, 237, 248, 234, 256, 253], [238, 266, 
    0, 230, 241, 248, 238, 238, 274, 234, 250, 248], [283, 242, 271, 0, 276,
    277, 264, 274, 264, 269, 283, 268], [244, 273, 260, 225, 0, 238, 254, 
    239, 241, 235, 267, 276], [227, 257, 253, 224, 263, 0, 237, 242, 231, 
    236, 269, 243], [254, 272, 263, 237, 247, 264, 0, 274, 277, 247, 270, 
    267], [239, 264, 263, 227, 262, 259, 227, 0, 238, 243, 262, 265], [228,
    253, 227, 237, 260, 270, 224, 263, 0, 251, 260, 254], [254, 267, 267, 
    232, 266, 265, 254, 258, 250, 0, 277, 262], [231, 245, 251, 218, 234, 
    232, 231, 239, 241, 224, 0, 222], [259, 248, 253, 233, 225, 258, 234, 
    236, 247, 239, 279, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 171, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 256, 245, 255, 256, 230, 254, 217, 258, 253, 236, 246],
    [245, 0, 249, 263, 253, 243, 233, 219, 256, 264, 237, 249], [256, 252, 
    0, 242, 276, 252, 258, 236, 267, 255, 249, 260], [246, 238, 259, 0, 254,
    248, 265, 214, 236, 254, 239, 222], [245, 248, 225, 247, 0, 229, 239, 
    224, 262, 249, 244, 247], [271, 258, 249, 253, 272, 0, 270, 233, 270, 
    284, 268, 264], [247, 268, 243, 236, 262, 231, 0, 224, 247, 253, 242, 
    255], [284, 282, 265, 287, 277, 268, 277, 0, 271, 289, 267, 246], [243,
    245, 234, 265, 239, 231, 254, 230, 0, 255, 236, 237], [248, 237, 246, 
    247, 252, 217, 248, 212, 246, 0, 240, 251], [265, 264, 252, 262, 257, 
    233, 259, 234, 265, 261, 0, 268], [255, 252, 241, 279, 254, 237, 246, 
    255, 264, 250, 233, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 172, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 266, 283, 243, 256, 255, 254, 253, 262, 283, 249, 232],
    [235, 0, 243, 222, 245, 272, 230, 240, 251, 324, 263, 226], [218, 258, 
    0, 228, 227, 219, 209, 234, 262, 252, 228, 186], [258, 279, 273, 0, 262,
    271, 206, 259, 290, 298, 298, 291], [245, 256, 274, 239, 0, 239, 210, 
    247, 284, 271, 237, 196], [246, 229, 282, 230, 262, 0, 195, 189, 247, 
    261, 259, 221], [247, 271, 292, 295, 291, 306, 0, 290, 225, 304, 284, 
    240], [248, 261, 267, 242, 254, 312, 211, 0, 303, 285, 251, 230], [239,
    250, 239, 211, 217, 254, 276, 198, 0, 267, 230, 227], [218, 177, 249, 
    203, 230, 240, 197, 216, 234, 0, 234, 210], [252, 238, 273, 203, 264, 
    242, 217, 250, 271, 267, 0, 246], [269, 275, 315, 210, 305, 280, 261, 
    271, 274, 291, 255, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 173, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 181, 182, 192, 249, 236, 186, 189, 238, 258, 233, 210],
    [320, 0, 283, 277, 321, 330, 236, 307, 302, 256, 275, 245], [319, 218, 
    0, 213, 267, 281, 236, 282, 318, 245, 283, 237], [309, 224, 288, 0, 351,
    266, 266, 365, 305, 216, 301, 309], [252, 180, 234, 150, 0, 219, 154, 
    271, 285, 209, 221, 222], [265, 171, 220, 235, 282, 0, 227, 294, 272, 
    211, 267, 263], [315, 265, 265, 235, 347, 274, 0, 307, 310, 298, 321, 
    280], [312, 194, 219, 136, 230, 207, 194, 0, 246, 195, 269, 265], [263,
    199, 183, 196, 216, 229, 191, 255, 0, 176, 185, 191], [243, 245, 256, 
    285, 292, 290, 203, 306, 325, 0, 228, 234], [268, 226, 218, 200, 280, 
    234, 180, 232, 316, 273, 0, 234], [291, 256, 264, 192, 279, 238, 221, 
    236, 310, 267, 267, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 174, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 271, 236, 234, 261, 239, 231, 235, 247, 233, 235, 250],
    [230, 0, 242, 233, 246, 254, 232, 238, 246, 238, 234, 236], [265, 259, 
    0, 249, 247, 247, 240, 229, 254, 230, 232, 238], [267, 268, 252, 0, 248,
    245, 257, 254, 259, 253, 255, 261], [240, 255, 254, 253, 0, 240, 237, 
    252, 251, 234, 237, 254], [262, 247, 254, 256, 261, 0, 252, 276, 253, 
    245, 255, 265], [270, 269, 261, 244, 264, 249, 0, 267, 259, 259, 244, 
    263], [266, 263, 272, 247, 249, 225, 234, 0, 240, 246, 233, 245], [254,
    255, 247, 242, 250, 248, 242, 261, 0, 242, 232, 240], [268, 263, 271, 
    248, 267, 256, 242, 255, 259, 0, 240, 250], [266, 267, 269, 246, 264, 
    246, 257, 268, 269, 261, 0, 247], [251, 265, 263, 240, 247, 236, 238, 
    256, 261, 251, 254, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 175, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 225, 254, 250, 234, 246, 247, 248, 237, 228, 246, 256],
    [276, 0, 262, 266, 249, 239, 255, 256, 253, 250, 263, 277], [247, 239, 
    0, 249, 252, 246, 255, 263, 246, 249, 228, 259], [251, 235, 252, 0, 224,
    260, 269, 251, 239, 233, 238, 266], [267, 252, 249, 277, 0, 264, 253, 
    249, 262, 248, 263, 264], [255, 262, 255, 241, 237, 0, 254, 248, 259, 
    252, 258, 296], [254, 246, 246, 232, 248, 247, 0, 260, 246, 250, 234, 
    245], [253, 245, 238, 250, 252, 253, 241, 0, 275, 247, 239, 263], [264,
    248, 255, 262, 239, 242, 255, 226, 0, 230, 224, 255], [273, 251, 252, 
    268, 253, 249, 251, 254, 271, 0, 253, 268], [255, 238, 273, 263, 238, 
    243, 267, 262, 277, 248, 0, 271], [245, 224, 242, 235, 237, 205, 256, 
    238, 246, 233, 230, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 176, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 256, 264, 235, 248, 256, 251, 264, 273, 292, 272, 260],
    [245, 0, 230, 235, 232, 236, 250, 253, 285, 259, 253, 244], [237, 271, 
    0, 252, 244, 259, 255, 265, 261, 274, 259, 255], [266, 266, 249, 0, 252,
    261, 266, 264, 256, 292, 249, 262], [253, 269, 257, 249, 0, 266, 238, 
    255, 264, 280, 249, 263], [245, 265, 242, 240, 235, 0, 232, 264, 257, 
    275, 264, 255], [250, 251, 246, 235, 263, 269, 0, 257, 267, 274, 269, 
    288], [237, 248, 236, 237, 246, 237, 244, 0, 256, 275, 261, 246], [228,
    216, 240, 245, 237, 244, 234, 245, 0, 257, 265, 270], [209, 242, 227, 
    209, 221, 226, 227, 226, 244, 0, 257, 231], [229, 248, 242, 252, 252, 
    237, 232, 240, 236, 244, 0, 247], [241, 257, 246, 239, 238, 246, 213, 
    255, 231, 270, 254, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 177, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 253, 231, 265, 271, 272, 275, 270, 274, 275, 246, 282],
    [248, 0, 244, 269, 295, 272, 254, 254, 252, 272, 284, 272], [270, 257, 
    0, 254, 284, 288, 266, 252, 235, 272, 270, 274], [236, 232, 247, 0, 249,
    247, 250, 252, 232, 242, 246, 246], [230, 206, 217, 252, 0, 265, 241, 
    250, 238, 248, 245, 260], [229, 229, 213, 254, 236, 0, 234, 244, 252, 
    252, 226, 259], [226, 247, 235, 251, 260, 267, 0, 238, 238, 251, 248, 
    256], [231, 247, 249, 249, 251, 257, 263, 0, 258, 265, 254, 262], [227,
    249, 266, 269, 263, 249, 263, 243, 0, 252, 248, 268], [226, 229, 229, 
    259, 253, 249, 250, 236, 249, 0, 229, 252], [255, 217, 231, 255, 256, 
    275, 253, 247, 253, 272, 0, 262], [219, 229, 227, 255, 241, 242, 245, 
    239, 233, 249, 239, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 178, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 231, 241, 224, 235, 231, 237, 257, 230, 227, 239, 226],
    [270, 0, 273, 242, 269, 243, 253, 261, 253, 251, 269, 246], [260, 228, 
    0, 235, 241, 245, 237, 255, 233, 240, 254, 231], [277, 259, 266, 0, 249,
    245, 238, 267, 265, 242, 258, 242], [266, 232, 260, 252, 0, 244, 259, 
    259, 248, 239, 264, 250], [270, 258, 256, 256, 257, 0, 255, 268, 262, 
    243, 259, 234], [264, 248, 264, 263, 242, 246, 0, 262, 263, 254, 253, 
    235], [244, 240, 246, 234, 242, 233, 239, 0, 242, 234, 234, 236], [271,
    248, 268, 236, 253, 239, 238, 259, 0, 238, 276, 256], [274, 250, 261, 
    259, 262, 258, 247, 267, 263, 0, 268, 252], [262, 232, 247, 243, 237, 
    242, 248, 267, 225, 233, 0, 231], [275, 255, 270, 259, 251, 267, 266, 
    265, 245, 249, 270, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 179, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 243, 256, 243, 261, 275, 267, 277, 286, 279, 270, 252],
    [258, 0, 263, 242, 266, 239, 240, 285, 306, 244, 280, 249], [245, 238, 
    0, 240, 256, 236, 248, 290, 268, 238, 264, 231], [258, 259, 261, 0, 253,
    269, 236, 268, 305, 259, 292, 220], [240, 235, 245, 248, 0, 236, 251, 
    270, 279, 266, 253, 249], [226, 262, 265, 232, 265, 0, 262, 296, 261, 
    236, 296, 244], [234, 261, 253, 265, 250, 239, 0, 293, 294, 241, 269, 
    244], [224, 216, 211, 233, 231, 205, 208, 0, 236, 208, 241, 203], [215,
    195, 233, 196, 222, 240, 207, 265, 0, 211, 271, 208], [222, 257, 263, 
    242, 235, 265, 260, 293, 290, 0, 288, 206], [231, 221, 237, 209, 248, 
    205, 232, 260, 230, 213, 0, 236], [249, 252, 270, 281, 252, 257, 257, 
    298, 293, 295, 265, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 180, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 264, 244, 279, 249, 254, 247, 262, 257, 252, 274, 249],
    [237, 0, 229, 231, 240, 245, 254, 261, 233, 218, 259, 234], [257, 272, 
    0, 268, 243, 274, 260, 267, 249, 249, 292, 264], [222, 270, 233, 0, 217,
    233, 240, 240, 231, 220, 259, 232], [252, 261, 258, 284, 0, 262, 267, 
    286, 241, 239, 276, 233], [247, 256, 227, 268, 239, 0, 259, 250, 222, 
    225, 262, 232], [254, 247, 241, 261, 234, 242, 0, 263, 206, 217, 249, 
    245], [239, 240, 234, 261, 215, 251, 238, 0, 194, 225, 248, 231], [244,
    268, 252, 270, 260, 279, 295, 307, 0, 262, 283, 263], [249, 283, 252, 
    281, 262, 276, 284, 276, 239, 0, 276, 270], [227, 242, 209, 242, 225, 
    239, 252, 253, 218, 225, 0, 223], [252, 267, 237, 269, 268, 269, 256, 
    270, 238, 231, 278, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 181, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 196, 326, 256, 236, 276, 296, 240, 262, 250, 254, 280],
    [305, 0, 290, 257, 252, 254, 305, 228, 255, 258, 284, 282], [175, 211, 
    0, 216, 245, 243, 304, 220, 266, 193, 238, 271], [245, 244, 285, 0, 214,
    276, 324, 221, 230, 249, 256, 306], [265, 249, 256, 287, 0, 282, 267, 
    229, 280, 267, 283, 271], [225, 247, 258, 225, 219, 0, 306, 190, 259, 
    213, 264, 274], [205, 196, 197, 177, 234, 195, 0, 182, 196, 199, 231, 
    288], [261, 273, 281, 280, 272, 311, 319, 0, 276, 250, 260, 302], [239,
    246, 235, 271, 221, 242, 305, 225, 0, 232, 254, 258], [251, 243, 308, 
    252, 234, 288, 302, 251, 269, 0, 258, 272], [247, 217, 263, 245, 218, 
    237, 270, 241, 247, 243, 0, 265], [221, 219, 230, 195, 230, 227, 213, 
    199, 243, 229, 236, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 182, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 241, 250, 241, 249, 234, 243, 241, 253, 251, 257, 260],
    [260, 0, 242, 245, 266, 239, 257, 252, 257, 246, 246, 266], [251, 259, 
    0, 258, 271, 244, 236, 254, 267, 266, 266, 273], [260, 256, 243, 0, 274,
    257, 245, 254, 259, 257, 245, 264], [252, 235, 230, 227, 0, 228, 228, 
    253, 240, 255, 244, 248], [267, 262, 257, 244, 273, 0, 265, 273, 271, 
    264, 268, 264], [258, 244, 265, 256, 273, 236, 0, 252, 266, 264, 251, 
    248], [260, 249, 247, 247, 248, 228, 249, 0, 252, 258, 253, 253], [248,
    244, 234, 242, 261, 230, 235, 249, 0, 257, 250, 249], [250, 255, 235, 
    244, 246, 237, 237, 243, 244, 0, 258, 256], [244, 255, 235, 256, 257, 
    233, 250, 248, 251, 243, 0, 241], [241, 235, 228, 237, 253, 237, 253, 
    248, 252, 245, 260, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 183, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 314, 263, 300, 270, 247, 281, 313, 214, 298, 299, 288],
    [187, 0, 169, 202, 226, 205, 238, 275, 205, 262, 255, 208], [238, 332, 
    0, 284, 330, 292, 242, 292, 231, 288, 285, 271], [201, 299, 217, 0, 294,
    213, 269, 313, 230, 297, 276, 263], [231, 275, 171, 207, 0, 201, 249, 
    243, 230, 250, 254, 251], [254, 296, 209, 288, 300, 0, 245, 254, 271, 
    245, 293, 275], [220, 263, 259, 232, 252, 256, 0, 338, 246, 280, 314, 
    295], [188, 226, 209, 188, 258, 247, 163, 0, 154, 238, 270, 234], [287,
    296, 270, 271, 271, 230, 255, 347, 0, 288, 323, 301], [203, 239, 213, 
    204, 251, 256, 221, 263, 213, 0, 280, 253], [202, 246, 216, 225, 247, 
    208, 187, 231, 178, 221, 0, 298], [213, 293, 230, 238, 250, 226, 206, 
    267, 200, 248, 203, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 184, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 252, 237, 240, 245, 258, 245, 237, 240, 240, 245, 251],
    [249, 0, 257, 243, 246, 247, 253, 240, 234, 244, 241, 250], [264, 244, 
    0, 264, 262, 252, 252, 262, 253, 252, 246, 250], [261, 258, 237, 0, 254,
    248, 253, 251, 256, 240, 243, 251], [256, 255, 239, 247, 0, 241, 255, 
    242, 239, 251, 225, 274], [243, 254, 249, 253, 260, 0, 248, 266, 267, 
    256, 247, 266], [256, 248, 249, 248, 246, 253, 0, 243, 251, 248, 251, 
    258], [264, 261, 239, 250, 259, 235, 258, 0, 250, 262, 251, 264], [261,
    267, 248, 245, 262, 234, 250, 251, 0, 251, 248, 275], [261, 257, 249, 
    261, 250, 245, 253, 239, 250, 0, 249, 265], [256, 260, 255, 258, 276, 
    254, 250, 250, 253, 252, 0, 245], [250, 251, 251, 250, 227, 235, 243, 
    237, 226, 236, 256, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 185, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 252, 218, 253, 248, 254, 246, 232, 258, 249, 268, 268],
    [249, 0, 224, 236, 257, 255, 228, 242, 243, 256, 270, 232], [283, 277, 
    0, 260, 266, 270, 265, 235, 264, 227, 273, 256], [248, 265, 241, 0, 235,
    247, 233, 234, 238, 248, 236, 232], [253, 244, 235, 266, 0, 257, 258, 
    248, 243, 262, 257, 252], [247, 246, 231, 254, 244, 0, 234, 219, 223, 
    243, 258, 237], [255, 273, 236, 268, 243, 267, 0, 259, 247, 257, 260, 
    220], [269, 259, 266, 267, 253, 282, 242, 0, 266, 254, 280, 238], [243,
    258, 237, 263, 258, 278, 254, 235, 0, 242, 276, 230], [252, 245, 274, 
    253, 239, 258, 244, 247, 259, 0, 289, 220], [233, 231, 228, 265, 244, 
    243, 241, 221, 225, 212, 0, 209], [233, 269, 245, 269, 249, 264, 281, 
    263, 271, 281, 292, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 186, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 245, 259, 240, 243, 251, 253, 246, 273, 248, 267, 239],
    [256, 0, 264, 261, 275, 254, 268, 259, 275, 255, 259, 247], [242, 237, 
    0, 241, 252, 231, 253, 224, 245, 238, 235, 241], [261, 240, 260, 0, 257,
    241, 257, 239, 253, 249, 248, 251], [258, 226, 249, 244, 0, 253, 250, 
    237, 253, 241, 241, 240], [250, 247, 270, 260, 248, 0, 252, 261, 246, 
    240, 254, 231], [248, 233, 248, 244, 251, 249, 0, 238, 255, 228, 238, 
    240], [255, 242, 277, 262, 264, 240, 263, 0, 266, 247, 268, 241], [228,
    226, 256, 248, 248, 255, 246, 235, 0, 246, 264, 257], [253, 246, 263, 
    252, 260, 261, 273, 254, 255, 0, 263, 265], [234, 242, 266, 253, 260, 
    247, 263, 233, 237, 238, 0, 249], [262, 254, 260, 250, 261, 270, 261, 
    260, 244, 236, 252, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 187, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 138, 264, 269, 158, 252, 162, 130, 165, 154, 130, 182],
    [363, 0, 283, 309, 188, 321, 279, 169, 348, 300, 291, 341], [237, 218, 
    0, 264, 248, 334, 278, 171, 292, 173, 236, 281], [232, 192, 237, 0, 115,
    228, 203, 183, 206, 228, 261, 202], [343, 313, 253, 386, 0, 347, 269, 
    266, 322, 248, 337, 264], [249, 180, 167, 273, 154, 0, 184, 201, 248, 
    199, 142, 244], [339, 222, 223, 298, 232, 317, 0, 177, 256, 240, 307, 
    218], [371, 332, 330, 318, 235, 300, 324, 0, 243, 267, 268, 252], [336,
    153, 209, 295, 179, 253, 245, 258, 0, 177, 253, 265], [347, 201, 328, 
    273, 253, 302, 261, 234, 324, 0, 315, 220], [371, 210, 265, 240, 164, 
    359, 194, 233, 248, 186, 0, 254], [319, 160, 220, 299, 237, 257, 283, 
    249, 236, 281, 247, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 188, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 247, 294, 275, 271, 252, 286, 271, 239, 232, 265, 275],
    [254, 0, 253, 208, 225, 232, 240, 231, 267, 262, 235, 225], [207, 248, 
    0, 240, 242, 204, 222, 207, 253, 241, 207, 240], [226, 293, 261, 0, 253,
    285, 260, 211, 280, 245, 253, 256], [230, 276, 259, 248, 0, 283, 231, 
    229, 285, 243, 237, 233], [249, 269, 297, 216, 218, 0, 251, 220, 258, 
    251, 232, 267], [215, 261, 279, 241, 270, 250, 0, 248, 292, 292, 262, 
    259], [230, 270, 294, 290, 272, 281, 253, 0, 255, 283, 270, 308], [262,
    234, 248, 221, 216, 243, 209, 246, 0, 228, 214, 233], [269, 239, 260, 
    256, 258, 250, 209, 218, 273, 0, 263, 227], [236, 266, 294, 248, 264, 
    269, 239, 231, 287, 238, 0, 258], [226, 276, 261, 245, 268, 234, 242, 
    193, 268, 274, 243, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 189, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 256, 256, 246, 258, 246, 250, 247, 246, 247, 253, 259],
    [245, 0, 254, 246, 265, 252, 242, 240, 257, 248, 253, 247], [245, 247, 
    0, 233, 257, 253, 245, 242, 255, 250, 238, 252], [255, 255, 268, 0, 266,
    249, 255, 247, 256, 253, 259, 251], [243, 236, 244, 235, 0, 232, 262, 
    243, 245, 241, 242, 250], [255, 249, 248, 252, 269, 0, 261, 250, 265, 
    259, 248, 251], [251, 259, 256, 246, 239, 240, 0, 258, 245, 246, 266, 
    249], [254, 261, 259, 254, 258, 251, 243, 0, 255, 249, 254, 248], [255,
    244, 246, 245, 256, 236, 256, 246, 0, 259, 247, 251], [254, 253, 251, 
    248, 260, 242, 255, 252, 242, 0, 261, 249], [248, 248, 263, 242, 259, 
    253, 235, 247, 254, 240, 0, 257], [242, 254, 249, 250, 251, 250, 252, 
    253, 250, 252, 244, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 190, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 264, 257, 244, 241, 258, 284, 266, 255, 245, 260, 247],
    [237, 0, 237, 219, 223, 225, 259, 253, 250, 228, 237, 241], [244, 264, 
    0, 235, 230, 242, 261, 250, 245, 241, 241, 243], [257, 282, 266, 0, 233,
    253, 271, 260, 261, 260, 253, 254], [260, 278, 271, 268, 0, 270, 273, 
    262, 256, 241, 256, 255], [243, 276, 259, 248, 231, 0, 270, 257, 252, 
    246, 257, 241], [217, 242, 240, 230, 228, 231, 0, 245, 241, 233, 243, 
    247], [235, 248, 251, 241, 239, 244, 256, 0, 246, 232, 249, 265], [246,
    251, 256, 240, 245, 249, 260, 255, 0, 235, 243, 253], [256, 273, 260, 
    241, 260, 255, 268, 269, 266, 0, 254, 269], [241, 264, 260, 248, 245, 
    244, 258, 252, 258, 247, 0, 265], [254, 260, 258, 247, 246, 260, 254, 
    236, 248, 232, 236, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 191, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 256, 305, 277, 309, 294, 273, 247, 259, 263, 238, 318],
    [245, 0, 256, 305, 318, 305, 300, 294, 257, 265, 259, 260], [196, 245, 
    0, 249, 281, 290, 254, 263, 226, 251, 225, 276], [224, 196, 252, 0, 315,
    292, 263, 243, 261, 279, 225, 264], [192, 183, 220, 186, 0, 228, 206, 
    194, 228, 206, 205, 224], [207, 196, 211, 209, 273, 0, 246, 240, 211, 
    204, 167, 221], [228, 201, 247, 238, 295, 255, 0, 283, 187, 202, 186, 
    242], [254, 207, 238, 258, 307, 261, 218, 0, 217, 253, 199, 262], [242,
    244, 275, 240, 273, 290, 314, 284, 0, 249, 194, 259], [238, 236, 250, 
    222, 295, 297, 299, 248, 252, 0, 222, 277], [263, 242, 276, 276, 296, 
    334, 315, 302, 307, 279, 0, 318], [183, 241, 225, 237, 277, 280, 259, 
    239, 242, 224, 183, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 192, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 258, 254, 251, 272, 265, 260, 240, 250, 258, 271, 257],
    [243, 0, 246, 232, 269, 247, 249, 247, 250, 236, 264, 265], [247, 255, 
    0, 247, 269, 267, 263, 256, 245, 242, 284, 273], [250, 269, 254, 0, 290,
    260, 267, 261, 277, 249, 287, 280], [229, 232, 232, 211, 0, 217, 236, 
    232, 231, 219, 245, 239], [236, 254, 234, 241, 284, 0, 257, 247, 247, 
    239, 264, 263], [241, 252, 238, 234, 265, 244, 0, 241, 246, 241, 257, 
    259], [261, 254, 245, 240, 269, 254, 260, 0, 250, 244, 284, 265], [251,
    251, 256, 224, 270, 254, 255, 251, 0, 239, 269, 257], [243, 265, 259, 
    252, 282, 262, 260, 257, 262, 0, 280, 269], [230, 237, 217, 214, 256, 
    237, 244, 217, 232, 221, 0, 244], [244, 236, 228, 221, 262, 238, 242, 
    236, 244, 232, 257, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 193, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 312, 258, 254, 267, 317, 283, 217, 351, 297, 275, 224],
    [189, 0, 229, 160, 220, 244, 205, 171, 234, 166, 242, 220], [243, 272, 
    0, 234, 261, 315, 167, 264, 292, 310, 277, 260], [247, 341, 267, 0, 295,
    326, 226, 162, 262, 231, 243, 263], [234, 281, 240, 206, 0, 191, 138, 
    215, 244, 228, 250, 259], [184, 257, 186, 175, 310, 0, 152, 114, 264, 
    127, 150, 254], [218, 296, 334, 275, 363, 349, 0, 270, 303, 255, 269, 
    315], [284, 330, 237, 339, 286, 387, 231, 0, 351, 293, 233, 322], [150,
    267, 209, 239, 257, 237, 198, 150, 0, 165, 200, 221], [204, 335, 191, 
    270, 273, 374, 246, 208, 336, 0, 228, 219], [226, 259, 224, 258, 251, 
    351, 232, 268, 301, 273, 0, 288], [277, 281, 241, 238, 242, 247, 186, 
    179, 280, 282, 213, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 194, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 219, 214, 256, 244, 236, 261, 242, 240, 250, 249, 220],
    [282, 0, 264, 258, 236, 279, 263, 271, 236, 287, 273, 249], [287, 237, 
    0, 263, 248, 269, 275, 273, 224, 272, 270, 255], [245, 243, 238, 0, 257,
    279, 270, 251, 237, 277, 274, 246], [257, 265, 253, 244, 0, 285, 280, 
    266, 267, 284, 284, 259], [265, 222, 232, 222, 216, 0, 272, 242, 234, 
    269, 277, 228], [240, 238, 226, 231, 221, 229, 0, 237, 229, 249, 258, 
    247], [259, 230, 228, 250, 235, 259, 264, 0, 245, 269, 261, 249], [261,
    265, 277, 264, 234, 267, 272, 256, 0, 279, 265, 264], [251, 214, 229, 
    224, 217, 232, 252, 232, 222, 0, 246, 239], [252, 228, 231, 227, 217, 
    224, 243, 240, 236, 255, 0, 224], [281, 252, 246, 255, 242, 273, 254, 
    252, 237, 262, 277, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 195, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 254, 238, 261, 255, 263, 244, 266, 257, 241, 257, 246],
    [247, 0, 255, 268, 239, 264, 242, 253, 247, 243, 256, 226], [263, 246, 
    0, 265, 263, 254, 240, 259, 246, 251, 262, 239], [240, 233, 236, 0, 238,
    257, 242, 252, 245, 228, 237, 257], [246, 262, 238, 263, 0, 256, 265, 
    249, 239, 237, 240, 252], [238, 237, 247, 244, 245, 0, 230, 260, 259, 
    241, 243, 244], [257, 259, 261, 259, 236, 271, 0, 276, 254, 249, 253, 
    245], [235, 248, 242, 249, 252, 241, 225, 0, 247, 249, 249, 225], [244,
    254, 255, 256, 262, 242, 247, 254, 0, 243, 244, 265], [260, 258, 250, 
    273, 264, 260, 252, 252, 258, 0, 262, 251], [244, 245, 239, 264, 261, 
    258, 248, 252, 257, 239, 0, 231], [255, 275, 262, 244, 249, 257, 256, 
    276, 236, 250, 270, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 196, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 240, 285, 247, 212, 236, 226, 231, 250, 236, 222, 250],
    [261, 0, 276, 244, 229, 244, 230, 242, 264, 256, 243, 252], [216, 225, 
    0, 219, 220, 214, 213, 219, 236, 231, 237, 223], [254, 257, 282, 0, 235,
    258, 292, 269, 276, 258, 242, 262], [289, 272, 281, 266, 0, 261, 269, 
    259, 287, 250, 270, 292], [265, 257, 287, 243, 240, 0, 237, 217, 269, 
    260, 263, 265], [275, 271, 288, 209, 232, 264, 0, 251, 241, 214, 223, 
    265], [270, 259, 282, 232, 242, 284, 250, 0, 258, 281, 257, 292], [251,
    237, 265, 225, 214, 232, 260, 243, 0, 245, 232, 266], [265, 245, 270, 
    243, 251, 241, 287, 220, 256, 0, 232, 264], [279, 258, 264, 259, 231, 
    238, 278, 244, 269, 269, 0, 259], [251, 249, 278, 239, 209, 236, 236, 
    209, 235, 237, 242, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 197, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 246, 216, 202, 248, 226, 206, 252, 263, 230, 247, 244],
    [255, 0, 246, 260, 269, 261, 242, 247, 241, 274, 273, 262], [285, 255, 
    0, 235, 270, 223, 225, 281, 268, 244, 260, 284], [299, 241, 266, 0, 275,
    264, 251, 257, 249, 279, 254, 276], [253, 232, 231, 226, 0, 227, 219, 
    233, 229, 257, 261, 251], [275, 240, 278, 237, 274, 0, 246, 282, 257, 
    254, 269, 261], [295, 259, 276, 250, 282, 255, 0, 300, 290, 269, 276, 
    272], [249, 254, 220, 244, 268, 219, 201, 0, 262, 241, 234, 258], [238,
    260, 233, 252, 272, 244, 211, 239, 0, 247, 265, 263], [271, 227, 257, 
    222, 244, 247, 232, 260, 254, 0, 266, 267], [254, 228, 241, 247, 240, 
    232, 225, 267, 236, 235, 0, 241], [257, 239, 217, 225, 250, 240, 229, 
    243, 238, 234, 260, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 198, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 256, 287, 251, 247, 283, 299, 284, 248, 287, 308, 195],
    [245, 0, 260, 239, 254, 300, 285, 241, 277, 276, 311, 246], [214, 241, 
    0, 240, 220, 280, 256, 278, 264, 271, 254, 223], [250, 262, 261, 0, 219,
    325, 274, 289, 289, 228, 283, 269], [254, 247, 281, 282, 0, 293, 324, 
    249, 290, 317, 284, 208], [218, 201, 221, 176, 208, 0, 260, 243, 231, 
    213, 257, 194], [202, 216, 245, 227, 177, 241, 0, 220, 223, 252, 251, 
    179], [217, 260, 223, 212, 252, 258, 281, 0, 269, 252, 255, 247], [253,
    224, 237, 212, 211, 270, 278, 232, 0, 244, 278, 236], [214, 225, 230, 
    273, 184, 288, 249, 249, 257, 0, 281, 238], [193, 190, 247, 218, 217, 
    244, 250, 246, 223, 220, 0, 203], [306, 255, 278, 232, 293, 307, 322, 
    254, 265, 263, 298, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 199, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 244, 238, 253, 250, 235, 231, 241, 239, 228, 244, 212],
    [257, 0, 266, 259, 258, 245, 247, 253, 260, 251, 256, 247], [263, 235, 
    0, 235, 243, 240, 232, 235, 246, 254, 237, 230], [248, 242, 266, 0, 249,
    237, 241, 229, 244, 234, 251, 237], [251, 243, 258, 252, 0, 242, 241, 
    230, 245, 259, 244, 231], [266, 256, 261, 264, 259, 0, 249, 247, 262, 
    269, 253, 245], [270, 254, 269, 260, 260, 252, 0, 247, 273, 256, 276, 
    243], [260, 248, 266, 272, 271, 254, 254, 0, 268, 248, 265, 255], [262,
    241, 255, 257, 256, 239, 228, 233, 0, 250, 254, 248], [273, 250, 247, 
    267, 242, 232, 245, 253, 251, 0, 245, 230], [257, 245, 264, 250, 257, 
    248, 225, 236, 247, 256, 0, 230], [289, 254, 271, 264, 270, 256, 258, 
    246, 253, 271, 271, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 200, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
pd.DataFrame(results).to_csv(
    '/Users/noeliarico/Desktop/folder-kemeny/2021EJOR/results/mebbd/mebbd_12_501.csv'
    , index=False, header=False)

import numpy as np
import pandas as pd
import time
from kemeny import algorithms as alg
from kemeny import sc
rep = 1
results = np.zeros(0).reshape(0, 7 + rep)
om = np.array([[0, 259, 278, 248, 255, 269, 234, 282, 266, 294, 272, 275],
    [242, 0, 252, 257, 217, 244, 226, 248, 239, 263, 240, 225], [223, 249, 
    0, 256, 228, 225, 242, 264, 268, 281, 263, 260], [253, 244, 245, 0, 243,
    231, 226, 267, 271, 274, 269, 284], [246, 284, 273, 258, 0, 242, 251, 
    274, 269, 269, 250, 240], [232, 257, 276, 270, 259, 0, 249, 262, 269, 
    286, 270, 254], [267, 275, 259, 275, 250, 252, 0, 302, 262, 282, 271, 
    266], [219, 253, 237, 234, 227, 239, 199, 0, 249, 278, 246, 241], [235,
    262, 233, 230, 232, 232, 239, 252, 0, 257, 260, 223], [207, 238, 220, 
    227, 232, 215, 219, 223, 244, 0, 222, 216], [229, 261, 238, 232, 251, 
    231, 230, 255, 241, 279, 0, 254], [226, 276, 241, 217, 261, 247, 235, 
    260, 278, 285, 247, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 1, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 259, 263, 250, 258, 235, 242, 245, 243, 272, 256, 244],
    [242, 0, 241, 232, 243, 234, 229, 248, 247, 247, 249, 249], [238, 260, 
    0, 233, 253, 249, 233, 238, 243, 254, 247, 241], [251, 269, 268, 0, 248,
    257, 239, 245, 259, 250, 266, 254], [243, 258, 248, 253, 0, 240, 246, 
    247, 243, 260, 259, 254], [266, 267, 252, 244, 261, 0, 255, 254, 250, 
    267, 255, 260], [259, 272, 268, 262, 255, 246, 0, 259, 260, 275, 266, 
    256], [256, 253, 263, 256, 254, 247, 242, 0, 241, 261, 254, 250], [258,
    254, 258, 242, 258, 251, 241, 260, 0, 268, 257, 252], [229, 254, 247, 
    251, 241, 234, 226, 240, 233, 0, 254, 243], [245, 252, 254, 235, 242, 
    246, 235, 247, 244, 247, 0, 248], [257, 252, 260, 247, 247, 241, 245, 
    251, 249, 258, 253, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 2, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 247, 229, 236, 228, 211, 241, 224, 225, 231, 224, 221],
    [254, 0, 237, 241, 251, 219, 246, 248, 235, 233, 229, 223], [272, 264, 
    0, 251, 252, 240, 269, 270, 245, 250, 232, 234], [265, 260, 250, 0, 240,
    242, 250, 272, 245, 238, 247, 236], [273, 250, 249, 261, 0, 234, 242, 
    248, 245, 237, 237, 245], [290, 282, 261, 259, 267, 0, 286, 259, 264, 
    247, 262, 247], [260, 255, 232, 251, 259, 215, 0, 248, 223, 235, 229, 
    238], [277, 253, 231, 229, 253, 242, 253, 0, 241, 242, 245, 239], [276,
    266, 256, 256, 256, 237, 278, 260, 0, 253, 238, 250], [270, 268, 251, 
    263, 264, 254, 266, 259, 248, 0, 249, 257], [277, 272, 269, 254, 264, 
    239, 272, 256, 263, 252, 0, 249], [280, 278, 267, 265, 256, 254, 263, 
    262, 251, 244, 252, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 3, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 266, 234, 275, 235, 284, 219, 265, 219, 263, 247, 246],
    [235, 0, 236, 283, 257, 299, 224, 274, 232, 245, 263, 263], [267, 265, 
    0, 291, 261, 313, 263, 268, 248, 277, 257, 269], [226, 218, 210, 0, 237,
    283, 215, 251, 216, 228, 256, 234], [266, 244, 240, 264, 0, 288, 244, 
    232, 250, 215, 256, 231], [217, 202, 188, 218, 213, 0, 198, 216, 221, 
    224, 194, 231], [282, 277, 238, 286, 257, 303, 0, 272, 259, 261, 252, 
    266], [236, 227, 233, 250, 269, 285, 229, 0, 202, 234, 235, 237], [282,
    269, 253, 285, 251, 280, 242, 299, 0, 275, 265, 259], [238, 256, 224, 
    273, 286, 277, 240, 267, 226, 0, 255, 238], [254, 238, 244, 245, 245, 
    307, 249, 266, 236, 246, 0, 256], [255, 238, 232, 267, 270, 270, 235, 
    264, 242, 263, 245, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 4, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 191, 219, 198, 169, 179, 190, 155, 217, 164, 245, 265],
    [310, 0, 227, 329, 266, 246, 261, 272, 287, 287, 261, 274], [282, 274, 
    0, 258, 268, 211, 186, 237, 261, 229, 178, 302], [303, 172, 243, 0, 209,
    264, 150, 185, 243, 192, 238, 270], [332, 235, 233, 292, 0, 250, 261, 
    295, 336, 213, 249, 294], [322, 255, 290, 237, 251, 0, 244, 294, 241, 
    251, 316, 261], [311, 240, 315, 351, 240, 257, 0, 244, 240, 303, 204, 
    350], [346, 229, 264, 316, 206, 207, 257, 0, 258, 282, 237, 310], [284,
    214, 240, 258, 165, 260, 261, 243, 0, 262, 200, 302], [337, 214, 272, 
    309, 288, 250, 198, 219, 239, 0, 220, 282], [256, 240, 323, 263, 252, 
    185, 297, 264, 301, 281, 0, 339], [236, 227, 199, 231, 207, 240, 151, 
    191, 199, 219, 162, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 5, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 275, 252, 277, 275, 281, 282, 239, 280, 255, 305, 329],
    [226, 0, 240, 288, 262, 229, 294, 193, 309, 244, 286, 290], [249, 261, 
    0, 267, 280, 260, 286, 205, 295, 203, 273, 277], [224, 213, 234, 0, 244,
    256, 232, 228, 248, 238, 263, 312], [226, 239, 221, 257, 0, 201, 256, 
    227, 248, 253, 285, 267], [220, 272, 241, 245, 300, 0, 287, 203, 258, 
    219, 283, 301], [219, 207, 215, 269, 245, 214, 0, 219, 312, 254, 287, 
    268], [262, 308, 296, 273, 274, 298, 282, 0, 337, 242, 311, 307], [221,
    192, 206, 253, 253, 243, 189, 164, 0, 179, 258, 306], [246, 257, 298, 
    263, 248, 282, 247, 259, 322, 0, 291, 274], [196, 215, 228, 238, 216, 
    218, 214, 190, 243, 210, 0, 239], [172, 211, 224, 189, 234, 200, 233, 
    194, 195, 227, 262, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 6, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 241, 223, 213, 255, 249, 259, 232, 254, 230, 241, 264],
    [260, 0, 241, 236, 263, 265, 272, 239, 279, 247, 263, 254], [278, 260, 
    0, 250, 276, 244, 304, 256, 266, 262, 267, 284], [288, 265, 251, 0, 267,
    255, 265, 249, 248, 244, 269, 268], [246, 238, 225, 234, 0, 253, 273, 
    252, 271, 244, 263, 266], [252, 236, 257, 246, 248, 0, 251, 251, 271, 
    238, 258, 270], [242, 229, 197, 236, 228, 250, 0, 214, 235, 236, 243, 
    264], [269, 262, 245, 252, 249, 250, 287, 0, 258, 246, 254, 270], [247,
    222, 235, 253, 230, 230, 266, 243, 0, 216, 232, 241], [271, 254, 239, 
    257, 257, 263, 265, 255, 285, 0, 290, 265], [260, 238, 234, 232, 238, 
    243, 258, 247, 269, 211, 0, 254], [237, 247, 217, 233, 235, 231, 237, 
    231, 260, 236, 247, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 7, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 234, 243, 240, 249, 237, 246, 246, 252, 250, 257, 255],
    [267, 0, 254, 267, 253, 248, 264, 258, 254, 263, 259, 256], [258, 247, 
    0, 251, 258, 263, 256, 251, 265, 254, 260, 265], [261, 234, 250, 0, 241,
    243, 264, 250, 247, 260, 249, 258], [252, 248, 243, 260, 0, 253, 253, 
    258, 243, 253, 246, 264], [264, 253, 238, 258, 248, 0, 266, 242, 263, 
    268, 240, 271], [255, 237, 245, 237, 248, 235, 0, 243, 233, 256, 242, 
    260], [255, 243, 250, 251, 243, 259, 258, 0, 249, 265, 264, 260], [249,
    247, 236, 254, 258, 238, 268, 252, 0, 257, 256, 263], [251, 238, 247, 
    241, 248, 233, 245, 236, 244, 0, 244, 258], [244, 242, 241, 252, 255, 
    261, 259, 237, 245, 257, 0, 259], [246, 245, 236, 243, 237, 230, 241, 
    241, 238, 243, 242, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 8, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 246, 259, 252, 252, 249, 259, 284, 265, 248, 278, 251],
    [255, 0, 259, 252, 249, 267, 262, 276, 279, 234, 271, 279], [242, 242, 
    0, 240, 254, 257, 255, 263, 264, 240, 246, 249], [249, 249, 261, 0, 241,
    279, 243, 267, 253, 261, 263, 257], [249, 252, 247, 260, 0, 255, 260, 
    270, 253, 262, 258, 268], [252, 234, 244, 222, 246, 0, 250, 258, 261, 
    240, 264, 258], [242, 239, 246, 258, 241, 251, 0, 265, 255, 253, 261, 
    269], [217, 225, 238, 234, 231, 243, 236, 0, 252, 234, 243, 247], [236,
    222, 237, 248, 248, 240, 246, 249, 0, 243, 236, 245], [253, 267, 261, 
    240, 239, 261, 248, 267, 258, 0, 240, 258], [223, 230, 255, 238, 243, 
    237, 240, 258, 265, 261, 0, 245], [250, 222, 252, 244, 233, 243, 232, 
    254, 256, 243, 256, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 9, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 251, 261, 223, 245, 237, 275, 220, 224, 243, 264, 242],
    [250, 0, 260, 222, 243, 243, 274, 215, 229, 242, 261, 273], [240, 241, 
    0, 231, 213, 225, 228, 252, 234, 239, 238, 258], [278, 279, 270, 0, 283,
    264, 295, 265, 246, 267, 271, 288], [256, 258, 288, 218, 0, 236, 261, 
    233, 216, 251, 267, 269], [264, 258, 276, 237, 265, 0, 275, 273, 253, 
    249, 262, 290], [226, 227, 273, 206, 240, 226, 0, 214, 240, 230, 245, 
    250], [281, 286, 249, 236, 268, 228, 287, 0, 276, 257, 245, 301], [277,
    272, 267, 255, 285, 248, 261, 225, 0, 271, 260, 280], [258, 259, 262, 
    234, 250, 252, 271, 244, 230, 0, 251, 302], [237, 240, 263, 230, 234, 
    239, 256, 256, 241, 250, 0, 266], [259, 228, 243, 213, 232, 211, 251, 
    200, 221, 199, 235, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 10, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 263, 241, 241, 215, 238, 216, 270, 205, 258, 258, 242],
    [238, 0, 245, 245, 239, 229, 232, 227, 215, 276, 229, 266], [260, 256, 
    0, 275, 273, 239, 220, 259, 233, 269, 248, 257], [260, 256, 226, 0, 249,
    235, 223, 253, 228, 256, 269, 302], [286, 262, 228, 252, 0, 235, 228, 
    264, 264, 270, 259, 277], [263, 272, 262, 266, 266, 0, 224, 256, 248, 
    265, 242, 264], [285, 269, 281, 278, 273, 277, 0, 275, 240, 266, 308, 
    318], [231, 274, 242, 248, 237, 245, 226, 0, 216, 279, 244, 253], [296,
    286, 268, 273, 237, 253, 261, 285, 0, 286, 258, 309], [243, 225, 232, 
    245, 231, 236, 235, 222, 215, 0, 262, 249], [243, 272, 253, 232, 242, 
    259, 193, 257, 243, 239, 0, 278], [259, 235, 244, 199, 224, 237, 183, 
    248, 192, 252, 223, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 11, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 227, 329, 294, 369, 243, 216, 235, 353, 255, 288, 277],
    [274, 0, 314, 328, 392, 297, 321, 230, 332, 353, 319, 280], [172, 187, 
    0, 216, 379, 238, 299, 171, 204, 228, 278, 241], [207, 173, 285, 0, 438,
    298, 365, 280, 234, 325, 313, 277], [132, 109, 122, 63, 0, 168, 199, 
    128, 168, 224, 227, 154], [258, 204, 263, 203, 333, 0, 301, 250, 291, 
    244, 326, 285], [285, 180, 202, 136, 302, 200, 0, 224, 216, 294, 237, 
    230], [266, 271, 330, 221, 373, 251, 277, 0, 300, 341, 283, 242], [148,
    169, 297, 267, 333, 210, 285, 201, 0, 211, 238, 189], [246, 148, 273, 
    176, 277, 257, 207, 160, 290, 0, 282, 220], [213, 182, 223, 188, 274, 
    175, 264, 218, 263, 219, 0, 208], [224, 221, 260, 224, 347, 216, 271, 
    259, 312, 281, 293, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 12, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 261, 248, 278, 247, 248, 246, 265, 258, 234, 235, 242],
    [240, 0, 253, 268, 258, 240, 252, 258, 271, 239, 252, 244], [253, 248, 
    0, 264, 273, 252, 246, 280, 265, 262, 250, 251], [223, 233, 237, 0, 251,
    250, 246, 255, 247, 232, 232, 244], [254, 243, 228, 250, 0, 242, 235, 
    261, 254, 243, 248, 245], [253, 261, 249, 251, 259, 0, 247, 257, 250, 
    244, 246, 244], [255, 249, 255, 255, 266, 254, 0, 269, 256, 248, 254, 
    235], [236, 243, 221, 246, 240, 244, 232, 0, 253, 228, 214, 233], [243,
    230, 236, 254, 247, 251, 245, 248, 0, 244, 239, 236], [267, 262, 239, 
    269, 258, 257, 253, 273, 257, 0, 251, 262], [266, 249, 251, 269, 253, 
    255, 247, 287, 262, 250, 0, 244], [259, 257, 250, 257, 256, 257, 266, 
    268, 265, 239, 257, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 13, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 243, 247, 249, 229, 244, 247, 245, 246, 231, 223, 272],
    [258, 0, 238, 235, 232, 243, 259, 231, 224, 236, 236, 257], [254, 263, 
    0, 259, 253, 258, 268, 267, 241, 267, 228, 278], [252, 266, 242, 0, 255,
    262, 264, 260, 248, 260, 258, 270], [272, 269, 248, 246, 0, 248, 270, 
    264, 259, 257, 239, 260], [257, 258, 243, 239, 253, 0, 252, 229, 244, 
    240, 223, 249], [254, 242, 233, 237, 231, 249, 0, 247, 245, 272, 253, 
    271], [256, 270, 234, 241, 237, 272, 254, 0, 244, 246, 245, 267], [255,
    277, 260, 253, 242, 257, 256, 257, 0, 247, 245, 257], [270, 265, 234, 
    241, 244, 261, 229, 255, 254, 0, 240, 250], [278, 265, 273, 243, 262, 
    278, 248, 256, 256, 261, 0, 268], [229, 244, 223, 231, 241, 252, 230, 
    234, 244, 251, 233, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 14, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 258, 251, 277, 239, 227, 263, 230, 231, 253, 266, 259],
    [243, 0, 258, 258, 238, 235, 240, 223, 245, 249, 247, 269], [250, 243, 
    0, 255, 247, 214, 238, 241, 259, 236, 249, 252], [224, 243, 246, 0, 227,
    241, 240, 202, 226, 228, 229, 242], [262, 263, 254, 274, 0, 253, 234, 
    232, 236, 238, 244, 271], [274, 266, 287, 260, 248, 0, 267, 221, 249, 
    260, 283, 284], [238, 261, 263, 261, 267, 234, 0, 248, 258, 251, 248, 
    275], [271, 278, 260, 299, 269, 280, 253, 0, 247, 270, 284, 279], [270,
    256, 242, 275, 265, 252, 243, 254, 0, 254, 283, 253], [248, 252, 265, 
    273, 263, 241, 250, 231, 247, 0, 270, 242], [235, 254, 252, 272, 257, 
    218, 253, 217, 218, 231, 0, 263], [242, 232, 249, 259, 230, 217, 226, 
    222, 248, 259, 238, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 15, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 301, 293, 246, 369, 267, 254, 241, 350, 231, 202, 252],
    [200, 0, 213, 189, 263, 260, 151, 155, 312, 186, 253, 273], [208, 288, 
    0, 243, 256, 274, 193, 255, 310, 225, 297, 313], [255, 312, 258, 0, 330,
    211, 199, 163, 306, 219, 228, 325], [132, 238, 245, 171, 0, 193, 184, 
    93, 254, 115, 161, 222], [234, 241, 227, 290, 308, 0, 189, 253, 277, 
    198, 205, 286], [247, 350, 308, 302, 317, 312, 0, 265, 348, 257, 244, 
    253], [260, 346, 246, 338, 408, 248, 236, 0, 403, 260, 296, 342], [151,
    189, 191, 195, 247, 224, 153, 98, 0, 122, 176, 151], [270, 315, 276, 
    282, 386, 303, 244, 241, 379, 0, 214, 293], [299, 248, 204, 273, 340, 
    296, 257, 205, 325, 287, 0, 199], [249, 228, 188, 176, 279, 215, 248, 
    159, 350, 208, 302, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 16, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 220, 223, 218, 230, 220, 235, 230, 246, 235, 206, 233],
    [281, 0, 220, 210, 225, 243, 211, 250, 224, 230, 188, 225], [278, 281, 
    0, 223, 267, 251, 250, 271, 268, 248, 259, 261], [283, 291, 278, 0, 262,
    291, 271, 277, 270, 257, 246, 290], [271, 276, 234, 239, 0, 280, 230, 
    235, 261, 250, 228, 267], [281, 258, 250, 210, 221, 0, 231, 258, 247, 
    232, 252, 258], [266, 290, 251, 230, 271, 270, 0, 279, 280, 258, 237, 
    273], [271, 251, 230, 224, 266, 243, 222, 0, 255, 228, 183, 248], [255,
    277, 233, 231, 240, 254, 221, 246, 0, 233, 184, 262], [266, 271, 253, 
    244, 251, 269, 243, 273, 268, 0, 254, 254], [295, 313, 242, 255, 273, 
    249, 264, 318, 317, 247, 0, 283], [268, 276, 240, 211, 234, 243, 228, 
    253, 239, 247, 218, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 17, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 233, 269, 273, 209, 223, 270, 272, 272, 263, 229, 237],
    [268, 0, 237, 246, 245, 223, 278, 266, 258, 255, 230, 202], [232, 264, 
    0, 298, 242, 269, 321, 224, 216, 214, 258, 199], [228, 255, 203, 0, 221,
    209, 301, 202, 242, 123, 205, 255], [292, 256, 259, 280, 0, 237, 265, 
    277, 291, 298, 210, 230], [278, 278, 232, 292, 264, 0, 234, 219, 301, 
    246, 280, 236], [231, 223, 180, 200, 236, 267, 0, 213, 225, 237, 231, 
    220], [229, 235, 277, 299, 224, 282, 288, 0, 267, 269, 197, 278], [229,
    243, 285, 259, 210, 200, 276, 234, 0, 209, 189, 249], [238, 246, 287, 
    378, 203, 255, 264, 232, 292, 0, 230, 247], [272, 271, 243, 296, 291, 
    221, 270, 304, 312, 271, 0, 264], [264, 299, 302, 246, 271, 265, 281, 
    223, 252, 254, 237, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 18, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 219, 259, 296, 276, 232, 249, 277, 268, 257, 277, 314],
    [282, 0, 203, 306, 290, 261, 283, 306, 279, 241, 288, 297], [242, 298, 
    0, 280, 247, 232, 291, 303, 216, 228, 277, 265], [205, 195, 221, 0, 225,
    170, 205, 233, 193, 197, 196, 217], [225, 211, 254, 276, 0, 226, 250, 
    254, 254, 207, 225, 264], [269, 240, 269, 331, 275, 0, 284, 298, 266, 
    248, 298, 277], [252, 218, 210, 296, 251, 217, 0, 257, 256, 198, 258, 
    249], [224, 195, 198, 268, 247, 203, 244, 0, 213, 190, 237, 219], [233,
    222, 285, 308, 247, 235, 245, 288, 0, 183, 267, 275], [244, 260, 273, 
    304, 294, 253, 303, 311, 318, 0, 278, 288], [224, 213, 224, 305, 276, 
    203, 243, 264, 234, 223, 0, 236], [187, 204, 236, 284, 237, 224, 252, 
    282, 226, 213, 265, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 19, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 232, 248, 245, 247, 231, 244, 236, 259, 223, 262, 267],
    [269, 0, 257, 249, 256, 267, 272, 268, 259, 260, 265, 279], [253, 244, 
    0, 261, 257, 262, 257, 246, 267, 252, 264, 274], [256, 252, 240, 0, 248,
    271, 262, 265, 262, 239, 249, 256], [254, 245, 244, 253, 0, 260, 263, 
    240, 262, 240, 239, 254], [270, 234, 239, 230, 241, 0, 251, 239, 260, 
    250, 241, 258], [257, 229, 244, 239, 238, 250, 0, 244, 255, 242, 249, 
    245], [265, 233, 255, 236, 261, 262, 257, 0, 263, 238, 245, 260], [242,
    242, 234, 239, 239, 241, 246, 238, 0, 236, 246, 251], [278, 241, 249, 
    262, 261, 251, 259, 263, 265, 0, 261, 266], [239, 236, 237, 252, 262, 
    260, 252, 256, 255, 240, 0, 245], [234, 222, 227, 245, 247, 243, 256, 
    241, 250, 235, 256, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 20, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 245, 259, 252, 251, 242, 258, 258, 253, 254, 244, 240],
    [256, 0, 247, 229, 244, 232, 238, 242, 263, 246, 244, 238], [242, 254, 
    0, 241, 262, 244, 245, 240, 253, 246, 245, 244], [249, 272, 260, 0, 258,
    248, 243, 250, 258, 263, 270, 242], [250, 257, 239, 243, 0, 234, 255, 
    251, 257, 248, 254, 239], [259, 269, 257, 253, 267, 0, 261, 243, 252, 
    262, 265, 234], [243, 263, 256, 258, 246, 240, 0, 260, 258, 255, 252, 
    251], [243, 259, 261, 251, 250, 258, 241, 0, 256, 245, 257, 241], [248,
    238, 248, 243, 244, 249, 243, 245, 0, 263, 269, 232], [247, 255, 255, 
    238, 253, 239, 246, 256, 238, 0, 246, 241], [257, 257, 256, 231, 247, 
    236, 249, 244, 232, 255, 0, 240], [261, 263, 257, 259, 262, 267, 250, 
    260, 269, 260, 261, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 21, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 244, 236, 236, 229, 250, 236, 241, 253, 237, 233, 236],
    [257, 0, 240, 241, 246, 253, 243, 244, 258, 243, 264, 254], [265, 261, 
    0, 248, 258, 254, 240, 249, 260, 252, 257, 256], [265, 260, 253, 0, 253,
    253, 244, 253, 264, 253, 250, 257], [272, 255, 243, 248, 0, 263, 267, 
    262, 256, 259, 258, 261], [251, 248, 247, 248, 238, 0, 236, 249, 262, 
    254, 248, 244], [265, 258, 261, 257, 234, 265, 0, 269, 264, 251, 268, 
    255], [260, 257, 252, 248, 239, 252, 232, 0, 255, 247, 250, 242], [248,
    243, 241, 237, 245, 239, 237, 246, 0, 252, 238, 238], [264, 258, 249, 
    248, 242, 247, 250, 254, 249, 0, 260, 258], [268, 237, 244, 251, 243, 
    253, 233, 251, 263, 241, 0, 249], [265, 247, 245, 244, 240, 257, 246, 
    259, 263, 243, 252, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 22, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 264, 246, 281, 272, 246, 280, 278, 256, 277, 282, 257],
    [237, 0, 239, 264, 249, 233, 253, 256, 277, 263, 256, 245], [255, 262, 
    0, 258, 252, 236, 268, 276, 254, 289, 268, 257], [220, 237, 243, 0, 254,
    217, 255, 256, 231, 271, 267, 232], [229, 252, 249, 247, 0, 255, 273, 
    289, 273, 279, 276, 268], [255, 268, 265, 284, 246, 0, 289, 273, 281, 
    272, 277, 284], [221, 248, 233, 246, 228, 212, 0, 247, 224, 265, 250, 
    217], [223, 245, 225, 245, 212, 228, 254, 0, 237, 232, 232, 222], [245,
    224, 247, 270, 228, 220, 277, 264, 0, 266, 251, 227], [224, 238, 212, 
    230, 222, 229, 236, 269, 235, 0, 250, 235], [219, 245, 233, 234, 225, 
    224, 251, 269, 250, 251, 0, 205], [244, 256, 244, 269, 233, 217, 284, 
    279, 274, 266, 296, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 23, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 232, 254, 274, 245, 255, 289, 269, 270, 232, 255, 258],
    [269, 0, 275, 264, 248, 245, 255, 276, 251, 254, 254, 249], [247, 226, 
    0, 242, 230, 267, 281, 251, 252, 242, 240, 258], [227, 237, 259, 0, 236,
    263, 272, 242, 240, 219, 239, 244], [256, 253, 271, 265, 0, 264, 283, 
    256, 273, 232, 271, 256], [246, 256, 234, 238, 237, 0, 255, 240, 218, 
    241, 259, 248], [212, 246, 220, 229, 218, 246, 0, 228, 228, 221, 222, 
    239], [232, 225, 250, 259, 245, 261, 273, 0, 248, 247, 275, 258], [231,
    250, 249, 261, 228, 283, 273, 253, 0, 242, 274, 245], [269, 247, 259, 
    282, 269, 260, 280, 254, 259, 0, 250, 270], [246, 247, 261, 262, 230, 
    242, 279, 226, 227, 251, 0, 257], [243, 252, 243, 257, 245, 253, 262, 
    243, 256, 231, 244, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 24, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 217, 220, 223, 203, 228, 205, 244, 238, 206, 217, 223],
    [284, 0, 215, 211, 237, 234, 246, 269, 250, 224, 251, 238], [281, 286, 
    0, 234, 254, 253, 215, 255, 230, 225, 276, 263], [278, 290, 267, 0, 258,
    255, 246, 310, 222, 222, 245, 265], [298, 264, 247, 243, 0, 253, 257, 
    268, 231, 239, 240, 253], [273, 267, 248, 246, 248, 0, 224, 266, 233, 
    220, 265, 257], [296, 255, 286, 255, 244, 277, 0, 280, 257, 261, 257, 
    252], [257, 232, 246, 191, 233, 235, 221, 0, 229, 216, 229, 248], [263,
    251, 271, 279, 270, 268, 244, 272, 0, 218, 253, 272], [295, 277, 276, 
    279, 262, 281, 240, 285, 283, 0, 266, 263], [284, 250, 225, 256, 261, 
    236, 244, 272, 248, 235, 0, 256], [278, 263, 238, 236, 248, 244, 249, 
    253, 229, 238, 245, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 25, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 242, 252, 205, 221, 228, 194, 243, 247, 209, 242, 210],
    [259, 0, 255, 237, 217, 244, 221, 240, 264, 245, 273, 233], [249, 246, 
    0, 218, 207, 236, 233, 247, 232, 219, 240, 235], [296, 264, 283, 0, 270,
    272, 269, 296, 301, 273, 258, 244], [280, 284, 294, 231, 0, 254, 247, 
    289, 255, 239, 229, 262], [273, 257, 265, 229, 247, 0, 226, 238, 241, 
    235, 239, 209], [307, 280, 268, 232, 254, 275, 0, 294, 270, 264, 257, 
    239], [258, 261, 254, 205, 212, 263, 207, 0, 251, 228, 232, 228], [254,
    237, 269, 200, 246, 260, 231, 250, 0, 222, 234, 209], [292, 256, 282, 
    228, 262, 266, 237, 273, 279, 0, 251, 254], [259, 228, 261, 243, 272, 
    262, 244, 269, 267, 250, 0, 272], [291, 268, 266, 257, 239, 292, 262, 
    273, 292, 247, 229, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 26, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 220, 248, 202, 215, 243, 224, 199, 237, 262, 245, 234],
    [281, 0, 282, 272, 243, 255, 238, 227, 273, 301, 295, 262], [253, 219, 
    0, 202, 245, 221, 242, 232, 273, 254, 297, 243], [299, 229, 299, 0, 240,
    255, 239, 251, 306, 292, 277, 231], [286, 258, 256, 261, 0, 292, 265, 
    256, 285, 292, 255, 239], [258, 246, 280, 246, 209, 0, 239, 218, 250, 
    261, 264, 238], [277, 263, 259, 262, 236, 262, 0, 231, 260, 261, 293, 
    240], [302, 274, 269, 250, 245, 283, 270, 0, 264, 279, 283, 244], [264,
    228, 228, 195, 216, 251, 241, 237, 0, 273, 246, 217], [239, 200, 247, 
    209, 209, 240, 240, 222, 228, 0, 257, 254], [256, 206, 204, 224, 246, 
    237, 208, 218, 255, 244, 0, 256], [267, 239, 258, 270, 262, 263, 261, 
    257, 284, 247, 245, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 27, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 290, 289, 219, 239, 286, 272, 257, 264, 233, 260, 263],
    [211, 0, 251, 217, 201, 224, 251, 222, 212, 244, 262, 197], [212, 250, 
    0, 214, 209, 259, 233, 225, 241, 213, 271, 205], [282, 284, 287, 0, 238,
    269, 272, 229, 257, 263, 274, 236], [262, 300, 292, 263, 0, 250, 261, 
    251, 238, 236, 283, 229], [215, 277, 242, 232, 251, 0, 229, 228, 216, 
    261, 265, 235], [229, 250, 268, 229, 240, 272, 0, 231, 249, 238, 278, 
    247], [244, 279, 276, 272, 250, 273, 270, 0, 272, 248, 275, 227], [237,
    289, 260, 244, 263, 285, 252, 229, 0, 266, 254, 231], [268, 257, 288, 
    238, 265, 240, 263, 253, 235, 0, 274, 232], [241, 239, 230, 227, 218, 
    236, 223, 226, 247, 227, 0, 224], [238, 304, 296, 265, 272, 266, 254, 
    274, 270, 269, 277, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 28, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 174, 251, 282, 240, 260, 314, 240, 198, 287, 278, 290],
    [327, 0, 205, 289, 266, 276, 282, 334, 191, 259, 359, 258], [250, 296, 
    0, 245, 343, 266, 390, 298, 224, 184, 355, 320], [219, 212, 256, 0, 268,
    272, 248, 245, 227, 204, 313, 250], [261, 235, 158, 233, 0, 202, 258, 
    220, 199, 147, 241, 205], [241, 225, 235, 229, 299, 0, 277, 234, 272, 
    172, 260, 329], [187, 219, 111, 253, 243, 224, 0, 205, 127, 199, 272, 
    243], [261, 167, 203, 256, 281, 267, 296, 0, 210, 154, 248, 218], [303,
    310, 277, 274, 302, 229, 374, 291, 0, 266, 323, 345], [214, 242, 317, 
    297, 354, 329, 302, 347, 235, 0, 354, 263], [223, 142, 146, 188, 260, 
    241, 229, 253, 178, 147, 0, 176], [211, 243, 181, 251, 296, 172, 258, 
    283, 156, 238, 325, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 29, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 251, 270, 270, 270, 259, 268, 241, 256, 269, 276, 264],
    [250, 0, 243, 255, 253, 266, 242, 239, 232, 255, 268, 271], [231, 258, 
    0, 254, 236, 240, 259, 243, 228, 254, 268, 246], [231, 246, 247, 0, 248,
    256, 246, 243, 235, 259, 258, 254], [231, 248, 265, 253, 0, 255, 241, 
    248, 244, 260, 257, 257], [242, 235, 261, 245, 246, 0, 240, 238, 244, 
    254, 256, 255], [233, 259, 242, 255, 260, 261, 0, 246, 271, 264, 270, 
    239], [260, 262, 258, 258, 253, 263, 255, 0, 246, 256, 266, 263], [245,
    269, 273, 266, 257, 257, 230, 255, 0, 267, 277, 258], [232, 246, 247, 
    242, 241, 247, 237, 245, 234, 0, 253, 265], [225, 233, 233, 243, 244, 
    245, 231, 235, 224, 248, 0, 254], [237, 230, 255, 247, 244, 246, 262, 
    238, 243, 236, 247, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 30, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 271, 258, 275, 254, 254, 251, 262, 273, 264, 247, 259],
    [230, 0, 233, 237, 219, 256, 221, 232, 223, 240, 244, 231], [243, 268, 
    0, 267, 244, 266, 229, 240, 246, 271, 269, 242], [226, 264, 234, 0, 270,
    269, 256, 258, 239, 264, 256, 226], [247, 282, 257, 231, 0, 262, 228, 
    271, 241, 276, 262, 244], [247, 245, 235, 232, 239, 0, 258, 276, 254, 
    249, 248, 228], [250, 280, 272, 245, 273, 243, 0, 274, 258, 271, 258, 
    243], [239, 269, 261, 243, 230, 225, 227, 0, 253, 263, 241, 244], [228,
    278, 255, 262, 260, 247, 243, 248, 0, 262, 260, 237], [237, 261, 230, 
    237, 225, 252, 230, 238, 239, 0, 254, 246], [254, 257, 232, 245, 239, 
    253, 243, 260, 241, 247, 0, 247], [242, 270, 259, 275, 257, 273, 258, 
    257, 264, 255, 254, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 31, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 244, 231, 273, 251, 278, 261, 270, 252, 239, 261, 272],
    [257, 0, 233, 290, 244, 280, 261, 262, 252, 242, 262, 243], [270, 268, 
    0, 283, 251, 277, 284, 255, 245, 256, 265, 265], [228, 211, 218, 0, 211,
    233, 226, 232, 210, 234, 210, 214], [250, 257, 250, 290, 0, 299, 266, 
    275, 255, 249, 257, 263], [223, 221, 224, 268, 202, 0, 224, 245, 230, 
    234, 223, 227], [240, 240, 217, 275, 235, 277, 0, 261, 231, 231, 241, 
    225], [231, 239, 246, 269, 226, 256, 240, 0, 230, 240, 237, 235], [249,
    249, 256, 291, 246, 271, 270, 271, 0, 261, 250, 268], [262, 259, 245, 
    267, 252, 267, 270, 261, 240, 0, 236, 248], [240, 239, 236, 291, 244, 
    278, 260, 264, 251, 265, 0, 260], [229, 258, 236, 287, 238, 274, 276, 
    266, 233, 253, 241, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 32, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 253, 198, 227, 207, 223, 196, 208, 220, 229, 188, 202],
    [248, 0, 244, 252, 241, 257, 240, 242, 260, 261, 221, 233], [303, 257, 
    0, 243, 256, 244, 230, 259, 267, 276, 209, 221], [274, 249, 258, 0, 239,
    237, 235, 233, 228, 262, 255, 250], [294, 260, 245, 262, 0, 258, 248, 
    266, 234, 258, 217, 214], [278, 244, 257, 264, 243, 0, 225, 224, 253, 
    251, 193, 213], [305, 261, 271, 266, 253, 276, 0, 265, 245, 244, 231, 
    248], [293, 259, 242, 268, 235, 277, 236, 0, 249, 255, 223, 236], [281,
    241, 234, 273, 267, 248, 256, 252, 0, 276, 223, 242], [272, 240, 225, 
    239, 243, 250, 257, 246, 225, 0, 227, 236], [313, 280, 292, 246, 284, 
    308, 270, 278, 278, 274, 0, 275], [299, 268, 280, 251, 287, 288, 253, 
    265, 259, 265, 226, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 33, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 267, 265, 260, 261, 273, 251, 272, 291, 246, 256, 261],
    [234, 0, 267, 234, 258, 264, 241, 252, 257, 245, 239, 235], [236, 234, 
    0, 249, 266, 225, 243, 263, 264, 255, 247, 253], [241, 267, 252, 0, 270,
    245, 247, 269, 293, 268, 268, 244], [240, 243, 235, 231, 0, 268, 250, 
    235, 257, 231, 258, 255], [228, 237, 276, 256, 233, 0, 235, 231, 238, 
    233, 235, 250], [250, 260, 258, 254, 251, 266, 0, 266, 267, 255, 239, 
    256], [229, 249, 238, 232, 266, 270, 235, 0, 252, 248, 253, 233], [210,
    244, 237, 208, 244, 263, 234, 249, 0, 235, 217, 236], [255, 256, 246, 
    233, 270, 268, 246, 253, 266, 0, 268, 269], [245, 262, 254, 233, 243, 
    266, 262, 248, 284, 233, 0, 268], [240, 266, 248, 257, 246, 251, 245, 
    268, 265, 232, 233, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 34, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 253, 253, 246, 252, 256, 266, 260, 234, 245, 258, 265],
    [248, 0, 255, 259, 258, 235, 251, 260, 234, 245, 240, 260], [248, 246, 
    0, 255, 263, 238, 243, 259, 252, 245, 250, 258], [255, 242, 246, 0, 267,
    255, 249, 250, 250, 225, 257, 242], [249, 243, 238, 234, 0, 242, 253, 
    253, 235, 235, 247, 264], [245, 266, 263, 246, 259, 0, 246, 253, 228, 
    269, 255, 262], [235, 250, 258, 252, 248, 255, 0, 259, 254, 257, 251, 
    245], [241, 241, 242, 251, 248, 248, 242, 0, 238, 247, 248, 258], [267,
    267, 249, 251, 266, 273, 247, 263, 0, 247, 258, 253], [256, 256, 256, 
    276, 266, 232, 244, 254, 254, 0, 261, 271], [243, 261, 251, 244, 254, 
    246, 250, 253, 243, 240, 0, 255], [236, 241, 243, 259, 237, 239, 256, 
    243, 248, 230, 246, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 35, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 246, 247, 240, 236, 256, 237, 246, 260, 279, 261, 238],
    [255, 0, 262, 266, 264, 252, 217, 267, 252, 272, 268, 246], [254, 239, 
    0, 255, 261, 271, 254, 244, 255, 270, 292, 252], [261, 235, 246, 0, 249,
    244, 242, 239, 274, 262, 249, 242], [265, 237, 240, 252, 0, 285, 226, 
    255, 277, 251, 259, 266], [245, 249, 230, 257, 216, 0, 234, 230, 235, 
    225, 258, 239], [264, 284, 247, 259, 275, 267, 0, 258, 271, 302, 297, 
    234], [255, 234, 257, 262, 246, 271, 243, 0, 250, 291, 278, 270], [241,
    249, 246, 227, 224, 266, 230, 251, 0, 264, 273, 232], [222, 229, 231, 
    239, 250, 276, 199, 210, 237, 0, 234, 216], [240, 233, 209, 252, 242, 
    243, 204, 223, 228, 267, 0, 228], [263, 255, 249, 259, 235, 262, 267, 
    231, 269, 285, 273, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 36, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 232, 241, 229, 264, 264, 220, 227, 265, 221, 261, 194],
    [269, 0, 282, 268, 260, 275, 301, 230, 255, 269, 285, 240], [260, 219, 
    0, 217, 270, 243, 245, 226, 254, 213, 240, 217], [272, 233, 284, 0, 284,
    268, 267, 274, 269, 254, 246, 224], [237, 241, 231, 217, 0, 235, 238, 
    199, 229, 210, 259, 183], [237, 226, 258, 233, 266, 0, 237, 240, 210, 
    247, 248, 228], [281, 200, 256, 234, 263, 264, 0, 189, 267, 257, 261, 
    210], [274, 271, 275, 227, 302, 261, 312, 0, 271, 257, 300, 294], [236,
    246, 247, 232, 272, 291, 234, 230, 0, 268, 252, 232], [280, 232, 288, 
    247, 291, 254, 244, 244, 233, 0, 272, 238], [240, 216, 261, 255, 242, 
    253, 240, 201, 249, 229, 0, 216], [307, 261, 284, 277, 318, 273, 291, 
    207, 269, 263, 285, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 37, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 236, 246, 263, 236, 248, 240, 257, 260, 244, 234, 273],
    [265, 0, 246, 263, 264, 264, 256, 263, 264, 255, 243, 289], [255, 255, 
    0, 268, 245, 250, 248, 242, 250, 251, 242, 264], [238, 238, 233, 0, 252,
    260, 243, 243, 251, 234, 234, 270], [265, 237, 256, 249, 0, 253, 247, 
    242, 252, 238, 256, 266], [253, 237, 251, 241, 248, 0, 240, 257, 229, 
    250, 247, 258], [261, 245, 253, 258, 254, 261, 0, 261, 263, 257, 249, 
    269], [244, 238, 259, 258, 259, 244, 240, 0, 263, 251, 242, 274], [241,
    237, 251, 250, 249, 272, 238, 238, 0, 240, 245, 255], [257, 246, 250, 
    267, 263, 251, 244, 250, 261, 0, 255, 276], [267, 258, 259, 267, 245, 
    254, 252, 259, 256, 246, 0, 286], [228, 212, 237, 231, 235, 243, 232, 
    227, 246, 225, 215, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 38, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 260, 239, 247, 245, 236, 253, 247, 243, 237, 260, 265],
    [241, 0, 229, 231, 237, 249, 259, 229, 238, 244, 266, 267], [262, 272, 
    0, 261, 232, 241, 263, 264, 251, 262, 262, 263], [254, 270, 240, 0, 258,
    256, 268, 277, 246, 262, 278, 272], [256, 264, 269, 243, 0, 252, 261, 
    265, 255, 272, 260, 267], [265, 252, 260, 245, 249, 0, 271, 267, 251, 
    251, 263, 281], [248, 242, 238, 233, 240, 230, 0, 229, 250, 254, 242, 
    257], [254, 272, 237, 224, 236, 234, 272, 0, 233, 251, 263, 251], [258,
    263, 250, 255, 246, 250, 251, 268, 0, 250, 275, 264], [264, 257, 239, 
    239, 229, 250, 247, 250, 251, 0, 270, 272], [241, 235, 239, 223, 241, 
    238, 259, 238, 226, 231, 0, 258], [236, 234, 238, 229, 234, 220, 244, 
    250, 237, 229, 243, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 39, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 230, 218, 231, 225, 259, 233, 245, 287, 232, 267, 218],
    [271, 0, 247, 274, 262, 314, 275, 260, 274, 217, 295, 236], [283, 254, 
    0, 284, 225, 310, 257, 250, 292, 252, 286, 215], [270, 227, 217, 0, 210,
    250, 225, 227, 243, 251, 278, 196], [276, 239, 276, 291, 0, 304, 255, 
    254, 280, 261, 306, 209], [242, 187, 191, 251, 197, 0, 196, 231, 258, 
    206, 218, 184], [268, 226, 244, 276, 246, 305, 0, 236, 277, 247, 275, 
    232], [256, 241, 251, 274, 247, 270, 265, 0, 290, 210, 278, 242], [214,
    227, 209, 258, 221, 243, 224, 211, 0, 196, 255, 236], [269, 284, 249, 
    250, 240, 295, 254, 291, 305, 0, 288, 252], [234, 206, 215, 223, 195, 
    283, 226, 223, 246, 213, 0, 224], [283, 265, 286, 305, 292, 317, 269, 
    259, 265, 249, 277, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 40, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 281, 245, 257, 246, 267, 251, 279, 242, 251, 257, 246],
    [220, 0, 231, 250, 224, 251, 253, 245, 226, 228, 222, 218], [256, 270, 
    0, 264, 263, 262, 267, 253, 239, 236, 256, 241], [244, 251, 237, 0, 236,
    263, 275, 250, 235, 239, 241, 225], [255, 277, 238, 265, 0, 248, 263, 
    253, 233, 259, 234, 255], [234, 250, 239, 238, 253, 0, 242, 265, 236, 
    242, 249, 217], [250, 248, 234, 226, 238, 259, 0, 263, 222, 267, 256, 
    212], [222, 256, 248, 251, 248, 236, 238, 0, 219, 226, 256, 226], [259,
    275, 262, 266, 268, 265, 279, 282, 0, 254, 257, 246], [250, 273, 265, 
    262, 242, 259, 234, 275, 247, 0, 256, 221], [244, 279, 245, 260, 267, 
    252, 245, 245, 244, 245, 0, 204], [255, 283, 260, 276, 246, 284, 289, 
    275, 255, 280, 297, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 41, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 256, 237, 238, 282, 230, 251, 250, 251, 257, 271, 256],
    [245, 0, 222, 252, 218, 259, 228, 242, 228, 258, 251, 237], [264, 279, 
    0, 256, 251, 263, 264, 235, 282, 266, 288, 264], [263, 249, 245, 0, 256,
    249, 248, 255, 262, 251, 283, 248], [219, 283, 250, 245, 0, 251, 227, 
    217, 255, 248, 260, 243], [271, 242, 238, 252, 250, 0, 227, 241, 264, 
    245, 262, 235], [250, 273, 237, 253, 274, 274, 0, 267, 258, 260, 286, 
    276], [251, 259, 266, 246, 284, 260, 234, 0, 276, 256, 283, 279], [250,
    273, 219, 239, 246, 237, 243, 225, 0, 236, 255, 237], [244, 243, 235, 
    250, 253, 256, 241, 245, 265, 0, 270, 244], [230, 250, 213, 218, 241, 
    239, 215, 218, 246, 231, 0, 263], [245, 264, 237, 253, 258, 266, 225, 
    222, 264, 257, 238, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 42, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 270, 261, 288, 269, 268, 260, 271, 254, 227, 254, 253],
    [231, 0, 243, 265, 259, 269, 260, 253, 228, 262, 240, 248], [240, 258, 
    0, 270, 272, 278, 262, 286, 238, 266, 256, 242], [213, 236, 231, 0, 243,
    261, 240, 233, 251, 234, 236, 226], [232, 242, 229, 258, 0, 267, 249, 
    238, 228, 242, 232, 216], [233, 232, 223, 240, 234, 0, 221, 246, 206, 
    245, 209, 211], [241, 241, 239, 261, 252, 280, 0, 255, 211, 261, 230, 
    239], [230, 248, 215, 268, 263, 255, 246, 0, 227, 245, 239, 229], [247,
    273, 263, 250, 273, 295, 290, 274, 0, 264, 274, 248], [274, 239, 235, 
    267, 259, 256, 240, 256, 237, 0, 238, 263], [247, 261, 245, 265, 269, 
    292, 271, 262, 227, 263, 0, 249], [248, 253, 259, 275, 285, 290, 262, 
    272, 253, 238, 252, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 43, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 254, 260, 268, 244, 245, 254, 263, 236, 251, 260, 234],
    [247, 0, 267, 263, 247, 242, 236, 249, 229, 241, 242, 233], [241, 234, 
    0, 244, 228, 238, 221, 251, 229, 231, 245, 231], [233, 238, 257, 0, 233,
    251, 241, 251, 239, 238, 249, 234], [257, 254, 273, 268, 0, 256, 252, 
    263, 238, 255, 260, 247], [256, 259, 263, 250, 245, 0, 238, 257, 236, 
    250, 261, 240], [247, 265, 280, 260, 249, 263, 0, 273, 251, 257, 265, 
    253], [238, 252, 250, 250, 238, 244, 228, 0, 229, 243, 232, 234], [265,
    272, 272, 262, 263, 265, 250, 272, 0, 261, 258, 256], [250, 260, 270, 
    263, 246, 251, 244, 258, 240, 0, 260, 245], [241, 259, 256, 252, 241, 
    240, 236, 269, 243, 241, 0, 230], [267, 268, 270, 267, 254, 261, 248, 
    267, 245, 256, 271, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 44, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 240, 303, 317, 307, 277, 245, 262, 338, 218, 306, 247],
    [261, 0, 278, 266, 314, 310, 219, 261, 275, 219, 272, 258], [198, 223, 
    0, 279, 237, 237, 192, 243, 234, 213, 275, 213], [184, 235, 222, 0, 236,
    269, 197, 201, 245, 206, 228, 222], [194, 187, 264, 265, 0, 306, 261, 
    237, 328, 257, 299, 260], [224, 191, 264, 232, 195, 0, 179, 174, 252, 
    210, 225, 228], [256, 282, 309, 304, 240, 322, 0, 279, 315, 262, 364, 
    261], [239, 240, 258, 300, 264, 327, 222, 0, 285, 254, 262, 246], [163,
    226, 267, 256, 173, 249, 186, 216, 0, 267, 280, 173], [283, 282, 288, 
    295, 244, 291, 239, 247, 234, 0, 291, 223], [195, 229, 226, 273, 202, 
    276, 137, 239, 221, 210, 0, 225], [254, 243, 288, 279, 241, 273, 240, 
    255, 328, 278, 276, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 45, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 340, 276, 362, 225, 300, 264, 225, 310, 236, 288, 255],
    [161, 0, 192, 253, 182, 220, 201, 200, 242, 185, 260, 246], [225, 309, 
    0, 270, 237, 286, 282, 268, 255, 290, 268, 272], [139, 248, 231, 0, 177,
    216, 181, 202, 185, 192, 193, 226], [276, 319, 264, 324, 0, 290, 263, 
    238, 323, 295, 246, 263], [201, 281, 215, 285, 211, 0, 248, 221, 254, 
    210, 227, 256], [237, 300, 219, 320, 238, 253, 0, 222, 275, 227, 288, 
    234], [276, 301, 233, 299, 263, 280, 279, 0, 314, 313, 339, 302], [191,
    259, 246, 316, 178, 247, 226, 187, 0, 214, 210, 220], [265, 316, 211, 
    309, 206, 291, 274, 188, 287, 0, 247, 256], [213, 241, 233, 308, 255, 
    274, 213, 162, 291, 254, 0, 257], [246, 255, 229, 275, 238, 245, 267, 
    199, 281, 245, 244, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 46, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 226, 242, 217, 271, 227, 267, 225, 243, 277, 213, 267],
    [275, 0, 251, 241, 270, 238, 246, 203, 242, 298, 229, 247], [259, 250, 
    0, 225, 238, 231, 222, 196, 214, 244, 242, 242], [284, 260, 276, 0, 261,
    276, 225, 253, 242, 273, 254, 254], [230, 231, 263, 240, 0, 272, 221, 
    228, 208, 259, 253, 214], [274, 263, 270, 225, 229, 0, 197, 265, 250, 
    296, 261, 267], [234, 255, 279, 276, 280, 304, 0, 269, 267, 277, 259, 
    261], [276, 298, 305, 248, 273, 236, 232, 0, 210, 276, 256, 215], [258,
    259, 287, 259, 293, 251, 234, 291, 0, 287, 219, 225], [224, 203, 257, 
    228, 242, 205, 224, 225, 214, 0, 210, 197], [288, 272, 259, 247, 248, 
    240, 242, 245, 282, 291, 0, 252], [234, 254, 259, 247, 287, 234, 240, 
    286, 276, 304, 249, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 47, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 248, 250, 222, 236, 236, 247, 244, 245, 240, 236, 246],
    [253, 0, 224, 226, 253, 243, 255, 243, 235, 255, 258, 237], [251, 277, 
    0, 247, 261, 267, 255, 256, 250, 254, 269, 232], [279, 275, 254, 0, 257,
    258, 302, 249, 270, 264, 266, 249], [265, 248, 240, 244, 0, 238, 257, 
    232, 257, 261, 237, 223], [265, 258, 234, 243, 263, 0, 277, 274, 270, 
    277, 295, 252], [254, 246, 246, 199, 244, 224, 0, 231, 266, 241, 235, 
    224], [257, 258, 245, 252, 269, 227, 270, 0, 237, 267, 243, 245], [256,
    266, 251, 231, 244, 231, 235, 264, 0, 228, 238, 231], [261, 246, 247, 
    237, 240, 224, 260, 234, 273, 0, 255, 230], [265, 243, 232, 235, 264, 
    206, 266, 258, 263, 246, 0, 219], [255, 264, 269, 252, 278, 249, 277, 
    256, 270, 271, 282, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 48, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 244, 259, 255, 264, 255, 255, 261, 258, 257, 254, 254],
    [257, 0, 242, 256, 274, 252, 257, 256, 271, 253, 227, 240], [242, 259, 
    0, 244, 261, 252, 248, 252, 258, 235, 238, 238], [246, 245, 257, 0, 259,
    250, 250, 258, 273, 235, 253, 249], [237, 227, 240, 242, 0, 248, 237, 
    258, 252, 227, 235, 244], [246, 249, 249, 251, 253, 0, 274, 269, 271, 
    256, 228, 250], [246, 244, 253, 251, 264, 227, 0, 257, 262, 240, 234, 
    250], [240, 245, 249, 243, 243, 232, 244, 0, 265, 247, 231, 237], [243,
    230, 243, 228, 249, 230, 239, 236, 0, 255, 236, 234], [244, 248, 266, 
    266, 274, 245, 261, 254, 246, 0, 239, 248], [247, 274, 263, 248, 266, 
    273, 267, 270, 265, 262, 0, 248], [247, 261, 263, 252, 257, 251, 251, 
    264, 267, 253, 253, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 49, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 260, 258, 254, 251, 226, 241, 267, 242, 260, 263, 284],
    [241, 0, 210, 262, 239, 234, 231, 253, 217, 277, 247, 259], [243, 291, 
    0, 275, 242, 213, 230, 251, 224, 261, 264, 239], [247, 239, 226, 0, 217,
    240, 205, 255, 236, 223, 249, 270], [250, 262, 259, 284, 0, 227, 259, 
    255, 242, 277, 260, 284], [275, 267, 288, 261, 274, 0, 240, 297, 234, 
    297, 294, 292], [260, 270, 271, 296, 242, 261, 0, 277, 254, 290, 295, 
    272], [234, 248, 250, 246, 246, 204, 224, 0, 220, 265, 240, 262], [259,
    284, 277, 265, 259, 267, 247, 281, 0, 281, 257, 297], [241, 224, 240, 
    278, 224, 204, 211, 236, 220, 0, 268, 274], [238, 254, 237, 252, 241, 
    207, 206, 261, 244, 233, 0, 286], [217, 242, 262, 231, 217, 209, 229, 
    239, 204, 227, 215, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 50, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 265, 237, 246, 255, 270, 248, 261, 263, 257, 252, 267],
    [236, 0, 241, 242, 244, 240, 238, 247, 254, 243, 251, 253], [264, 260, 
    0, 253, 252, 260, 242, 262, 261, 272, 264, 266], [255, 259, 248, 0, 264,
    247, 248, 255, 257, 261, 258, 261], [246, 257, 249, 237, 0, 256, 253, 
    265, 268, 248, 261, 271], [231, 261, 241, 254, 245, 0, 249, 260, 244, 
    253, 259, 266], [253, 263, 259, 253, 248, 252, 0, 264, 264, 251, 264, 
    268], [240, 254, 239, 246, 236, 241, 237, 0, 242, 241, 268, 258], [238,
    247, 240, 244, 233, 257, 237, 259, 0, 243, 255, 261], [244, 258, 229, 
    240, 253, 248, 250, 260, 258, 0, 265, 279], [249, 250, 237, 243, 240, 
    242, 237, 233, 246, 236, 0, 264], [234, 248, 235, 240, 230, 235, 233, 
    243, 240, 222, 237, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 51, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 265, 242, 272, 248, 240, 208, 244, 250, 249, 251, 215],
    [236, 0, 250, 229, 229, 255, 236, 235, 268, 267, 244, 231], [259, 251, 
    0, 239, 208, 213, 226, 251, 239, 248, 226, 217], [229, 272, 262, 0, 236,
    250, 238, 238, 270, 253, 239, 230], [253, 272, 293, 265, 0, 261, 261, 
    266, 244, 295, 272, 259], [261, 246, 288, 251, 240, 0, 262, 234, 235, 
    276, 267, 229], [293, 265, 275, 263, 240, 239, 0, 227, 245, 305, 263, 
    224], [257, 266, 250, 263, 235, 267, 274, 0, 267, 296, 280, 234], [251,
    233, 262, 231, 257, 266, 256, 234, 0, 278, 293, 224], [252, 234, 253, 
    248, 206, 225, 196, 205, 223, 0, 240, 223], [250, 257, 275, 262, 229, 
    234, 238, 221, 208, 261, 0, 212], [286, 270, 284, 271, 242, 272, 277, 
    267, 277, 278, 289, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 52, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 254, 238, 260, 247, 224, 244, 269, 221, 239, 228, 251],
    [247, 0, 237, 252, 234, 230, 228, 227, 213, 254, 211, 261], [263, 264, 
    0, 243, 249, 251, 254, 269, 242, 253, 247, 247], [241, 249, 258, 0, 252,
    239, 259, 254, 226, 258, 227, 259], [254, 267, 252, 249, 0, 249, 257, 
    261, 228, 262, 240, 253], [277, 271, 250, 262, 252, 0, 280, 253, 230, 
    262, 231, 267], [257, 273, 247, 242, 244, 221, 0, 256, 234, 261, 244, 
    263], [232, 274, 232, 247, 240, 248, 245, 0, 252, 280, 230, 275], [280,
    288, 259, 275, 273, 271, 267, 249, 0, 272, 254, 255], [262, 247, 248, 
    243, 239, 239, 240, 221, 229, 0, 218, 256], [273, 290, 254, 274, 261, 
    270, 257, 271, 247, 283, 0, 283], [250, 240, 254, 242, 248, 234, 238, 
    226, 246, 245, 218, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 53, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 225, 254, 236, 250, 241, 237, 259, 257, 227, 270, 245],
    [276, 0, 269, 256, 282, 255, 250, 257, 257, 250, 269, 258], [247, 232, 
    0, 242, 272, 229, 240, 262, 236, 238, 260, 249], [265, 245, 259, 0, 274,
    244, 250, 278, 258, 255, 266, 275], [251, 219, 229, 227, 0, 230, 239, 
    248, 239, 240, 288, 245], [260, 246, 272, 257, 271, 0, 265, 273, 248, 
    257, 285, 252], [264, 251, 261, 251, 262, 236, 0, 257, 264, 220, 281, 
    247], [242, 244, 239, 223, 253, 228, 244, 0, 234, 220, 275, 222], [244,
    244, 265, 243, 262, 253, 237, 267, 0, 227, 268, 244], [274, 251, 263, 
    246, 261, 244, 281, 281, 274, 0, 289, 261], [231, 232, 241, 235, 213, 
    216, 220, 226, 233, 212, 0, 252], [256, 243, 252, 226, 256, 249, 254, 
    279, 257, 240, 249, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 54, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 251, 243, 263, 258, 250, 252, 241, 236, 240, 263, 261],
    [250, 0, 245, 265, 258, 248, 253, 248, 243, 247, 266, 258], [258, 256, 
    0, 275, 276, 245, 265, 255, 257, 247, 270, 261], [238, 236, 226, 0, 247,
    247, 259, 247, 235, 243, 248, 247], [243, 243, 225, 254, 0, 249, 256, 
    244, 229, 245, 254, 265], [251, 253, 256, 254, 252, 0, 257, 253, 244, 
    236, 243, 263], [249, 248, 236, 242, 245, 244, 0, 233, 242, 243, 251, 
    250], [260, 253, 246, 254, 257, 248, 268, 0, 249, 241, 241, 246], [265,
    258, 244, 266, 272, 257, 259, 252, 0, 266, 261, 258], [261, 254, 254, 
    258, 256, 265, 258, 260, 235, 0, 253, 256], [238, 235, 231, 253, 247, 
    258, 250, 260, 240, 248, 0, 263], [240, 243, 240, 254, 236, 238, 251, 
    255, 243, 245, 238, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 55, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 253, 245, 266, 254, 258, 244, 265, 239, 253, 254, 297],
    [248, 0, 245, 269, 248, 259, 249, 233, 245, 235, 231, 269], [256, 256, 
    0, 277, 271, 278, 259, 227, 249, 244, 246, 268], [235, 232, 224, 0, 251,
    233, 245, 228, 230, 255, 226, 266], [247, 253, 230, 250, 0, 254, 246, 
    253, 257, 227, 237, 276], [243, 242, 223, 268, 247, 0, 247, 229, 240, 
    253, 223, 259], [257, 252, 242, 256, 255, 254, 0, 236, 237, 243, 250, 
    283], [236, 268, 274, 273, 248, 272, 265, 0, 240, 264, 246, 280], [262,
    256, 252, 271, 244, 261, 264, 261, 0, 240, 263, 273], [248, 266, 257, 
    246, 274, 248, 258, 237, 261, 0, 235, 283], [247, 270, 255, 275, 264, 
    278, 251, 255, 238, 266, 0, 288], [204, 232, 233, 235, 225, 242, 218, 
    221, 228, 218, 213, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 56, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 237, 241, 236, 264, 274, 255, 250, 273, 250, 252, 272],
    [264, 0, 249, 254, 258, 272, 258, 250, 291, 276, 240, 288], [260, 252, 
    0, 246, 249, 253, 239, 243, 261, 277, 247, 276], [265, 247, 255, 0, 240,
    248, 261, 227, 283, 271, 252, 242], [237, 243, 252, 261, 0, 248, 238, 
    238, 248, 261, 236, 256], [227, 229, 248, 253, 253, 0, 231, 219, 261, 
    252, 223, 245], [246, 243, 262, 240, 263, 270, 0, 260, 264, 253, 253, 
    263], [251, 251, 258, 274, 263, 282, 241, 0, 281, 271, 249, 268], [228,
    210, 240, 218, 253, 240, 237, 220, 0, 256, 201, 232], [251, 225, 224, 
    230, 240, 249, 248, 230, 245, 0, 232, 254], [249, 261, 254, 249, 265, 
    278, 248, 252, 300, 269, 0, 270], [229, 213, 225, 259, 245, 256, 238, 
    233, 269, 247, 231, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 57, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 240, 252, 264, 229, 249, 256, 263, 239, 251, 237, 242],
    [261, 0, 251, 257, 243, 251, 250, 237, 257, 252, 253, 248], [249, 250, 
    0, 238, 238, 246, 269, 243, 252, 262, 246, 243], [237, 244, 263, 0, 236,
    236, 252, 236, 244, 260, 243, 235], [272, 258, 263, 265, 0, 267, 255, 
    254, 251, 253, 249, 253], [252, 250, 255, 265, 234, 0, 263, 259, 254, 
    254, 254, 226], [245, 251, 232, 249, 246, 238, 0, 245, 249, 247, 251, 
    235], [238, 264, 258, 265, 247, 242, 256, 0, 269, 261, 250, 251], [262,
    244, 249, 257, 250, 247, 252, 232, 0, 243, 244, 229], [250, 249, 239, 
    241, 248, 247, 254, 240, 258, 0, 244, 225], [264, 248, 255, 258, 252, 
    247, 250, 251, 257, 257, 0, 247], [259, 253, 258, 266, 248, 275, 266, 
    250, 272, 276, 254, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 58, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 253, 244, 249, 250, 248, 244, 232, 235, 258, 247, 248],
    [248, 0, 245, 230, 240, 236, 254, 246, 229, 260, 250, 247], [257, 256, 
    0, 243, 258, 240, 253, 237, 250, 253, 237, 253], [252, 271, 258, 0, 260,
    255, 250, 240, 259, 258, 246, 250], [251, 261, 243, 241, 0, 244, 249, 
    233, 235, 242, 250, 242], [253, 265, 261, 246, 257, 0, 262, 247, 247, 
    260, 266, 235], [257, 247, 248, 251, 252, 239, 0, 231, 243, 248, 252, 
    266], [269, 255, 264, 261, 268, 254, 270, 0, 246, 271, 263, 263], [266,
    272, 251, 242, 266, 254, 258, 255, 0, 276, 256, 257], [243, 241, 248, 
    243, 259, 241, 253, 230, 225, 0, 237, 253], [254, 251, 264, 255, 251, 
    235, 249, 238, 245, 264, 0, 250], [253, 254, 248, 251, 259, 266, 235, 
    238, 244, 248, 251, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 59, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 235, 218, 239, 242, 227, 245, 261, 249, 263, 236, 225],
    [266, 0, 222, 286, 275, 274, 253, 274, 270, 263, 282, 257], [283, 279, 
    0, 270, 257, 259, 270, 275, 281, 266, 271, 250], [262, 215, 231, 0, 243,
    274, 244, 270, 281, 271, 237, 245], [259, 226, 244, 258, 0, 258, 275, 
    273, 276, 272, 262, 250], [274, 227, 242, 227, 243, 0, 291, 251, 263, 
    273, 259, 267], [256, 248, 231, 257, 226, 210, 0, 247, 245, 245, 248, 
    226], [240, 227, 226, 231, 228, 250, 254, 0, 240, 247, 262, 210], [252,
    231, 220, 220, 225, 238, 256, 261, 0, 251, 251, 220], [238, 238, 235, 
    230, 229, 228, 256, 254, 250, 0, 264, 248], [265, 219, 230, 264, 239, 
    242, 253, 239, 250, 237, 0, 248], [276, 244, 251, 256, 251, 234, 275, 
    291, 281, 253, 253, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 60, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 246, 240, 274, 267, 244, 258, 250, 258, 251, 264, 234],
    [255, 0, 248, 254, 244, 250, 242, 250, 255, 253, 250, 261], [261, 253, 
    0, 267, 244, 242, 257, 238, 241, 242, 224, 220], [227, 247, 234, 0, 245,
    224, 248, 213, 225, 247, 224, 235], [234, 257, 257, 256, 0, 249, 263, 
    244, 261, 241, 253, 243], [257, 251, 259, 277, 252, 0, 242, 218, 235, 
    258, 264, 228], [243, 259, 244, 253, 238, 259, 0, 230, 253, 248, 230, 
    229], [251, 251, 263, 288, 257, 283, 271, 0, 265, 257, 245, 239], [243,
    246, 260, 276, 240, 266, 248, 236, 0, 263, 242, 254], [250, 248, 259, 
    254, 260, 243, 253, 244, 238, 0, 248, 242], [237, 251, 277, 277, 248, 
    237, 271, 256, 259, 253, 0, 244], [267, 240, 281, 266, 258, 273, 272, 
    262, 247, 259, 257, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 61, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 249, 259, 256, 247, 253, 262, 249, 266, 248, 267, 242],
    [252, 0, 241, 246, 248, 232, 253, 259, 245, 237, 258, 241], [242, 260, 
    0, 242, 245, 232, 252, 253, 255, 242, 259, 250], [245, 255, 259, 0, 252,
    253, 248, 240, 252, 246, 249, 238], [254, 253, 256, 249, 0, 249, 247, 
    259, 262, 245, 255, 242], [248, 269, 269, 248, 252, 0, 275, 273, 262, 
    250, 271, 240], [239, 248, 249, 253, 254, 226, 0, 251, 248, 245, 254, 
    233], [252, 242, 248, 261, 242, 228, 250, 0, 237, 259, 237, 254], [235,
    256, 246, 249, 239, 239, 253, 264, 0, 235, 247, 237], [253, 264, 259, 
    255, 256, 251, 256, 242, 266, 0, 251, 243], [234, 243, 242, 252, 246, 
    230, 247, 264, 254, 250, 0, 238], [259, 260, 251, 263, 259, 261, 268, 
    247, 264, 258, 263, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 62, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 259, 247, 262, 253, 242, 219, 241, 266, 252, 259, 263],
    [242, 0, 241, 250, 245, 246, 246, 242, 249, 254, 248, 232], [254, 260, 
    0, 245, 266, 252, 271, 253, 259, 245, 274, 260], [239, 251, 256, 0, 216,
    241, 237, 225, 240, 237, 239, 235], [248, 256, 235, 285, 0, 253, 244, 
    236, 250, 243, 266, 250], [259, 255, 249, 260, 248, 0, 249, 227, 254, 
    262, 252, 249], [282, 255, 230, 264, 257, 252, 0, 265, 272, 268, 270, 
    264], [260, 259, 248, 276, 265, 274, 236, 0, 265, 253, 245, 247], [235,
    252, 242, 261, 251, 247, 229, 236, 0, 251, 238, 243], [249, 247, 256, 
    264, 258, 239, 233, 248, 250, 0, 255, 254], [242, 253, 227, 262, 235, 
    249, 231, 256, 263, 246, 0, 243], [238, 269, 241, 266, 251, 252, 237, 
    254, 258, 247, 258, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 63, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 268, 311, 301, 240, 262, 298, 258, 227, 299, 260, 275],
    [233, 0, 299, 264, 247, 277, 241, 256, 238, 292, 253, 287], [190, 202, 
    0, 277, 234, 234, 259, 224, 205, 234, 201, 276], [200, 237, 224, 0, 198,
    214, 252, 229, 224, 231, 229, 224], [261, 254, 267, 303, 0, 278, 267, 
    235, 258, 263, 211, 269], [239, 224, 267, 287, 223, 0, 279, 221, 210, 
    251, 241, 269], [203, 260, 242, 249, 234, 222, 0, 250, 216, 226, 266, 
    253], [243, 245, 277, 272, 266, 280, 251, 0, 262, 285, 244, 272], [274,
    263, 296, 277, 243, 291, 285, 239, 0, 253, 261, 293], [202, 209, 267, 
    270, 238, 250, 275, 216, 248, 0, 221, 259], [241, 248, 300, 272, 290, 
    260, 235, 257, 240, 280, 0, 268], [226, 214, 225, 277, 232, 232, 248, 
    229, 208, 242, 233, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 64, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 267, 240, 243, 246, 260, 256, 246, 245, 269, 268, 244],
    [234, 0, 248, 249, 248, 271, 245, 241, 248, 262, 242, 244], [261, 253, 
    0, 253, 262, 247, 226, 252, 259, 258, 253, 239], [258, 252, 248, 0, 234,
    262, 239, 244, 239, 281, 240, 258], [255, 253, 239, 267, 0, 261, 250, 
    247, 228, 272, 251, 239], [241, 230, 254, 239, 240, 0, 237, 221, 231, 
    258, 237, 245], [245, 256, 275, 262, 251, 264, 0, 234, 249, 268, 269, 
    257], [255, 260, 249, 257, 254, 280, 267, 0, 255, 258, 253, 264], [256,
    253, 242, 262, 273, 270, 252, 246, 0, 263, 263, 260], [232, 239, 243, 
    220, 229, 243, 233, 243, 238, 0, 263, 240], [233, 259, 248, 261, 250, 
    264, 232, 248, 238, 238, 0, 251], [257, 257, 262, 243, 262, 256, 244, 
    237, 241, 261, 250, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 65, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 241, 243, 242, 256, 246, 238, 246, 249, 249, 244, 242],
    [260, 0, 234, 239, 237, 266, 223, 238, 255, 249, 244, 244], [258, 267, 
    0, 249, 253, 272, 274, 249, 234, 259, 258, 262], [259, 262, 252, 0, 257,
    283, 247, 254, 256, 264, 251, 274], [245, 264, 248, 244, 0, 262, 257, 
    236, 258, 249, 256, 237], [255, 235, 229, 218, 239, 0, 227, 227, 235, 
    239, 228, 243], [263, 278, 227, 254, 244, 274, 0, 239, 253, 274, 258, 
    256], [255, 263, 252, 247, 265, 274, 262, 0, 247, 270, 256, 242], [252,
    246, 267, 245, 243, 266, 248, 254, 0, 267, 244, 245], [252, 252, 242, 
    237, 252, 262, 227, 231, 234, 0, 264, 255], [257, 257, 243, 250, 245, 
    273, 243, 245, 257, 237, 0, 268], [259, 257, 239, 227, 264, 258, 245, 
    259, 256, 246, 233, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 66, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 231, 234, 235, 216, 198, 245, 216, 252, 267, 253, 229],
    [270, 0, 265, 254, 247, 236, 273, 242, 262, 259, 280, 257], [267, 236, 
    0, 228, 267, 270, 275, 285, 241, 229, 280, 250], [266, 247, 273, 0, 248,
    248, 241, 235, 265, 267, 262, 284], [285, 254, 234, 253, 0, 251, 249, 
    239, 239, 266, 260, 241], [303, 265, 231, 253, 250, 0, 263, 250, 266, 
    269, 291, 247], [256, 228, 226, 260, 252, 238, 0, 244, 236, 256, 289, 
    240], [285, 259, 216, 266, 262, 251, 257, 0, 267, 274, 271, 233], [249,
    239, 260, 236, 262, 235, 265, 234, 0, 248, 254, 244], [234, 242, 272, 
    234, 235, 232, 245, 227, 253, 0, 252, 224], [248, 221, 221, 239, 241, 
    210, 212, 230, 247, 249, 0, 228], [272, 244, 251, 217, 260, 254, 261, 
    268, 257, 277, 273, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 67, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 287, 286, 342, 281, 245, 232, 294, 340, 267, 321, 226],
    [214, 0, 271, 267, 269, 201, 212, 261, 234, 196, 228, 164], [215, 230, 
    0, 264, 214, 248, 208, 260, 207, 198, 194, 135], [159, 234, 237, 0, 236,
    180, 206, 238, 307, 241, 238, 187], [220, 232, 287, 265, 0, 262, 253, 
    254, 251, 231, 308, 263], [256, 300, 253, 321, 239, 0, 231, 249, 239, 
    267, 296, 244], [269, 289, 293, 295, 248, 270, 0, 234, 298, 187, 268, 
    249], [207, 240, 241, 263, 247, 252, 267, 0, 190, 208, 211, 178], [161,
    267, 294, 194, 250, 262, 203, 311, 0, 241, 290, 231], [234, 305, 303, 
    260, 270, 234, 314, 293, 260, 0, 278, 191], [180, 273, 307, 263, 193, 
    205, 233, 290, 211, 223, 0, 216], [275, 337, 366, 314, 238, 257, 252, 
    323, 270, 310, 285, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 68, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 255, 247, 272, 244, 257, 256, 246, 260, 278, 247, 253],
    [246, 0, 266, 263, 241, 253, 244, 243, 261, 283, 239, 239], [254, 235, 
    0, 267, 248, 247, 265, 244, 248, 287, 230, 243], [229, 238, 234, 0, 229,
    226, 245, 215, 239, 279, 219, 225], [257, 260, 253, 272, 0, 244, 263, 
    243, 263, 295, 254, 258], [244, 248, 254, 275, 257, 0, 270, 254, 266, 
    283, 228, 264], [245, 257, 236, 256, 238, 231, 0, 243, 263, 272, 233, 
    229], [255, 258, 257, 286, 258, 247, 258, 0, 279, 290, 259, 260], [241,
    240, 253, 262, 238, 235, 238, 222, 0, 255, 219, 230], [223, 218, 214, 
    222, 206, 218, 229, 211, 246, 0, 222, 237], [254, 262, 271, 282, 247, 
    273, 268, 242, 282, 279, 0, 258], [248, 262, 258, 276, 243, 237, 272, 
    241, 271, 264, 243, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 69, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 219, 318, 222, 290, 252, 305, 219, 344, 304, 261, 346],
    [282, 0, 384, 198, 313, 249, 290, 299, 366, 295, 320, 308], [183, 117, 
    0, 220, 205, 167, 149, 154, 256, 192, 229, 201], [279, 303, 281, 0, 344,
    217, 280, 304, 299, 250, 282, 347], [211, 188, 296, 157, 0, 252, 215, 
    223, 309, 234, 237, 284], [249, 252, 334, 284, 249, 0, 245, 207, 324, 
    221, 241, 278], [196, 211, 352, 221, 286, 256, 0, 286, 310, 209, 247, 
    271], [282, 202, 347, 197, 278, 294, 215, 0, 368, 310, 279, 285], [157,
    135, 245, 202, 192, 177, 191, 133, 0, 221, 145, 256], [197, 206, 309, 
    251, 267, 280, 292, 191, 280, 0, 234, 321], [240, 181, 272, 219, 264, 
    260, 254, 222, 356, 267, 0, 293], [155, 193, 300, 154, 217, 223, 230, 
    216, 245, 180, 208, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 70, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 245, 224, 243, 207, 324, 286, 257, 247, 318, 233, 239],
    [256, 0, 250, 205, 240, 363, 275, 289, 303, 358, 285, 266], [277, 251, 
    0, 191, 286, 301, 238, 255, 258, 325, 275, 281], [258, 296, 310, 0, 295,
    322, 318, 249, 270, 376, 311, 282], [294, 261, 215, 206, 0, 271, 285, 
    227, 273, 351, 283, 250], [177, 138, 200, 179, 230, 0, 227, 174, 218, 
    260, 188, 219], [215, 226, 263, 183, 216, 274, 0, 172, 208, 277, 204, 
    218], [244, 212, 246, 252, 274, 327, 329, 0, 271, 283, 272, 269], [254,
    198, 243, 231, 228, 283, 293, 230, 0, 297, 273, 216], [183, 143, 176, 
    125, 150, 241, 224, 218, 204, 0, 194, 152], [268, 216, 226, 190, 218, 
    313, 297, 229, 228, 307, 0, 272], [262, 235, 220, 219, 251, 282, 283, 
    232, 285, 349, 229, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 71, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 246, 243, 206, 277, 216, 252, 242, 233, 256, 247, 227],
    [255, 0, 240, 258, 298, 255, 262, 267, 267, 293, 240, 219], [258, 261, 
    0, 238, 320, 279, 282, 266, 266, 275, 240, 262], [295, 243, 263, 0, 282,
    246, 273, 319, 250, 257, 251, 266], [224, 203, 181, 219, 0, 207, 226, 
    236, 235, 234, 215, 231], [285, 246, 222, 255, 294, 0, 267, 257, 249, 
    295, 249, 257], [249, 239, 219, 228, 275, 234, 0, 251, 247, 271, 240, 
    215], [259, 234, 235, 182, 265, 244, 250, 0, 259, 243, 263, 232], [268,
    234, 235, 251, 266, 252, 254, 242, 0, 266, 235, 237], [245, 208, 226, 
    244, 267, 206, 230, 258, 235, 0, 234, 218], [254, 261, 261, 250, 286, 
    252, 261, 238, 266, 267, 0, 241], [274, 282, 239, 235, 270, 244, 286, 
    269, 264, 283, 260, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 72, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 262, 259, 245, 221, 264, 223, 242, 260, 244, 240, 245],
    [239, 0, 260, 273, 261, 272, 233, 230, 239, 233, 270, 253], [242, 241, 
    0, 236, 254, 267, 222, 235, 254, 245, 254, 249], [256, 228, 265, 0, 248,
    258, 219, 236, 263, 248, 251, 249], [280, 240, 247, 253, 0, 278, 229, 
    254, 262, 238, 261, 247], [237, 229, 234, 243, 223, 0, 224, 230, 252, 
    220, 248, 230], [278, 268, 279, 282, 272, 277, 0, 239, 263, 257, 284, 
    263], [259, 271, 266, 265, 247, 271, 262, 0, 268, 246, 268, 258], [241,
    262, 247, 238, 239, 249, 238, 233, 0, 257, 262, 282], [257, 268, 256, 
    253, 263, 281, 244, 255, 244, 0, 263, 261], [261, 231, 247, 250, 240, 
    253, 217, 233, 239, 238, 0, 243], [256, 248, 252, 252, 254, 271, 238, 
    243, 219, 240, 258, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 73, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 285, 277, 247, 266, 257, 250, 256, 262, 259, 268, 282],
    [216, 0, 243, 219, 200, 220, 217, 235, 231, 232, 231, 233], [224, 258, 
    0, 222, 224, 238, 202, 247, 233, 231, 246, 245], [254, 282, 279, 0, 237,
    253, 238, 267, 263, 249, 258, 260], [235, 301, 277, 264, 0, 255, 255, 
    272, 276, 252, 262, 260], [244, 281, 263, 248, 246, 0, 253, 258, 256, 
    233, 269, 248], [251, 284, 299, 263, 246, 248, 0, 284, 251, 259, 277, 
    266], [245, 266, 254, 234, 229, 243, 217, 0, 244, 239, 243, 235], [239,
    270, 268, 238, 225, 245, 250, 257, 0, 239, 250, 258], [242, 269, 270, 
    252, 249, 268, 242, 262, 262, 0, 240, 262], [233, 270, 255, 243, 239, 
    232, 224, 258, 251, 261, 0, 252], [219, 268, 256, 241, 241, 253, 235, 
    266, 243, 239, 249, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 74, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 244, 238, 263, 263, 267, 222, 240, 246, 233, 260, 248],
    [257, 0, 248, 273, 252, 271, 242, 275, 247, 230, 262, 245], [263, 253, 
    0, 258, 251, 260, 232, 259, 259, 236, 234, 245], [238, 228, 243, 0, 247,
    242, 239, 252, 255, 223, 235, 237], [238, 249, 250, 254, 0, 261, 245, 
    243, 256, 238, 245, 244], [234, 230, 241, 259, 240, 0, 219, 247, 262, 
    224, 241, 235], [279, 259, 269, 262, 256, 282, 0, 272, 274, 258, 264, 
    245], [261, 226, 242, 249, 258, 254, 229, 0, 265, 244, 245, 234], [255,
    254, 242, 246, 245, 239, 227, 236, 0, 216, 239, 223], [268, 271, 265, 
    278, 263, 277, 243, 257, 285, 0, 267, 251], [241, 239, 267, 266, 256, 
    260, 237, 256, 262, 234, 0, 245], [253, 256, 256, 264, 257, 266, 256, 
    267, 278, 250, 256, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 75, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 270, 246, 256, 245, 260, 234, 254, 256, 263, 225, 260],
    [231, 0, 253, 243, 231, 253, 239, 254, 261, 246, 243, 226], [255, 248, 
    0, 256, 230, 274, 247, 247, 270, 240, 248, 256], [245, 258, 245, 0, 233,
    257, 250, 241, 264, 263, 232, 280], [256, 270, 271, 268, 0, 272, 275, 
    250, 285, 256, 248, 277], [241, 248, 227, 244, 229, 0, 229, 234, 248, 
    243, 223, 230], [267, 262, 254, 251, 226, 272, 0, 238, 264, 278, 241, 
    255], [247, 247, 254, 260, 251, 267, 263, 0, 253, 274, 259, 242], [245,
    240, 231, 237, 216, 253, 237, 248, 0, 258, 230, 229], [238, 255, 261, 
    238, 245, 258, 223, 227, 243, 0, 216, 256], [276, 258, 253, 269, 253, 
    278, 260, 242, 271, 285, 0, 255], [241, 275, 245, 221, 224, 271, 246, 
    259, 272, 245, 246, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 76, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 187, 205, 265, 221, 301, 211, 170, 215, 193, 230, 243],
    [314, 0, 294, 313, 250, 316, 263, 207, 294, 270, 271, 237], [296, 207, 
    0, 272, 223, 277, 232, 248, 299, 205, 244, 239], [236, 188, 229, 0, 266,
    240, 183, 169, 259, 210, 245, 217], [280, 251, 278, 235, 0, 265, 196, 
    250, 298, 267, 277, 235], [200, 185, 224, 261, 236, 0, 208, 223, 231, 
    254, 248, 224], [290, 238, 269, 318, 305, 293, 0, 307, 291, 303, 319, 
    321], [331, 294, 253, 332, 251, 278, 194, 0, 302, 282, 245, 214], [286,
    207, 202, 242, 203, 270, 210, 199, 0, 256, 241, 195], [308, 231, 296, 
    291, 234, 247, 198, 219, 245, 0, 238, 240], [271, 230, 257, 256, 224, 
    253, 182, 256, 260, 263, 0, 255], [258, 264, 262, 284, 266, 277, 180, 
    287, 306, 261, 246, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 77, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 254, 275, 290, 281, 257, 287, 256, 275, 277, 286, 242],
    [247, 0, 278, 270, 262, 220, 276, 248, 265, 267, 253, 268], [226, 223, 
    0, 257, 256, 232, 254, 221, 231, 250, 254, 237], [211, 231, 244, 0, 229,
    231, 224, 240, 239, 255, 240, 247], [220, 239, 245, 272, 0, 228, 261, 
    236, 246, 266, 261, 242], [244, 281, 269, 270, 273, 0, 277, 246, 262, 
    286, 262, 270], [214, 225, 247, 277, 240, 224, 0, 245, 239, 244, 232, 
    240], [245, 253, 280, 261, 265, 255, 256, 0, 261, 260, 262, 248], [226,
    236, 270, 262, 255, 239, 262, 240, 0, 261, 267, 244], [224, 234, 251, 
    246, 235, 215, 257, 241, 240, 0, 241, 247], [215, 248, 247, 261, 240, 
    239, 269, 239, 234, 260, 0, 237], [259, 233, 264, 254, 259, 231, 261, 
    253, 257, 254, 264, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 78, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 254, 229, 258, 252, 240, 259, 246, 260, 263, 269, 246],
    [247, 0, 252, 263, 261, 256, 267, 256, 258, 274, 249, 253], [272, 249, 
    0, 266, 263, 245, 273, 262, 267, 260, 267, 254], [243, 238, 235, 0, 273,
    236, 270, 247, 234, 269, 250, 236], [249, 240, 238, 228, 0, 245, 264, 
    242, 241, 264, 239, 219], [261, 245, 256, 265, 256, 0, 273, 264, 279, 
    268, 265, 245], [242, 234, 228, 231, 237, 228, 0, 235, 245, 260, 234, 
    221], [255, 245, 239, 254, 259, 237, 266, 0, 252, 267, 255, 239], [241,
    243, 234, 267, 260, 222, 256, 249, 0, 266, 261, 239], [238, 227, 241, 
    232, 237, 233, 241, 234, 235, 0, 233, 234], [232, 252, 234, 251, 262, 
    236, 267, 246, 240, 268, 0, 225], [255, 248, 247, 265, 282, 256, 280, 
    262, 262, 267, 276, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 79, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 264, 269, 241, 252, 268, 275, 245, 253, 249, 252, 281],
    [237, 0, 247, 262, 255, 264, 270, 239, 249, 257, 249, 265], [232, 254, 
    0, 236, 224, 226, 253, 223, 232, 247, 247, 252], [260, 239, 265, 0, 259,
    264, 271, 258, 268, 262, 255, 277], [249, 246, 277, 242, 0, 250, 262, 
    248, 249, 242, 252, 262], [233, 237, 275, 237, 251, 0, 254, 244, 222, 
    240, 245, 264], [226, 231, 248, 230, 239, 247, 0, 236, 238, 258, 235, 
    250], [256, 262, 278, 243, 253, 257, 265, 0, 257, 260, 270, 284], [248,
    252, 269, 233, 252, 279, 263, 244, 0, 258, 264, 262], [252, 244, 254, 
    239, 259, 261, 243, 241, 243, 0, 252, 274], [249, 252, 254, 246, 249, 
    256, 266, 231, 237, 249, 0, 272], [220, 236, 249, 224, 239, 237, 251, 
    217, 239, 227, 229, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 80, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 258, 253, 245, 271, 210, 236, 222, 209, 205, 233, 232],
    [243, 0, 292, 351, 313, 285, 218, 311, 259, 262, 270, 279], [248, 209, 
    0, 235, 209, 190, 206, 218, 185, 172, 189, 179], [256, 150, 266, 0, 274,
    229, 215, 209, 206, 172, 272, 213], [230, 188, 292, 227, 0, 265, 224, 
    171, 182, 168, 261, 238], [291, 216, 311, 272, 236, 0, 268, 221, 245, 
    211, 274, 216], [265, 283, 295, 286, 277, 233, 0, 244, 243, 258, 268, 
    283], [279, 190, 283, 292, 330, 280, 257, 0, 208, 230, 268, 264], [292,
    242, 316, 295, 319, 256, 258, 293, 0, 280, 254, 272], [296, 239, 329, 
    329, 333, 290, 243, 271, 221, 0, 293, 264], [268, 231, 312, 229, 240, 
    227, 233, 233, 247, 208, 0, 284], [269, 222, 322, 288, 263, 285, 218, 
    237, 229, 237, 217, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 81, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 269, 243, 258, 277, 260, 260, 249, 271, 250, 255, 254],
    [232, 0, 243, 224, 229, 256, 241, 240, 272, 232, 235, 251], [258, 258, 
    0, 243, 236, 263, 252, 248, 240, 238, 236, 282], [243, 277, 258, 0, 238,
    273, 250, 242, 261, 260, 260, 269], [224, 272, 265, 263, 0, 269, 271, 
    251, 276, 238, 256, 257], [241, 245, 238, 228, 232, 0, 244, 221, 218, 
    229, 233, 253], [241, 260, 249, 251, 230, 257, 0, 224, 261, 239, 259, 
    260], [252, 261, 253, 259, 250, 280, 277, 0, 273, 269, 246, 269], [230,
    229, 261, 240, 225, 283, 240, 228, 0, 244, 260, 251], [251, 269, 263, 
    241, 263, 272, 262, 232, 257, 0, 242, 265], [246, 266, 265, 241, 245, 
    268, 242, 255, 241, 259, 0, 262], [247, 250, 219, 232, 244, 248, 241, 
    232, 250, 236, 239, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 82, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 254, 252, 248, 245, 253, 239, 253, 245, 246, 253, 252],
    [247, 0, 245, 237, 240, 243, 243, 260, 239, 250, 241, 236], [249, 256, 
    0, 253, 240, 248, 250, 259, 236, 255, 227, 237], [253, 264, 248, 0, 268,
    259, 264, 262, 243, 247, 251, 248], [256, 261, 261, 233, 0, 259, 244, 
    253, 261, 255, 234, 246], [248, 258, 253, 242, 242, 0, 240, 259, 243, 
    259, 233, 239], [262, 258, 251, 237, 257, 261, 0, 252, 244, 270, 255, 
    250], [248, 241, 242, 239, 248, 242, 249, 0, 232, 264, 231, 248], [256,
    262, 265, 258, 240, 258, 257, 269, 0, 255, 256, 235], [255, 251, 246, 
    254, 246, 242, 231, 237, 246, 0, 241, 246], [248, 260, 274, 250, 267, 
    268, 246, 270, 245, 260, 0, 249], [249, 265, 264, 253, 255, 262, 251, 
    253, 266, 255, 252, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 83, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 254, 273, 257, 255, 248, 250, 251, 254, 266, 261, 256],
    [247, 0, 270, 254, 245, 273, 265, 255, 253, 254, 262, 251], [228, 231, 
    0, 223, 227, 236, 253, 224, 227, 234, 237, 195], [244, 247, 278, 0, 233,
    265, 246, 250, 264, 246, 227, 233], [246, 256, 274, 268, 0, 266, 248, 
    266, 263, 257, 266, 263], [253, 228, 265, 236, 235, 0, 254, 246, 278, 
    242, 222, 250], [251, 236, 248, 255, 253, 247, 0, 253, 268, 246, 257, 
    239], [250, 246, 277, 251, 235, 255, 248, 0, 273, 257, 265, 246], [247,
    248, 274, 237, 238, 223, 233, 228, 0, 261, 232, 210], [235, 247, 267, 
    255, 244, 259, 255, 244, 240, 0, 232, 210], [240, 239, 264, 274, 235, 
    279, 244, 236, 269, 269, 0, 230], [245, 250, 306, 268, 238, 251, 262, 
    255, 291, 291, 271, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 84, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 147, 226, 263, 272, 250, 243, 259, 236, 224, 252, 175],
    [354, 0, 206, 276, 302, 275, 282, 232, 254, 233, 304, 261], [275, 295, 
    0, 289, 294, 290, 250, 242, 263, 240, 287, 251], [238, 225, 212, 0, 254,
    266, 240, 218, 275, 219, 247, 185], [229, 199, 207, 247, 0, 199, 226, 
    178, 238, 201, 266, 254], [251, 226, 211, 235, 302, 0, 235, 225, 189, 
    229, 252, 238], [258, 219, 251, 261, 275, 266, 0, 228, 264, 225, 301, 
    226], [242, 269, 259, 283, 323, 276, 273, 0, 267, 292, 278, 287], [265,
    247, 238, 226, 263, 312, 237, 234, 0, 242, 335, 284], [277, 268, 261, 
    282, 300, 272, 276, 209, 259, 0, 306, 267], [249, 197, 214, 254, 235, 
    249, 200, 223, 166, 195, 0, 202], [326, 240, 250, 316, 247, 263, 275, 
    214, 217, 234, 299, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 85, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 264, 283, 254, 253, 279, 257, 295, 242, 263, 236, 258],
    [237, 0, 261, 253, 257, 274, 251, 260, 262, 264, 237, 245], [218, 240, 
    0, 242, 259, 255, 227, 262, 258, 236, 241, 235], [247, 248, 259, 0, 247,
    269, 233, 284, 276, 278, 254, 236], [248, 244, 242, 254, 0, 258, 245, 
    266, 254, 266, 227, 225], [222, 227, 246, 232, 243, 0, 220, 278, 260, 
    245, 234, 228], [244, 250, 274, 268, 256, 281, 0, 281, 255, 261, 240, 
    252], [206, 241, 239, 217, 235, 223, 220, 0, 247, 242, 233, 214], [259,
    239, 243, 225, 247, 241, 246, 254, 0, 242, 239, 236], [238, 237, 265, 
    223, 235, 256, 240, 259, 259, 0, 246, 243], [265, 264, 260, 247, 274, 
    267, 261, 268, 262, 255, 0, 250], [243, 256, 266, 265, 276, 273, 249, 
    287, 265, 258, 251, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 86, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 262, 260, 259, 258, 276, 266, 260, 268, 273, 250, 270],
    [239, 0, 240, 241, 226, 264, 270, 248, 239, 257, 245, 260], [241, 261, 
    0, 251, 238, 256, 259, 250, 250, 259, 251, 242], [242, 260, 250, 0, 236,
    259, 272, 256, 257, 267, 255, 253], [243, 275, 263, 265, 0, 281, 275, 
    260, 271, 267, 277, 260], [225, 237, 245, 242, 220, 0, 245, 236, 238, 
    245, 247, 247], [235, 231, 242, 229, 226, 256, 0, 241, 235, 249, 259, 
    253], [241, 253, 251, 245, 241, 265, 260, 0, 262, 253, 259, 247], [233,
    262, 251, 244, 230, 263, 266, 239, 0, 273, 259, 242], [228, 244, 242, 
    234, 234, 256, 252, 248, 228, 0, 245, 251], [251, 256, 250, 246, 224, 
    254, 242, 242, 242, 256, 0, 244], [231, 241, 259, 248, 241, 254, 248, 
    254, 259, 250, 257, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 87, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 243, 257, 267, 242, 271, 253, 246, 277, 291, 273, 264],
    [258, 0, 235, 246, 248, 265, 268, 282, 291, 297, 283, 259], [244, 266, 
    0, 270, 256, 275, 264, 258, 304, 300, 307, 263], [234, 255, 231, 0, 227,
    272, 233, 239, 259, 285, 268, 251], [259, 253, 245, 274, 0, 279, 264, 
    246, 268, 285, 271, 284], [230, 236, 226, 229, 222, 0, 241, 240, 253, 
    280, 247, 239], [248, 233, 237, 268, 237, 260, 0, 262, 285, 276, 259, 
    278], [255, 219, 243, 262, 255, 261, 239, 0, 284, 278, 282, 251], [224,
    210, 197, 242, 233, 248, 216, 217, 0, 270, 263, 232], [210, 204, 201, 
    216, 216, 221, 225, 223, 231, 0, 231, 218], [228, 218, 194, 233, 230, 
    254, 242, 219, 238, 270, 0, 248], [237, 242, 238, 250, 217, 262, 223, 
    250, 269, 283, 253, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 88, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 212, 245, 204, 237, 233, 198, 237, 232, 240, 154, 238],
    [289, 0, 242, 287, 269, 255, 284, 318, 228, 240, 240, 254], [256, 259, 
    0, 264, 253, 256, 262, 259, 261, 236, 210, 267], [297, 214, 237, 0, 289,
    254, 238, 228, 260, 266, 239, 261], [264, 232, 248, 212, 0, 252, 229, 
    250, 251, 233, 251, 252], [268, 246, 245, 247, 249, 0, 250, 264, 244, 
    244, 208, 275], [303, 217, 239, 263, 272, 251, 0, 266, 258, 279, 214, 
    270], [264, 183, 242, 273, 251, 237, 235, 0, 262, 231, 220, 239], [269,
    273, 240, 241, 250, 257, 243, 239, 0, 268, 221, 257], [261, 261, 265, 
    235, 268, 257, 222, 270, 233, 0, 235, 285], [347, 261, 291, 262, 250, 
    293, 287, 281, 280, 266, 0, 250], [263, 247, 234, 240, 249, 226, 231, 
    262, 244, 216, 251, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 89, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 195, 253, 193, 167, 162, 211, 172, 254, 170, 212, 247],
    [306, 0, 183, 264, 234, 180, 277, 213, 211, 154, 219, 248], [248, 318, 
    0, 311, 186, 230, 241, 229, 218, 251, 249, 282], [308, 237, 190, 0, 146,
    217, 206, 185, 214, 189, 289, 216], [334, 267, 315, 355, 0, 303, 283, 
    229, 271, 295, 309, 272], [339, 321, 271, 284, 198, 0, 213, 264, 204, 
    232, 229, 290], [290, 224, 260, 295, 218, 288, 0, 210, 245, 225, 240, 
    318], [329, 288, 272, 316, 272, 237, 291, 0, 268, 321, 312, 303], [247,
    290, 283, 287, 230, 297, 256, 233, 0, 240, 217, 273], [331, 347, 250, 
    312, 206, 269, 276, 180, 261, 0, 345, 268], [289, 282, 252, 212, 192, 
    272, 261, 189, 284, 156, 0, 285], [254, 253, 219, 285, 229, 211, 183, 
    198, 228, 233, 216, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 90, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 259, 260, 244, 253, 244, 247, 249, 259, 248, 267, 251],
    [242, 0, 243, 264, 244, 228, 243, 241, 245, 247, 264, 251], [241, 258, 
    0, 258, 252, 232, 242, 252, 255, 247, 279, 246], [257, 237, 243, 0, 270,
    256, 246, 256, 257, 250, 268, 253], [248, 257, 249, 231, 0, 220, 245, 
    248, 261, 243, 258, 246], [257, 273, 269, 245, 281, 0, 261, 255, 255, 
    257, 278, 268], [254, 258, 259, 255, 256, 240, 0, 243, 267, 251, 277, 
    235], [252, 260, 249, 245, 253, 246, 258, 0, 260, 248, 268, 259], [242,
    256, 246, 244, 240, 246, 234, 241, 0, 245, 297, 239], [253, 254, 254, 
    251, 258, 244, 250, 253, 256, 0, 266, 271], [234, 237, 222, 233, 243, 
    223, 224, 233, 204, 235, 0, 238], [250, 250, 255, 248, 255, 233, 266, 
    242, 262, 230, 263, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 91, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 242, 264, 269, 275, 314, 279, 288, 255, 274, 252, 278],
    [259, 0, 288, 296, 293, 315, 325, 315, 243, 302, 267, 292], [237, 213, 
    0, 241, 232, 253, 302, 289, 200, 277, 214, 262], [232, 205, 260, 0, 224,
    241, 221, 248, 201, 225, 185, 256], [226, 208, 269, 277, 0, 281, 304, 
    290, 219, 258, 211, 255], [187, 186, 248, 260, 220, 0, 292, 233, 237, 
    270, 189, 242], [222, 176, 199, 280, 197, 209, 0, 246, 256, 235, 179, 
    249], [213, 186, 212, 253, 211, 268, 255, 0, 203, 234, 169, 245], [246,
    258, 301, 300, 282, 264, 245, 298, 0, 265, 291, 298], [227, 199, 224, 
    276, 243, 231, 266, 267, 236, 0, 197, 239], [249, 234, 287, 316, 290, 
    312, 322, 332, 210, 304, 0, 310], [223, 209, 239, 245, 246, 259, 252, 
    256, 203, 262, 191, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 92, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 241, 212, 262, 245, 195, 185, 246, 214, 220, 231, 212],
    [260, 0, 252, 233, 250, 260, 197, 233, 253, 268, 254, 229], [289, 249, 
    0, 239, 278, 278, 211, 268, 281, 251, 258, 247], [239, 268, 262, 0, 266,
    266, 224, 272, 274, 250, 220, 219], [256, 251, 223, 235, 0, 244, 222, 
    233, 239, 245, 251, 227], [306, 241, 223, 235, 257, 0, 220, 250, 240, 
    249, 229, 244], [316, 304, 290, 277, 279, 281, 0, 247, 297, 308, 283, 
    273], [255, 268, 233, 229, 268, 251, 254, 0, 244, 278, 285, 252], [287,
    248, 220, 227, 262, 261, 204, 257, 0, 237, 256, 262], [281, 233, 250, 
    251, 256, 252, 193, 223, 264, 0, 227, 249], [270, 247, 243, 281, 250, 
    272, 218, 216, 245, 274, 0, 232], [289, 272, 254, 282, 274, 257, 228, 
    249, 239, 252, 269, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 93, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 238, 247, 239, 260, 262, 253, 295, 254, 234, 245, 252],
    [263, 0, 260, 242, 270, 249, 255, 283, 244, 234, 252, 251], [254, 241, 
    0, 230, 243, 248, 265, 274, 254, 244, 239, 243], [262, 259, 271, 0, 261,
    261, 262, 267, 263, 238, 259, 253], [241, 231, 258, 240, 0, 255, 239, 
    269, 241, 223, 245, 243], [239, 252, 253, 240, 246, 0, 253, 274, 253, 
    245, 249, 244], [248, 246, 236, 239, 262, 248, 0, 289, 258, 257, 246, 
    248], [206, 218, 227, 234, 232, 227, 212, 0, 212, 196, 221, 206], [247,
    257, 247, 238, 260, 248, 243, 289, 0, 233, 245, 236], [267, 267, 257, 
    263, 278, 256, 244, 305, 268, 0, 254, 260], [256, 249, 262, 242, 256, 
    252, 255, 280, 256, 247, 0, 260], [249, 250, 258, 248, 258, 257, 253, 
    295, 265, 241, 241, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 94, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 242, 240, 236, 254, 227, 249, 240, 242, 229, 235, 239],
    [259, 0, 248, 258, 240, 237, 248, 249, 239, 230, 232, 262], [261, 253, 
    0, 246, 253, 236, 234, 248, 247, 240, 241, 259], [265, 243, 255, 0, 240,
    226, 250, 253, 232, 235, 238, 237], [247, 261, 248, 261, 0, 237, 262, 
    249, 261, 234, 234, 248], [274, 264, 265, 275, 264, 0, 265, 261, 252, 
    240, 274, 255], [252, 253, 267, 251, 239, 236, 0, 259, 253, 253, 248, 
    249], [261, 252, 253, 248, 252, 240, 242, 0, 246, 236, 237, 250], [259,
    262, 254, 269, 240, 249, 248, 255, 0, 250, 260, 259], [272, 271, 261, 
    266, 267, 261, 248, 265, 251, 0, 261, 255], [266, 269, 260, 263, 267, 
    227, 253, 264, 241, 240, 0, 261], [262, 239, 242, 264, 253, 246, 252, 
    251, 242, 246, 240, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 95, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 268, 258, 267, 261, 249, 259, 267, 248, 244, 263, 260],
    [233, 0, 242, 257, 244, 229, 237, 244, 259, 237, 239, 249], [243, 259, 
    0, 268, 257, 225, 272, 261, 277, 252, 258, 267], [234, 244, 233, 0, 261,
    228, 252, 251, 250, 219, 235, 255], [240, 257, 244, 240, 0, 238, 248, 
    263, 245, 230, 235, 277], [252, 272, 276, 273, 263, 0, 250, 249, 304, 
    243, 259, 281], [242, 264, 229, 249, 253, 251, 0, 259, 254, 245, 250, 
    274], [234, 257, 240, 250, 238, 252, 242, 0, 244, 236, 253, 250], [253,
    242, 224, 251, 256, 197, 247, 257, 0, 237, 245, 260], [257, 264, 249, 
    282, 271, 258, 256, 265, 264, 0, 247, 255], [238, 262, 243, 266, 266, 
    242, 251, 248, 256, 254, 0, 269], [241, 252, 234, 246, 224, 220, 227, 
    251, 241, 246, 232, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 96, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 240, 221, 227, 190, 194, 241, 203, 225, 189, 186, 207],
    [261, 0, 250, 222, 161, 229, 231, 234, 259, 247, 241, 230], [280, 251, 
    0, 258, 235, 233, 223, 229, 266, 259, 215, 208], [274, 279, 243, 0, 203,
    235, 217, 224, 200, 223, 233, 197], [311, 340, 266, 298, 0, 285, 284, 
    272, 259, 233, 262, 257], [307, 272, 268, 266, 216, 0, 284, 280, 283, 
    225, 229, 224], [260, 270, 278, 284, 217, 217, 0, 263, 265, 214, 245, 
    240], [298, 267, 272, 277, 229, 221, 238, 0, 285, 227, 247, 229], [276,
    242, 235, 301, 242, 218, 236, 216, 0, 240, 196, 193], [312, 254, 242, 
    278, 268, 276, 287, 274, 261, 0, 270, 216], [315, 260, 286, 268, 239, 
    272, 256, 254, 305, 231, 0, 225], [294, 271, 293, 304, 244, 277, 261, 
    272, 308, 285, 276, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 97, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 262, 252, 262, 259, 252, 266, 242, 267, 252, 251, 253],
    [239, 0, 242, 253, 257, 240, 234, 253, 253, 252, 240, 245], [249, 259, 
    0, 264, 251, 228, 245, 257, 250, 246, 241, 251], [239, 248, 237, 0, 239,
    227, 229, 250, 240, 230, 226, 238], [242, 244, 250, 262, 0, 240, 240, 
    246, 258, 240, 240, 254], [249, 261, 273, 274, 261, 0, 243, 243, 254, 
    242, 255, 259], [235, 267, 256, 272, 261, 258, 0, 261, 255, 260, 263, 
    268], [259, 248, 244, 251, 255, 258, 240, 0, 266, 237, 260, 238], [234,
    248, 251, 261, 243, 247, 246, 235, 0, 240, 245, 239], [249, 249, 255, 
    271, 261, 259, 241, 264, 261, 0, 246, 258], [250, 261, 260, 275, 261, 
    246, 238, 241, 256, 255, 0, 250], [248, 256, 250, 263, 247, 242, 233, 
    263, 262, 243, 251, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 98, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 213, 234, 275, 214, 245, 228, 201, 209, 247, 234, 227],
    [288, 0, 264, 304, 250, 272, 276, 245, 253, 282, 261, 256], [267, 237, 
    0, 285, 229, 244, 258, 225, 250, 252, 234, 238], [226, 197, 216, 0, 205,
    239, 249, 219, 206, 228, 213, 236], [287, 251, 272, 296, 0, 248, 263, 
    239, 243, 261, 253, 263], [256, 229, 257, 262, 253, 0, 241, 252, 222, 
    238, 233, 245], [273, 225, 243, 252, 238, 260, 0, 246, 208, 241, 251, 
    242], [300, 256, 276, 282, 262, 249, 255, 0, 248, 273, 245, 283], [292,
    248, 251, 295, 258, 279, 293, 253, 0, 267, 289, 285], [254, 219, 249, 
    273, 240, 263, 260, 228, 234, 0, 249, 260], [267, 240, 267, 288, 248, 
    268, 250, 256, 212, 252, 0, 246], [274, 245, 263, 265, 238, 256, 259, 
    218, 216, 241, 255, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 99, 'ME-BBd', exec_time, sol.shape[0],
    algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 235, 238, 238, 262, 260, 259, 253, 259, 240, 261, 260],
    [266, 0, 282, 242, 288, 261, 261, 295, 255, 260, 288, 260], [263, 219, 
    0, 232, 252, 252, 249, 260, 242, 246, 251, 238], [263, 259, 269, 0, 263,
    245, 279, 261, 258, 286, 276, 269], [239, 213, 249, 238, 0, 251, 255, 
    269, 237, 251, 255, 252], [241, 240, 249, 256, 250, 0, 249, 275, 258, 
    265, 278, 247], [242, 240, 252, 222, 246, 252, 0, 261, 255, 258, 267, 
    247], [248, 206, 241, 240, 232, 226, 240, 0, 260, 236, 253, 231], [242,
    246, 259, 243, 264, 243, 246, 241, 0, 256, 245, 264], [261, 241, 255, 
    215, 250, 236, 243, 265, 245, 0, 259, 256], [240, 213, 250, 225, 246, 
    223, 234, 248, 256, 242, 0, 234], [241, 241, 263, 232, 249, 254, 254, 
    270, 237, 245, 267, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 100, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 245, 278, 280, 240, 220, 244, 277, 270, 255, 277, 253],
    [256, 0, 228, 277, 236, 281, 220, 267, 279, 284, 244, 242], [223, 273, 
    0, 267, 209, 283, 249, 262, 286, 226, 263, 213], [221, 224, 234, 0, 225,
    221, 241, 249, 255, 242, 263, 189], [261, 265, 292, 276, 0, 246, 248, 
    274, 273, 221, 270, 282], [281, 220, 218, 280, 255, 0, 264, 269, 271, 
    260, 279, 226], [257, 281, 252, 260, 253, 237, 0, 252, 294, 251, 239, 
    236], [224, 234, 239, 252, 227, 232, 249, 0, 268, 238, 271, 205], [231,
    222, 215, 246, 228, 230, 207, 233, 0, 270, 245, 225], [246, 217, 275, 
    259, 280, 241, 250, 263, 231, 0, 248, 235], [224, 257, 238, 238, 231, 
    222, 262, 230, 256, 253, 0, 223], [248, 259, 288, 312, 219, 275, 265, 
    296, 276, 266, 278, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 101, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 228, 229, 216, 237, 235, 225, 220, 240, 254, 210, 239],
    [273, 0, 258, 264, 239, 241, 256, 263, 268, 245, 263, 277], [272, 243, 
    0, 236, 229, 221, 210, 247, 233, 241, 195, 262], [285, 237, 265, 0, 238,
    235, 249, 263, 243, 268, 233, 270], [264, 262, 272, 263, 0, 243, 245, 
    257, 262, 271, 240, 259], [266, 260, 280, 266, 258, 0, 264, 258, 245, 
    303, 280, 287], [276, 245, 291, 252, 256, 237, 0, 249, 268, 255, 251, 
    256], [281, 238, 254, 238, 244, 243, 252, 0, 230, 268, 256, 255], [261,
    233, 268, 258, 239, 256, 233, 271, 0, 260, 253, 264], [247, 256, 260, 
    233, 230, 198, 246, 233, 241, 0, 228, 248], [291, 238, 306, 268, 261, 
    221, 250, 245, 248, 273, 0, 296], [262, 224, 239, 231, 242, 214, 245, 
    246, 237, 253, 205, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 102, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 256, 251, 259, 247, 247, 252, 242, 249, 242, 254, 268],
    [245, 0, 247, 254, 254, 242, 241, 221, 241, 248, 248, 253], [250, 254, 
    0, 266, 269, 275, 256, 264, 254, 254, 261, 267], [242, 247, 235, 0, 235,
    249, 254, 232, 229, 243, 246, 258], [254, 247, 232, 266, 0, 246, 255, 
    261, 239, 240, 244, 263], [254, 259, 226, 252, 255, 0, 245, 245, 241, 
    245, 259, 258], [249, 260, 245, 247, 246, 256, 0, 256, 256, 250, 248, 
    261], [259, 280, 237, 269, 240, 256, 245, 0, 245, 255, 245, 259], [252,
    260, 247, 272, 262, 260, 245, 256, 0, 257, 267, 271], [259, 253, 247, 
    258, 261, 256, 251, 246, 244, 0, 246, 254], [247, 253, 240, 255, 257, 
    242, 253, 256, 234, 255, 0, 253], [233, 248, 234, 243, 238, 243, 240, 
    242, 230, 247, 248, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 103, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 248, 259, 262, 243, 256, 261, 255, 273, 239, 272, 260],
    [253, 0, 249, 257, 244, 250, 262, 247, 275, 262, 277, 268], [242, 252, 
    0, 257, 242, 254, 264, 249, 265, 254, 259, 264], [239, 244, 244, 0, 247,
    252, 244, 244, 272, 255, 260, 252], [258, 257, 259, 254, 0, 244, 253, 
    250, 261, 243, 259, 256], [245, 251, 247, 249, 257, 0, 255, 253, 273, 
    255, 269, 256], [240, 239, 237, 257, 248, 246, 0, 255, 263, 251, 272, 
    255], [246, 254, 252, 257, 251, 248, 246, 0, 260, 250, 276, 256], [228,
    226, 236, 229, 240, 228, 238, 241, 0, 245, 250, 251], [262, 239, 247, 
    246, 258, 246, 250, 251, 256, 0, 253, 244], [229, 224, 242, 241, 242, 
    232, 229, 225, 251, 248, 0, 245], [241, 233, 237, 249, 245, 245, 246, 
    245, 250, 257, 256, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 104, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 242, 254, 219, 236, 227, 247, 264, 230, 280, 239, 249],
    [259, 0, 230, 259, 269, 283, 269, 278, 256, 278, 250, 254], [247, 271, 
    0, 211, 259, 238, 260, 278, 220, 243, 248, 237], [282, 242, 290, 0, 278,
    253, 270, 276, 258, 291, 272, 285], [265, 232, 242, 223, 0, 249, 247, 
    258, 200, 240, 231, 245], [274, 218, 263, 248, 252, 0, 288, 285, 241, 
    287, 259, 270], [254, 232, 241, 231, 254, 213, 0, 251, 214, 270, 223, 
    260], [237, 223, 223, 225, 243, 216, 250, 0, 191, 250, 228, 231], [271,
    245, 281, 243, 301, 260, 287, 310, 0, 282, 266, 280], [221, 223, 258, 
    210, 261, 214, 231, 251, 219, 0, 250, 262], [262, 251, 253, 229, 270, 
    242, 278, 273, 235, 251, 0, 284], [252, 247, 264, 216, 256, 231, 241, 
    270, 221, 239, 217, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 105, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 249, 247, 229, 260, 244, 242, 240, 246, 254, 244, 241],
    [252, 0, 265, 259, 258, 251, 246, 232, 246, 262, 257, 258], [254, 236, 
    0, 235, 252, 230, 227, 222, 235, 249, 234, 227], [272, 242, 266, 0, 272,
    264, 245, 234, 236, 258, 243, 256], [241, 243, 249, 229, 0, 229, 224, 
    223, 219, 245, 223, 234], [257, 250, 271, 237, 272, 0, 247, 243, 267, 
    240, 246, 246], [259, 255, 274, 256, 277, 254, 0, 235, 257, 258, 270, 
    241], [261, 269, 279, 267, 278, 258, 266, 0, 250, 280, 267, 257], [255,
    255, 266, 265, 282, 234, 244, 251, 0, 262, 259, 256], [247, 239, 252, 
    243, 256, 261, 243, 221, 239, 0, 248, 243], [257, 244, 267, 258, 278, 
    255, 231, 234, 242, 253, 0, 266], [260, 243, 274, 245, 267, 255, 260, 
    244, 245, 258, 235, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 106, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 224, 216, 254, 240, 226, 245, 243, 227, 245, 235, 234],
    [277, 0, 269, 268, 251, 264, 269, 267, 253, 258, 247, 249], [285, 232, 
    0, 251, 247, 259, 274, 249, 254, 256, 247, 247], [247, 233, 250, 0, 241,
    252, 268, 242, 242, 255, 270, 237], [261, 250, 254, 260, 0, 258, 274, 
    258, 254, 275, 250, 234], [275, 237, 242, 249, 243, 0, 271, 264, 248, 
    256, 246, 249], [256, 232, 227, 233, 227, 230, 0, 222, 213, 231, 231, 
    211], [258, 234, 252, 259, 243, 237, 279, 0, 244, 279, 225, 258], [274,
    248, 247, 259, 247, 253, 288, 257, 0, 262, 253, 248], [256, 243, 245, 
    246, 226, 245, 270, 222, 239, 0, 250, 235], [266, 254, 254, 231, 251, 
    255, 270, 276, 248, 251, 0, 260], [267, 252, 254, 264, 267, 252, 290, 
    243, 253, 266, 241, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 107, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 251, 226, 234, 242, 235, 249, 229, 243, 258, 242, 246],
    [250, 0, 226, 261, 234, 254, 229, 258, 242, 234, 230, 278], [275, 275, 
    0, 260, 242, 283, 251, 261, 247, 253, 251, 302], [267, 240, 241, 0, 239,
    254, 261, 251, 269, 252, 244, 273], [259, 267, 259, 262, 0, 242, 253, 
    267, 264, 276, 259, 288], [266, 247, 218, 247, 259, 0, 233, 239, 210, 
    251, 261, 270], [252, 272, 250, 240, 248, 268, 0, 263, 252, 240, 260, 
    270], [272, 243, 240, 250, 234, 262, 238, 0, 252, 246, 254, 265], [258,
    259, 254, 232, 237, 291, 249, 249, 0, 243, 254, 266], [243, 267, 248, 
    249, 225, 250, 261, 255, 258, 0, 244, 284], [259, 271, 250, 257, 242, 
    240, 241, 247, 247, 257, 0, 253], [255, 223, 199, 228, 213, 231, 231, 
    236, 235, 217, 248, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 108, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 265, 156, 392, 353, 234, 323, 340, 347, 376, 285, 304],
    [236, 0, 326, 314, 236, 308, 335, 316, 370, 277, 204, 258], [345, 175, 
    0, 345, 247, 203, 485, 347, 326, 386, 238, 408], [109, 187, 156, 0, 306,
    165, 382, 235, 297, 306, 143, 129], [148, 265, 254, 195, 0, 184, 344, 
    256, 238, 314, 197, 261], [267, 193, 298, 336, 317, 0, 407, 397, 385, 
    335, 238, 358], [178, 166, 16, 119, 157, 94, 0, 241, 137, 157, 141, 160
    ], [161, 185, 154, 266, 245, 104, 260, 0, 166, 245, 238, 233], [154, 
    131, 175, 204, 263, 116, 364, 335, 0, 222, 184, 226], [125, 224, 115, 
    195, 187, 166, 344, 256, 279, 0, 156, 308], [216, 297, 263, 358, 304, 
    263, 360, 263, 317, 345, 0, 365], [197, 243, 93, 372, 240, 143, 341, 
    268, 275, 193, 136, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 109, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 248, 268, 242, 261, 252, 261, 225, 257, 247, 239, 258],
    [253, 0, 266, 271, 286, 271, 270, 255, 275, 264, 249, 263], [233, 235, 
    0, 240, 255, 255, 267, 236, 236, 242, 237, 240], [259, 230, 261, 0, 275,
    257, 278, 249, 230, 258, 236, 223], [240, 215, 246, 226, 0, 245, 252, 
    220, 241, 237, 206, 234], [249, 230, 246, 244, 256, 0, 292, 228, 249, 
    228, 242, 226], [240, 231, 234, 223, 249, 209, 0, 218, 230, 230, 212, 
    221], [276, 246, 265, 252, 281, 273, 283, 0, 262, 272, 256, 257], [244,
    226, 265, 271, 260, 252, 271, 239, 0, 250, 242, 267], [254, 237, 259, 
    243, 264, 273, 271, 229, 251, 0, 228, 258], [262, 252, 264, 265, 295, 
    259, 289, 245, 259, 273, 0, 254], [243, 238, 261, 278, 267, 275, 280, 
    244, 234, 243, 247, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 110, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 292, 220, 239, 220, 209, 243, 225, 221, 269, 214, 220],
    [209, 0, 239, 191, 225, 225, 222, 248, 212, 222, 180, 212], [281, 262, 
    0, 319, 228, 313, 266, 285, 263, 224, 282, 260], [262, 310, 182, 0, 264,
    318, 303, 296, 220, 229, 194, 236], [281, 276, 273, 237, 0, 280, 333, 
    246, 222, 233, 272, 247], [292, 276, 188, 183, 221, 0, 261, 249, 251, 
    225, 239, 231], [258, 279, 235, 198, 168, 240, 0, 248, 240, 243, 266, 
    216], [276, 253, 216, 205, 255, 252, 253, 0, 210, 243, 225, 213], [280,
    289, 238, 281, 279, 250, 261, 291, 0, 243, 230, 237], [232, 279, 277, 
    272, 268, 276, 258, 258, 258, 0, 220, 170], [287, 321, 219, 307, 229, 
    262, 235, 276, 271, 281, 0, 267], [281, 289, 241, 265, 254, 270, 285, 
    288, 264, 331, 234, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 111, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 277, 250, 263, 266, 291, 268, 262, 264, 262, 255, 271],
    [224, 0, 224, 241, 245, 263, 230, 242, 247, 237, 229, 243], [251, 277, 
    0, 260, 260, 249, 241, 267, 269, 264, 240, 250], [238, 260, 241, 0, 249,
    243, 253, 259, 250, 228, 251, 240], [235, 256, 241, 252, 0, 236, 242, 
    247, 253, 241, 229, 243], [210, 238, 252, 258, 265, 0, 233, 245, 234, 
    234, 218, 254], [233, 271, 260, 248, 259, 268, 0, 261, 257, 244, 265, 
    269], [239, 259, 234, 242, 254, 256, 240, 0, 252, 257, 252, 241], [237,
    254, 232, 251, 248, 267, 244, 249, 0, 244, 231, 259], [239, 264, 237, 
    273, 260, 267, 257, 244, 257, 0, 252, 242], [246, 272, 261, 250, 272, 
    283, 236, 249, 270, 249, 0, 254], [230, 258, 251, 261, 258, 247, 232, 
    260, 242, 259, 247, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 112, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 252, 267, 254, 246, 243, 275, 252, 257, 254, 230, 264],
    [249, 0, 275, 232, 259, 245, 278, 261, 280, 232, 242, 231], [234, 226, 
    0, 214, 239, 226, 240, 223, 258, 223, 230, 228], [247, 269, 287, 0, 244,
    241, 270, 270, 265, 246, 263, 259], [255, 242, 262, 257, 0, 238, 253, 
    250, 259, 253, 238, 240], [258, 256, 275, 260, 263, 0, 275, 258, 261, 
    261, 251, 243], [226, 223, 261, 231, 248, 226, 0, 250, 252, 221, 239, 
    223], [249, 240, 278, 231, 251, 243, 251, 0, 260, 216, 237, 240], [244,
    221, 243, 236, 242, 240, 249, 241, 0, 231, 251, 241], [247, 269, 278, 
    255, 248, 240, 280, 285, 270, 0, 283, 256], [271, 259, 271, 238, 263, 
    250, 262, 264, 250, 218, 0, 244], [237, 270, 273, 242, 261, 258, 278, 
    261, 260, 245, 257, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 113, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 322, 322, 267, 363, 285, 289, 297, 329, 249, 302, 276],
    [179, 0, 242, 253, 249, 256, 280, 310, 375, 256, 294, 235], [179, 259, 
    0, 177, 278, 275, 230, 235, 272, 235, 223, 184], [234, 248, 324, 0, 243,
    283, 361, 254, 339, 294, 268, 196], [138, 252, 223, 258, 0, 274, 237, 
    260, 285, 254, 298, 212], [216, 245, 226, 218, 227, 0, 300, 231, 359, 
    280, 293, 196], [212, 221, 271, 140, 264, 201, 0, 249, 291, 244, 254, 
    175], [204, 191, 266, 247, 241, 270, 252, 0, 288, 263, 236, 153], [172,
    126, 229, 162, 216, 142, 210, 213, 0, 202, 194, 166], [252, 245, 266, 
    207, 247, 221, 257, 238, 299, 0, 202, 199], [199, 207, 278, 233, 203, 
    208, 247, 265, 307, 299, 0, 146], [225, 266, 317, 305, 289, 305, 326, 
    348, 335, 302, 355, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 114, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 257, 275, 253, 262, 246, 270, 242, 242, 263, 258, 242],
    [244, 0, 264, 234, 250, 241, 245, 254, 240, 250, 238, 239], [226, 237, 
    0, 239, 225, 245, 236, 229, 241, 244, 251, 229], [248, 267, 262, 0, 261,
    253, 272, 260, 234, 271, 260, 249], [239, 251, 276, 240, 0, 260, 249, 
    248, 237, 259, 251, 235], [255, 260, 256, 248, 241, 0, 262, 244, 235, 
    259, 234, 255], [231, 256, 265, 229, 252, 239, 0, 250, 239, 250, 242, 
    239], [259, 247, 272, 241, 253, 257, 251, 0, 249, 279, 257, 270], [259,
    261, 260, 267, 264, 266, 262, 252, 0, 284, 242, 244], [238, 251, 257, 
    230, 242, 242, 251, 222, 217, 0, 236, 248], [243, 263, 250, 241, 250, 
    267, 259, 244, 259, 265, 0, 227], [259, 262, 272, 252, 266, 246, 262, 
    231, 257, 253, 274, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 115, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 235, 254, 243, 280, 266, 251, 261, 286, 318, 253, 290],
    [266, 0, 251, 256, 306, 308, 278, 230, 283, 303, 270, 324], [247, 250, 
    0, 227, 277, 326, 256, 225, 255, 280, 237, 272], [258, 245, 274, 0, 302,
    295, 269, 254, 282, 283, 265, 297], [221, 195, 224, 199, 0, 266, 232, 
    224, 231, 242, 234, 302], [235, 193, 175, 206, 235, 0, 200, 245, 227, 
    260, 199, 233], [250, 223, 245, 232, 269, 301, 0, 241, 204, 261, 247, 
    247], [240, 271, 276, 247, 277, 256, 260, 0, 226, 260, 242, 326], [215,
    218, 246, 219, 270, 274, 297, 275, 0, 272, 235, 263], [183, 198, 221, 
    218, 259, 241, 240, 241, 229, 0, 249, 249], [248, 231, 264, 236, 267, 
    302, 254, 259, 266, 252, 0, 277], [211, 177, 229, 204, 199, 268, 254, 
    175, 238, 252, 224, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 116, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 235, 282, 264, 277, 255, 279, 314, 307, 285, 311, 260],
    [266, 0, 277, 237, 238, 241, 260, 275, 291, 284, 305, 274], [219, 224, 
    0, 207, 247, 252, 205, 267, 290, 259, 295, 231], [237, 264, 294, 0, 225,
    280, 303, 261, 283, 316, 299, 275], [224, 263, 254, 276, 0, 265, 268, 
    302, 285, 279, 290, 264], [246, 260, 249, 221, 236, 0, 280, 297, 293, 
    272, 306, 264], [222, 241, 296, 198, 233, 221, 0, 282, 303, 264, 258, 
    252], [187, 226, 234, 240, 199, 204, 219, 0, 274, 194, 272, 230], [194,
    210, 211, 218, 216, 208, 198, 227, 0, 224, 262, 238], [216, 217, 242, 
    185, 222, 229, 237, 307, 277, 0, 256, 233], [190, 196, 206, 202, 211, 
    195, 243, 229, 239, 245, 0, 218], [241, 227, 270, 226, 237, 237, 249, 
    271, 263, 268, 283, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 117, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 242, 253, 253, 254, 246, 271, 240, 246, 237, 276, 260],
    [259, 0, 259, 241, 273, 255, 257, 266, 257, 264, 254, 260], [248, 242, 
    0, 242, 271, 243, 246, 254, 249, 228, 268, 251], [248, 260, 259, 0, 269,
    242, 265, 259, 239, 240, 273, 257], [247, 228, 230, 232, 0, 201, 235, 
    209, 225, 209, 244, 216], [255, 246, 258, 259, 300, 0, 271, 268, 235, 
    240, 267, 254], [230, 244, 255, 236, 266, 230, 0, 232, 241, 235, 257, 
    234], [261, 235, 247, 242, 292, 233, 269, 0, 237, 239, 263, 265], [255,
    244, 252, 262, 276, 266, 260, 264, 0, 250, 282, 261], [264, 237, 273, 
    261, 292, 261, 266, 262, 251, 0, 264, 270], [225, 247, 233, 228, 257, 
    234, 244, 238, 219, 237, 0, 229], [241, 241, 250, 244, 285, 247, 267, 
    236, 240, 231, 272, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 118, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 206, 180, 187, 207, 226, 307, 335, 145, 149, 195, 186],
    [295, 0, 260, 219, 280, 269, 321, 318, 240, 274, 267, 273], [321, 241, 
    0, 284, 267, 325, 340, 337, 197, 242, 271, 255], [314, 282, 217, 0, 244,
    253, 292, 265, 206, 232, 245, 268], [294, 221, 234, 257, 0, 270, 293, 
    341, 230, 192, 221, 229], [275, 232, 176, 248, 231, 0, 307, 248, 178, 
    236, 232, 234], [194, 180, 161, 209, 208, 194, 0, 200, 144, 125, 213, 
    180], [166, 183, 164, 236, 160, 253, 301, 0, 166, 155, 209, 218], [356,
    261, 304, 295, 271, 323, 357, 335, 0, 241, 208, 292], [352, 227, 259, 
    269, 309, 265, 376, 346, 260, 0, 277, 277], [306, 234, 230, 256, 280, 
    269, 288, 292, 293, 224, 0, 274], [315, 228, 246, 233, 272, 267, 321, 
    283, 209, 224, 227, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 119, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 267, 249, 252, 264, 260, 228, 280, 206, 256, 280, 254],
    [234, 0, 298, 266, 303, 290, 317, 271, 275, 285, 274, 308], [252, 203, 
    0, 220, 286, 298, 291, 265, 225, 255, 269, 269], [249, 235, 281, 0, 292,
    256, 267, 284, 252, 244, 269, 291], [237, 198, 215, 209, 0, 238, 188, 
    240, 270, 221, 239, 266], [241, 211, 203, 245, 263, 0, 226, 233, 235, 
    199, 245, 259], [273, 184, 210, 234, 313, 275, 0, 226, 239, 245, 254, 
    286], [221, 230, 236, 217, 261, 268, 275, 0, 216, 245, 229, 257], [295,
    226, 276, 249, 231, 266, 262, 285, 0, 256, 272, 292], [245, 216, 246, 
    257, 280, 302, 256, 256, 245, 0, 287, 264], [221, 227, 232, 232, 262, 
    256, 247, 272, 229, 214, 0, 262], [247, 193, 232, 210, 235, 242, 215, 
    244, 209, 237, 239, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 120, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 255, 217, 217, 255, 222, 211, 208, 237, 240, 224, 219],
    [246, 0, 225, 228, 238, 215, 246, 242, 251, 243, 206, 257], [284, 276, 
    0, 250, 263, 261, 264, 264, 269, 252, 260, 262], [284, 273, 251, 0, 268,
    276, 246, 266, 276, 261, 268, 259], [246, 263, 238, 233, 0, 239, 209, 
    221, 262, 227, 249, 242], [279, 286, 240, 225, 262, 0, 254, 244, 276, 
    265, 240, 241], [290, 255, 237, 255, 292, 247, 0, 229, 269, 253, 257, 
    248], [293, 259, 237, 235, 280, 257, 272, 0, 288, 260, 245, 246], [264,
    250, 232, 225, 239, 225, 232, 213, 0, 248, 236, 225], [261, 258, 249, 
    240, 274, 236, 248, 241, 253, 0, 261, 256], [277, 295, 241, 233, 252, 
    261, 244, 256, 265, 240, 0, 252], [282, 244, 239, 242, 259, 260, 253, 
    255, 276, 245, 249, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 121, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 262, 278, 270, 286, 244, 301, 253, 251, 274, 254, 283],
    [239, 0, 283, 272, 323, 261, 239, 272, 257, 296, 235, 230], [223, 218, 
    0, 264, 254, 207, 241, 223, 230, 259, 232, 229], [231, 229, 237, 0, 255,
    207, 233, 223, 189, 249, 224, 195], [215, 178, 247, 246, 0, 221, 263, 
    243, 232, 257, 227, 207], [257, 240, 294, 294, 280, 0, 293, 266, 263, 
    309, 272, 285], [200, 262, 260, 268, 238, 208, 0, 276, 215, 283, 240, 
    251], [248, 229, 278, 278, 258, 235, 225, 0, 228, 256, 248, 252], [250,
    244, 271, 312, 269, 238, 286, 273, 0, 257, 238, 282], [227, 205, 242, 
    252, 244, 192, 218, 245, 244, 0, 243, 269], [247, 266, 269, 277, 274, 
    229, 261, 253, 263, 258, 0, 276], [218, 271, 272, 306, 294, 216, 250, 
    249, 219, 232, 225, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 122, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 214, 241, 249, 213, 251, 241, 258, 248, 237, 253, 231],
    [287, 0, 280, 259, 254, 254, 245, 266, 261, 258, 250, 274], [260, 221, 
    0, 240, 227, 250, 237, 245, 267, 249, 257, 217], [252, 242, 261, 0, 236,
    248, 243, 242, 243, 251, 251, 223], [288, 247, 274, 265, 0, 261, 252, 
    264, 266, 258, 259, 240], [250, 247, 251, 253, 240, 0, 246, 243, 254, 
    254, 252, 238], [260, 256, 264, 258, 249, 255, 0, 247, 269, 257, 248, 
    254], [243, 235, 256, 259, 237, 258, 254, 0, 255, 241, 253, 244], [253,
    240, 234, 258, 235, 247, 232, 246, 0, 239, 255, 245], [264, 243, 252, 
    250, 243, 247, 244, 260, 262, 0, 263, 278], [248, 251, 244, 250, 242, 
    249, 253, 248, 246, 238, 0, 245], [270, 227, 284, 278, 261, 263, 247, 
    257, 256, 223, 256, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 123, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 241, 214, 295, 251, 197, 252, 222, 272, 238, 219, 221],
    [260, 0, 233, 299, 328, 337, 280, 255, 319, 299, 286, 254], [287, 268, 
    0, 257, 268, 241, 294, 212, 287, 278, 297, 256], [206, 202, 244, 0, 215,
    185, 270, 186, 245, 267, 253, 208], [250, 173, 233, 286, 0, 273, 285, 
    231, 265, 265, 253, 208], [304, 164, 260, 316, 228, 0, 258, 224, 217, 
    265, 251, 235], [249, 221, 207, 231, 216, 243, 0, 211, 229, 236, 243, 
    225], [279, 246, 289, 315, 270, 277, 290, 0, 232, 261, 261, 238], [229,
    182, 214, 256, 236, 284, 272, 269, 0, 288, 230, 230], [263, 202, 223, 
    234, 236, 236, 265, 240, 213, 0, 242, 258], [282, 215, 204, 248, 248, 
    250, 258, 240, 271, 259, 0, 203], [280, 247, 245, 293, 293, 266, 276, 
    263, 271, 243, 298, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 124, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 270, 251, 240, 268, 262, 258, 275, 270, 273, 259, 258],
    [231, 0, 245, 242, 260, 252, 245, 257, 260, 253, 262, 264], [250, 256, 
    0, 264, 237, 242, 254, 244, 250, 259, 261, 260], [261, 259, 237, 0, 243,
    254, 255, 264, 251, 264, 252, 263], [233, 241, 264, 258, 0, 247, 249, 
    252, 245, 249, 251, 268], [239, 249, 259, 247, 254, 0, 254, 266, 259, 
    263, 272, 259], [243, 256, 247, 246, 252, 247, 0, 267, 259, 267, 247, 
    257], [226, 244, 257, 237, 249, 235, 234, 0, 238, 253, 256, 253], [231,
    241, 251, 250, 256, 242, 242, 263, 0, 254, 264, 261], [228, 248, 242, 
    237, 252, 238, 234, 248, 247, 0, 255, 248], [242, 239, 240, 249, 250, 
    229, 254, 245, 237, 246, 0, 251], [243, 237, 241, 238, 233, 242, 244, 
    248, 240, 253, 250, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 125, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 217, 223, 225, 268, 250, 230, 261, 234, 265, 236, 210],
    [284, 0, 230, 276, 225, 208, 260, 260, 244, 244, 229, 239], [278, 271, 
    0, 274, 260, 238, 271, 299, 264, 263, 227, 254], [276, 225, 227, 0, 239,
    242, 237, 239, 258, 223, 220, 225], [233, 276, 241, 262, 0, 260, 237, 
    258, 265, 291, 252, 225], [251, 293, 263, 259, 241, 0, 262, 246, 248, 
    277, 249, 213], [271, 241, 230, 264, 264, 239, 0, 285, 251, 257, 222, 
    234], [240, 241, 202, 262, 243, 255, 216, 0, 223, 256, 236, 197], [267,
    257, 237, 243, 236, 253, 250, 278, 0, 255, 278, 214], [236, 257, 238, 
    278, 210, 224, 244, 245, 246, 0, 232, 206], [265, 272, 274, 281, 249, 
    252, 279, 265, 223, 269, 0, 227], [291, 262, 247, 276, 276, 288, 267, 
    304, 287, 295, 274, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 126, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 243, 256, 246, 227, 243, 240, 257, 243, 240, 238, 245],
    [258, 0, 256, 265, 250, 252, 259, 268, 261, 251, 259, 260], [245, 245, 
    0, 266, 253, 236, 241, 274, 257, 239, 257, 248], [255, 236, 235, 0, 244,
    241, 245, 266, 252, 242, 232, 234], [274, 251, 248, 257, 0, 251, 252, 
    266, 264, 244, 253, 256], [258, 249, 265, 260, 250, 0, 247, 268, 263, 
    239, 256, 267], [261, 242, 260, 256, 249, 254, 0, 271, 264, 240, 255, 
    250], [244, 233, 227, 235, 235, 233, 230, 0, 256, 233, 222, 236], [258,
    240, 244, 249, 237, 238, 237, 245, 0, 237, 232, 254], [261, 250, 262, 
    259, 257, 262, 261, 268, 264, 0, 254, 259], [263, 242, 244, 269, 248, 
    245, 246, 279, 269, 247, 0, 260], [256, 241, 253, 267, 245, 234, 251, 
    265, 247, 242, 241, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 127, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 277, 288, 245, 252, 254, 265, 240, 252, 272, 253, 250],
    [224, 0, 248, 234, 232, 253, 244, 242, 266, 255, 218, 244], [213, 253, 
    0, 246, 232, 240, 245, 253, 252, 280, 248, 239], [256, 267, 255, 0, 254,
    235, 273, 259, 253, 273, 231, 236], [249, 269, 269, 247, 0, 255, 269, 
    242, 265, 275, 269, 261], [247, 248, 261, 266, 246, 0, 246, 251, 276, 
    260, 242, 252], [236, 257, 256, 228, 232, 255, 0, 251, 233, 252, 225, 
    235], [261, 259, 248, 242, 259, 250, 250, 0, 250, 274, 250, 233], [249,
    235, 249, 248, 236, 225, 268, 251, 0, 268, 232, 237], [229, 246, 221, 
    228, 226, 241, 249, 227, 233, 0, 222, 227], [248, 283, 253, 270, 232, 
    259, 276, 251, 269, 279, 0, 269], [251, 257, 262, 265, 240, 249, 266, 
    268, 264, 274, 232, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 128, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 201, 317, 215, 295, 248, 271, 246, 264, 255, 252, 256],
    [300, 0, 305, 317, 266, 306, 204, 317, 250, 238, 287, 255], [184, 196, 
    0, 182, 234, 280, 189, 169, 216, 172, 160, 197], [286, 184, 319, 0, 297,
    332, 263, 185, 241, 294, 212, 136], [206, 235, 267, 204, 0, 303, 184, 
    254, 218, 282, 241, 132], [253, 195, 221, 169, 198, 0, 265, 190, 239, 
    211, 202, 110], [230, 297, 312, 238, 317, 236, 0, 260, 270, 290, 210, 
    197], [255, 184, 332, 316, 247, 311, 241, 0, 274, 232, 247, 151], [237,
    251, 285, 260, 283, 262, 231, 227, 0, 295, 173, 192], [246, 263, 329, 
    207, 219, 290, 211, 269, 206, 0, 209, 149], [249, 214, 341, 289, 260, 
    299, 291, 254, 328, 292, 0, 219], [245, 246, 304, 365, 369, 391, 304, 
    350, 309, 352, 282, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 129, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 268, 231, 267, 280, 289, 265, 288, 271, 278, 249, 253],
    [233, 0, 218, 227, 301, 250, 233, 251, 255, 266, 256, 256], [270, 283, 
    0, 269, 277, 277, 248, 255, 265, 312, 283, 282], [234, 274, 232, 0, 298,
    279, 274, 326, 265, 259, 278, 301], [221, 200, 224, 203, 0, 268, 246, 
    266, 207, 220, 254, 201], [212, 251, 224, 222, 233, 0, 208, 261, 218, 
    219, 214, 266], [236, 268, 253, 227, 255, 293, 0, 274, 237, 243, 268, 
    275], [213, 250, 246, 175, 235, 240, 227, 0, 196, 226, 239, 238], [230,
    246, 236, 236, 294, 283, 264, 305, 0, 261, 278, 233], [223, 235, 189, 
    242, 281, 282, 258, 275, 240, 0, 242, 225], [252, 245, 218, 223, 247, 
    287, 233, 262, 223, 259, 0, 233], [248, 245, 219, 200, 300, 235, 226, 
    263, 268, 276, 268, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 130, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 223, 210, 215, 244, 217, 258, 234, 216, 252, 216, 234],
    [278, 0, 254, 236, 221, 284, 275, 261, 275, 241, 267, 238], [291, 247, 
    0, 196, 257, 246, 240, 268, 256, 260, 282, 274], [286, 265, 305, 0, 258,
    256, 275, 291, 277, 279, 294, 247], [257, 280, 244, 243, 0, 207, 261, 
    276, 258, 239, 288, 268], [284, 217, 255, 245, 294, 0, 250, 257, 227, 
    283, 267, 265], [243, 226, 261, 226, 240, 251, 0, 277, 228, 258, 247, 
    249], [267, 240, 233, 210, 225, 244, 224, 0, 226, 273, 232, 187], [285,
    226, 245, 224, 243, 274, 273, 275, 0, 222, 270, 257], [249, 260, 241, 
    222, 262, 218, 243, 228, 279, 0, 241, 189], [285, 234, 219, 207, 213, 
    234, 254, 269, 231, 260, 0, 226], [267, 263, 227, 254, 233, 236, 252, 
    314, 244, 312, 275, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 131, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 239, 245, 256, 256, 223, 261, 228, 220, 206, 273, 241],
    [262, 0, 280, 298, 258, 253, 270, 238, 255, 246, 281, 222], [256, 221, 
    0, 267, 273, 220, 254, 231, 253, 235, 260, 246], [245, 203, 234, 0, 241,
    215, 216, 223, 220, 215, 230, 242], [245, 243, 228, 260, 0, 224, 206, 
    218, 235, 203, 234, 222], [278, 248, 281, 286, 277, 0, 280, 255, 247, 
    230, 245, 248], [240, 231, 247, 285, 295, 221, 0, 251, 226, 237, 236, 
    207], [273, 263, 270, 278, 283, 246, 250, 0, 240, 247, 254, 241], [281,
    246, 248, 281, 266, 254, 275, 261, 0, 244, 254, 263], [295, 255, 266, 
    286, 298, 271, 264, 254, 257, 0, 276, 238], [228, 220, 241, 271, 267, 
    256, 265, 247, 247, 225, 0, 243], [260, 279, 255, 259, 279, 253, 294, 
    260, 238, 263, 258, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 132, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 216, 276, 228, 273, 295, 247, 276, 211, 256, 264, 294],
    [285, 0, 289, 278, 322, 327, 273, 281, 297, 288, 246, 335], [225, 212, 
    0, 218, 241, 273, 203, 232, 218, 251, 230, 283], [273, 223, 283, 0, 282,
    275, 251, 240, 219, 264, 261, 258], [228, 179, 260, 219, 0, 242, 196, 
    241, 189, 240, 215, 219], [206, 174, 228, 226, 259, 0, 198, 234, 195, 
    222, 225, 231], [254, 228, 298, 250, 305, 303, 0, 277, 278, 294, 254, 
    277], [225, 220, 269, 261, 260, 267, 224, 0, 197, 245, 263, 222], [290,
    204, 283, 282, 312, 306, 223, 304, 0, 275, 242, 274], [245, 213, 250, 
    237, 261, 279, 207, 256, 226, 0, 244, 257], [237, 255, 271, 240, 286, 
    276, 247, 238, 259, 257, 0, 277], [207, 166, 218, 243, 282, 270, 224, 
    279, 227, 244, 224, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 133, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 341, 283, 289, 314, 223, 279, 278, 305, 221, 277, 249],
    [160, 0, 167, 236, 271, 200, 228, 210, 251, 164, 210, 257], [218, 334, 
    0, 240, 273, 285, 250, 324, 301, 255, 253, 264], [212, 265, 261, 0, 276,
    247, 253, 272, 269, 228, 227, 251], [187, 230, 228, 225, 0, 213, 277, 
    240, 244, 193, 232, 271], [278, 301, 216, 254, 288, 0, 310, 295, 277, 
    202, 285, 274], [222, 273, 251, 248, 224, 191, 0, 306, 267, 209, 228, 
    241], [223, 291, 177, 229, 261, 206, 195, 0, 278, 242, 249, 184], [196,
    250, 200, 232, 257, 224, 234, 223, 0, 167, 197, 241], [280, 337, 246, 
    273, 308, 299, 292, 259, 334, 0, 320, 300], [224, 291, 248, 274, 269, 
    216, 273, 252, 304, 181, 0, 294], [252, 244, 237, 250, 230, 227, 260, 
    317, 260, 201, 207, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 134, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 258, 261, 250, 231, 259, 266, 202, 253, 191, 198, 267],
    [243, 0, 268, 273, 265, 240, 253, 273, 270, 257, 269, 265], [240, 233, 
    0, 206, 193, 232, 216, 223, 197, 162, 214, 217], [251, 228, 295, 0, 245,
    308, 250, 232, 293, 191, 276, 221], [270, 236, 308, 256, 0, 265, 290, 
    231, 252, 284, 324, 257], [242, 261, 269, 193, 236, 0, 284, 274, 264, 
    255, 289, 263], [235, 248, 285, 251, 211, 217, 0, 208, 257, 198, 311, 
    247], [299, 228, 278, 269, 270, 227, 293, 0, 298, 224, 251, 291], [248,
    231, 304, 208, 249, 237, 244, 203, 0, 210, 248, 203], [310, 244, 339, 
    310, 217, 246, 303, 277, 291, 0, 317, 250], [303, 232, 287, 225, 177, 
    212, 190, 250, 253, 184, 0, 239], [234, 236, 284, 280, 244, 238, 254, 
    210, 298, 251, 262, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 135, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 273, 236, 275, 266, 261, 252, 259, 264, 253, 269, 242],
    [228, 0, 244, 269, 254, 240, 238, 250, 247, 237, 247, 233], [265, 257, 
    0, 262, 257, 255, 248, 276, 250, 247, 244, 243], [226, 232, 239, 0, 248,
    231, 238, 256, 240, 248, 243, 225], [235, 247, 244, 253, 0, 241, 247, 
    265, 260, 242, 260, 236], [240, 261, 246, 270, 260, 0, 240, 257, 260, 
    250, 254, 251], [249, 263, 253, 263, 254, 261, 0, 259, 269, 245, 257, 
    239], [242, 251, 225, 245, 236, 244, 242, 0, 249, 238, 245, 223], [237,
    254, 251, 261, 241, 241, 232, 252, 0, 234, 255, 240], [248, 264, 254, 
    253, 259, 251, 256, 263, 267, 0, 258, 237], [232, 254, 257, 258, 241, 
    247, 244, 256, 246, 243, 0, 235], [259, 268, 258, 276, 265, 250, 262, 
    278, 261, 264, 266, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 136, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 217, 223, 236, 265, 284, 227, 253, 266, 269, 256, 275],
    [284, 0, 246, 272, 296, 284, 325, 296, 287, 307, 285, 285], [278, 255, 
    0, 272, 295, 239, 267, 288, 276, 281, 292, 290], [265, 229, 229, 0, 252,
    244, 271, 267, 259, 297, 270, 293], [236, 205, 206, 249, 0, 233, 224, 
    278, 219, 248, 266, 255], [217, 217, 262, 257, 268, 0, 263, 282, 247, 
    263, 279, 287], [274, 176, 234, 230, 277, 238, 0, 267, 254, 279, 276, 
    271], [248, 205, 213, 234, 223, 219, 234, 0, 228, 263, 255, 238], [235,
    214, 225, 242, 282, 254, 247, 273, 0, 278, 280, 266], [232, 194, 220, 
    204, 253, 238, 222, 238, 223, 0, 234, 248], [245, 216, 209, 231, 235, 
    222, 225, 246, 221, 267, 0, 264], [226, 216, 211, 208, 246, 214, 230, 
    263, 235, 253, 237, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 137, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 225, 234, 235, 244, 253, 248, 264, 252, 230, 237, 223],
    [276, 0, 260, 259, 273, 266, 273, 295, 269, 235, 264, 268], [267, 241, 
    0, 250, 244, 257, 248, 261, 249, 228, 237, 239], [266, 242, 251, 0, 249,
    264, 247, 295, 274, 247, 243, 259], [257, 228, 257, 252, 0, 269, 248, 
    287, 260, 228, 255, 231], [248, 235, 244, 237, 232, 0, 239, 255, 237, 
    231, 233, 222], [253, 228, 253, 254, 253, 262, 0, 286, 274, 246, 236, 
    246], [237, 206, 240, 206, 214, 246, 215, 0, 230, 224, 212, 229], [249,
    232, 252, 227, 241, 264, 227, 271, 0, 239, 220, 240], [271, 266, 273, 
    254, 273, 270, 255, 277, 262, 0, 236, 260], [264, 237, 264, 258, 246, 
    268, 265, 289, 281, 265, 0, 248], [278, 233, 262, 242, 270, 279, 255, 
    272, 261, 241, 253, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 138, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 295, 282, 264, 304, 264, 265, 261, 291, 250, 270, 286],
    [206, 0, 219, 243, 217, 246, 193, 218, 224, 202, 242, 231], [219, 282, 
    0, 278, 282, 252, 193, 257, 265, 234, 256, 263], [237, 258, 223, 0, 263,
    239, 230, 244, 247, 206, 243, 257], [197, 284, 219, 238, 0, 211, 212, 
    233, 244, 200, 233, 235], [237, 255, 249, 262, 290, 0, 228, 249, 246, 
    241, 258, 276], [236, 308, 308, 271, 289, 273, 0, 252, 262, 261, 272, 
    267], [240, 283, 244, 257, 268, 252, 249, 0, 267, 232, 249, 267], [210,
    277, 236, 254, 257, 255, 239, 234, 0, 217, 252, 245], [251, 299, 267, 
    295, 301, 260, 240, 269, 284, 0, 269, 285], [231, 259, 245, 258, 268, 
    243, 229, 252, 249, 232, 0, 246], [215, 270, 238, 244, 266, 225, 234, 
    234, 256, 216, 255, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 139, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 254, 260, 251, 248, 240, 216, 263, 269, 241, 246, 263],
    [247, 0, 254, 224, 256, 242, 237, 261, 266, 245, 236, 260], [241, 247, 
    0, 233, 261, 232, 233, 260, 246, 241, 251, 267], [250, 277, 268, 0, 258,
    258, 253, 269, 287, 272, 257, 305], [253, 245, 240, 243, 0, 227, 230, 
    252, 280, 255, 233, 270], [261, 259, 269, 243, 274, 0, 247, 265, 291, 
    255, 273, 274], [285, 264, 268, 248, 271, 254, 0, 268, 293, 287, 265, 
    290], [238, 240, 241, 232, 249, 236, 233, 0, 258, 254, 245, 273], [232,
    235, 255, 214, 221, 210, 208, 243, 0, 217, 244, 263], [260, 256, 260, 
    229, 246, 246, 214, 247, 284, 0, 264, 259], [255, 265, 250, 244, 268, 
    228, 236, 256, 257, 237, 0, 257], [238, 241, 234, 196, 231, 227, 211, 
    228, 238, 242, 244, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 140, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 249, 265, 268, 283, 256, 248, 258, 243, 276, 266, 269],
    [252, 0, 261, 277, 264, 251, 271, 255, 261, 280, 274, 245], [236, 240, 
    0, 245, 250, 237, 230, 238, 243, 240, 248, 248], [233, 224, 256, 0, 250,
    245, 244, 238, 246, 253, 249, 241], [218, 237, 251, 251, 0, 243, 255, 
    255, 254, 258, 231, 257], [245, 250, 264, 256, 258, 0, 260, 258, 254, 
    263, 265, 250], [253, 230, 271, 257, 246, 241, 0, 238, 241, 255, 258, 
    229], [243, 246, 263, 263, 246, 243, 263, 0, 244, 261, 259, 254], [258,
    240, 258, 255, 247, 247, 260, 257, 0, 261, 265, 259], [225, 221, 261, 
    248, 243, 238, 246, 240, 240, 0, 240, 225], [235, 227, 253, 252, 270, 
    236, 243, 242, 236, 261, 0, 247], [232, 256, 253, 260, 244, 251, 272, 
    247, 242, 276, 254, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 141, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 169, 181, 135, 252, 237, 272, 233, 181, 195, 164, 235],
    [332, 0, 288, 276, 293, 286, 334, 278, 188, 244, 279, 262], [320, 213, 
    0, 217, 304, 336, 382, 304, 232, 274, 226, 300], [366, 225, 284, 0, 216,
    366, 336, 272, 344, 222, 281, 284], [249, 208, 197, 285, 0, 271, 268, 
    209, 261, 140, 207, 207], [264, 215, 165, 135, 230, 0, 262, 209, 188, 
    184, 233, 167], [229, 167, 119, 165, 233, 239, 0, 234, 241, 186, 184, 
    188], [268, 223, 197, 229, 292, 292, 267, 0, 246, 204, 215, 303], [320,
    313, 269, 157, 240, 313, 260, 255, 0, 253, 183, 231], [306, 257, 227, 
    279, 361, 317, 315, 297, 248, 0, 283, 320], [337, 222, 275, 220, 294, 
    268, 317, 286, 318, 218, 0, 294], [266, 239, 201, 217, 294, 334, 313, 
    198, 270, 181, 207, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 142, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 235, 268, 257, 259, 259, 245, 284, 255, 274, 267, 260],
    [266, 0, 260, 257, 266, 270, 244, 282, 255, 276, 279, 259], [233, 241, 
    0, 248, 256, 235, 234, 273, 240, 259, 267, 236], [244, 244, 253, 0, 251,
    264, 235, 263, 242, 259, 244, 252], [242, 235, 245, 250, 0, 258, 240, 
    258, 230, 257, 259, 252], [242, 231, 266, 237, 243, 0, 255, 278, 250, 
    277, 264, 256], [256, 257, 267, 266, 261, 246, 0, 291, 252, 277, 278, 
    272], [217, 219, 228, 238, 243, 223, 210, 0, 207, 228, 237, 232], [246,
    246, 261, 259, 271, 251, 249, 294, 0, 265, 267, 251], [227, 225, 242, 
    242, 244, 224, 224, 273, 236, 0, 259, 237], [234, 222, 234, 257, 242, 
    237, 223, 264, 234, 242, 0, 245], [241, 242, 265, 249, 249, 245, 229, 
    269, 250, 264, 256, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 143, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 245, 243, 227, 258, 259, 242, 236, 232, 243, 248, 247],
    [256, 0, 247, 271, 262, 256, 274, 258, 251, 252, 270, 249], [258, 254, 
    0, 256, 262, 267, 262, 247, 265, 268, 277, 262], [274, 230, 245, 0, 270,
    260, 271, 260, 260, 254, 279, 267], [243, 239, 239, 231, 0, 248, 251, 
    238, 233, 241, 256, 250], [242, 245, 234, 241, 253, 0, 262, 237, 240, 
    245, 255, 249], [259, 227, 239, 230, 250, 239, 0, 251, 238, 250, 261, 
    255], [265, 243, 254, 241, 263, 264, 250, 0, 251, 242, 254, 254], [269,
    250, 236, 241, 268, 261, 263, 250, 0, 264, 262, 264], [258, 249, 233, 
    247, 260, 256, 251, 259, 237, 0, 261, 229], [253, 231, 224, 222, 245, 
    246, 240, 247, 239, 240, 0, 244], [254, 252, 239, 234, 251, 252, 246, 
    247, 237, 272, 257, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 144, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 246, 274, 260, 263, 258, 258, 258, 242, 255, 253, 266],
    [255, 0, 250, 249, 249, 256, 265, 251, 252, 247, 261, 254], [227, 251, 
    0, 240, 259, 247, 266, 231, 231, 257, 256, 241], [241, 252, 261, 0, 271,
    260, 281, 245, 260, 253, 254, 255], [238, 252, 242, 230, 0, 225, 254, 
    236, 243, 238, 240, 221], [243, 245, 254, 241, 276, 0, 262, 256, 259, 
    267, 261, 249], [243, 236, 235, 220, 247, 239, 0, 223, 212, 237, 233, 
    230], [243, 250, 270, 256, 265, 245, 278, 0, 264, 252, 256, 248], [259,
    249, 270, 241, 258, 242, 289, 237, 0, 264, 247, 256], [246, 254, 244, 
    248, 263, 234, 264, 249, 237, 0, 261, 255], [248, 240, 245, 247, 261, 
    240, 268, 245, 254, 240, 0, 240], [235, 247, 260, 246, 280, 252, 271, 
    253, 245, 246, 261, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 145, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 271, 288, 231, 262, 251, 263, 260, 280, 262, 214, 245],
    [230, 0, 281, 231, 263, 256, 253, 237, 271, 245, 229, 228], [213, 220, 
    0, 193, 205, 226, 220, 201, 234, 233, 216, 210], [270, 270, 308, 0, 279,
    281, 248, 273, 291, 254, 245, 261], [239, 238, 296, 222, 0, 250, 249, 
    222, 247, 229, 215, 221], [250, 245, 275, 220, 251, 0, 240, 240, 276, 
    213, 220, 236], [238, 248, 281, 253, 252, 261, 0, 261, 259, 239, 231, 
    238], [241, 264, 300, 228, 279, 261, 240, 0, 274, 250, 263, 237], [221,
    230, 267, 210, 254, 225, 242, 227, 0, 233, 191, 207], [239, 256, 268, 
    247, 272, 288, 262, 251, 268, 0, 240, 231], [287, 272, 285, 256, 286, 
    281, 270, 238, 310, 261, 0, 256], [256, 273, 291, 240, 280, 265, 263, 
    264, 294, 270, 245, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 146, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 240, 211, 249, 253, 203, 252, 239, 225, 258, 271, 275],
    [261, 0, 243, 246, 267, 246, 220, 242, 234, 283, 302, 261], [290, 258, 
    0, 257, 233, 233, 274, 262, 272, 282, 300, 294], [252, 255, 244, 0, 244,
    210, 251, 229, 197, 286, 308, 279], [248, 234, 268, 257, 0, 229, 260, 
    238, 260, 307, 320, 289], [298, 255, 268, 291, 272, 0, 256, 233, 226, 
    263, 278, 292], [249, 281, 227, 250, 241, 245, 0, 228, 234, 291, 289, 
    260], [262, 259, 239, 272, 263, 268, 273, 0, 241, 290, 323, 296], [276,
    267, 229, 304, 241, 275, 267, 260, 0, 264, 329, 299], [243, 218, 219, 
    215, 194, 238, 210, 211, 237, 0, 280, 236], [230, 199, 201, 193, 181, 
    223, 212, 178, 172, 221, 0, 234], [226, 240, 207, 222, 212, 209, 241, 
    205, 202, 265, 267, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 147, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 245, 235, 249, 236, 253, 253, 249, 253, 224, 241, 241],
    [256, 0, 253, 269, 248, 251, 250, 283, 266, 255, 257, 268], [266, 248, 
    0, 258, 241, 252, 248, 271, 259, 251, 239, 245], [252, 232, 243, 0, 234,
    246, 250, 252, 257, 217, 234, 254], [265, 253, 260, 267, 0, 255, 248, 
    270, 275, 243, 256, 257], [248, 250, 249, 255, 246, 0, 254, 252, 253, 
    226, 251, 252], [248, 251, 253, 251, 253, 247, 0, 265, 253, 245, 264, 
    269], [252, 218, 230, 249, 231, 249, 236, 0, 245, 245, 246, 240], [248,
    235, 242, 244, 226, 248, 248, 256, 0, 234, 252, 246], [277, 246, 250, 
    284, 258, 275, 256, 256, 267, 0, 274, 256], [260, 244, 262, 267, 245, 
    250, 237, 255, 249, 227, 0, 255], [260, 233, 256, 247, 244, 249, 232, 
    261, 255, 245, 246, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 148, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 282, 168, 181, 167, 308, 263, 211, 240, 237, 218, 214],
    [219, 0, 207, 194, 129, 294, 253, 135, 261, 237, 172, 200], [333, 294, 
    0, 211, 263, 340, 319, 255, 291, 267, 230, 240], [320, 307, 290, 0, 228,
    308, 281, 250, 331, 312, 316, 237], [334, 372, 238, 273, 0, 403, 286, 
    322, 339, 325, 285, 301], [193, 207, 161, 193, 98, 0, 186, 159, 228, 
    238, 218, 126], [238, 248, 182, 220, 215, 315, 0, 220, 245, 223, 235, 
    289], [290, 366, 246, 251, 179, 342, 281, 0, 286, 277, 262, 255], [261,
    240, 210, 170, 162, 273, 256, 215, 0, 239, 268, 242], [264, 264, 234, 
    189, 176, 263, 278, 224, 262, 0, 214, 236], [283, 329, 271, 185, 216, 
    283, 266, 239, 233, 287, 0, 214], [287, 301, 261, 264, 200, 375, 212, 
    246, 259, 265, 287, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 149, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 247, 280, 289, 263, 243, 289, 285, 272, 277, 291, 276],
    [254, 0, 231, 296, 224, 217, 248, 269, 264, 220, 274, 269], [221, 270, 
    0, 243, 210, 231, 246, 234, 238, 273, 262, 226], [212, 205, 258, 0, 190,
    206, 236, 216, 213, 217, 222, 229], [238, 277, 291, 311, 0, 278, 286, 
    287, 280, 248, 308, 300], [258, 284, 270, 295, 223, 0, 267, 240, 301, 
    270, 270, 268], [212, 253, 255, 265, 215, 234, 0, 235, 247, 228, 288, 
    233], [216, 232, 267, 285, 214, 261, 266, 0, 239, 237, 281, 261], [229,
    237, 263, 288, 221, 200, 254, 262, 0, 208, 253, 225], [224, 281, 228, 
    284, 253, 231, 273, 264, 293, 0, 273, 260], [210, 227, 239, 279, 193, 
    231, 213, 220, 248, 228, 0, 265], [225, 232, 275, 272, 201, 233, 268, 
    240, 276, 241, 236, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 150, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 253, 268, 253, 288, 248, 266, 246, 278, 288, 256, 259],
    [248, 0, 237, 232, 254, 226, 219, 250, 252, 251, 233, 230], [233, 264, 
    0, 252, 242, 263, 251, 257, 260, 274, 252, 257], [248, 269, 249, 0, 274,
    243, 250, 255, 269, 280, 250, 245], [213, 247, 259, 227, 0, 232, 238, 
    237, 235, 238, 260, 212], [253, 275, 238, 258, 269, 0, 232, 253, 268, 
    276, 256, 253], [235, 282, 250, 251, 263, 269, 0, 234, 275, 262, 267, 
    264], [255, 251, 244, 246, 264, 248, 267, 0, 254, 271, 250, 253], [223,
    249, 241, 232, 266, 233, 226, 247, 0, 254, 262, 234], [213, 250, 227, 
    221, 263, 225, 239, 230, 247, 0, 224, 218], [245, 268, 249, 251, 241, 
    245, 234, 251, 239, 277, 0, 229], [242, 271, 244, 256, 289, 248, 237, 
    248, 267, 283, 272, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 151, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 264, 253, 256, 264, 266, 240, 255, 263, 248, 255, 259],
    [237, 0, 236, 230, 239, 234, 235, 235, 240, 217, 230, 234], [248, 265, 
    0, 258, 281, 258, 256, 246, 271, 261, 263, 259], [245, 271, 243, 0, 259,
    244, 254, 240, 254, 248, 251, 243], [237, 262, 220, 242, 0, 229, 239, 
    244, 239, 231, 255, 250], [235, 267, 243, 257, 272, 0, 255, 242, 254, 
    242, 269, 252], [261, 266, 245, 247, 262, 246, 0, 243, 251, 259, 257, 
    266], [246, 266, 255, 261, 257, 259, 258, 0, 263, 269, 271, 258], [238,
    261, 230, 247, 262, 247, 250, 238, 0, 245, 248, 256], [253, 284, 240, 
    253, 270, 259, 242, 232, 256, 0, 267, 265], [246, 271, 238, 250, 246, 
    232, 244, 230, 253, 234, 0, 233], [242, 267, 242, 258, 251, 249, 235, 
    243, 245, 236, 268, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 152, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 272, 244, 268, 254, 267, 264, 279, 282, 280, 253, 242],
    [229, 0, 225, 240, 224, 239, 257, 262, 270, 262, 246, 252], [257, 276, 
    0, 261, 247, 260, 282, 270, 280, 296, 252, 268], [233, 261, 240, 0, 228,
    252, 263, 249, 255, 254, 237, 252], [247, 277, 254, 273, 0, 261, 291, 
    291, 280, 272, 268, 249], [234, 262, 241, 249, 240, 0, 264, 248, 271, 
    254, 250, 240], [237, 244, 219, 238, 210, 237, 0, 239, 250, 247, 229, 
    227], [222, 239, 231, 252, 210, 253, 262, 0, 275, 252, 272, 235], [219,
    231, 221, 246, 221, 230, 251, 226, 0, 246, 222, 250], [221, 239, 205, 
    247, 229, 247, 254, 249, 255, 0, 240, 228], [248, 255, 249, 264, 233, 
    251, 272, 229, 279, 261, 0, 253], [259, 249, 233, 249, 252, 261, 274, 
    266, 251, 273, 248, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 153, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 226, 214, 221, 224, 219, 229, 225, 234, 245, 219, 253],
    [275, 0, 267, 223, 241, 250, 246, 234, 263, 278, 278, 271], [287, 234, 
    0, 249, 250, 241, 274, 228, 247, 277, 248, 264], [280, 278, 252, 0, 249,
    270, 243, 255, 285, 288, 265, 289], [277, 260, 251, 252, 0, 252, 263, 
    244, 257, 284, 254, 263], [282, 251, 260, 231, 249, 0, 266, 262, 263, 
    294, 258, 245], [272, 255, 227, 258, 238, 235, 0, 236, 252, 255, 250, 
    249], [276, 267, 273, 246, 257, 239, 265, 0, 249, 288, 238, 252], [267,
    238, 254, 216, 244, 238, 249, 252, 0, 286, 250, 259], [256, 223, 224, 
    213, 217, 207, 246, 213, 215, 0, 213, 219], [282, 223, 253, 236, 247, 
    243, 251, 263, 251, 288, 0, 266], [248, 230, 237, 212, 238, 256, 252, 
    249, 242, 282, 235, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 154, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 267, 273, 242, 256, 252, 287, 236, 267, 287, 242, 225],
    [234, 0, 225, 191, 231, 218, 231, 251, 251, 255, 214, 198], [228, 276, 
    0, 196, 216, 250, 268, 269, 249, 261, 233, 220], [259, 310, 305, 0, 231,
    284, 278, 274, 302, 267, 272, 275], [245, 270, 285, 270, 0, 283, 260, 
    276, 274, 264, 260, 236], [249, 283, 251, 217, 218, 0, 244, 264, 253, 
    254, 254, 240], [214, 270, 233, 223, 241, 257, 0, 232, 240, 279, 197, 
    202], [265, 250, 232, 227, 225, 237, 269, 0, 253, 265, 243, 204], [234,
    250, 252, 199, 227, 248, 261, 248, 0, 272, 235, 206], [214, 246, 240, 
    234, 237, 247, 222, 236, 229, 0, 208, 218], [259, 287, 268, 229, 241, 
    247, 304, 258, 266, 293, 0, 238], [276, 303, 281, 226, 265, 261, 299, 
    297, 295, 283, 263, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 155, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 278, 250, 296, 254, 278, 258, 260, 258, 244, 262, 248],
    [223, 0, 238, 253, 222, 237, 241, 181, 252, 218, 236, 217], [251, 263, 
    0, 263, 217, 259, 246, 171, 248, 213, 253, 239], [205, 248, 238, 0, 229,
    231, 248, 214, 217, 190, 223, 244], [247, 279, 284, 272, 0, 288, 299, 
    187, 249, 218, 262, 238], [223, 264, 242, 270, 213, 0, 257, 202, 257, 
    212, 201, 255], [243, 260, 255, 253, 202, 244, 0, 183, 264, 215, 208, 
    198], [241, 320, 330, 287, 314, 299, 318, 0, 273, 302, 293, 324], [243,
    249, 253, 284, 252, 244, 237, 228, 0, 228, 246, 265], [257, 283, 288, 
    311, 283, 289, 286, 199, 273, 0, 290, 262], [239, 265, 248, 278, 239, 
    300, 293, 208, 255, 211, 0, 275], [253, 284, 262, 257, 263, 246, 303, 
    177, 236, 239, 226, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 156, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 254, 262, 242, 244, 242, 264, 245, 261, 238, 246, 249],
    [247, 0, 263, 254, 250, 255, 266, 264, 260, 241, 273, 241], [239, 238, 
    0, 236, 222, 235, 250, 241, 255, 228, 253, 234], [259, 247, 265, 0, 235,
    259, 263, 251, 258, 253, 265, 260], [257, 251, 279, 266, 0, 247, 273, 
    262, 257, 251, 270, 250], [259, 246, 266, 242, 254, 0, 255, 257, 268, 
    244, 264, 254], [237, 235, 251, 238, 228, 246, 0, 232, 242, 228, 265, 
    241], [256, 237, 260, 250, 239, 244, 269, 0, 253, 247, 261, 248], [240,
    241, 246, 243, 244, 233, 259, 248, 0, 229, 250, 233], [263, 260, 273, 
    248, 250, 257, 273, 254, 272, 0, 250, 252], [255, 228, 248, 236, 231, 
    237, 236, 240, 251, 251, 0, 229], [252, 260, 267, 241, 251, 247, 260, 
    253, 268, 249, 272, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 157, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 281, 247, 303, 292, 223, 290, 319, 291, 252, 276, 289],
    [220, 0, 246, 233, 243, 235, 268, 263, 263, 252, 260, 267], [254, 255, 
    0, 260, 246, 237, 288, 299, 240, 248, 244, 270], [198, 268, 241, 0, 269,
    220, 253, 291, 261, 252, 227, 223], [209, 258, 255, 232, 0, 215, 288, 
    296, 255, 244, 265, 248], [278, 266, 264, 281, 286, 0, 322, 318, 249, 
    253, 309, 257], [211, 233, 213, 248, 213, 179, 0, 278, 227, 189, 220, 
    214], [182, 238, 202, 210, 205, 183, 223, 0, 213, 227, 227, 188], [210,
    238, 261, 240, 246, 252, 274, 288, 0, 251, 272, 256], [249, 249, 253, 
    249, 257, 248, 312, 274, 250, 0, 265, 255], [225, 241, 257, 274, 236, 
    192, 281, 274, 229, 236, 0, 243], [212, 234, 231, 278, 253, 244, 287, 
    313, 245, 246, 258, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 158, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 233, 252, 293, 302, 227, 234, 257, 282, 260, 196, 319],
    [268, 0, 272, 295, 328, 240, 288, 286, 277, 323, 251, 305], [249, 229, 
    0, 250, 237, 207, 228, 228, 251, 240, 214, 277], [208, 206, 251, 0, 282,
    208, 200, 231, 250, 251, 193, 234], [199, 173, 264, 219, 0, 192, 206, 
    210, 239, 238, 215, 248], [274, 261, 294, 293, 309, 0, 229, 259, 323, 
    278, 233, 278], [267, 213, 273, 301, 295, 272, 0, 240, 245, 264, 197, 
    242], [244, 215, 273, 270, 291, 242, 261, 0, 244, 242, 225, 291], [219,
    224, 250, 251, 262, 178, 256, 257, 0, 254, 222, 274], [241, 178, 261, 
    250, 263, 223, 237, 259, 247, 0, 248, 277], [305, 250, 287, 308, 286, 
    268, 304, 276, 279, 253, 0, 277], [182, 196, 224, 267, 253, 223, 259, 
    210, 227, 224, 224, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 159, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 210, 230, 257, 250, 187, 391, 268, 214, 215, 302, 277],
    [291, 0, 202, 236, 214, 282, 390, 313, 235, 186, 285, 249], [271, 299, 
    0, 299, 202, 305, 314, 242, 212, 258, 339, 307], [244, 265, 202, 0, 217,
    281, 418, 303, 253, 275, 273, 298], [251, 287, 299, 284, 0, 369, 372, 
    295, 358, 206, 332, 280], [314, 219, 196, 220, 132, 0, 354, 281, 241, 
    221, 257, 260], [110, 111, 187, 83, 129, 147, 0, 185, 150, 118, 147, 
    113], [233, 188, 259, 198, 206, 220, 316, 0, 298, 196, 286, 287], [287,
    266, 289, 248, 143, 260, 351, 203, 0, 192, 287, 191], [286, 315, 243, 
    226, 295, 280, 383, 305, 309, 0, 315, 334], [199, 216, 162, 228, 169, 
    244, 354, 215, 214, 186, 0, 265], [224, 252, 194, 203, 221, 241, 388, 
    214, 310, 167, 236, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 160, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 247, 239, 236, 258, 259, 258, 254, 261, 248, 255, 245],
    [254, 0, 240, 241, 241, 248, 243, 250, 254, 259, 251, 236], [262, 261, 
    0, 239, 269, 263, 244, 249, 282, 257, 250, 240], [265, 260, 262, 0, 266,
    260, 260, 257, 263, 246, 259, 241], [243, 260, 232, 235, 0, 259, 247, 
    266, 246, 245, 247, 247], [242, 253, 238, 241, 242, 0, 236, 240, 252, 
    273, 262, 242], [243, 258, 257, 241, 254, 265, 0, 251, 252, 247, 257, 
    240], [247, 251, 252, 244, 235, 261, 250, 0, 257, 242, 264, 255], [240,
    247, 219, 238, 255, 249, 249, 244, 0, 246, 251, 228], [253, 242, 244, 
    255, 256, 228, 254, 259, 255, 0, 239, 244], [246, 250, 251, 242, 254, 
    239, 244, 237, 250, 262, 0, 241], [256, 265, 261, 260, 254, 259, 261, 
    246, 273, 257, 260, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 161, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 253, 232, 263, 238, 248, 230, 237, 264, 245, 234, 277],
    [248, 0, 249, 244, 248, 252, 240, 247, 265, 248, 240, 260], [269, 252, 
    0, 266, 248, 243, 233, 243, 284, 266, 260, 254], [238, 257, 235, 0, 268,
    248, 228, 237, 253, 256, 242, 250], [263, 253, 253, 233, 0, 248, 254, 
    256, 253, 254, 240, 262], [253, 249, 258, 253, 253, 0, 244, 243, 252, 
    266, 248, 262], [271, 261, 268, 273, 247, 257, 0, 253, 287, 268, 248, 
    264], [264, 254, 258, 264, 245, 258, 248, 0, 256, 251, 260, 266], [237,
    236, 217, 248, 248, 249, 214, 245, 0, 259, 234, 239], [256, 253, 235, 
    245, 247, 235, 233, 250, 242, 0, 250, 251], [267, 261, 241, 259, 261, 
    253, 253, 241, 267, 251, 0, 237], [224, 241, 247, 251, 239, 239, 237, 
    235, 262, 250, 264, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 162, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 261, 230, 222, 227, 231, 244, 261, 227, 247, 235, 243],
    [240, 0, 213, 231, 239, 222, 225, 244, 227, 246, 233, 234], [271, 288, 
    0, 238, 277, 275, 250, 272, 248, 276, 254, 264], [279, 270, 263, 0, 247,
    255, 248, 273, 269, 271, 256, 271], [274, 262, 224, 254, 0, 252, 226, 
    244, 261, 266, 260, 264], [270, 279, 226, 246, 249, 0, 251, 272, 264, 
    256, 267, 272], [257, 276, 251, 253, 275, 250, 0, 278, 254, 260, 265, 
    264], [240, 257, 229, 228, 257, 229, 223, 0, 240, 272, 243, 255], [274,
    274, 253, 232, 240, 237, 247, 261, 0, 263, 251, 257], [254, 255, 225, 
    230, 235, 245, 241, 229, 238, 0, 238, 255], [266, 268, 247, 245, 241, 
    234, 236, 258, 250, 263, 0, 277], [258, 267, 237, 230, 237, 229, 237, 
    246, 244, 246, 224, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 163, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 242, 261, 218, 245, 242, 270, 224, 241, 219, 258, 246],
    [259, 0, 264, 242, 240, 269, 259, 275, 258, 264, 245, 265], [240, 237, 
    0, 224, 233, 262, 254, 252, 257, 258, 252, 259], [283, 259, 277, 0, 248,
    259, 287, 246, 265, 260, 245, 289], [256, 261, 268, 253, 0, 246, 284, 
    252, 262, 261, 269, 264], [259, 232, 239, 242, 255, 0, 256, 255, 245, 
    258, 235, 227], [231, 242, 247, 214, 217, 245, 0, 251, 219, 252, 253, 
    247], [277, 226, 249, 255, 249, 246, 250, 0, 257, 265, 261, 254], [260,
    243, 244, 236, 239, 256, 282, 244, 0, 261, 245, 252], [282, 237, 243, 
    241, 240, 243, 249, 236, 240, 0, 257, 261], [243, 256, 249, 256, 232, 
    266, 248, 240, 256, 244, 0, 255], [255, 236, 242, 212, 237, 274, 254, 
    247, 249, 240, 246, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 164, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 221, 255, 246, 236, 230, 246, 282, 276, 225, 210, 270],
    [280, 0, 287, 290, 265, 268, 250, 267, 273, 283, 248, 307], [246, 214, 
    0, 299, 261, 304, 253, 272, 256, 286, 229, 248], [255, 211, 202, 0, 261,
    222, 164, 250, 272, 263, 234, 241], [265, 236, 240, 240, 0, 271, 191, 
    241, 271, 272, 204, 249], [271, 233, 197, 279, 230, 0, 198, 227, 275, 
    207, 206, 236], [255, 251, 248, 337, 310, 303, 0, 269, 275, 253, 263, 
    310], [219, 234, 229, 251, 260, 274, 232, 0, 278, 270, 224, 242], [225,
    228, 245, 229, 230, 226, 226, 223, 0, 203, 180, 212], [276, 218, 215, 
    238, 229, 294, 248, 231, 298, 0, 234, 272], [291, 253, 272, 267, 297, 
    295, 238, 277, 321, 267, 0, 277], [231, 194, 253, 260, 252, 265, 191, 
    259, 289, 229, 224, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 165, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 227, 215, 221, 247, 220, 242, 259, 243, 230, 236, 232],
    [274, 0, 234, 259, 260, 228, 261, 265, 263, 229, 234, 276], [286, 267, 
    0, 244, 266, 255, 268, 262, 262, 235, 244, 271], [280, 242, 257, 0, 258,
    249, 263, 249, 275, 256, 239, 246], [254, 241, 235, 243, 0, 230, 249, 
    235, 258, 245, 221, 251], [281, 273, 246, 252, 271, 0, 269, 259, 265, 
    241, 244, 275], [259, 240, 233, 238, 252, 232, 0, 278, 252, 240, 238, 
    222], [242, 236, 239, 252, 266, 242, 223, 0, 274, 246, 229, 259], [258,
    238, 239, 226, 243, 236, 249, 227, 0, 233, 212, 255], [271, 272, 266, 
    245, 256, 260, 261, 255, 268, 0, 254, 289], [265, 267, 257, 262, 280, 
    257, 263, 272, 289, 247, 0, 265], [269, 225, 230, 255, 250, 226, 279, 
    242, 246, 212, 236, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 166, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 231, 318, 252, 298, 292, 298, 296, 282, 232, 256, 294],
    [270, 0, 325, 291, 258, 276, 343, 291, 313, 332, 257, 248], [183, 176, 
    0, 218, 250, 227, 259, 292, 311, 231, 205, 259], [249, 210, 283, 0, 206,
    295, 316, 263, 268, 252, 233, 233], [203, 243, 251, 295, 0, 291, 370, 
    259, 299, 253, 275, 217], [209, 225, 274, 206, 210, 0, 292, 251, 274, 
    284, 200, 196], [203, 158, 242, 185, 131, 209, 0, 229, 243, 223, 153, 
    132], [205, 210, 209, 238, 242, 250, 272, 0, 223, 249, 245, 223], [219,
    188, 190, 233, 202, 227, 258, 278, 0, 216, 191, 183], [269, 169, 270, 
    249, 248, 217, 278, 252, 285, 0, 173, 255], [245, 244, 296, 268, 226, 
    301, 348, 256, 310, 328, 0, 252], [207, 253, 242, 268, 284, 305, 369, 
    278, 318, 246, 249, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 167, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 227, 274, 240, 225, 288, 297, 270, 225, 301, 283, 292],
    [274, 0, 283, 273, 284, 293, 310, 238, 251, 321, 312, 256], [227, 218, 
    0, 260, 261, 248, 260, 226, 224, 260, 249, 271], [261, 228, 241, 0, 234,
    286, 310, 252, 231, 282, 279, 276], [276, 217, 240, 267, 0, 238, 264, 
    297, 230, 293, 253, 303], [213, 208, 253, 215, 263, 0, 256, 222, 212, 
    264, 234, 268], [204, 191, 241, 191, 237, 245, 0, 229, 204, 272, 208, 
    233], [231, 263, 275, 249, 204, 279, 272, 0, 248, 260, 232, 273], [276,
    250, 277, 270, 271, 289, 297, 253, 0, 314, 253, 274], [200, 180, 241, 
    219, 208, 237, 229, 241, 187, 0, 215, 221], [218, 189, 252, 222, 248, 
    267, 293, 269, 248, 286, 0, 268], [209, 245, 230, 225, 198, 233, 268, 
    228, 227, 280, 233, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 168, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 274, 269, 244, 264, 243, 265, 267, 244, 239, 252, 256],
    [227, 0, 250, 252, 261, 222, 245, 241, 230, 244, 244, 240], [232, 251, 
    0, 231, 248, 238, 244, 255, 221, 225, 209, 234], [257, 249, 270, 0, 253,
    249, 254, 264, 243, 244, 249, 255], [237, 240, 253, 248, 0, 250, 242, 
    266, 223, 238, 220, 229], [258, 279, 263, 252, 251, 0, 273, 261, 249, 
    240, 245, 237], [236, 256, 257, 247, 259, 228, 0, 239, 231, 241, 228, 
    241], [234, 260, 246, 237, 235, 240, 262, 0, 228, 229, 226, 245], [257,
    271, 280, 258, 278, 252, 270, 273, 0, 252, 254, 247], [262, 257, 276, 
    257, 263, 261, 260, 272, 249, 0, 259, 266], [249, 257, 292, 252, 281, 
    256, 273, 275, 247, 242, 0, 260], [245, 261, 267, 246, 272, 264, 260, 
    256, 254, 235, 241, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 169, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 231, 234, 254, 255, 254, 246, 232, 242, 258, 252, 274],
    [270, 0, 260, 275, 256, 255, 267, 266, 247, 260, 256, 261], [267, 241, 
    0, 240, 261, 253, 248, 245, 246, 251, 261, 261], [247, 226, 261, 0, 241,
    264, 249, 220, 236, 247, 239, 253], [246, 245, 240, 260, 0, 245, 263, 
    246, 262, 257, 245, 278], [247, 246, 248, 237, 256, 0, 246, 246, 237, 
    243, 250, 260], [255, 234, 253, 252, 238, 255, 0, 227, 253, 241, 238, 
    262], [269, 235, 256, 281, 255, 255, 274, 0, 252, 280, 273, 274], [259,
    254, 255, 265, 239, 264, 248, 249, 0, 250, 255, 278], [243, 241, 250, 
    254, 244, 258, 260, 221, 251, 0, 241, 271], [249, 245, 240, 262, 256, 
    251, 263, 228, 246, 260, 0, 262], [227, 240, 240, 248, 223, 241, 239, 
    227, 223, 230, 239, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 170, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 268, 263, 218, 257, 274, 247, 262, 273, 247, 270, 242],
    [233, 0, 235, 259, 228, 244, 229, 237, 248, 234, 256, 253], [238, 266, 
    0, 230, 241, 248, 238, 238, 274, 234, 250, 248], [283, 242, 271, 0, 276,
    277, 264, 274, 264, 269, 283, 268], [244, 273, 260, 225, 0, 238, 254, 
    239, 241, 235, 267, 276], [227, 257, 253, 224, 263, 0, 237, 242, 231, 
    236, 269, 243], [254, 272, 263, 237, 247, 264, 0, 274, 277, 247, 270, 
    267], [239, 264, 263, 227, 262, 259, 227, 0, 238, 243, 262, 265], [228,
    253, 227, 237, 260, 270, 224, 263, 0, 251, 260, 254], [254, 267, 267, 
    232, 266, 265, 254, 258, 250, 0, 277, 262], [231, 245, 251, 218, 234, 
    232, 231, 239, 241, 224, 0, 222], [259, 248, 253, 233, 225, 258, 234, 
    236, 247, 239, 279, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 171, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 256, 245, 255, 256, 230, 254, 217, 258, 253, 236, 246],
    [245, 0, 249, 263, 253, 243, 233, 219, 256, 264, 237, 249], [256, 252, 
    0, 242, 276, 252, 258, 236, 267, 255, 249, 260], [246, 238, 259, 0, 254,
    248, 265, 214, 236, 254, 239, 222], [245, 248, 225, 247, 0, 229, 239, 
    224, 262, 249, 244, 247], [271, 258, 249, 253, 272, 0, 270, 233, 270, 
    284, 268, 264], [247, 268, 243, 236, 262, 231, 0, 224, 247, 253, 242, 
    255], [284, 282, 265, 287, 277, 268, 277, 0, 271, 289, 267, 246], [243,
    245, 234, 265, 239, 231, 254, 230, 0, 255, 236, 237], [248, 237, 246, 
    247, 252, 217, 248, 212, 246, 0, 240, 251], [265, 264, 252, 262, 257, 
    233, 259, 234, 265, 261, 0, 268], [255, 252, 241, 279, 254, 237, 246, 
    255, 264, 250, 233, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 172, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 266, 283, 243, 256, 255, 254, 253, 262, 283, 249, 232],
    [235, 0, 243, 222, 245, 272, 230, 240, 251, 324, 263, 226], [218, 258, 
    0, 228, 227, 219, 209, 234, 262, 252, 228, 186], [258, 279, 273, 0, 262,
    271, 206, 259, 290, 298, 298, 291], [245, 256, 274, 239, 0, 239, 210, 
    247, 284, 271, 237, 196], [246, 229, 282, 230, 262, 0, 195, 189, 247, 
    261, 259, 221], [247, 271, 292, 295, 291, 306, 0, 290, 225, 304, 284, 
    240], [248, 261, 267, 242, 254, 312, 211, 0, 303, 285, 251, 230], [239,
    250, 239, 211, 217, 254, 276, 198, 0, 267, 230, 227], [218, 177, 249, 
    203, 230, 240, 197, 216, 234, 0, 234, 210], [252, 238, 273, 203, 264, 
    242, 217, 250, 271, 267, 0, 246], [269, 275, 315, 210, 305, 280, 261, 
    271, 274, 291, 255, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 173, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 181, 182, 192, 249, 236, 186, 189, 238, 258, 233, 210],
    [320, 0, 283, 277, 321, 330, 236, 307, 302, 256, 275, 245], [319, 218, 
    0, 213, 267, 281, 236, 282, 318, 245, 283, 237], [309, 224, 288, 0, 351,
    266, 266, 365, 305, 216, 301, 309], [252, 180, 234, 150, 0, 219, 154, 
    271, 285, 209, 221, 222], [265, 171, 220, 235, 282, 0, 227, 294, 272, 
    211, 267, 263], [315, 265, 265, 235, 347, 274, 0, 307, 310, 298, 321, 
    280], [312, 194, 219, 136, 230, 207, 194, 0, 246, 195, 269, 265], [263,
    199, 183, 196, 216, 229, 191, 255, 0, 176, 185, 191], [243, 245, 256, 
    285, 292, 290, 203, 306, 325, 0, 228, 234], [268, 226, 218, 200, 280, 
    234, 180, 232, 316, 273, 0, 234], [291, 256, 264, 192, 279, 238, 221, 
    236, 310, 267, 267, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 174, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 271, 236, 234, 261, 239, 231, 235, 247, 233, 235, 250],
    [230, 0, 242, 233, 246, 254, 232, 238, 246, 238, 234, 236], [265, 259, 
    0, 249, 247, 247, 240, 229, 254, 230, 232, 238], [267, 268, 252, 0, 248,
    245, 257, 254, 259, 253, 255, 261], [240, 255, 254, 253, 0, 240, 237, 
    252, 251, 234, 237, 254], [262, 247, 254, 256, 261, 0, 252, 276, 253, 
    245, 255, 265], [270, 269, 261, 244, 264, 249, 0, 267, 259, 259, 244, 
    263], [266, 263, 272, 247, 249, 225, 234, 0, 240, 246, 233, 245], [254,
    255, 247, 242, 250, 248, 242, 261, 0, 242, 232, 240], [268, 263, 271, 
    248, 267, 256, 242, 255, 259, 0, 240, 250], [266, 267, 269, 246, 264, 
    246, 257, 268, 269, 261, 0, 247], [251, 265, 263, 240, 247, 236, 238, 
    256, 261, 251, 254, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 175, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 225, 254, 250, 234, 246, 247, 248, 237, 228, 246, 256],
    [276, 0, 262, 266, 249, 239, 255, 256, 253, 250, 263, 277], [247, 239, 
    0, 249, 252, 246, 255, 263, 246, 249, 228, 259], [251, 235, 252, 0, 224,
    260, 269, 251, 239, 233, 238, 266], [267, 252, 249, 277, 0, 264, 253, 
    249, 262, 248, 263, 264], [255, 262, 255, 241, 237, 0, 254, 248, 259, 
    252, 258, 296], [254, 246, 246, 232, 248, 247, 0, 260, 246, 250, 234, 
    245], [253, 245, 238, 250, 252, 253, 241, 0, 275, 247, 239, 263], [264,
    248, 255, 262, 239, 242, 255, 226, 0, 230, 224, 255], [273, 251, 252, 
    268, 253, 249, 251, 254, 271, 0, 253, 268], [255, 238, 273, 263, 238, 
    243, 267, 262, 277, 248, 0, 271], [245, 224, 242, 235, 237, 205, 256, 
    238, 246, 233, 230, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 176, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 256, 264, 235, 248, 256, 251, 264, 273, 292, 272, 260],
    [245, 0, 230, 235, 232, 236, 250, 253, 285, 259, 253, 244], [237, 271, 
    0, 252, 244, 259, 255, 265, 261, 274, 259, 255], [266, 266, 249, 0, 252,
    261, 266, 264, 256, 292, 249, 262], [253, 269, 257, 249, 0, 266, 238, 
    255, 264, 280, 249, 263], [245, 265, 242, 240, 235, 0, 232, 264, 257, 
    275, 264, 255], [250, 251, 246, 235, 263, 269, 0, 257, 267, 274, 269, 
    288], [237, 248, 236, 237, 246, 237, 244, 0, 256, 275, 261, 246], [228,
    216, 240, 245, 237, 244, 234, 245, 0, 257, 265, 270], [209, 242, 227, 
    209, 221, 226, 227, 226, 244, 0, 257, 231], [229, 248, 242, 252, 252, 
    237, 232, 240, 236, 244, 0, 247], [241, 257, 246, 239, 238, 246, 213, 
    255, 231, 270, 254, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 177, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 253, 231, 265, 271, 272, 275, 270, 274, 275, 246, 282],
    [248, 0, 244, 269, 295, 272, 254, 254, 252, 272, 284, 272], [270, 257, 
    0, 254, 284, 288, 266, 252, 235, 272, 270, 274], [236, 232, 247, 0, 249,
    247, 250, 252, 232, 242, 246, 246], [230, 206, 217, 252, 0, 265, 241, 
    250, 238, 248, 245, 260], [229, 229, 213, 254, 236, 0, 234, 244, 252, 
    252, 226, 259], [226, 247, 235, 251, 260, 267, 0, 238, 238, 251, 248, 
    256], [231, 247, 249, 249, 251, 257, 263, 0, 258, 265, 254, 262], [227,
    249, 266, 269, 263, 249, 263, 243, 0, 252, 248, 268], [226, 229, 229, 
    259, 253, 249, 250, 236, 249, 0, 229, 252], [255, 217, 231, 255, 256, 
    275, 253, 247, 253, 272, 0, 262], [219, 229, 227, 255, 241, 242, 245, 
    239, 233, 249, 239, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 178, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 231, 241, 224, 235, 231, 237, 257, 230, 227, 239, 226],
    [270, 0, 273, 242, 269, 243, 253, 261, 253, 251, 269, 246], [260, 228, 
    0, 235, 241, 245, 237, 255, 233, 240, 254, 231], [277, 259, 266, 0, 249,
    245, 238, 267, 265, 242, 258, 242], [266, 232, 260, 252, 0, 244, 259, 
    259, 248, 239, 264, 250], [270, 258, 256, 256, 257, 0, 255, 268, 262, 
    243, 259, 234], [264, 248, 264, 263, 242, 246, 0, 262, 263, 254, 253, 
    235], [244, 240, 246, 234, 242, 233, 239, 0, 242, 234, 234, 236], [271,
    248, 268, 236, 253, 239, 238, 259, 0, 238, 276, 256], [274, 250, 261, 
    259, 262, 258, 247, 267, 263, 0, 268, 252], [262, 232, 247, 243, 237, 
    242, 248, 267, 225, 233, 0, 231], [275, 255, 270, 259, 251, 267, 266, 
    265, 245, 249, 270, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 179, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 243, 256, 243, 261, 275, 267, 277, 286, 279, 270, 252],
    [258, 0, 263, 242, 266, 239, 240, 285, 306, 244, 280, 249], [245, 238, 
    0, 240, 256, 236, 248, 290, 268, 238, 264, 231], [258, 259, 261, 0, 253,
    269, 236, 268, 305, 259, 292, 220], [240, 235, 245, 248, 0, 236, 251, 
    270, 279, 266, 253, 249], [226, 262, 265, 232, 265, 0, 262, 296, 261, 
    236, 296, 244], [234, 261, 253, 265, 250, 239, 0, 293, 294, 241, 269, 
    244], [224, 216, 211, 233, 231, 205, 208, 0, 236, 208, 241, 203], [215,
    195, 233, 196, 222, 240, 207, 265, 0, 211, 271, 208], [222, 257, 263, 
    242, 235, 265, 260, 293, 290, 0, 288, 206], [231, 221, 237, 209, 248, 
    205, 232, 260, 230, 213, 0, 236], [249, 252, 270, 281, 252, 257, 257, 
    298, 293, 295, 265, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 180, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 264, 244, 279, 249, 254, 247, 262, 257, 252, 274, 249],
    [237, 0, 229, 231, 240, 245, 254, 261, 233, 218, 259, 234], [257, 272, 
    0, 268, 243, 274, 260, 267, 249, 249, 292, 264], [222, 270, 233, 0, 217,
    233, 240, 240, 231, 220, 259, 232], [252, 261, 258, 284, 0, 262, 267, 
    286, 241, 239, 276, 233], [247, 256, 227, 268, 239, 0, 259, 250, 222, 
    225, 262, 232], [254, 247, 241, 261, 234, 242, 0, 263, 206, 217, 249, 
    245], [239, 240, 234, 261, 215, 251, 238, 0, 194, 225, 248, 231], [244,
    268, 252, 270, 260, 279, 295, 307, 0, 262, 283, 263], [249, 283, 252, 
    281, 262, 276, 284, 276, 239, 0, 276, 270], [227, 242, 209, 242, 225, 
    239, 252, 253, 218, 225, 0, 223], [252, 267, 237, 269, 268, 269, 256, 
    270, 238, 231, 278, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 181, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 196, 326, 256, 236, 276, 296, 240, 262, 250, 254, 280],
    [305, 0, 290, 257, 252, 254, 305, 228, 255, 258, 284, 282], [175, 211, 
    0, 216, 245, 243, 304, 220, 266, 193, 238, 271], [245, 244, 285, 0, 214,
    276, 324, 221, 230, 249, 256, 306], [265, 249, 256, 287, 0, 282, 267, 
    229, 280, 267, 283, 271], [225, 247, 258, 225, 219, 0, 306, 190, 259, 
    213, 264, 274], [205, 196, 197, 177, 234, 195, 0, 182, 196, 199, 231, 
    288], [261, 273, 281, 280, 272, 311, 319, 0, 276, 250, 260, 302], [239,
    246, 235, 271, 221, 242, 305, 225, 0, 232, 254, 258], [251, 243, 308, 
    252, 234, 288, 302, 251, 269, 0, 258, 272], [247, 217, 263, 245, 218, 
    237, 270, 241, 247, 243, 0, 265], [221, 219, 230, 195, 230, 227, 213, 
    199, 243, 229, 236, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 182, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 241, 250, 241, 249, 234, 243, 241, 253, 251, 257, 260],
    [260, 0, 242, 245, 266, 239, 257, 252, 257, 246, 246, 266], [251, 259, 
    0, 258, 271, 244, 236, 254, 267, 266, 266, 273], [260, 256, 243, 0, 274,
    257, 245, 254, 259, 257, 245, 264], [252, 235, 230, 227, 0, 228, 228, 
    253, 240, 255, 244, 248], [267, 262, 257, 244, 273, 0, 265, 273, 271, 
    264, 268, 264], [258, 244, 265, 256, 273, 236, 0, 252, 266, 264, 251, 
    248], [260, 249, 247, 247, 248, 228, 249, 0, 252, 258, 253, 253], [248,
    244, 234, 242, 261, 230, 235, 249, 0, 257, 250, 249], [250, 255, 235, 
    244, 246, 237, 237, 243, 244, 0, 258, 256], [244, 255, 235, 256, 257, 
    233, 250, 248, 251, 243, 0, 241], [241, 235, 228, 237, 253, 237, 253, 
    248, 252, 245, 260, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 183, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 314, 263, 300, 270, 247, 281, 313, 214, 298, 299, 288],
    [187, 0, 169, 202, 226, 205, 238, 275, 205, 262, 255, 208], [238, 332, 
    0, 284, 330, 292, 242, 292, 231, 288, 285, 271], [201, 299, 217, 0, 294,
    213, 269, 313, 230, 297, 276, 263], [231, 275, 171, 207, 0, 201, 249, 
    243, 230, 250, 254, 251], [254, 296, 209, 288, 300, 0, 245, 254, 271, 
    245, 293, 275], [220, 263, 259, 232, 252, 256, 0, 338, 246, 280, 314, 
    295], [188, 226, 209, 188, 258, 247, 163, 0, 154, 238, 270, 234], [287,
    296, 270, 271, 271, 230, 255, 347, 0, 288, 323, 301], [203, 239, 213, 
    204, 251, 256, 221, 263, 213, 0, 280, 253], [202, 246, 216, 225, 247, 
    208, 187, 231, 178, 221, 0, 298], [213, 293, 230, 238, 250, 226, 206, 
    267, 200, 248, 203, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 184, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 252, 237, 240, 245, 258, 245, 237, 240, 240, 245, 251],
    [249, 0, 257, 243, 246, 247, 253, 240, 234, 244, 241, 250], [264, 244, 
    0, 264, 262, 252, 252, 262, 253, 252, 246, 250], [261, 258, 237, 0, 254,
    248, 253, 251, 256, 240, 243, 251], [256, 255, 239, 247, 0, 241, 255, 
    242, 239, 251, 225, 274], [243, 254, 249, 253, 260, 0, 248, 266, 267, 
    256, 247, 266], [256, 248, 249, 248, 246, 253, 0, 243, 251, 248, 251, 
    258], [264, 261, 239, 250, 259, 235, 258, 0, 250, 262, 251, 264], [261,
    267, 248, 245, 262, 234, 250, 251, 0, 251, 248, 275], [261, 257, 249, 
    261, 250, 245, 253, 239, 250, 0, 249, 265], [256, 260, 255, 258, 276, 
    254, 250, 250, 253, 252, 0, 245], [250, 251, 251, 250, 227, 235, 243, 
    237, 226, 236, 256, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 185, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 252, 218, 253, 248, 254, 246, 232, 258, 249, 268, 268],
    [249, 0, 224, 236, 257, 255, 228, 242, 243, 256, 270, 232], [283, 277, 
    0, 260, 266, 270, 265, 235, 264, 227, 273, 256], [248, 265, 241, 0, 235,
    247, 233, 234, 238, 248, 236, 232], [253, 244, 235, 266, 0, 257, 258, 
    248, 243, 262, 257, 252], [247, 246, 231, 254, 244, 0, 234, 219, 223, 
    243, 258, 237], [255, 273, 236, 268, 243, 267, 0, 259, 247, 257, 260, 
    220], [269, 259, 266, 267, 253, 282, 242, 0, 266, 254, 280, 238], [243,
    258, 237, 263, 258, 278, 254, 235, 0, 242, 276, 230], [252, 245, 274, 
    253, 239, 258, 244, 247, 259, 0, 289, 220], [233, 231, 228, 265, 244, 
    243, 241, 221, 225, 212, 0, 209], [233, 269, 245, 269, 249, 264, 281, 
    263, 271, 281, 292, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 186, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 245, 259, 240, 243, 251, 253, 246, 273, 248, 267, 239],
    [256, 0, 264, 261, 275, 254, 268, 259, 275, 255, 259, 247], [242, 237, 
    0, 241, 252, 231, 253, 224, 245, 238, 235, 241], [261, 240, 260, 0, 257,
    241, 257, 239, 253, 249, 248, 251], [258, 226, 249, 244, 0, 253, 250, 
    237, 253, 241, 241, 240], [250, 247, 270, 260, 248, 0, 252, 261, 246, 
    240, 254, 231], [248, 233, 248, 244, 251, 249, 0, 238, 255, 228, 238, 
    240], [255, 242, 277, 262, 264, 240, 263, 0, 266, 247, 268, 241], [228,
    226, 256, 248, 248, 255, 246, 235, 0, 246, 264, 257], [253, 246, 263, 
    252, 260, 261, 273, 254, 255, 0, 263, 265], [234, 242, 266, 253, 260, 
    247, 263, 233, 237, 238, 0, 249], [262, 254, 260, 250, 261, 270, 261, 
    260, 244, 236, 252, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 187, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 138, 264, 269, 158, 252, 162, 130, 165, 154, 130, 182],
    [363, 0, 283, 309, 188, 321, 279, 169, 348, 300, 291, 341], [237, 218, 
    0, 264, 248, 334, 278, 171, 292, 173, 236, 281], [232, 192, 237, 0, 115,
    228, 203, 183, 206, 228, 261, 202], [343, 313, 253, 386, 0, 347, 269, 
    266, 322, 248, 337, 264], [249, 180, 167, 273, 154, 0, 184, 201, 248, 
    199, 142, 244], [339, 222, 223, 298, 232, 317, 0, 177, 256, 240, 307, 
    218], [371, 332, 330, 318, 235, 300, 324, 0, 243, 267, 268, 252], [336,
    153, 209, 295, 179, 253, 245, 258, 0, 177, 253, 265], [347, 201, 328, 
    273, 253, 302, 261, 234, 324, 0, 315, 220], [371, 210, 265, 240, 164, 
    359, 194, 233, 248, 186, 0, 254], [319, 160, 220, 299, 237, 257, 283, 
    249, 236, 281, 247, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 188, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 247, 294, 275, 271, 252, 286, 271, 239, 232, 265, 275],
    [254, 0, 253, 208, 225, 232, 240, 231, 267, 262, 235, 225], [207, 248, 
    0, 240, 242, 204, 222, 207, 253, 241, 207, 240], [226, 293, 261, 0, 253,
    285, 260, 211, 280, 245, 253, 256], [230, 276, 259, 248, 0, 283, 231, 
    229, 285, 243, 237, 233], [249, 269, 297, 216, 218, 0, 251, 220, 258, 
    251, 232, 267], [215, 261, 279, 241, 270, 250, 0, 248, 292, 292, 262, 
    259], [230, 270, 294, 290, 272, 281, 253, 0, 255, 283, 270, 308], [262,
    234, 248, 221, 216, 243, 209, 246, 0, 228, 214, 233], [269, 239, 260, 
    256, 258, 250, 209, 218, 273, 0, 263, 227], [236, 266, 294, 248, 264, 
    269, 239, 231, 287, 238, 0, 258], [226, 276, 261, 245, 268, 234, 242, 
    193, 268, 274, 243, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 189, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 256, 256, 246, 258, 246, 250, 247, 246, 247, 253, 259],
    [245, 0, 254, 246, 265, 252, 242, 240, 257, 248, 253, 247], [245, 247, 
    0, 233, 257, 253, 245, 242, 255, 250, 238, 252], [255, 255, 268, 0, 266,
    249, 255, 247, 256, 253, 259, 251], [243, 236, 244, 235, 0, 232, 262, 
    243, 245, 241, 242, 250], [255, 249, 248, 252, 269, 0, 261, 250, 265, 
    259, 248, 251], [251, 259, 256, 246, 239, 240, 0, 258, 245, 246, 266, 
    249], [254, 261, 259, 254, 258, 251, 243, 0, 255, 249, 254, 248], [255,
    244, 246, 245, 256, 236, 256, 246, 0, 259, 247, 251], [254, 253, 251, 
    248, 260, 242, 255, 252, 242, 0, 261, 249], [248, 248, 263, 242, 259, 
    253, 235, 247, 254, 240, 0, 257], [242, 254, 249, 250, 251, 250, 252, 
    253, 250, 252, 244, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 190, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 264, 257, 244, 241, 258, 284, 266, 255, 245, 260, 247],
    [237, 0, 237, 219, 223, 225, 259, 253, 250, 228, 237, 241], [244, 264, 
    0, 235, 230, 242, 261, 250, 245, 241, 241, 243], [257, 282, 266, 0, 233,
    253, 271, 260, 261, 260, 253, 254], [260, 278, 271, 268, 0, 270, 273, 
    262, 256, 241, 256, 255], [243, 276, 259, 248, 231, 0, 270, 257, 252, 
    246, 257, 241], [217, 242, 240, 230, 228, 231, 0, 245, 241, 233, 243, 
    247], [235, 248, 251, 241, 239, 244, 256, 0, 246, 232, 249, 265], [246,
    251, 256, 240, 245, 249, 260, 255, 0, 235, 243, 253], [256, 273, 260, 
    241, 260, 255, 268, 269, 266, 0, 254, 269], [241, 264, 260, 248, 245, 
    244, 258, 252, 258, 247, 0, 265], [254, 260, 258, 247, 246, 260, 254, 
    236, 248, 232, 236, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 191, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 256, 305, 277, 309, 294, 273, 247, 259, 263, 238, 318],
    [245, 0, 256, 305, 318, 305, 300, 294, 257, 265, 259, 260], [196, 245, 
    0, 249, 281, 290, 254, 263, 226, 251, 225, 276], [224, 196, 252, 0, 315,
    292, 263, 243, 261, 279, 225, 264], [192, 183, 220, 186, 0, 228, 206, 
    194, 228, 206, 205, 224], [207, 196, 211, 209, 273, 0, 246, 240, 211, 
    204, 167, 221], [228, 201, 247, 238, 295, 255, 0, 283, 187, 202, 186, 
    242], [254, 207, 238, 258, 307, 261, 218, 0, 217, 253, 199, 262], [242,
    244, 275, 240, 273, 290, 314, 284, 0, 249, 194, 259], [238, 236, 250, 
    222, 295, 297, 299, 248, 252, 0, 222, 277], [263, 242, 276, 276, 296, 
    334, 315, 302, 307, 279, 0, 318], [183, 241, 225, 237, 277, 280, 259, 
    239, 242, 224, 183, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 192, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 258, 254, 251, 272, 265, 260, 240, 250, 258, 271, 257],
    [243, 0, 246, 232, 269, 247, 249, 247, 250, 236, 264, 265], [247, 255, 
    0, 247, 269, 267, 263, 256, 245, 242, 284, 273], [250, 269, 254, 0, 290,
    260, 267, 261, 277, 249, 287, 280], [229, 232, 232, 211, 0, 217, 236, 
    232, 231, 219, 245, 239], [236, 254, 234, 241, 284, 0, 257, 247, 247, 
    239, 264, 263], [241, 252, 238, 234, 265, 244, 0, 241, 246, 241, 257, 
    259], [261, 254, 245, 240, 269, 254, 260, 0, 250, 244, 284, 265], [251,
    251, 256, 224, 270, 254, 255, 251, 0, 239, 269, 257], [243, 265, 259, 
    252, 282, 262, 260, 257, 262, 0, 280, 269], [230, 237, 217, 214, 256, 
    237, 244, 217, 232, 221, 0, 244], [244, 236, 228, 221, 262, 238, 242, 
    236, 244, 232, 257, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 193, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 312, 258, 254, 267, 317, 283, 217, 351, 297, 275, 224],
    [189, 0, 229, 160, 220, 244, 205, 171, 234, 166, 242, 220], [243, 272, 
    0, 234, 261, 315, 167, 264, 292, 310, 277, 260], [247, 341, 267, 0, 295,
    326, 226, 162, 262, 231, 243, 263], [234, 281, 240, 206, 0, 191, 138, 
    215, 244, 228, 250, 259], [184, 257, 186, 175, 310, 0, 152, 114, 264, 
    127, 150, 254], [218, 296, 334, 275, 363, 349, 0, 270, 303, 255, 269, 
    315], [284, 330, 237, 339, 286, 387, 231, 0, 351, 293, 233, 322], [150,
    267, 209, 239, 257, 237, 198, 150, 0, 165, 200, 221], [204, 335, 191, 
    270, 273, 374, 246, 208, 336, 0, 228, 219], [226, 259, 224, 258, 251, 
    351, 232, 268, 301, 273, 0, 288], [277, 281, 241, 238, 242, 247, 186, 
    179, 280, 282, 213, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 194, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 219, 214, 256, 244, 236, 261, 242, 240, 250, 249, 220],
    [282, 0, 264, 258, 236, 279, 263, 271, 236, 287, 273, 249], [287, 237, 
    0, 263, 248, 269, 275, 273, 224, 272, 270, 255], [245, 243, 238, 0, 257,
    279, 270, 251, 237, 277, 274, 246], [257, 265, 253, 244, 0, 285, 280, 
    266, 267, 284, 284, 259], [265, 222, 232, 222, 216, 0, 272, 242, 234, 
    269, 277, 228], [240, 238, 226, 231, 221, 229, 0, 237, 229, 249, 258, 
    247], [259, 230, 228, 250, 235, 259, 264, 0, 245, 269, 261, 249], [261,
    265, 277, 264, 234, 267, 272, 256, 0, 279, 265, 264], [251, 214, 229, 
    224, 217, 232, 252, 232, 222, 0, 246, 239], [252, 228, 231, 227, 217, 
    224, 243, 240, 236, 255, 0, 224], [281, 252, 246, 255, 242, 273, 254, 
    252, 237, 262, 277, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 195, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 254, 238, 261, 255, 263, 244, 266, 257, 241, 257, 246],
    [247, 0, 255, 268, 239, 264, 242, 253, 247, 243, 256, 226], [263, 246, 
    0, 265, 263, 254, 240, 259, 246, 251, 262, 239], [240, 233, 236, 0, 238,
    257, 242, 252, 245, 228, 237, 257], [246, 262, 238, 263, 0, 256, 265, 
    249, 239, 237, 240, 252], [238, 237, 247, 244, 245, 0, 230, 260, 259, 
    241, 243, 244], [257, 259, 261, 259, 236, 271, 0, 276, 254, 249, 253, 
    245], [235, 248, 242, 249, 252, 241, 225, 0, 247, 249, 249, 225], [244,
    254, 255, 256, 262, 242, 247, 254, 0, 243, 244, 265], [260, 258, 250, 
    273, 264, 260, 252, 252, 258, 0, 262, 251], [244, 245, 239, 264, 261, 
    258, 248, 252, 257, 239, 0, 231], [255, 275, 262, 244, 249, 257, 256, 
    276, 236, 250, 270, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 196, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 240, 285, 247, 212, 236, 226, 231, 250, 236, 222, 250],
    [261, 0, 276, 244, 229, 244, 230, 242, 264, 256, 243, 252], [216, 225, 
    0, 219, 220, 214, 213, 219, 236, 231, 237, 223], [254, 257, 282, 0, 235,
    258, 292, 269, 276, 258, 242, 262], [289, 272, 281, 266, 0, 261, 269, 
    259, 287, 250, 270, 292], [265, 257, 287, 243, 240, 0, 237, 217, 269, 
    260, 263, 265], [275, 271, 288, 209, 232, 264, 0, 251, 241, 214, 223, 
    265], [270, 259, 282, 232, 242, 284, 250, 0, 258, 281, 257, 292], [251,
    237, 265, 225, 214, 232, 260, 243, 0, 245, 232, 266], [265, 245, 270, 
    243, 251, 241, 287, 220, 256, 0, 232, 264], [279, 258, 264, 259, 231, 
    238, 278, 244, 269, 269, 0, 259], [251, 249, 278, 239, 209, 236, 236, 
    209, 235, 237, 242, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 197, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 246, 216, 202, 248, 226, 206, 252, 263, 230, 247, 244],
    [255, 0, 246, 260, 269, 261, 242, 247, 241, 274, 273, 262], [285, 255, 
    0, 235, 270, 223, 225, 281, 268, 244, 260, 284], [299, 241, 266, 0, 275,
    264, 251, 257, 249, 279, 254, 276], [253, 232, 231, 226, 0, 227, 219, 
    233, 229, 257, 261, 251], [275, 240, 278, 237, 274, 0, 246, 282, 257, 
    254, 269, 261], [295, 259, 276, 250, 282, 255, 0, 300, 290, 269, 276, 
    272], [249, 254, 220, 244, 268, 219, 201, 0, 262, 241, 234, 258], [238,
    260, 233, 252, 272, 244, 211, 239, 0, 247, 265, 263], [271, 227, 257, 
    222, 244, 247, 232, 260, 254, 0, 266, 267], [254, 228, 241, 247, 240, 
    232, 225, 267, 236, 235, 0, 241], [257, 239, 217, 225, 250, 240, 229, 
    243, 238, 234, 260, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 198, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 256, 287, 251, 247, 283, 299, 284, 248, 287, 308, 195],
    [245, 0, 260, 239, 254, 300, 285, 241, 277, 276, 311, 246], [214, 241, 
    0, 240, 220, 280, 256, 278, 264, 271, 254, 223], [250, 262, 261, 0, 219,
    325, 274, 289, 289, 228, 283, 269], [254, 247, 281, 282, 0, 293, 324, 
    249, 290, 317, 284, 208], [218, 201, 221, 176, 208, 0, 260, 243, 231, 
    213, 257, 194], [202, 216, 245, 227, 177, 241, 0, 220, 223, 252, 251, 
    179], [217, 260, 223, 212, 252, 258, 281, 0, 269, 252, 255, 247], [253,
    224, 237, 212, 211, 270, 278, 232, 0, 244, 278, 236], [214, 225, 230, 
    273, 184, 288, 249, 249, 257, 0, 281, 238], [193, 190, 247, 218, 217, 
    244, 250, 246, 223, 220, 0, 203], [306, 255, 278, 232, 293, 307, 322, 
    254, 265, 263, 298, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 199, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
om = np.array([[0, 244, 238, 253, 250, 235, 231, 241, 239, 228, 244, 212],
    [257, 0, 266, 259, 258, 245, 247, 253, 260, 251, 256, 247], [263, 235, 
    0, 235, 243, 240, 232, 235, 246, 254, 237, 230], [248, 242, 266, 0, 249,
    237, 241, 229, 244, 234, 251, 237], [251, 243, 258, 252, 0, 242, 241, 
    230, 245, 259, 244, 231], [266, 256, 261, 264, 259, 0, 249, 247, 262, 
    269, 253, 245], [270, 254, 269, 260, 260, 252, 0, 247, 273, 256, 276, 
    243], [260, 248, 266, 272, 271, 254, 254, 0, 268, 248, 265, 255], [262,
    241, 255, 257, 256, 239, 228, 233, 0, 250, 254, 248], [273, 250, 247, 
    267, 242, 232, 245, 253, 251, 0, 245, 230], [257, 245, 264, 250, 257, 
    248, 225, 236, 247, 256, 0, 230], [289, 254, 271, 264, 270, 256, 258, 
    246, 253, 271, 271, 0]])
times = np.zeros(rep)
for i in range(rep):
    algorithm = alg.AzziniMunda5(om)
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = time.time() - start_time
    times[i] = t
exec_time = np.median(times)
result = np.append(np.array([12, 501, 200, 'ME-BBd', exec_time, sol.shape[0
    ], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))
pd.DataFrame(results).to_csv(
    '/Users/noeliarico/Desktop/folder-kemeny/2021EJOR/results/mebbd/mebbd_12_501.csv'
    , index=False, header=False)


import numpy as np
import pandas as pd
import time
from kemeny import algorithms as alg
from kemeny import sc

rep = 1
results = np.zeros(0).reshape(0,7+rep)

##############################################################
om = np.array([
[0,259,278,248,255,269,234,282,266,294,272,275],
[242,0,252,257,217,244,226,248,239,263,240,225],
[223,249,0,256,228,225,242,264,268,281,263,260],
[253,244,245,0,243,231,226,267,271,274,269,284],
[246,284,273,258,0,242,251,274,269,269,250,240],
[232,257,276,270,259,0,249,262,269,286,270,254],
[267,275,259,275,250,252,0,302,262,282,271,266],
[219,253,237,234,227,239,199,0,249,278,246,241],
[235,262,233,230,232,232,239,252,0,257,260,223],
[207,238,220,227,232,215,219,223,244,0,222,216],
[229,261,238,232,251,231,230,255,241,279,0,254],
[226,276,241,217,261,247,235,260,278,285,247,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 1, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,259,263,250,258,235,242,245,243,272,256,244],
[242,0,241,232,243,234,229,248,247,247,249,249],
[238,260,0,233,253,249,233,238,243,254,247,241],
[251,269,268,0,248,257,239,245,259,250,266,254],
[243,258,248,253,0,240,246,247,243,260,259,254],
[266,267,252,244,261,0,255,254,250,267,255,260],
[259,272,268,262,255,246,0,259,260,275,266,256],
[256,253,263,256,254,247,242,0,241,261,254,250],
[258,254,258,242,258,251,241,260,0,268,257,252],
[229,254,247,251,241,234,226,240,233,0,254,243],
[245,252,254,235,242,246,235,247,244,247,0,248],
[257,252,260,247,247,241,245,251,249,258,253,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 2, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,247,229,236,228,211,241,224,225,231,224,221],
[254,0,237,241,251,219,246,248,235,233,229,223],
[272,264,0,251,252,240,269,270,245,250,232,234],
[265,260,250,0,240,242,250,272,245,238,247,236],
[273,250,249,261,0,234,242,248,245,237,237,245],
[290,282,261,259,267,0,286,259,264,247,262,247],
[260,255,232,251,259,215,0,248,223,235,229,238],
[277,253,231,229,253,242,253,0,241,242,245,239],
[276,266,256,256,256,237,278,260,0,253,238,250],
[270,268,251,263,264,254,266,259,248,0,249,257],
[277,272,269,254,264,239,272,256,263,252,0,249],
[280,278,267,265,256,254,263,262,251,244,252,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 3, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,266,234,275,235,284,219,265,219,263,247,246],
[235,0,236,283,257,299,224,274,232,245,263,263],
[267,265,0,291,261,313,263,268,248,277,257,269],
[226,218,210,0,237,283,215,251,216,228,256,234],
[266,244,240,264,0,288,244,232,250,215,256,231],
[217,202,188,218,213,0,198,216,221,224,194,231],
[282,277,238,286,257,303,0,272,259,261,252,266],
[236,227,233,250,269,285,229,0,202,234,235,237],
[282,269,253,285,251,280,242,299,0,275,265,259],
[238,256,224,273,286,277,240,267,226,0,255,238],
[254,238,244,245,245,307,249,266,236,246,0,256],
[255,238,232,267,270,270,235,264,242,263,245,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 4, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,191,219,198,169,179,190,155,217,164,245,265],
[310,0,227,329,266,246,261,272,287,287,261,274],
[282,274,0,258,268,211,186,237,261,229,178,302],
[303,172,243,0,209,264,150,185,243,192,238,270],
[332,235,233,292,0,250,261,295,336,213,249,294],
[322,255,290,237,251,0,244,294,241,251,316,261],
[311,240,315,351,240,257,0,244,240,303,204,350],
[346,229,264,316,206,207,257,0,258,282,237,310],
[284,214,240,258,165,260,261,243,0,262,200,302],
[337,214,272,309,288,250,198,219,239,0,220,282],
[256,240,323,263,252,185,297,264,301,281,0,339],
[236,227,199,231,207,240,151,191,199,219,162,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 5, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,275,252,277,275,281,282,239,280,255,305,329],
[226,0,240,288,262,229,294,193,309,244,286,290],
[249,261,0,267,280,260,286,205,295,203,273,277],
[224,213,234,0,244,256,232,228,248,238,263,312],
[226,239,221,257,0,201,256,227,248,253,285,267],
[220,272,241,245,300,0,287,203,258,219,283,301],
[219,207,215,269,245,214,0,219,312,254,287,268],
[262,308,296,273,274,298,282,0,337,242,311,307],
[221,192,206,253,253,243,189,164,0,179,258,306],
[246,257,298,263,248,282,247,259,322,0,291,274],
[196,215,228,238,216,218,214,190,243,210,0,239],
[172,211,224,189,234,200,233,194,195,227,262,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 6, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,241,223,213,255,249,259,232,254,230,241,264],
[260,0,241,236,263,265,272,239,279,247,263,254],
[278,260,0,250,276,244,304,256,266,262,267,284],
[288,265,251,0,267,255,265,249,248,244,269,268],
[246,238,225,234,0,253,273,252,271,244,263,266],
[252,236,257,246,248,0,251,251,271,238,258,270],
[242,229,197,236,228,250,0,214,235,236,243,264],
[269,262,245,252,249,250,287,0,258,246,254,270],
[247,222,235,253,230,230,266,243,0,216,232,241],
[271,254,239,257,257,263,265,255,285,0,290,265],
[260,238,234,232,238,243,258,247,269,211,0,254],
[237,247,217,233,235,231,237,231,260,236,247,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 7, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,234,243,240,249,237,246,246,252,250,257,255],
[267,0,254,267,253,248,264,258,254,263,259,256],
[258,247,0,251,258,263,256,251,265,254,260,265],
[261,234,250,0,241,243,264,250,247,260,249,258],
[252,248,243,260,0,253,253,258,243,253,246,264],
[264,253,238,258,248,0,266,242,263,268,240,271],
[255,237,245,237,248,235,0,243,233,256,242,260],
[255,243,250,251,243,259,258,0,249,265,264,260],
[249,247,236,254,258,238,268,252,0,257,256,263],
[251,238,247,241,248,233,245,236,244,0,244,258],
[244,242,241,252,255,261,259,237,245,257,0,259],
[246,245,236,243,237,230,241,241,238,243,242,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 8, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,246,259,252,252,249,259,284,265,248,278,251],
[255,0,259,252,249,267,262,276,279,234,271,279],
[242,242,0,240,254,257,255,263,264,240,246,249],
[249,249,261,0,241,279,243,267,253,261,263,257],
[249,252,247,260,0,255,260,270,253,262,258,268],
[252,234,244,222,246,0,250,258,261,240,264,258],
[242,239,246,258,241,251,0,265,255,253,261,269],
[217,225,238,234,231,243,236,0,252,234,243,247],
[236,222,237,248,248,240,246,249,0,243,236,245],
[253,267,261,240,239,261,248,267,258,0,240,258],
[223,230,255,238,243,237,240,258,265,261,0,245],
[250,222,252,244,233,243,232,254,256,243,256,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 9, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,251,261,223,245,237,275,220,224,243,264,242],
[250,0,260,222,243,243,274,215,229,242,261,273],
[240,241,0,231,213,225,228,252,234,239,238,258],
[278,279,270,0,283,264,295,265,246,267,271,288],
[256,258,288,218,0,236,261,233,216,251,267,269],
[264,258,276,237,265,0,275,273,253,249,262,290],
[226,227,273,206,240,226,0,214,240,230,245,250],
[281,286,249,236,268,228,287,0,276,257,245,301],
[277,272,267,255,285,248,261,225,0,271,260,280],
[258,259,262,234,250,252,271,244,230,0,251,302],
[237,240,263,230,234,239,256,256,241,250,0,266],
[259,228,243,213,232,211,251,200,221,199,235,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 10, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,263,241,241,215,238,216,270,205,258,258,242],
[238,0,245,245,239,229,232,227,215,276,229,266],
[260,256,0,275,273,239,220,259,233,269,248,257],
[260,256,226,0,249,235,223,253,228,256,269,302],
[286,262,228,252,0,235,228,264,264,270,259,277],
[263,272,262,266,266,0,224,256,248,265,242,264],
[285,269,281,278,273,277,0,275,240,266,308,318],
[231,274,242,248,237,245,226,0,216,279,244,253],
[296,286,268,273,237,253,261,285,0,286,258,309],
[243,225,232,245,231,236,235,222,215,0,262,249],
[243,272,253,232,242,259,193,257,243,239,0,278],
[259,235,244,199,224,237,183,248,192,252,223,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 11, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,227,329,294,369,243,216,235,353,255,288,277],
[274,0,314,328,392,297,321,230,332,353,319,280],
[172,187,0,216,379,238,299,171,204,228,278,241],
[207,173,285,0,438,298,365,280,234,325,313,277],
[132,109,122,63,0,168,199,128,168,224,227,154],
[258,204,263,203,333,0,301,250,291,244,326,285],
[285,180,202,136,302,200,0,224,216,294,237,230],
[266,271,330,221,373,251,277,0,300,341,283,242],
[148,169,297,267,333,210,285,201,0,211,238,189],
[246,148,273,176,277,257,207,160,290,0,282,220],
[213,182,223,188,274,175,264,218,263,219,0,208],
[224,221,260,224,347,216,271,259,312,281,293,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 12, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,261,248,278,247,248,246,265,258,234,235,242],
[240,0,253,268,258,240,252,258,271,239,252,244],
[253,248,0,264,273,252,246,280,265,262,250,251],
[223,233,237,0,251,250,246,255,247,232,232,244],
[254,243,228,250,0,242,235,261,254,243,248,245],
[253,261,249,251,259,0,247,257,250,244,246,244],
[255,249,255,255,266,254,0,269,256,248,254,235],
[236,243,221,246,240,244,232,0,253,228,214,233],
[243,230,236,254,247,251,245,248,0,244,239,236],
[267,262,239,269,258,257,253,273,257,0,251,262],
[266,249,251,269,253,255,247,287,262,250,0,244],
[259,257,250,257,256,257,266,268,265,239,257,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 13, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,243,247,249,229,244,247,245,246,231,223,272],
[258,0,238,235,232,243,259,231,224,236,236,257],
[254,263,0,259,253,258,268,267,241,267,228,278],
[252,266,242,0,255,262,264,260,248,260,258,270],
[272,269,248,246,0,248,270,264,259,257,239,260],
[257,258,243,239,253,0,252,229,244,240,223,249],
[254,242,233,237,231,249,0,247,245,272,253,271],
[256,270,234,241,237,272,254,0,244,246,245,267],
[255,277,260,253,242,257,256,257,0,247,245,257],
[270,265,234,241,244,261,229,255,254,0,240,250],
[278,265,273,243,262,278,248,256,256,261,0,268],
[229,244,223,231,241,252,230,234,244,251,233,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 14, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,258,251,277,239,227,263,230,231,253,266,259],
[243,0,258,258,238,235,240,223,245,249,247,269],
[250,243,0,255,247,214,238,241,259,236,249,252],
[224,243,246,0,227,241,240,202,226,228,229,242],
[262,263,254,274,0,253,234,232,236,238,244,271],
[274,266,287,260,248,0,267,221,249,260,283,284],
[238,261,263,261,267,234,0,248,258,251,248,275],
[271,278,260,299,269,280,253,0,247,270,284,279],
[270,256,242,275,265,252,243,254,0,254,283,253],
[248,252,265,273,263,241,250,231,247,0,270,242],
[235,254,252,272,257,218,253,217,218,231,0,263],
[242,232,249,259,230,217,226,222,248,259,238,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 15, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,301,293,246,369,267,254,241,350,231,202,252],
[200,0,213,189,263,260,151,155,312,186,253,273],
[208,288,0,243,256,274,193,255,310,225,297,313],
[255,312,258,0,330,211,199,163,306,219,228,325],
[132,238,245,171,0,193,184,93,254,115,161,222],
[234,241,227,290,308,0,189,253,277,198,205,286],
[247,350,308,302,317,312,0,265,348,257,244,253],
[260,346,246,338,408,248,236,0,403,260,296,342],
[151,189,191,195,247,224,153,98,0,122,176,151],
[270,315,276,282,386,303,244,241,379,0,214,293],
[299,248,204,273,340,296,257,205,325,287,0,199],
[249,228,188,176,279,215,248,159,350,208,302,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 16, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,220,223,218,230,220,235,230,246,235,206,233],
[281,0,220,210,225,243,211,250,224,230,188,225],
[278,281,0,223,267,251,250,271,268,248,259,261],
[283,291,278,0,262,291,271,277,270,257,246,290],
[271,276,234,239,0,280,230,235,261,250,228,267],
[281,258,250,210,221,0,231,258,247,232,252,258],
[266,290,251,230,271,270,0,279,280,258,237,273],
[271,251,230,224,266,243,222,0,255,228,183,248],
[255,277,233,231,240,254,221,246,0,233,184,262],
[266,271,253,244,251,269,243,273,268,0,254,254],
[295,313,242,255,273,249,264,318,317,247,0,283],
[268,276,240,211,234,243,228,253,239,247,218,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 17, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,233,269,273,209,223,270,272,272,263,229,237],
[268,0,237,246,245,223,278,266,258,255,230,202],
[232,264,0,298,242,269,321,224,216,214,258,199],
[228,255,203,0,221,209,301,202,242,123,205,255],
[292,256,259,280,0,237,265,277,291,298,210,230],
[278,278,232,292,264,0,234,219,301,246,280,236],
[231,223,180,200,236,267,0,213,225,237,231,220],
[229,235,277,299,224,282,288,0,267,269,197,278],
[229,243,285,259,210,200,276,234,0,209,189,249],
[238,246,287,378,203,255,264,232,292,0,230,247],
[272,271,243,296,291,221,270,304,312,271,0,264],
[264,299,302,246,271,265,281,223,252,254,237,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 18, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,219,259,296,276,232,249,277,268,257,277,314],
[282,0,203,306,290,261,283,306,279,241,288,297],
[242,298,0,280,247,232,291,303,216,228,277,265],
[205,195,221,0,225,170,205,233,193,197,196,217],
[225,211,254,276,0,226,250,254,254,207,225,264],
[269,240,269,331,275,0,284,298,266,248,298,277],
[252,218,210,296,251,217,0,257,256,198,258,249],
[224,195,198,268,247,203,244,0,213,190,237,219],
[233,222,285,308,247,235,245,288,0,183,267,275],
[244,260,273,304,294,253,303,311,318,0,278,288],
[224,213,224,305,276,203,243,264,234,223,0,236],
[187,204,236,284,237,224,252,282,226,213,265,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 19, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,232,248,245,247,231,244,236,259,223,262,267],
[269,0,257,249,256,267,272,268,259,260,265,279],
[253,244,0,261,257,262,257,246,267,252,264,274],
[256,252,240,0,248,271,262,265,262,239,249,256],
[254,245,244,253,0,260,263,240,262,240,239,254],
[270,234,239,230,241,0,251,239,260,250,241,258],
[257,229,244,239,238,250,0,244,255,242,249,245],
[265,233,255,236,261,262,257,0,263,238,245,260],
[242,242,234,239,239,241,246,238,0,236,246,251],
[278,241,249,262,261,251,259,263,265,0,261,266],
[239,236,237,252,262,260,252,256,255,240,0,245],
[234,222,227,245,247,243,256,241,250,235,256,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 20, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,245,259,252,251,242,258,258,253,254,244,240],
[256,0,247,229,244,232,238,242,263,246,244,238],
[242,254,0,241,262,244,245,240,253,246,245,244],
[249,272,260,0,258,248,243,250,258,263,270,242],
[250,257,239,243,0,234,255,251,257,248,254,239],
[259,269,257,253,267,0,261,243,252,262,265,234],
[243,263,256,258,246,240,0,260,258,255,252,251],
[243,259,261,251,250,258,241,0,256,245,257,241],
[248,238,248,243,244,249,243,245,0,263,269,232],
[247,255,255,238,253,239,246,256,238,0,246,241],
[257,257,256,231,247,236,249,244,232,255,0,240],
[261,263,257,259,262,267,250,260,269,260,261,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 21, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,244,236,236,229,250,236,241,253,237,233,236],
[257,0,240,241,246,253,243,244,258,243,264,254],
[265,261,0,248,258,254,240,249,260,252,257,256],
[265,260,253,0,253,253,244,253,264,253,250,257],
[272,255,243,248,0,263,267,262,256,259,258,261],
[251,248,247,248,238,0,236,249,262,254,248,244],
[265,258,261,257,234,265,0,269,264,251,268,255],
[260,257,252,248,239,252,232,0,255,247,250,242],
[248,243,241,237,245,239,237,246,0,252,238,238],
[264,258,249,248,242,247,250,254,249,0,260,258],
[268,237,244,251,243,253,233,251,263,241,0,249],
[265,247,245,244,240,257,246,259,263,243,252,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 22, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,264,246,281,272,246,280,278,256,277,282,257],
[237,0,239,264,249,233,253,256,277,263,256,245],
[255,262,0,258,252,236,268,276,254,289,268,257],
[220,237,243,0,254,217,255,256,231,271,267,232],
[229,252,249,247,0,255,273,289,273,279,276,268],
[255,268,265,284,246,0,289,273,281,272,277,284],
[221,248,233,246,228,212,0,247,224,265,250,217],
[223,245,225,245,212,228,254,0,237,232,232,222],
[245,224,247,270,228,220,277,264,0,266,251,227],
[224,238,212,230,222,229,236,269,235,0,250,235],
[219,245,233,234,225,224,251,269,250,251,0,205],
[244,256,244,269,233,217,284,279,274,266,296,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 23, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,232,254,274,245,255,289,269,270,232,255,258],
[269,0,275,264,248,245,255,276,251,254,254,249],
[247,226,0,242,230,267,281,251,252,242,240,258],
[227,237,259,0,236,263,272,242,240,219,239,244],
[256,253,271,265,0,264,283,256,273,232,271,256],
[246,256,234,238,237,0,255,240,218,241,259,248],
[212,246,220,229,218,246,0,228,228,221,222,239],
[232,225,250,259,245,261,273,0,248,247,275,258],
[231,250,249,261,228,283,273,253,0,242,274,245],
[269,247,259,282,269,260,280,254,259,0,250,270],
[246,247,261,262,230,242,279,226,227,251,0,257],
[243,252,243,257,245,253,262,243,256,231,244,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 24, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,217,220,223,203,228,205,244,238,206,217,223],
[284,0,215,211,237,234,246,269,250,224,251,238],
[281,286,0,234,254,253,215,255,230,225,276,263],
[278,290,267,0,258,255,246,310,222,222,245,265],
[298,264,247,243,0,253,257,268,231,239,240,253],
[273,267,248,246,248,0,224,266,233,220,265,257],
[296,255,286,255,244,277,0,280,257,261,257,252],
[257,232,246,191,233,235,221,0,229,216,229,248],
[263,251,271,279,270,268,244,272,0,218,253,272],
[295,277,276,279,262,281,240,285,283,0,266,263],
[284,250,225,256,261,236,244,272,248,235,0,256],
[278,263,238,236,248,244,249,253,229,238,245,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 25, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,242,252,205,221,228,194,243,247,209,242,210],
[259,0,255,237,217,244,221,240,264,245,273,233],
[249,246,0,218,207,236,233,247,232,219,240,235],
[296,264,283,0,270,272,269,296,301,273,258,244],
[280,284,294,231,0,254,247,289,255,239,229,262],
[273,257,265,229,247,0,226,238,241,235,239,209],
[307,280,268,232,254,275,0,294,270,264,257,239],
[258,261,254,205,212,263,207,0,251,228,232,228],
[254,237,269,200,246,260,231,250,0,222,234,209],
[292,256,282,228,262,266,237,273,279,0,251,254],
[259,228,261,243,272,262,244,269,267,250,0,272],
[291,268,266,257,239,292,262,273,292,247,229,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 26, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,220,248,202,215,243,224,199,237,262,245,234],
[281,0,282,272,243,255,238,227,273,301,295,262],
[253,219,0,202,245,221,242,232,273,254,297,243],
[299,229,299,0,240,255,239,251,306,292,277,231],
[286,258,256,261,0,292,265,256,285,292,255,239],
[258,246,280,246,209,0,239,218,250,261,264,238],
[277,263,259,262,236,262,0,231,260,261,293,240],
[302,274,269,250,245,283,270,0,264,279,283,244],
[264,228,228,195,216,251,241,237,0,273,246,217],
[239,200,247,209,209,240,240,222,228,0,257,254],
[256,206,204,224,246,237,208,218,255,244,0,256],
[267,239,258,270,262,263,261,257,284,247,245,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 27, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,290,289,219,239,286,272,257,264,233,260,263],
[211,0,251,217,201,224,251,222,212,244,262,197],
[212,250,0,214,209,259,233,225,241,213,271,205],
[282,284,287,0,238,269,272,229,257,263,274,236],
[262,300,292,263,0,250,261,251,238,236,283,229],
[215,277,242,232,251,0,229,228,216,261,265,235],
[229,250,268,229,240,272,0,231,249,238,278,247],
[244,279,276,272,250,273,270,0,272,248,275,227],
[237,289,260,244,263,285,252,229,0,266,254,231],
[268,257,288,238,265,240,263,253,235,0,274,232],
[241,239,230,227,218,236,223,226,247,227,0,224],
[238,304,296,265,272,266,254,274,270,269,277,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 28, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,174,251,282,240,260,314,240,198,287,278,290],
[327,0,205,289,266,276,282,334,191,259,359,258],
[250,296,0,245,343,266,390,298,224,184,355,320],
[219,212,256,0,268,272,248,245,227,204,313,250],
[261,235,158,233,0,202,258,220,199,147,241,205],
[241,225,235,229,299,0,277,234,272,172,260,329],
[187,219,111,253,243,224,0,205,127,199,272,243],
[261,167,203,256,281,267,296,0,210,154,248,218],
[303,310,277,274,302,229,374,291,0,266,323,345],
[214,242,317,297,354,329,302,347,235,0,354,263],
[223,142,146,188,260,241,229,253,178,147,0,176],
[211,243,181,251,296,172,258,283,156,238,325,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 29, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,251,270,270,270,259,268,241,256,269,276,264],
[250,0,243,255,253,266,242,239,232,255,268,271],
[231,258,0,254,236,240,259,243,228,254,268,246],
[231,246,247,0,248,256,246,243,235,259,258,254],
[231,248,265,253,0,255,241,248,244,260,257,257],
[242,235,261,245,246,0,240,238,244,254,256,255],
[233,259,242,255,260,261,0,246,271,264,270,239],
[260,262,258,258,253,263,255,0,246,256,266,263],
[245,269,273,266,257,257,230,255,0,267,277,258],
[232,246,247,242,241,247,237,245,234,0,253,265],
[225,233,233,243,244,245,231,235,224,248,0,254],
[237,230,255,247,244,246,262,238,243,236,247,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 30, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,271,258,275,254,254,251,262,273,264,247,259],
[230,0,233,237,219,256,221,232,223,240,244,231],
[243,268,0,267,244,266,229,240,246,271,269,242],
[226,264,234,0,270,269,256,258,239,264,256,226],
[247,282,257,231,0,262,228,271,241,276,262,244],
[247,245,235,232,239,0,258,276,254,249,248,228],
[250,280,272,245,273,243,0,274,258,271,258,243],
[239,269,261,243,230,225,227,0,253,263,241,244],
[228,278,255,262,260,247,243,248,0,262,260,237],
[237,261,230,237,225,252,230,238,239,0,254,246],
[254,257,232,245,239,253,243,260,241,247,0,247],
[242,270,259,275,257,273,258,257,264,255,254,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 31, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,244,231,273,251,278,261,270,252,239,261,272],
[257,0,233,290,244,280,261,262,252,242,262,243],
[270,268,0,283,251,277,284,255,245,256,265,265],
[228,211,218,0,211,233,226,232,210,234,210,214],
[250,257,250,290,0,299,266,275,255,249,257,263],
[223,221,224,268,202,0,224,245,230,234,223,227],
[240,240,217,275,235,277,0,261,231,231,241,225],
[231,239,246,269,226,256,240,0,230,240,237,235],
[249,249,256,291,246,271,270,271,0,261,250,268],
[262,259,245,267,252,267,270,261,240,0,236,248],
[240,239,236,291,244,278,260,264,251,265,0,260],
[229,258,236,287,238,274,276,266,233,253,241,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 32, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,253,198,227,207,223,196,208,220,229,188,202],
[248,0,244,252,241,257,240,242,260,261,221,233],
[303,257,0,243,256,244,230,259,267,276,209,221],
[274,249,258,0,239,237,235,233,228,262,255,250],
[294,260,245,262,0,258,248,266,234,258,217,214],
[278,244,257,264,243,0,225,224,253,251,193,213],
[305,261,271,266,253,276,0,265,245,244,231,248],
[293,259,242,268,235,277,236,0,249,255,223,236],
[281,241,234,273,267,248,256,252,0,276,223,242],
[272,240,225,239,243,250,257,246,225,0,227,236],
[313,280,292,246,284,308,270,278,278,274,0,275],
[299,268,280,251,287,288,253,265,259,265,226,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 33, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,267,265,260,261,273,251,272,291,246,256,261],
[234,0,267,234,258,264,241,252,257,245,239,235],
[236,234,0,249,266,225,243,263,264,255,247,253],
[241,267,252,0,270,245,247,269,293,268,268,244],
[240,243,235,231,0,268,250,235,257,231,258,255],
[228,237,276,256,233,0,235,231,238,233,235,250],
[250,260,258,254,251,266,0,266,267,255,239,256],
[229,249,238,232,266,270,235,0,252,248,253,233],
[210,244,237,208,244,263,234,249,0,235,217,236],
[255,256,246,233,270,268,246,253,266,0,268,269],
[245,262,254,233,243,266,262,248,284,233,0,268],
[240,266,248,257,246,251,245,268,265,232,233,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 34, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,253,253,246,252,256,266,260,234,245,258,265],
[248,0,255,259,258,235,251,260,234,245,240,260],
[248,246,0,255,263,238,243,259,252,245,250,258],
[255,242,246,0,267,255,249,250,250,225,257,242],
[249,243,238,234,0,242,253,253,235,235,247,264],
[245,266,263,246,259,0,246,253,228,269,255,262],
[235,250,258,252,248,255,0,259,254,257,251,245],
[241,241,242,251,248,248,242,0,238,247,248,258],
[267,267,249,251,266,273,247,263,0,247,258,253],
[256,256,256,276,266,232,244,254,254,0,261,271],
[243,261,251,244,254,246,250,253,243,240,0,255],
[236,241,243,259,237,239,256,243,248,230,246,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 35, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,246,247,240,236,256,237,246,260,279,261,238],
[255,0,262,266,264,252,217,267,252,272,268,246],
[254,239,0,255,261,271,254,244,255,270,292,252],
[261,235,246,0,249,244,242,239,274,262,249,242],
[265,237,240,252,0,285,226,255,277,251,259,266],
[245,249,230,257,216,0,234,230,235,225,258,239],
[264,284,247,259,275,267,0,258,271,302,297,234],
[255,234,257,262,246,271,243,0,250,291,278,270],
[241,249,246,227,224,266,230,251,0,264,273,232],
[222,229,231,239,250,276,199,210,237,0,234,216],
[240,233,209,252,242,243,204,223,228,267,0,228],
[263,255,249,259,235,262,267,231,269,285,273,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 36, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,232,241,229,264,264,220,227,265,221,261,194],
[269,0,282,268,260,275,301,230,255,269,285,240],
[260,219,0,217,270,243,245,226,254,213,240,217],
[272,233,284,0,284,268,267,274,269,254,246,224],
[237,241,231,217,0,235,238,199,229,210,259,183],
[237,226,258,233,266,0,237,240,210,247,248,228],
[281,200,256,234,263,264,0,189,267,257,261,210],
[274,271,275,227,302,261,312,0,271,257,300,294],
[236,246,247,232,272,291,234,230,0,268,252,232],
[280,232,288,247,291,254,244,244,233,0,272,238],
[240,216,261,255,242,253,240,201,249,229,0,216],
[307,261,284,277,318,273,291,207,269,263,285,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 37, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,236,246,263,236,248,240,257,260,244,234,273],
[265,0,246,263,264,264,256,263,264,255,243,289],
[255,255,0,268,245,250,248,242,250,251,242,264],
[238,238,233,0,252,260,243,243,251,234,234,270],
[265,237,256,249,0,253,247,242,252,238,256,266],
[253,237,251,241,248,0,240,257,229,250,247,258],
[261,245,253,258,254,261,0,261,263,257,249,269],
[244,238,259,258,259,244,240,0,263,251,242,274],
[241,237,251,250,249,272,238,238,0,240,245,255],
[257,246,250,267,263,251,244,250,261,0,255,276],
[267,258,259,267,245,254,252,259,256,246,0,286],
[228,212,237,231,235,243,232,227,246,225,215,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 38, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,260,239,247,245,236,253,247,243,237,260,265],
[241,0,229,231,237,249,259,229,238,244,266,267],
[262,272,0,261,232,241,263,264,251,262,262,263],
[254,270,240,0,258,256,268,277,246,262,278,272],
[256,264,269,243,0,252,261,265,255,272,260,267],
[265,252,260,245,249,0,271,267,251,251,263,281],
[248,242,238,233,240,230,0,229,250,254,242,257],
[254,272,237,224,236,234,272,0,233,251,263,251],
[258,263,250,255,246,250,251,268,0,250,275,264],
[264,257,239,239,229,250,247,250,251,0,270,272],
[241,235,239,223,241,238,259,238,226,231,0,258],
[236,234,238,229,234,220,244,250,237,229,243,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 39, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,230,218,231,225,259,233,245,287,232,267,218],
[271,0,247,274,262,314,275,260,274,217,295,236],
[283,254,0,284,225,310,257,250,292,252,286,215],
[270,227,217,0,210,250,225,227,243,251,278,196],
[276,239,276,291,0,304,255,254,280,261,306,209],
[242,187,191,251,197,0,196,231,258,206,218,184],
[268,226,244,276,246,305,0,236,277,247,275,232],
[256,241,251,274,247,270,265,0,290,210,278,242],
[214,227,209,258,221,243,224,211,0,196,255,236],
[269,284,249,250,240,295,254,291,305,0,288,252],
[234,206,215,223,195,283,226,223,246,213,0,224],
[283,265,286,305,292,317,269,259,265,249,277,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 40, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,281,245,257,246,267,251,279,242,251,257,246],
[220,0,231,250,224,251,253,245,226,228,222,218],
[256,270,0,264,263,262,267,253,239,236,256,241],
[244,251,237,0,236,263,275,250,235,239,241,225],
[255,277,238,265,0,248,263,253,233,259,234,255],
[234,250,239,238,253,0,242,265,236,242,249,217],
[250,248,234,226,238,259,0,263,222,267,256,212],
[222,256,248,251,248,236,238,0,219,226,256,226],
[259,275,262,266,268,265,279,282,0,254,257,246],
[250,273,265,262,242,259,234,275,247,0,256,221],
[244,279,245,260,267,252,245,245,244,245,0,204],
[255,283,260,276,246,284,289,275,255,280,297,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 41, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,256,237,238,282,230,251,250,251,257,271,256],
[245,0,222,252,218,259,228,242,228,258,251,237],
[264,279,0,256,251,263,264,235,282,266,288,264],
[263,249,245,0,256,249,248,255,262,251,283,248],
[219,283,250,245,0,251,227,217,255,248,260,243],
[271,242,238,252,250,0,227,241,264,245,262,235],
[250,273,237,253,274,274,0,267,258,260,286,276],
[251,259,266,246,284,260,234,0,276,256,283,279],
[250,273,219,239,246,237,243,225,0,236,255,237],
[244,243,235,250,253,256,241,245,265,0,270,244],
[230,250,213,218,241,239,215,218,246,231,0,263],
[245,264,237,253,258,266,225,222,264,257,238,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 42, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,270,261,288,269,268,260,271,254,227,254,253],
[231,0,243,265,259,269,260,253,228,262,240,248],
[240,258,0,270,272,278,262,286,238,266,256,242],
[213,236,231,0,243,261,240,233,251,234,236,226],
[232,242,229,258,0,267,249,238,228,242,232,216],
[233,232,223,240,234,0,221,246,206,245,209,211],
[241,241,239,261,252,280,0,255,211,261,230,239],
[230,248,215,268,263,255,246,0,227,245,239,229],
[247,273,263,250,273,295,290,274,0,264,274,248],
[274,239,235,267,259,256,240,256,237,0,238,263],
[247,261,245,265,269,292,271,262,227,263,0,249],
[248,253,259,275,285,290,262,272,253,238,252,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 43, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,254,260,268,244,245,254,263,236,251,260,234],
[247,0,267,263,247,242,236,249,229,241,242,233],
[241,234,0,244,228,238,221,251,229,231,245,231],
[233,238,257,0,233,251,241,251,239,238,249,234],
[257,254,273,268,0,256,252,263,238,255,260,247],
[256,259,263,250,245,0,238,257,236,250,261,240],
[247,265,280,260,249,263,0,273,251,257,265,253],
[238,252,250,250,238,244,228,0,229,243,232,234],
[265,272,272,262,263,265,250,272,0,261,258,256],
[250,260,270,263,246,251,244,258,240,0,260,245],
[241,259,256,252,241,240,236,269,243,241,0,230],
[267,268,270,267,254,261,248,267,245,256,271,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 44, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,240,303,317,307,277,245,262,338,218,306,247],
[261,0,278,266,314,310,219,261,275,219,272,258],
[198,223,0,279,237,237,192,243,234,213,275,213],
[184,235,222,0,236,269,197,201,245,206,228,222],
[194,187,264,265,0,306,261,237,328,257,299,260],
[224,191,264,232,195,0,179,174,252,210,225,228],
[256,282,309,304,240,322,0,279,315,262,364,261],
[239,240,258,300,264,327,222,0,285,254,262,246],
[163,226,267,256,173,249,186,216,0,267,280,173],
[283,282,288,295,244,291,239,247,234,0,291,223],
[195,229,226,273,202,276,137,239,221,210,0,225],
[254,243,288,279,241,273,240,255,328,278,276,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 45, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,340,276,362,225,300,264,225,310,236,288,255],
[161,0,192,253,182,220,201,200,242,185,260,246],
[225,309,0,270,237,286,282,268,255,290,268,272],
[139,248,231,0,177,216,181,202,185,192,193,226],
[276,319,264,324,0,290,263,238,323,295,246,263],
[201,281,215,285,211,0,248,221,254,210,227,256],
[237,300,219,320,238,253,0,222,275,227,288,234],
[276,301,233,299,263,280,279,0,314,313,339,302],
[191,259,246,316,178,247,226,187,0,214,210,220],
[265,316,211,309,206,291,274,188,287,0,247,256],
[213,241,233,308,255,274,213,162,291,254,0,257],
[246,255,229,275,238,245,267,199,281,245,244,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 46, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,226,242,217,271,227,267,225,243,277,213,267],
[275,0,251,241,270,238,246,203,242,298,229,247],
[259,250,0,225,238,231,222,196,214,244,242,242],
[284,260,276,0,261,276,225,253,242,273,254,254],
[230,231,263,240,0,272,221,228,208,259,253,214],
[274,263,270,225,229,0,197,265,250,296,261,267],
[234,255,279,276,280,304,0,269,267,277,259,261],
[276,298,305,248,273,236,232,0,210,276,256,215],
[258,259,287,259,293,251,234,291,0,287,219,225],
[224,203,257,228,242,205,224,225,214,0,210,197],
[288,272,259,247,248,240,242,245,282,291,0,252],
[234,254,259,247,287,234,240,286,276,304,249,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 47, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,248,250,222,236,236,247,244,245,240,236,246],
[253,0,224,226,253,243,255,243,235,255,258,237],
[251,277,0,247,261,267,255,256,250,254,269,232],
[279,275,254,0,257,258,302,249,270,264,266,249],
[265,248,240,244,0,238,257,232,257,261,237,223],
[265,258,234,243,263,0,277,274,270,277,295,252],
[254,246,246,199,244,224,0,231,266,241,235,224],
[257,258,245,252,269,227,270,0,237,267,243,245],
[256,266,251,231,244,231,235,264,0,228,238,231],
[261,246,247,237,240,224,260,234,273,0,255,230],
[265,243,232,235,264,206,266,258,263,246,0,219],
[255,264,269,252,278,249,277,256,270,271,282,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 48, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,244,259,255,264,255,255,261,258,257,254,254],
[257,0,242,256,274,252,257,256,271,253,227,240],
[242,259,0,244,261,252,248,252,258,235,238,238],
[246,245,257,0,259,250,250,258,273,235,253,249],
[237,227,240,242,0,248,237,258,252,227,235,244],
[246,249,249,251,253,0,274,269,271,256,228,250],
[246,244,253,251,264,227,0,257,262,240,234,250],
[240,245,249,243,243,232,244,0,265,247,231,237],
[243,230,243,228,249,230,239,236,0,255,236,234],
[244,248,266,266,274,245,261,254,246,0,239,248],
[247,274,263,248,266,273,267,270,265,262,0,248],
[247,261,263,252,257,251,251,264,267,253,253,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 49, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,260,258,254,251,226,241,267,242,260,263,284],
[241,0,210,262,239,234,231,253,217,277,247,259],
[243,291,0,275,242,213,230,251,224,261,264,239],
[247,239,226,0,217,240,205,255,236,223,249,270],
[250,262,259,284,0,227,259,255,242,277,260,284],
[275,267,288,261,274,0,240,297,234,297,294,292],
[260,270,271,296,242,261,0,277,254,290,295,272],
[234,248,250,246,246,204,224,0,220,265,240,262],
[259,284,277,265,259,267,247,281,0,281,257,297],
[241,224,240,278,224,204,211,236,220,0,268,274],
[238,254,237,252,241,207,206,261,244,233,0,286],
[217,242,262,231,217,209,229,239,204,227,215,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 50, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,265,237,246,255,270,248,261,263,257,252,267],
[236,0,241,242,244,240,238,247,254,243,251,253],
[264,260,0,253,252,260,242,262,261,272,264,266],
[255,259,248,0,264,247,248,255,257,261,258,261],
[246,257,249,237,0,256,253,265,268,248,261,271],
[231,261,241,254,245,0,249,260,244,253,259,266],
[253,263,259,253,248,252,0,264,264,251,264,268],
[240,254,239,246,236,241,237,0,242,241,268,258],
[238,247,240,244,233,257,237,259,0,243,255,261],
[244,258,229,240,253,248,250,260,258,0,265,279],
[249,250,237,243,240,242,237,233,246,236,0,264],
[234,248,235,240,230,235,233,243,240,222,237,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 51, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,265,242,272,248,240,208,244,250,249,251,215],
[236,0,250,229,229,255,236,235,268,267,244,231],
[259,251,0,239,208,213,226,251,239,248,226,217],
[229,272,262,0,236,250,238,238,270,253,239,230],
[253,272,293,265,0,261,261,266,244,295,272,259],
[261,246,288,251,240,0,262,234,235,276,267,229],
[293,265,275,263,240,239,0,227,245,305,263,224],
[257,266,250,263,235,267,274,0,267,296,280,234],
[251,233,262,231,257,266,256,234,0,278,293,224],
[252,234,253,248,206,225,196,205,223,0,240,223],
[250,257,275,262,229,234,238,221,208,261,0,212],
[286,270,284,271,242,272,277,267,277,278,289,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 52, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,254,238,260,247,224,244,269,221,239,228,251],
[247,0,237,252,234,230,228,227,213,254,211,261],
[263,264,0,243,249,251,254,269,242,253,247,247],
[241,249,258,0,252,239,259,254,226,258,227,259],
[254,267,252,249,0,249,257,261,228,262,240,253],
[277,271,250,262,252,0,280,253,230,262,231,267],
[257,273,247,242,244,221,0,256,234,261,244,263],
[232,274,232,247,240,248,245,0,252,280,230,275],
[280,288,259,275,273,271,267,249,0,272,254,255],
[262,247,248,243,239,239,240,221,229,0,218,256],
[273,290,254,274,261,270,257,271,247,283,0,283],
[250,240,254,242,248,234,238,226,246,245,218,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 53, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,225,254,236,250,241,237,259,257,227,270,245],
[276,0,269,256,282,255,250,257,257,250,269,258],
[247,232,0,242,272,229,240,262,236,238,260,249],
[265,245,259,0,274,244,250,278,258,255,266,275],
[251,219,229,227,0,230,239,248,239,240,288,245],
[260,246,272,257,271,0,265,273,248,257,285,252],
[264,251,261,251,262,236,0,257,264,220,281,247],
[242,244,239,223,253,228,244,0,234,220,275,222],
[244,244,265,243,262,253,237,267,0,227,268,244],
[274,251,263,246,261,244,281,281,274,0,289,261],
[231,232,241,235,213,216,220,226,233,212,0,252],
[256,243,252,226,256,249,254,279,257,240,249,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 54, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,251,243,263,258,250,252,241,236,240,263,261],
[250,0,245,265,258,248,253,248,243,247,266,258],
[258,256,0,275,276,245,265,255,257,247,270,261],
[238,236,226,0,247,247,259,247,235,243,248,247],
[243,243,225,254,0,249,256,244,229,245,254,265],
[251,253,256,254,252,0,257,253,244,236,243,263],
[249,248,236,242,245,244,0,233,242,243,251,250],
[260,253,246,254,257,248,268,0,249,241,241,246],
[265,258,244,266,272,257,259,252,0,266,261,258],
[261,254,254,258,256,265,258,260,235,0,253,256],
[238,235,231,253,247,258,250,260,240,248,0,263],
[240,243,240,254,236,238,251,255,243,245,238,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 55, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,253,245,266,254,258,244,265,239,253,254,297],
[248,0,245,269,248,259,249,233,245,235,231,269],
[256,256,0,277,271,278,259,227,249,244,246,268],
[235,232,224,0,251,233,245,228,230,255,226,266],
[247,253,230,250,0,254,246,253,257,227,237,276],
[243,242,223,268,247,0,247,229,240,253,223,259],
[257,252,242,256,255,254,0,236,237,243,250,283],
[236,268,274,273,248,272,265,0,240,264,246,280],
[262,256,252,271,244,261,264,261,0,240,263,273],
[248,266,257,246,274,248,258,237,261,0,235,283],
[247,270,255,275,264,278,251,255,238,266,0,288],
[204,232,233,235,225,242,218,221,228,218,213,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 56, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,237,241,236,264,274,255,250,273,250,252,272],
[264,0,249,254,258,272,258,250,291,276,240,288],
[260,252,0,246,249,253,239,243,261,277,247,276],
[265,247,255,0,240,248,261,227,283,271,252,242],
[237,243,252,261,0,248,238,238,248,261,236,256],
[227,229,248,253,253,0,231,219,261,252,223,245],
[246,243,262,240,263,270,0,260,264,253,253,263],
[251,251,258,274,263,282,241,0,281,271,249,268],
[228,210,240,218,253,240,237,220,0,256,201,232],
[251,225,224,230,240,249,248,230,245,0,232,254],
[249,261,254,249,265,278,248,252,300,269,0,270],
[229,213,225,259,245,256,238,233,269,247,231,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 57, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,240,252,264,229,249,256,263,239,251,237,242],
[261,0,251,257,243,251,250,237,257,252,253,248],
[249,250,0,238,238,246,269,243,252,262,246,243],
[237,244,263,0,236,236,252,236,244,260,243,235],
[272,258,263,265,0,267,255,254,251,253,249,253],
[252,250,255,265,234,0,263,259,254,254,254,226],
[245,251,232,249,246,238,0,245,249,247,251,235],
[238,264,258,265,247,242,256,0,269,261,250,251],
[262,244,249,257,250,247,252,232,0,243,244,229],
[250,249,239,241,248,247,254,240,258,0,244,225],
[264,248,255,258,252,247,250,251,257,257,0,247],
[259,253,258,266,248,275,266,250,272,276,254,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 58, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,253,244,249,250,248,244,232,235,258,247,248],
[248,0,245,230,240,236,254,246,229,260,250,247],
[257,256,0,243,258,240,253,237,250,253,237,253],
[252,271,258,0,260,255,250,240,259,258,246,250],
[251,261,243,241,0,244,249,233,235,242,250,242],
[253,265,261,246,257,0,262,247,247,260,266,235],
[257,247,248,251,252,239,0,231,243,248,252,266],
[269,255,264,261,268,254,270,0,246,271,263,263],
[266,272,251,242,266,254,258,255,0,276,256,257],
[243,241,248,243,259,241,253,230,225,0,237,253],
[254,251,264,255,251,235,249,238,245,264,0,250],
[253,254,248,251,259,266,235,238,244,248,251,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 59, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,235,218,239,242,227,245,261,249,263,236,225],
[266,0,222,286,275,274,253,274,270,263,282,257],
[283,279,0,270,257,259,270,275,281,266,271,250],
[262,215,231,0,243,274,244,270,281,271,237,245],
[259,226,244,258,0,258,275,273,276,272,262,250],
[274,227,242,227,243,0,291,251,263,273,259,267],
[256,248,231,257,226,210,0,247,245,245,248,226],
[240,227,226,231,228,250,254,0,240,247,262,210],
[252,231,220,220,225,238,256,261,0,251,251,220],
[238,238,235,230,229,228,256,254,250,0,264,248],
[265,219,230,264,239,242,253,239,250,237,0,248],
[276,244,251,256,251,234,275,291,281,253,253,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 60, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,246,240,274,267,244,258,250,258,251,264,234],
[255,0,248,254,244,250,242,250,255,253,250,261],
[261,253,0,267,244,242,257,238,241,242,224,220],
[227,247,234,0,245,224,248,213,225,247,224,235],
[234,257,257,256,0,249,263,244,261,241,253,243],
[257,251,259,277,252,0,242,218,235,258,264,228],
[243,259,244,253,238,259,0,230,253,248,230,229],
[251,251,263,288,257,283,271,0,265,257,245,239],
[243,246,260,276,240,266,248,236,0,263,242,254],
[250,248,259,254,260,243,253,244,238,0,248,242],
[237,251,277,277,248,237,271,256,259,253,0,244],
[267,240,281,266,258,273,272,262,247,259,257,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 61, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,249,259,256,247,253,262,249,266,248,267,242],
[252,0,241,246,248,232,253,259,245,237,258,241],
[242,260,0,242,245,232,252,253,255,242,259,250],
[245,255,259,0,252,253,248,240,252,246,249,238],
[254,253,256,249,0,249,247,259,262,245,255,242],
[248,269,269,248,252,0,275,273,262,250,271,240],
[239,248,249,253,254,226,0,251,248,245,254,233],
[252,242,248,261,242,228,250,0,237,259,237,254],
[235,256,246,249,239,239,253,264,0,235,247,237],
[253,264,259,255,256,251,256,242,266,0,251,243],
[234,243,242,252,246,230,247,264,254,250,0,238],
[259,260,251,263,259,261,268,247,264,258,263,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 62, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,259,247,262,253,242,219,241,266,252,259,263],
[242,0,241,250,245,246,246,242,249,254,248,232],
[254,260,0,245,266,252,271,253,259,245,274,260],
[239,251,256,0,216,241,237,225,240,237,239,235],
[248,256,235,285,0,253,244,236,250,243,266,250],
[259,255,249,260,248,0,249,227,254,262,252,249],
[282,255,230,264,257,252,0,265,272,268,270,264],
[260,259,248,276,265,274,236,0,265,253,245,247],
[235,252,242,261,251,247,229,236,0,251,238,243],
[249,247,256,264,258,239,233,248,250,0,255,254],
[242,253,227,262,235,249,231,256,263,246,0,243],
[238,269,241,266,251,252,237,254,258,247,258,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 63, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,268,311,301,240,262,298,258,227,299,260,275],
[233,0,299,264,247,277,241,256,238,292,253,287],
[190,202,0,277,234,234,259,224,205,234,201,276],
[200,237,224,0,198,214,252,229,224,231,229,224],
[261,254,267,303,0,278,267,235,258,263,211,269],
[239,224,267,287,223,0,279,221,210,251,241,269],
[203,260,242,249,234,222,0,250,216,226,266,253],
[243,245,277,272,266,280,251,0,262,285,244,272],
[274,263,296,277,243,291,285,239,0,253,261,293],
[202,209,267,270,238,250,275,216,248,0,221,259],
[241,248,300,272,290,260,235,257,240,280,0,268],
[226,214,225,277,232,232,248,229,208,242,233,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 64, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,267,240,243,246,260,256,246,245,269,268,244],
[234,0,248,249,248,271,245,241,248,262,242,244],
[261,253,0,253,262,247,226,252,259,258,253,239],
[258,252,248,0,234,262,239,244,239,281,240,258],
[255,253,239,267,0,261,250,247,228,272,251,239],
[241,230,254,239,240,0,237,221,231,258,237,245],
[245,256,275,262,251,264,0,234,249,268,269,257],
[255,260,249,257,254,280,267,0,255,258,253,264],
[256,253,242,262,273,270,252,246,0,263,263,260],
[232,239,243,220,229,243,233,243,238,0,263,240],
[233,259,248,261,250,264,232,248,238,238,0,251],
[257,257,262,243,262,256,244,237,241,261,250,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 65, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,241,243,242,256,246,238,246,249,249,244,242],
[260,0,234,239,237,266,223,238,255,249,244,244],
[258,267,0,249,253,272,274,249,234,259,258,262],
[259,262,252,0,257,283,247,254,256,264,251,274],
[245,264,248,244,0,262,257,236,258,249,256,237],
[255,235,229,218,239,0,227,227,235,239,228,243],
[263,278,227,254,244,274,0,239,253,274,258,256],
[255,263,252,247,265,274,262,0,247,270,256,242],
[252,246,267,245,243,266,248,254,0,267,244,245],
[252,252,242,237,252,262,227,231,234,0,264,255],
[257,257,243,250,245,273,243,245,257,237,0,268],
[259,257,239,227,264,258,245,259,256,246,233,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 66, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,231,234,235,216,198,245,216,252,267,253,229],
[270,0,265,254,247,236,273,242,262,259,280,257],
[267,236,0,228,267,270,275,285,241,229,280,250],
[266,247,273,0,248,248,241,235,265,267,262,284],
[285,254,234,253,0,251,249,239,239,266,260,241],
[303,265,231,253,250,0,263,250,266,269,291,247],
[256,228,226,260,252,238,0,244,236,256,289,240],
[285,259,216,266,262,251,257,0,267,274,271,233],
[249,239,260,236,262,235,265,234,0,248,254,244],
[234,242,272,234,235,232,245,227,253,0,252,224],
[248,221,221,239,241,210,212,230,247,249,0,228],
[272,244,251,217,260,254,261,268,257,277,273,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 67, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,287,286,342,281,245,232,294,340,267,321,226],
[214,0,271,267,269,201,212,261,234,196,228,164],
[215,230,0,264,214,248,208,260,207,198,194,135],
[159,234,237,0,236,180,206,238,307,241,238,187],
[220,232,287,265,0,262,253,254,251,231,308,263],
[256,300,253,321,239,0,231,249,239,267,296,244],
[269,289,293,295,248,270,0,234,298,187,268,249],
[207,240,241,263,247,252,267,0,190,208,211,178],
[161,267,294,194,250,262,203,311,0,241,290,231],
[234,305,303,260,270,234,314,293,260,0,278,191],
[180,273,307,263,193,205,233,290,211,223,0,216],
[275,337,366,314,238,257,252,323,270,310,285,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 68, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,255,247,272,244,257,256,246,260,278,247,253],
[246,0,266,263,241,253,244,243,261,283,239,239],
[254,235,0,267,248,247,265,244,248,287,230,243],
[229,238,234,0,229,226,245,215,239,279,219,225],
[257,260,253,272,0,244,263,243,263,295,254,258],
[244,248,254,275,257,0,270,254,266,283,228,264],
[245,257,236,256,238,231,0,243,263,272,233,229],
[255,258,257,286,258,247,258,0,279,290,259,260],
[241,240,253,262,238,235,238,222,0,255,219,230],
[223,218,214,222,206,218,229,211,246,0,222,237],
[254,262,271,282,247,273,268,242,282,279,0,258],
[248,262,258,276,243,237,272,241,271,264,243,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 69, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,219,318,222,290,252,305,219,344,304,261,346],
[282,0,384,198,313,249,290,299,366,295,320,308],
[183,117,0,220,205,167,149,154,256,192,229,201],
[279,303,281,0,344,217,280,304,299,250,282,347],
[211,188,296,157,0,252,215,223,309,234,237,284],
[249,252,334,284,249,0,245,207,324,221,241,278],
[196,211,352,221,286,256,0,286,310,209,247,271],
[282,202,347,197,278,294,215,0,368,310,279,285],
[157,135,245,202,192,177,191,133,0,221,145,256],
[197,206,309,251,267,280,292,191,280,0,234,321],
[240,181,272,219,264,260,254,222,356,267,0,293],
[155,193,300,154,217,223,230,216,245,180,208,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 70, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,245,224,243,207,324,286,257,247,318,233,239],
[256,0,250,205,240,363,275,289,303,358,285,266],
[277,251,0,191,286,301,238,255,258,325,275,281],
[258,296,310,0,295,322,318,249,270,376,311,282],
[294,261,215,206,0,271,285,227,273,351,283,250],
[177,138,200,179,230,0,227,174,218,260,188,219],
[215,226,263,183,216,274,0,172,208,277,204,218],
[244,212,246,252,274,327,329,0,271,283,272,269],
[254,198,243,231,228,283,293,230,0,297,273,216],
[183,143,176,125,150,241,224,218,204,0,194,152],
[268,216,226,190,218,313,297,229,228,307,0,272],
[262,235,220,219,251,282,283,232,285,349,229,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 71, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,246,243,206,277,216,252,242,233,256,247,227],
[255,0,240,258,298,255,262,267,267,293,240,219],
[258,261,0,238,320,279,282,266,266,275,240,262],
[295,243,263,0,282,246,273,319,250,257,251,266],
[224,203,181,219,0,207,226,236,235,234,215,231],
[285,246,222,255,294,0,267,257,249,295,249,257],
[249,239,219,228,275,234,0,251,247,271,240,215],
[259,234,235,182,265,244,250,0,259,243,263,232],
[268,234,235,251,266,252,254,242,0,266,235,237],
[245,208,226,244,267,206,230,258,235,0,234,218],
[254,261,261,250,286,252,261,238,266,267,0,241],
[274,282,239,235,270,244,286,269,264,283,260,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 72, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,262,259,245,221,264,223,242,260,244,240,245],
[239,0,260,273,261,272,233,230,239,233,270,253],
[242,241,0,236,254,267,222,235,254,245,254,249],
[256,228,265,0,248,258,219,236,263,248,251,249],
[280,240,247,253,0,278,229,254,262,238,261,247],
[237,229,234,243,223,0,224,230,252,220,248,230],
[278,268,279,282,272,277,0,239,263,257,284,263],
[259,271,266,265,247,271,262,0,268,246,268,258],
[241,262,247,238,239,249,238,233,0,257,262,282],
[257,268,256,253,263,281,244,255,244,0,263,261],
[261,231,247,250,240,253,217,233,239,238,0,243],
[256,248,252,252,254,271,238,243,219,240,258,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 73, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,285,277,247,266,257,250,256,262,259,268,282],
[216,0,243,219,200,220,217,235,231,232,231,233],
[224,258,0,222,224,238,202,247,233,231,246,245],
[254,282,279,0,237,253,238,267,263,249,258,260],
[235,301,277,264,0,255,255,272,276,252,262,260],
[244,281,263,248,246,0,253,258,256,233,269,248],
[251,284,299,263,246,248,0,284,251,259,277,266],
[245,266,254,234,229,243,217,0,244,239,243,235],
[239,270,268,238,225,245,250,257,0,239,250,258],
[242,269,270,252,249,268,242,262,262,0,240,262],
[233,270,255,243,239,232,224,258,251,261,0,252],
[219,268,256,241,241,253,235,266,243,239,249,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 74, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,244,238,263,263,267,222,240,246,233,260,248],
[257,0,248,273,252,271,242,275,247,230,262,245],
[263,253,0,258,251,260,232,259,259,236,234,245],
[238,228,243,0,247,242,239,252,255,223,235,237],
[238,249,250,254,0,261,245,243,256,238,245,244],
[234,230,241,259,240,0,219,247,262,224,241,235],
[279,259,269,262,256,282,0,272,274,258,264,245],
[261,226,242,249,258,254,229,0,265,244,245,234],
[255,254,242,246,245,239,227,236,0,216,239,223],
[268,271,265,278,263,277,243,257,285,0,267,251],
[241,239,267,266,256,260,237,256,262,234,0,245],
[253,256,256,264,257,266,256,267,278,250,256,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 75, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,270,246,256,245,260,234,254,256,263,225,260],
[231,0,253,243,231,253,239,254,261,246,243,226],
[255,248,0,256,230,274,247,247,270,240,248,256],
[245,258,245,0,233,257,250,241,264,263,232,280],
[256,270,271,268,0,272,275,250,285,256,248,277],
[241,248,227,244,229,0,229,234,248,243,223,230],
[267,262,254,251,226,272,0,238,264,278,241,255],
[247,247,254,260,251,267,263,0,253,274,259,242],
[245,240,231,237,216,253,237,248,0,258,230,229],
[238,255,261,238,245,258,223,227,243,0,216,256],
[276,258,253,269,253,278,260,242,271,285,0,255],
[241,275,245,221,224,271,246,259,272,245,246,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 76, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,187,205,265,221,301,211,170,215,193,230,243],
[314,0,294,313,250,316,263,207,294,270,271,237],
[296,207,0,272,223,277,232,248,299,205,244,239],
[236,188,229,0,266,240,183,169,259,210,245,217],
[280,251,278,235,0,265,196,250,298,267,277,235],
[200,185,224,261,236,0,208,223,231,254,248,224],
[290,238,269,318,305,293,0,307,291,303,319,321],
[331,294,253,332,251,278,194,0,302,282,245,214],
[286,207,202,242,203,270,210,199,0,256,241,195],
[308,231,296,291,234,247,198,219,245,0,238,240],
[271,230,257,256,224,253,182,256,260,263,0,255],
[258,264,262,284,266,277,180,287,306,261,246,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 77, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,254,275,290,281,257,287,256,275,277,286,242],
[247,0,278,270,262,220,276,248,265,267,253,268],
[226,223,0,257,256,232,254,221,231,250,254,237],
[211,231,244,0,229,231,224,240,239,255,240,247],
[220,239,245,272,0,228,261,236,246,266,261,242],
[244,281,269,270,273,0,277,246,262,286,262,270],
[214,225,247,277,240,224,0,245,239,244,232,240],
[245,253,280,261,265,255,256,0,261,260,262,248],
[226,236,270,262,255,239,262,240,0,261,267,244],
[224,234,251,246,235,215,257,241,240,0,241,247],
[215,248,247,261,240,239,269,239,234,260,0,237],
[259,233,264,254,259,231,261,253,257,254,264,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 78, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,254,229,258,252,240,259,246,260,263,269,246],
[247,0,252,263,261,256,267,256,258,274,249,253],
[272,249,0,266,263,245,273,262,267,260,267,254],
[243,238,235,0,273,236,270,247,234,269,250,236],
[249,240,238,228,0,245,264,242,241,264,239,219],
[261,245,256,265,256,0,273,264,279,268,265,245],
[242,234,228,231,237,228,0,235,245,260,234,221],
[255,245,239,254,259,237,266,0,252,267,255,239],
[241,243,234,267,260,222,256,249,0,266,261,239],
[238,227,241,232,237,233,241,234,235,0,233,234],
[232,252,234,251,262,236,267,246,240,268,0,225],
[255,248,247,265,282,256,280,262,262,267,276,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 79, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,264,269,241,252,268,275,245,253,249,252,281],
[237,0,247,262,255,264,270,239,249,257,249,265],
[232,254,0,236,224,226,253,223,232,247,247,252],
[260,239,265,0,259,264,271,258,268,262,255,277],
[249,246,277,242,0,250,262,248,249,242,252,262],
[233,237,275,237,251,0,254,244,222,240,245,264],
[226,231,248,230,239,247,0,236,238,258,235,250],
[256,262,278,243,253,257,265,0,257,260,270,284],
[248,252,269,233,252,279,263,244,0,258,264,262],
[252,244,254,239,259,261,243,241,243,0,252,274],
[249,252,254,246,249,256,266,231,237,249,0,272],
[220,236,249,224,239,237,251,217,239,227,229,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 80, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,258,253,245,271,210,236,222,209,205,233,232],
[243,0,292,351,313,285,218,311,259,262,270,279],
[248,209,0,235,209,190,206,218,185,172,189,179],
[256,150,266,0,274,229,215,209,206,172,272,213],
[230,188,292,227,0,265,224,171,182,168,261,238],
[291,216,311,272,236,0,268,221,245,211,274,216],
[265,283,295,286,277,233,0,244,243,258,268,283],
[279,190,283,292,330,280,257,0,208,230,268,264],
[292,242,316,295,319,256,258,293,0,280,254,272],
[296,239,329,329,333,290,243,271,221,0,293,264],
[268,231,312,229,240,227,233,233,247,208,0,284],
[269,222,322,288,263,285,218,237,229,237,217,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 81, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,269,243,258,277,260,260,249,271,250,255,254],
[232,0,243,224,229,256,241,240,272,232,235,251],
[258,258,0,243,236,263,252,248,240,238,236,282],
[243,277,258,0,238,273,250,242,261,260,260,269],
[224,272,265,263,0,269,271,251,276,238,256,257],
[241,245,238,228,232,0,244,221,218,229,233,253],
[241,260,249,251,230,257,0,224,261,239,259,260],
[252,261,253,259,250,280,277,0,273,269,246,269],
[230,229,261,240,225,283,240,228,0,244,260,251],
[251,269,263,241,263,272,262,232,257,0,242,265],
[246,266,265,241,245,268,242,255,241,259,0,262],
[247,250,219,232,244,248,241,232,250,236,239,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 82, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,254,252,248,245,253,239,253,245,246,253,252],
[247,0,245,237,240,243,243,260,239,250,241,236],
[249,256,0,253,240,248,250,259,236,255,227,237],
[253,264,248,0,268,259,264,262,243,247,251,248],
[256,261,261,233,0,259,244,253,261,255,234,246],
[248,258,253,242,242,0,240,259,243,259,233,239],
[262,258,251,237,257,261,0,252,244,270,255,250],
[248,241,242,239,248,242,249,0,232,264,231,248],
[256,262,265,258,240,258,257,269,0,255,256,235],
[255,251,246,254,246,242,231,237,246,0,241,246],
[248,260,274,250,267,268,246,270,245,260,0,249],
[249,265,264,253,255,262,251,253,266,255,252,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 83, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,254,273,257,255,248,250,251,254,266,261,256],
[247,0,270,254,245,273,265,255,253,254,262,251],
[228,231,0,223,227,236,253,224,227,234,237,195],
[244,247,278,0,233,265,246,250,264,246,227,233],
[246,256,274,268,0,266,248,266,263,257,266,263],
[253,228,265,236,235,0,254,246,278,242,222,250],
[251,236,248,255,253,247,0,253,268,246,257,239],
[250,246,277,251,235,255,248,0,273,257,265,246],
[247,248,274,237,238,223,233,228,0,261,232,210],
[235,247,267,255,244,259,255,244,240,0,232,210],
[240,239,264,274,235,279,244,236,269,269,0,230],
[245,250,306,268,238,251,262,255,291,291,271,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 84, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,147,226,263,272,250,243,259,236,224,252,175],
[354,0,206,276,302,275,282,232,254,233,304,261],
[275,295,0,289,294,290,250,242,263,240,287,251],
[238,225,212,0,254,266,240,218,275,219,247,185],
[229,199,207,247,0,199,226,178,238,201,266,254],
[251,226,211,235,302,0,235,225,189,229,252,238],
[258,219,251,261,275,266,0,228,264,225,301,226],
[242,269,259,283,323,276,273,0,267,292,278,287],
[265,247,238,226,263,312,237,234,0,242,335,284],
[277,268,261,282,300,272,276,209,259,0,306,267],
[249,197,214,254,235,249,200,223,166,195,0,202],
[326,240,250,316,247,263,275,214,217,234,299,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 85, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,264,283,254,253,279,257,295,242,263,236,258],
[237,0,261,253,257,274,251,260,262,264,237,245],
[218,240,0,242,259,255,227,262,258,236,241,235],
[247,248,259,0,247,269,233,284,276,278,254,236],
[248,244,242,254,0,258,245,266,254,266,227,225],
[222,227,246,232,243,0,220,278,260,245,234,228],
[244,250,274,268,256,281,0,281,255,261,240,252],
[206,241,239,217,235,223,220,0,247,242,233,214],
[259,239,243,225,247,241,246,254,0,242,239,236],
[238,237,265,223,235,256,240,259,259,0,246,243],
[265,264,260,247,274,267,261,268,262,255,0,250],
[243,256,266,265,276,273,249,287,265,258,251,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 86, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,262,260,259,258,276,266,260,268,273,250,270],
[239,0,240,241,226,264,270,248,239,257,245,260],
[241,261,0,251,238,256,259,250,250,259,251,242],
[242,260,250,0,236,259,272,256,257,267,255,253],
[243,275,263,265,0,281,275,260,271,267,277,260],
[225,237,245,242,220,0,245,236,238,245,247,247],
[235,231,242,229,226,256,0,241,235,249,259,253],
[241,253,251,245,241,265,260,0,262,253,259,247],
[233,262,251,244,230,263,266,239,0,273,259,242],
[228,244,242,234,234,256,252,248,228,0,245,251],
[251,256,250,246,224,254,242,242,242,256,0,244],
[231,241,259,248,241,254,248,254,259,250,257,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 87, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,243,257,267,242,271,253,246,277,291,273,264],
[258,0,235,246,248,265,268,282,291,297,283,259],
[244,266,0,270,256,275,264,258,304,300,307,263],
[234,255,231,0,227,272,233,239,259,285,268,251],
[259,253,245,274,0,279,264,246,268,285,271,284],
[230,236,226,229,222,0,241,240,253,280,247,239],
[248,233,237,268,237,260,0,262,285,276,259,278],
[255,219,243,262,255,261,239,0,284,278,282,251],
[224,210,197,242,233,248,216,217,0,270,263,232],
[210,204,201,216,216,221,225,223,231,0,231,218],
[228,218,194,233,230,254,242,219,238,270,0,248],
[237,242,238,250,217,262,223,250,269,283,253,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 88, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,212,245,204,237,233,198,237,232,240,154,238],
[289,0,242,287,269,255,284,318,228,240,240,254],
[256,259,0,264,253,256,262,259,261,236,210,267],
[297,214,237,0,289,254,238,228,260,266,239,261],
[264,232,248,212,0,252,229,250,251,233,251,252],
[268,246,245,247,249,0,250,264,244,244,208,275],
[303,217,239,263,272,251,0,266,258,279,214,270],
[264,183,242,273,251,237,235,0,262,231,220,239],
[269,273,240,241,250,257,243,239,0,268,221,257],
[261,261,265,235,268,257,222,270,233,0,235,285],
[347,261,291,262,250,293,287,281,280,266,0,250],
[263,247,234,240,249,226,231,262,244,216,251,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 89, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,195,253,193,167,162,211,172,254,170,212,247],
[306,0,183,264,234,180,277,213,211,154,219,248],
[248,318,0,311,186,230,241,229,218,251,249,282],
[308,237,190,0,146,217,206,185,214,189,289,216],
[334,267,315,355,0,303,283,229,271,295,309,272],
[339,321,271,284,198,0,213,264,204,232,229,290],
[290,224,260,295,218,288,0,210,245,225,240,318],
[329,288,272,316,272,237,291,0,268,321,312,303],
[247,290,283,287,230,297,256,233,0,240,217,273],
[331,347,250,312,206,269,276,180,261,0,345,268],
[289,282,252,212,192,272,261,189,284,156,0,285],
[254,253,219,285,229,211,183,198,228,233,216,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 90, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,259,260,244,253,244,247,249,259,248,267,251],
[242,0,243,264,244,228,243,241,245,247,264,251],
[241,258,0,258,252,232,242,252,255,247,279,246],
[257,237,243,0,270,256,246,256,257,250,268,253],
[248,257,249,231,0,220,245,248,261,243,258,246],
[257,273,269,245,281,0,261,255,255,257,278,268],
[254,258,259,255,256,240,0,243,267,251,277,235],
[252,260,249,245,253,246,258,0,260,248,268,259],
[242,256,246,244,240,246,234,241,0,245,297,239],
[253,254,254,251,258,244,250,253,256,0,266,271],
[234,237,222,233,243,223,224,233,204,235,0,238],
[250,250,255,248,255,233,266,242,262,230,263,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 91, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,242,264,269,275,314,279,288,255,274,252,278],
[259,0,288,296,293,315,325,315,243,302,267,292],
[237,213,0,241,232,253,302,289,200,277,214,262],
[232,205,260,0,224,241,221,248,201,225,185,256],
[226,208,269,277,0,281,304,290,219,258,211,255],
[187,186,248,260,220,0,292,233,237,270,189,242],
[222,176,199,280,197,209,0,246,256,235,179,249],
[213,186,212,253,211,268,255,0,203,234,169,245],
[246,258,301,300,282,264,245,298,0,265,291,298],
[227,199,224,276,243,231,266,267,236,0,197,239],
[249,234,287,316,290,312,322,332,210,304,0,310],
[223,209,239,245,246,259,252,256,203,262,191,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 92, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,241,212,262,245,195,185,246,214,220,231,212],
[260,0,252,233,250,260,197,233,253,268,254,229],
[289,249,0,239,278,278,211,268,281,251,258,247],
[239,268,262,0,266,266,224,272,274,250,220,219],
[256,251,223,235,0,244,222,233,239,245,251,227],
[306,241,223,235,257,0,220,250,240,249,229,244],
[316,304,290,277,279,281,0,247,297,308,283,273],
[255,268,233,229,268,251,254,0,244,278,285,252],
[287,248,220,227,262,261,204,257,0,237,256,262],
[281,233,250,251,256,252,193,223,264,0,227,249],
[270,247,243,281,250,272,218,216,245,274,0,232],
[289,272,254,282,274,257,228,249,239,252,269,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 93, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,238,247,239,260,262,253,295,254,234,245,252],
[263,0,260,242,270,249,255,283,244,234,252,251],
[254,241,0,230,243,248,265,274,254,244,239,243],
[262,259,271,0,261,261,262,267,263,238,259,253],
[241,231,258,240,0,255,239,269,241,223,245,243],
[239,252,253,240,246,0,253,274,253,245,249,244],
[248,246,236,239,262,248,0,289,258,257,246,248],
[206,218,227,234,232,227,212,0,212,196,221,206],
[247,257,247,238,260,248,243,289,0,233,245,236],
[267,267,257,263,278,256,244,305,268,0,254,260],
[256,249,262,242,256,252,255,280,256,247,0,260],
[249,250,258,248,258,257,253,295,265,241,241,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 94, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,242,240,236,254,227,249,240,242,229,235,239],
[259,0,248,258,240,237,248,249,239,230,232,262],
[261,253,0,246,253,236,234,248,247,240,241,259],
[265,243,255,0,240,226,250,253,232,235,238,237],
[247,261,248,261,0,237,262,249,261,234,234,248],
[274,264,265,275,264,0,265,261,252,240,274,255],
[252,253,267,251,239,236,0,259,253,253,248,249],
[261,252,253,248,252,240,242,0,246,236,237,250],
[259,262,254,269,240,249,248,255,0,250,260,259],
[272,271,261,266,267,261,248,265,251,0,261,255],
[266,269,260,263,267,227,253,264,241,240,0,261],
[262,239,242,264,253,246,252,251,242,246,240,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 95, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,268,258,267,261,249,259,267,248,244,263,260],
[233,0,242,257,244,229,237,244,259,237,239,249],
[243,259,0,268,257,225,272,261,277,252,258,267],
[234,244,233,0,261,228,252,251,250,219,235,255],
[240,257,244,240,0,238,248,263,245,230,235,277],
[252,272,276,273,263,0,250,249,304,243,259,281],
[242,264,229,249,253,251,0,259,254,245,250,274],
[234,257,240,250,238,252,242,0,244,236,253,250],
[253,242,224,251,256,197,247,257,0,237,245,260],
[257,264,249,282,271,258,256,265,264,0,247,255],
[238,262,243,266,266,242,251,248,256,254,0,269],
[241,252,234,246,224,220,227,251,241,246,232,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 96, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,240,221,227,190,194,241,203,225,189,186,207],
[261,0,250,222,161,229,231,234,259,247,241,230],
[280,251,0,258,235,233,223,229,266,259,215,208],
[274,279,243,0,203,235,217,224,200,223,233,197],
[311,340,266,298,0,285,284,272,259,233,262,257],
[307,272,268,266,216,0,284,280,283,225,229,224],
[260,270,278,284,217,217,0,263,265,214,245,240],
[298,267,272,277,229,221,238,0,285,227,247,229],
[276,242,235,301,242,218,236,216,0,240,196,193],
[312,254,242,278,268,276,287,274,261,0,270,216],
[315,260,286,268,239,272,256,254,305,231,0,225],
[294,271,293,304,244,277,261,272,308,285,276,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 97, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,262,252,262,259,252,266,242,267,252,251,253],
[239,0,242,253,257,240,234,253,253,252,240,245],
[249,259,0,264,251,228,245,257,250,246,241,251],
[239,248,237,0,239,227,229,250,240,230,226,238],
[242,244,250,262,0,240,240,246,258,240,240,254],
[249,261,273,274,261,0,243,243,254,242,255,259],
[235,267,256,272,261,258,0,261,255,260,263,268],
[259,248,244,251,255,258,240,0,266,237,260,238],
[234,248,251,261,243,247,246,235,0,240,245,239],
[249,249,255,271,261,259,241,264,261,0,246,258],
[250,261,260,275,261,246,238,241,256,255,0,250],
[248,256,250,263,247,242,233,263,262,243,251,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 98, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,213,234,275,214,245,228,201,209,247,234,227],
[288,0,264,304,250,272,276,245,253,282,261,256],
[267,237,0,285,229,244,258,225,250,252,234,238],
[226,197,216,0,205,239,249,219,206,228,213,236],
[287,251,272,296,0,248,263,239,243,261,253,263],
[256,229,257,262,253,0,241,252,222,238,233,245],
[273,225,243,252,238,260,0,246,208,241,251,242],
[300,256,276,282,262,249,255,0,248,273,245,283],
[292,248,251,295,258,279,293,253,0,267,289,285],
[254,219,249,273,240,263,260,228,234,0,249,260],
[267,240,267,288,248,268,250,256,212,252,0,246],
[274,245,263,265,238,256,259,218,216,241,255,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 99, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,235,238,238,262,260,259,253,259,240,261,260],
[266,0,282,242,288,261,261,295,255,260,288,260],
[263,219,0,232,252,252,249,260,242,246,251,238],
[263,259,269,0,263,245,279,261,258,286,276,269],
[239,213,249,238,0,251,255,269,237,251,255,252],
[241,240,249,256,250,0,249,275,258,265,278,247],
[242,240,252,222,246,252,0,261,255,258,267,247],
[248,206,241,240,232,226,240,0,260,236,253,231],
[242,246,259,243,264,243,246,241,0,256,245,264],
[261,241,255,215,250,236,243,265,245,0,259,256],
[240,213,250,225,246,223,234,248,256,242,0,234],
[241,241,263,232,249,254,254,270,237,245,267,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 100, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,245,278,280,240,220,244,277,270,255,277,253],
[256,0,228,277,236,281,220,267,279,284,244,242],
[223,273,0,267,209,283,249,262,286,226,263,213],
[221,224,234,0,225,221,241,249,255,242,263,189],
[261,265,292,276,0,246,248,274,273,221,270,282],
[281,220,218,280,255,0,264,269,271,260,279,226],
[257,281,252,260,253,237,0,252,294,251,239,236],
[224,234,239,252,227,232,249,0,268,238,271,205],
[231,222,215,246,228,230,207,233,0,270,245,225],
[246,217,275,259,280,241,250,263,231,0,248,235],
[224,257,238,238,231,222,262,230,256,253,0,223],
[248,259,288,312,219,275,265,296,276,266,278,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 101, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,228,229,216,237,235,225,220,240,254,210,239],
[273,0,258,264,239,241,256,263,268,245,263,277],
[272,243,0,236,229,221,210,247,233,241,195,262],
[285,237,265,0,238,235,249,263,243,268,233,270],
[264,262,272,263,0,243,245,257,262,271,240,259],
[266,260,280,266,258,0,264,258,245,303,280,287],
[276,245,291,252,256,237,0,249,268,255,251,256],
[281,238,254,238,244,243,252,0,230,268,256,255],
[261,233,268,258,239,256,233,271,0,260,253,264],
[247,256,260,233,230,198,246,233,241,0,228,248],
[291,238,306,268,261,221,250,245,248,273,0,296],
[262,224,239,231,242,214,245,246,237,253,205,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 102, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,256,251,259,247,247,252,242,249,242,254,268],
[245,0,247,254,254,242,241,221,241,248,248,253],
[250,254,0,266,269,275,256,264,254,254,261,267],
[242,247,235,0,235,249,254,232,229,243,246,258],
[254,247,232,266,0,246,255,261,239,240,244,263],
[254,259,226,252,255,0,245,245,241,245,259,258],
[249,260,245,247,246,256,0,256,256,250,248,261],
[259,280,237,269,240,256,245,0,245,255,245,259],
[252,260,247,272,262,260,245,256,0,257,267,271],
[259,253,247,258,261,256,251,246,244,0,246,254],
[247,253,240,255,257,242,253,256,234,255,0,253],
[233,248,234,243,238,243,240,242,230,247,248,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 103, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,248,259,262,243,256,261,255,273,239,272,260],
[253,0,249,257,244,250,262,247,275,262,277,268],
[242,252,0,257,242,254,264,249,265,254,259,264],
[239,244,244,0,247,252,244,244,272,255,260,252],
[258,257,259,254,0,244,253,250,261,243,259,256],
[245,251,247,249,257,0,255,253,273,255,269,256],
[240,239,237,257,248,246,0,255,263,251,272,255],
[246,254,252,257,251,248,246,0,260,250,276,256],
[228,226,236,229,240,228,238,241,0,245,250,251],
[262,239,247,246,258,246,250,251,256,0,253,244],
[229,224,242,241,242,232,229,225,251,248,0,245],
[241,233,237,249,245,245,246,245,250,257,256,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 104, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,242,254,219,236,227,247,264,230,280,239,249],
[259,0,230,259,269,283,269,278,256,278,250,254],
[247,271,0,211,259,238,260,278,220,243,248,237],
[282,242,290,0,278,253,270,276,258,291,272,285],
[265,232,242,223,0,249,247,258,200,240,231,245],
[274,218,263,248,252,0,288,285,241,287,259,270],
[254,232,241,231,254,213,0,251,214,270,223,260],
[237,223,223,225,243,216,250,0,191,250,228,231],
[271,245,281,243,301,260,287,310,0,282,266,280],
[221,223,258,210,261,214,231,251,219,0,250,262],
[262,251,253,229,270,242,278,273,235,251,0,284],
[252,247,264,216,256,231,241,270,221,239,217,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 105, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,249,247,229,260,244,242,240,246,254,244,241],
[252,0,265,259,258,251,246,232,246,262,257,258],
[254,236,0,235,252,230,227,222,235,249,234,227],
[272,242,266,0,272,264,245,234,236,258,243,256],
[241,243,249,229,0,229,224,223,219,245,223,234],
[257,250,271,237,272,0,247,243,267,240,246,246],
[259,255,274,256,277,254,0,235,257,258,270,241],
[261,269,279,267,278,258,266,0,250,280,267,257],
[255,255,266,265,282,234,244,251,0,262,259,256],
[247,239,252,243,256,261,243,221,239,0,248,243],
[257,244,267,258,278,255,231,234,242,253,0,266],
[260,243,274,245,267,255,260,244,245,258,235,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 106, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,224,216,254,240,226,245,243,227,245,235,234],
[277,0,269,268,251,264,269,267,253,258,247,249],
[285,232,0,251,247,259,274,249,254,256,247,247],
[247,233,250,0,241,252,268,242,242,255,270,237],
[261,250,254,260,0,258,274,258,254,275,250,234],
[275,237,242,249,243,0,271,264,248,256,246,249],
[256,232,227,233,227,230,0,222,213,231,231,211],
[258,234,252,259,243,237,279,0,244,279,225,258],
[274,248,247,259,247,253,288,257,0,262,253,248],
[256,243,245,246,226,245,270,222,239,0,250,235],
[266,254,254,231,251,255,270,276,248,251,0,260],
[267,252,254,264,267,252,290,243,253,266,241,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 107, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,251,226,234,242,235,249,229,243,258,242,246],
[250,0,226,261,234,254,229,258,242,234,230,278],
[275,275,0,260,242,283,251,261,247,253,251,302],
[267,240,241,0,239,254,261,251,269,252,244,273],
[259,267,259,262,0,242,253,267,264,276,259,288],
[266,247,218,247,259,0,233,239,210,251,261,270],
[252,272,250,240,248,268,0,263,252,240,260,270],
[272,243,240,250,234,262,238,0,252,246,254,265],
[258,259,254,232,237,291,249,249,0,243,254,266],
[243,267,248,249,225,250,261,255,258,0,244,284],
[259,271,250,257,242,240,241,247,247,257,0,253],
[255,223,199,228,213,231,231,236,235,217,248,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 108, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,265,156,392,353,234,323,340,347,376,285,304],
[236,0,326,314,236,308,335,316,370,277,204,258],
[345,175,0,345,247,203,485,347,326,386,238,408],
[109,187,156,0,306,165,382,235,297,306,143,129],
[148,265,254,195,0,184,344,256,238,314,197,261],
[267,193,298,336,317,0,407,397,385,335,238,358],
[178,166,16,119,157,94,0,241,137,157,141,160],
[161,185,154,266,245,104,260,0,166,245,238,233],
[154,131,175,204,263,116,364,335,0,222,184,226],
[125,224,115,195,187,166,344,256,279,0,156,308],
[216,297,263,358,304,263,360,263,317,345,0,365],
[197,243,93,372,240,143,341,268,275,193,136,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 109, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,248,268,242,261,252,261,225,257,247,239,258],
[253,0,266,271,286,271,270,255,275,264,249,263],
[233,235,0,240,255,255,267,236,236,242,237,240],
[259,230,261,0,275,257,278,249,230,258,236,223],
[240,215,246,226,0,245,252,220,241,237,206,234],
[249,230,246,244,256,0,292,228,249,228,242,226],
[240,231,234,223,249,209,0,218,230,230,212,221],
[276,246,265,252,281,273,283,0,262,272,256,257],
[244,226,265,271,260,252,271,239,0,250,242,267],
[254,237,259,243,264,273,271,229,251,0,228,258],
[262,252,264,265,295,259,289,245,259,273,0,254],
[243,238,261,278,267,275,280,244,234,243,247,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 110, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,292,220,239,220,209,243,225,221,269,214,220],
[209,0,239,191,225,225,222,248,212,222,180,212],
[281,262,0,319,228,313,266,285,263,224,282,260],
[262,310,182,0,264,318,303,296,220,229,194,236],
[281,276,273,237,0,280,333,246,222,233,272,247],
[292,276,188,183,221,0,261,249,251,225,239,231],
[258,279,235,198,168,240,0,248,240,243,266,216],
[276,253,216,205,255,252,253,0,210,243,225,213],
[280,289,238,281,279,250,261,291,0,243,230,237],
[232,279,277,272,268,276,258,258,258,0,220,170],
[287,321,219,307,229,262,235,276,271,281,0,267],
[281,289,241,265,254,270,285,288,264,331,234,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 111, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,277,250,263,266,291,268,262,264,262,255,271],
[224,0,224,241,245,263,230,242,247,237,229,243],
[251,277,0,260,260,249,241,267,269,264,240,250],
[238,260,241,0,249,243,253,259,250,228,251,240],
[235,256,241,252,0,236,242,247,253,241,229,243],
[210,238,252,258,265,0,233,245,234,234,218,254],
[233,271,260,248,259,268,0,261,257,244,265,269],
[239,259,234,242,254,256,240,0,252,257,252,241],
[237,254,232,251,248,267,244,249,0,244,231,259],
[239,264,237,273,260,267,257,244,257,0,252,242],
[246,272,261,250,272,283,236,249,270,249,0,254],
[230,258,251,261,258,247,232,260,242,259,247,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 112, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,252,267,254,246,243,275,252,257,254,230,264],
[249,0,275,232,259,245,278,261,280,232,242,231],
[234,226,0,214,239,226,240,223,258,223,230,228],
[247,269,287,0,244,241,270,270,265,246,263,259],
[255,242,262,257,0,238,253,250,259,253,238,240],
[258,256,275,260,263,0,275,258,261,261,251,243],
[226,223,261,231,248,226,0,250,252,221,239,223],
[249,240,278,231,251,243,251,0,260,216,237,240],
[244,221,243,236,242,240,249,241,0,231,251,241],
[247,269,278,255,248,240,280,285,270,0,283,256],
[271,259,271,238,263,250,262,264,250,218,0,244],
[237,270,273,242,261,258,278,261,260,245,257,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 113, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,322,322,267,363,285,289,297,329,249,302,276],
[179,0,242,253,249,256,280,310,375,256,294,235],
[179,259,0,177,278,275,230,235,272,235,223,184],
[234,248,324,0,243,283,361,254,339,294,268,196],
[138,252,223,258,0,274,237,260,285,254,298,212],
[216,245,226,218,227,0,300,231,359,280,293,196],
[212,221,271,140,264,201,0,249,291,244,254,175],
[204,191,266,247,241,270,252,0,288,263,236,153],
[172,126,229,162,216,142,210,213,0,202,194,166],
[252,245,266,207,247,221,257,238,299,0,202,199],
[199,207,278,233,203,208,247,265,307,299,0,146],
[225,266,317,305,289,305,326,348,335,302,355,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 114, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,257,275,253,262,246,270,242,242,263,258,242],
[244,0,264,234,250,241,245,254,240,250,238,239],
[226,237,0,239,225,245,236,229,241,244,251,229],
[248,267,262,0,261,253,272,260,234,271,260,249],
[239,251,276,240,0,260,249,248,237,259,251,235],
[255,260,256,248,241,0,262,244,235,259,234,255],
[231,256,265,229,252,239,0,250,239,250,242,239],
[259,247,272,241,253,257,251,0,249,279,257,270],
[259,261,260,267,264,266,262,252,0,284,242,244],
[238,251,257,230,242,242,251,222,217,0,236,248],
[243,263,250,241,250,267,259,244,259,265,0,227],
[259,262,272,252,266,246,262,231,257,253,274,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 115, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,235,254,243,280,266,251,261,286,318,253,290],
[266,0,251,256,306,308,278,230,283,303,270,324],
[247,250,0,227,277,326,256,225,255,280,237,272],
[258,245,274,0,302,295,269,254,282,283,265,297],
[221,195,224,199,0,266,232,224,231,242,234,302],
[235,193,175,206,235,0,200,245,227,260,199,233],
[250,223,245,232,269,301,0,241,204,261,247,247],
[240,271,276,247,277,256,260,0,226,260,242,326],
[215,218,246,219,270,274,297,275,0,272,235,263],
[183,198,221,218,259,241,240,241,229,0,249,249],
[248,231,264,236,267,302,254,259,266,252,0,277],
[211,177,229,204,199,268,254,175,238,252,224,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 116, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,235,282,264,277,255,279,314,307,285,311,260],
[266,0,277,237,238,241,260,275,291,284,305,274],
[219,224,0,207,247,252,205,267,290,259,295,231],
[237,264,294,0,225,280,303,261,283,316,299,275],
[224,263,254,276,0,265,268,302,285,279,290,264],
[246,260,249,221,236,0,280,297,293,272,306,264],
[222,241,296,198,233,221,0,282,303,264,258,252],
[187,226,234,240,199,204,219,0,274,194,272,230],
[194,210,211,218,216,208,198,227,0,224,262,238],
[216,217,242,185,222,229,237,307,277,0,256,233],
[190,196,206,202,211,195,243,229,239,245,0,218],
[241,227,270,226,237,237,249,271,263,268,283,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 117, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,242,253,253,254,246,271,240,246,237,276,260],
[259,0,259,241,273,255,257,266,257,264,254,260],
[248,242,0,242,271,243,246,254,249,228,268,251],
[248,260,259,0,269,242,265,259,239,240,273,257],
[247,228,230,232,0,201,235,209,225,209,244,216],
[255,246,258,259,300,0,271,268,235,240,267,254],
[230,244,255,236,266,230,0,232,241,235,257,234],
[261,235,247,242,292,233,269,0,237,239,263,265],
[255,244,252,262,276,266,260,264,0,250,282,261],
[264,237,273,261,292,261,266,262,251,0,264,270],
[225,247,233,228,257,234,244,238,219,237,0,229],
[241,241,250,244,285,247,267,236,240,231,272,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 118, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,206,180,187,207,226,307,335,145,149,195,186],
[295,0,260,219,280,269,321,318,240,274,267,273],
[321,241,0,284,267,325,340,337,197,242,271,255],
[314,282,217,0,244,253,292,265,206,232,245,268],
[294,221,234,257,0,270,293,341,230,192,221,229],
[275,232,176,248,231,0,307,248,178,236,232,234],
[194,180,161,209,208,194,0,200,144,125,213,180],
[166,183,164,236,160,253,301,0,166,155,209,218],
[356,261,304,295,271,323,357,335,0,241,208,292],
[352,227,259,269,309,265,376,346,260,0,277,277],
[306,234,230,256,280,269,288,292,293,224,0,274],
[315,228,246,233,272,267,321,283,209,224,227,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 119, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,267,249,252,264,260,228,280,206,256,280,254],
[234,0,298,266,303,290,317,271,275,285,274,308],
[252,203,0,220,286,298,291,265,225,255,269,269],
[249,235,281,0,292,256,267,284,252,244,269,291],
[237,198,215,209,0,238,188,240,270,221,239,266],
[241,211,203,245,263,0,226,233,235,199,245,259],
[273,184,210,234,313,275,0,226,239,245,254,286],
[221,230,236,217,261,268,275,0,216,245,229,257],
[295,226,276,249,231,266,262,285,0,256,272,292],
[245,216,246,257,280,302,256,256,245,0,287,264],
[221,227,232,232,262,256,247,272,229,214,0,262],
[247,193,232,210,235,242,215,244,209,237,239,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 120, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,255,217,217,255,222,211,208,237,240,224,219],
[246,0,225,228,238,215,246,242,251,243,206,257],
[284,276,0,250,263,261,264,264,269,252,260,262],
[284,273,251,0,268,276,246,266,276,261,268,259],
[246,263,238,233,0,239,209,221,262,227,249,242],
[279,286,240,225,262,0,254,244,276,265,240,241],
[290,255,237,255,292,247,0,229,269,253,257,248],
[293,259,237,235,280,257,272,0,288,260,245,246],
[264,250,232,225,239,225,232,213,0,248,236,225],
[261,258,249,240,274,236,248,241,253,0,261,256],
[277,295,241,233,252,261,244,256,265,240,0,252],
[282,244,239,242,259,260,253,255,276,245,249,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 121, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,262,278,270,286,244,301,253,251,274,254,283],
[239,0,283,272,323,261,239,272,257,296,235,230],
[223,218,0,264,254,207,241,223,230,259,232,229],
[231,229,237,0,255,207,233,223,189,249,224,195],
[215,178,247,246,0,221,263,243,232,257,227,207],
[257,240,294,294,280,0,293,266,263,309,272,285],
[200,262,260,268,238,208,0,276,215,283,240,251],
[248,229,278,278,258,235,225,0,228,256,248,252],
[250,244,271,312,269,238,286,273,0,257,238,282],
[227,205,242,252,244,192,218,245,244,0,243,269],
[247,266,269,277,274,229,261,253,263,258,0,276],
[218,271,272,306,294,216,250,249,219,232,225,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 122, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,214,241,249,213,251,241,258,248,237,253,231],
[287,0,280,259,254,254,245,266,261,258,250,274],
[260,221,0,240,227,250,237,245,267,249,257,217],
[252,242,261,0,236,248,243,242,243,251,251,223],
[288,247,274,265,0,261,252,264,266,258,259,240],
[250,247,251,253,240,0,246,243,254,254,252,238],
[260,256,264,258,249,255,0,247,269,257,248,254],
[243,235,256,259,237,258,254,0,255,241,253,244],
[253,240,234,258,235,247,232,246,0,239,255,245],
[264,243,252,250,243,247,244,260,262,0,263,278],
[248,251,244,250,242,249,253,248,246,238,0,245],
[270,227,284,278,261,263,247,257,256,223,256,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 123, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,241,214,295,251,197,252,222,272,238,219,221],
[260,0,233,299,328,337,280,255,319,299,286,254],
[287,268,0,257,268,241,294,212,287,278,297,256],
[206,202,244,0,215,185,270,186,245,267,253,208],
[250,173,233,286,0,273,285,231,265,265,253,208],
[304,164,260,316,228,0,258,224,217,265,251,235],
[249,221,207,231,216,243,0,211,229,236,243,225],
[279,246,289,315,270,277,290,0,232,261,261,238],
[229,182,214,256,236,284,272,269,0,288,230,230],
[263,202,223,234,236,236,265,240,213,0,242,258],
[282,215,204,248,248,250,258,240,271,259,0,203],
[280,247,245,293,293,266,276,263,271,243,298,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 124, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,270,251,240,268,262,258,275,270,273,259,258],
[231,0,245,242,260,252,245,257,260,253,262,264],
[250,256,0,264,237,242,254,244,250,259,261,260],
[261,259,237,0,243,254,255,264,251,264,252,263],
[233,241,264,258,0,247,249,252,245,249,251,268],
[239,249,259,247,254,0,254,266,259,263,272,259],
[243,256,247,246,252,247,0,267,259,267,247,257],
[226,244,257,237,249,235,234,0,238,253,256,253],
[231,241,251,250,256,242,242,263,0,254,264,261],
[228,248,242,237,252,238,234,248,247,0,255,248],
[242,239,240,249,250,229,254,245,237,246,0,251],
[243,237,241,238,233,242,244,248,240,253,250,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 125, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,217,223,225,268,250,230,261,234,265,236,210],
[284,0,230,276,225,208,260,260,244,244,229,239],
[278,271,0,274,260,238,271,299,264,263,227,254],
[276,225,227,0,239,242,237,239,258,223,220,225],
[233,276,241,262,0,260,237,258,265,291,252,225],
[251,293,263,259,241,0,262,246,248,277,249,213],
[271,241,230,264,264,239,0,285,251,257,222,234],
[240,241,202,262,243,255,216,0,223,256,236,197],
[267,257,237,243,236,253,250,278,0,255,278,214],
[236,257,238,278,210,224,244,245,246,0,232,206],
[265,272,274,281,249,252,279,265,223,269,0,227],
[291,262,247,276,276,288,267,304,287,295,274,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 126, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,243,256,246,227,243,240,257,243,240,238,245],
[258,0,256,265,250,252,259,268,261,251,259,260],
[245,245,0,266,253,236,241,274,257,239,257,248],
[255,236,235,0,244,241,245,266,252,242,232,234],
[274,251,248,257,0,251,252,266,264,244,253,256],
[258,249,265,260,250,0,247,268,263,239,256,267],
[261,242,260,256,249,254,0,271,264,240,255,250],
[244,233,227,235,235,233,230,0,256,233,222,236],
[258,240,244,249,237,238,237,245,0,237,232,254],
[261,250,262,259,257,262,261,268,264,0,254,259],
[263,242,244,269,248,245,246,279,269,247,0,260],
[256,241,253,267,245,234,251,265,247,242,241,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 127, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,277,288,245,252,254,265,240,252,272,253,250],
[224,0,248,234,232,253,244,242,266,255,218,244],
[213,253,0,246,232,240,245,253,252,280,248,239],
[256,267,255,0,254,235,273,259,253,273,231,236],
[249,269,269,247,0,255,269,242,265,275,269,261],
[247,248,261,266,246,0,246,251,276,260,242,252],
[236,257,256,228,232,255,0,251,233,252,225,235],
[261,259,248,242,259,250,250,0,250,274,250,233],
[249,235,249,248,236,225,268,251,0,268,232,237],
[229,246,221,228,226,241,249,227,233,0,222,227],
[248,283,253,270,232,259,276,251,269,279,0,269],
[251,257,262,265,240,249,266,268,264,274,232,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 128, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,201,317,215,295,248,271,246,264,255,252,256],
[300,0,305,317,266,306,204,317,250,238,287,255],
[184,196,0,182,234,280,189,169,216,172,160,197],
[286,184,319,0,297,332,263,185,241,294,212,136],
[206,235,267,204,0,303,184,254,218,282,241,132],
[253,195,221,169,198,0,265,190,239,211,202,110],
[230,297,312,238,317,236,0,260,270,290,210,197],
[255,184,332,316,247,311,241,0,274,232,247,151],
[237,251,285,260,283,262,231,227,0,295,173,192],
[246,263,329,207,219,290,211,269,206,0,209,149],
[249,214,341,289,260,299,291,254,328,292,0,219],
[245,246,304,365,369,391,304,350,309,352,282,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 129, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,268,231,267,280,289,265,288,271,278,249,253],
[233,0,218,227,301,250,233,251,255,266,256,256],
[270,283,0,269,277,277,248,255,265,312,283,282],
[234,274,232,0,298,279,274,326,265,259,278,301],
[221,200,224,203,0,268,246,266,207,220,254,201],
[212,251,224,222,233,0,208,261,218,219,214,266],
[236,268,253,227,255,293,0,274,237,243,268,275],
[213,250,246,175,235,240,227,0,196,226,239,238],
[230,246,236,236,294,283,264,305,0,261,278,233],
[223,235,189,242,281,282,258,275,240,0,242,225],
[252,245,218,223,247,287,233,262,223,259,0,233],
[248,245,219,200,300,235,226,263,268,276,268,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 130, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,223,210,215,244,217,258,234,216,252,216,234],
[278,0,254,236,221,284,275,261,275,241,267,238],
[291,247,0,196,257,246,240,268,256,260,282,274],
[286,265,305,0,258,256,275,291,277,279,294,247],
[257,280,244,243,0,207,261,276,258,239,288,268],
[284,217,255,245,294,0,250,257,227,283,267,265],
[243,226,261,226,240,251,0,277,228,258,247,249],
[267,240,233,210,225,244,224,0,226,273,232,187],
[285,226,245,224,243,274,273,275,0,222,270,257],
[249,260,241,222,262,218,243,228,279,0,241,189],
[285,234,219,207,213,234,254,269,231,260,0,226],
[267,263,227,254,233,236,252,314,244,312,275,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 131, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,239,245,256,256,223,261,228,220,206,273,241],
[262,0,280,298,258,253,270,238,255,246,281,222],
[256,221,0,267,273,220,254,231,253,235,260,246],
[245,203,234,0,241,215,216,223,220,215,230,242],
[245,243,228,260,0,224,206,218,235,203,234,222],
[278,248,281,286,277,0,280,255,247,230,245,248],
[240,231,247,285,295,221,0,251,226,237,236,207],
[273,263,270,278,283,246,250,0,240,247,254,241],
[281,246,248,281,266,254,275,261,0,244,254,263],
[295,255,266,286,298,271,264,254,257,0,276,238],
[228,220,241,271,267,256,265,247,247,225,0,243],
[260,279,255,259,279,253,294,260,238,263,258,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 132, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,216,276,228,273,295,247,276,211,256,264,294],
[285,0,289,278,322,327,273,281,297,288,246,335],
[225,212,0,218,241,273,203,232,218,251,230,283],
[273,223,283,0,282,275,251,240,219,264,261,258],
[228,179,260,219,0,242,196,241,189,240,215,219],
[206,174,228,226,259,0,198,234,195,222,225,231],
[254,228,298,250,305,303,0,277,278,294,254,277],
[225,220,269,261,260,267,224,0,197,245,263,222],
[290,204,283,282,312,306,223,304,0,275,242,274],
[245,213,250,237,261,279,207,256,226,0,244,257],
[237,255,271,240,286,276,247,238,259,257,0,277],
[207,166,218,243,282,270,224,279,227,244,224,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 133, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,341,283,289,314,223,279,278,305,221,277,249],
[160,0,167,236,271,200,228,210,251,164,210,257],
[218,334,0,240,273,285,250,324,301,255,253,264],
[212,265,261,0,276,247,253,272,269,228,227,251],
[187,230,228,225,0,213,277,240,244,193,232,271],
[278,301,216,254,288,0,310,295,277,202,285,274],
[222,273,251,248,224,191,0,306,267,209,228,241],
[223,291,177,229,261,206,195,0,278,242,249,184],
[196,250,200,232,257,224,234,223,0,167,197,241],
[280,337,246,273,308,299,292,259,334,0,320,300],
[224,291,248,274,269,216,273,252,304,181,0,294],
[252,244,237,250,230,227,260,317,260,201,207,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 134, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,258,261,250,231,259,266,202,253,191,198,267],
[243,0,268,273,265,240,253,273,270,257,269,265],
[240,233,0,206,193,232,216,223,197,162,214,217],
[251,228,295,0,245,308,250,232,293,191,276,221],
[270,236,308,256,0,265,290,231,252,284,324,257],
[242,261,269,193,236,0,284,274,264,255,289,263],
[235,248,285,251,211,217,0,208,257,198,311,247],
[299,228,278,269,270,227,293,0,298,224,251,291],
[248,231,304,208,249,237,244,203,0,210,248,203],
[310,244,339,310,217,246,303,277,291,0,317,250],
[303,232,287,225,177,212,190,250,253,184,0,239],
[234,236,284,280,244,238,254,210,298,251,262,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 135, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,273,236,275,266,261,252,259,264,253,269,242],
[228,0,244,269,254,240,238,250,247,237,247,233],
[265,257,0,262,257,255,248,276,250,247,244,243],
[226,232,239,0,248,231,238,256,240,248,243,225],
[235,247,244,253,0,241,247,265,260,242,260,236],
[240,261,246,270,260,0,240,257,260,250,254,251],
[249,263,253,263,254,261,0,259,269,245,257,239],
[242,251,225,245,236,244,242,0,249,238,245,223],
[237,254,251,261,241,241,232,252,0,234,255,240],
[248,264,254,253,259,251,256,263,267,0,258,237],
[232,254,257,258,241,247,244,256,246,243,0,235],
[259,268,258,276,265,250,262,278,261,264,266,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 136, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,217,223,236,265,284,227,253,266,269,256,275],
[284,0,246,272,296,284,325,296,287,307,285,285],
[278,255,0,272,295,239,267,288,276,281,292,290],
[265,229,229,0,252,244,271,267,259,297,270,293],
[236,205,206,249,0,233,224,278,219,248,266,255],
[217,217,262,257,268,0,263,282,247,263,279,287],
[274,176,234,230,277,238,0,267,254,279,276,271],
[248,205,213,234,223,219,234,0,228,263,255,238],
[235,214,225,242,282,254,247,273,0,278,280,266],
[232,194,220,204,253,238,222,238,223,0,234,248],
[245,216,209,231,235,222,225,246,221,267,0,264],
[226,216,211,208,246,214,230,263,235,253,237,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 137, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,225,234,235,244,253,248,264,252,230,237,223],
[276,0,260,259,273,266,273,295,269,235,264,268],
[267,241,0,250,244,257,248,261,249,228,237,239],
[266,242,251,0,249,264,247,295,274,247,243,259],
[257,228,257,252,0,269,248,287,260,228,255,231],
[248,235,244,237,232,0,239,255,237,231,233,222],
[253,228,253,254,253,262,0,286,274,246,236,246],
[237,206,240,206,214,246,215,0,230,224,212,229],
[249,232,252,227,241,264,227,271,0,239,220,240],
[271,266,273,254,273,270,255,277,262,0,236,260],
[264,237,264,258,246,268,265,289,281,265,0,248],
[278,233,262,242,270,279,255,272,261,241,253,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 138, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,295,282,264,304,264,265,261,291,250,270,286],
[206,0,219,243,217,246,193,218,224,202,242,231],
[219,282,0,278,282,252,193,257,265,234,256,263],
[237,258,223,0,263,239,230,244,247,206,243,257],
[197,284,219,238,0,211,212,233,244,200,233,235],
[237,255,249,262,290,0,228,249,246,241,258,276],
[236,308,308,271,289,273,0,252,262,261,272,267],
[240,283,244,257,268,252,249,0,267,232,249,267],
[210,277,236,254,257,255,239,234,0,217,252,245],
[251,299,267,295,301,260,240,269,284,0,269,285],
[231,259,245,258,268,243,229,252,249,232,0,246],
[215,270,238,244,266,225,234,234,256,216,255,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 139, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,254,260,251,248,240,216,263,269,241,246,263],
[247,0,254,224,256,242,237,261,266,245,236,260],
[241,247,0,233,261,232,233,260,246,241,251,267],
[250,277,268,0,258,258,253,269,287,272,257,305],
[253,245,240,243,0,227,230,252,280,255,233,270],
[261,259,269,243,274,0,247,265,291,255,273,274],
[285,264,268,248,271,254,0,268,293,287,265,290],
[238,240,241,232,249,236,233,0,258,254,245,273],
[232,235,255,214,221,210,208,243,0,217,244,263],
[260,256,260,229,246,246,214,247,284,0,264,259],
[255,265,250,244,268,228,236,256,257,237,0,257],
[238,241,234,196,231,227,211,228,238,242,244,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 140, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,249,265,268,283,256,248,258,243,276,266,269],
[252,0,261,277,264,251,271,255,261,280,274,245],
[236,240,0,245,250,237,230,238,243,240,248,248],
[233,224,256,0,250,245,244,238,246,253,249,241],
[218,237,251,251,0,243,255,255,254,258,231,257],
[245,250,264,256,258,0,260,258,254,263,265,250],
[253,230,271,257,246,241,0,238,241,255,258,229],
[243,246,263,263,246,243,263,0,244,261,259,254],
[258,240,258,255,247,247,260,257,0,261,265,259],
[225,221,261,248,243,238,246,240,240,0,240,225],
[235,227,253,252,270,236,243,242,236,261,0,247],
[232,256,253,260,244,251,272,247,242,276,254,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 141, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,169,181,135,252,237,272,233,181,195,164,235],
[332,0,288,276,293,286,334,278,188,244,279,262],
[320,213,0,217,304,336,382,304,232,274,226,300],
[366,225,284,0,216,366,336,272,344,222,281,284],
[249,208,197,285,0,271,268,209,261,140,207,207],
[264,215,165,135,230,0,262,209,188,184,233,167],
[229,167,119,165,233,239,0,234,241,186,184,188],
[268,223,197,229,292,292,267,0,246,204,215,303],
[320,313,269,157,240,313,260,255,0,253,183,231],
[306,257,227,279,361,317,315,297,248,0,283,320],
[337,222,275,220,294,268,317,286,318,218,0,294],
[266,239,201,217,294,334,313,198,270,181,207,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 142, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,235,268,257,259,259,245,284,255,274,267,260],
[266,0,260,257,266,270,244,282,255,276,279,259],
[233,241,0,248,256,235,234,273,240,259,267,236],
[244,244,253,0,251,264,235,263,242,259,244,252],
[242,235,245,250,0,258,240,258,230,257,259,252],
[242,231,266,237,243,0,255,278,250,277,264,256],
[256,257,267,266,261,246,0,291,252,277,278,272],
[217,219,228,238,243,223,210,0,207,228,237,232],
[246,246,261,259,271,251,249,294,0,265,267,251],
[227,225,242,242,244,224,224,273,236,0,259,237],
[234,222,234,257,242,237,223,264,234,242,0,245],
[241,242,265,249,249,245,229,269,250,264,256,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 143, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,245,243,227,258,259,242,236,232,243,248,247],
[256,0,247,271,262,256,274,258,251,252,270,249],
[258,254,0,256,262,267,262,247,265,268,277,262],
[274,230,245,0,270,260,271,260,260,254,279,267],
[243,239,239,231,0,248,251,238,233,241,256,250],
[242,245,234,241,253,0,262,237,240,245,255,249],
[259,227,239,230,250,239,0,251,238,250,261,255],
[265,243,254,241,263,264,250,0,251,242,254,254],
[269,250,236,241,268,261,263,250,0,264,262,264],
[258,249,233,247,260,256,251,259,237,0,261,229],
[253,231,224,222,245,246,240,247,239,240,0,244],
[254,252,239,234,251,252,246,247,237,272,257,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 144, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,246,274,260,263,258,258,258,242,255,253,266],
[255,0,250,249,249,256,265,251,252,247,261,254],
[227,251,0,240,259,247,266,231,231,257,256,241],
[241,252,261,0,271,260,281,245,260,253,254,255],
[238,252,242,230,0,225,254,236,243,238,240,221],
[243,245,254,241,276,0,262,256,259,267,261,249],
[243,236,235,220,247,239,0,223,212,237,233,230],
[243,250,270,256,265,245,278,0,264,252,256,248],
[259,249,270,241,258,242,289,237,0,264,247,256],
[246,254,244,248,263,234,264,249,237,0,261,255],
[248,240,245,247,261,240,268,245,254,240,0,240],
[235,247,260,246,280,252,271,253,245,246,261,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 145, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,271,288,231,262,251,263,260,280,262,214,245],
[230,0,281,231,263,256,253,237,271,245,229,228],
[213,220,0,193,205,226,220,201,234,233,216,210],
[270,270,308,0,279,281,248,273,291,254,245,261],
[239,238,296,222,0,250,249,222,247,229,215,221],
[250,245,275,220,251,0,240,240,276,213,220,236],
[238,248,281,253,252,261,0,261,259,239,231,238],
[241,264,300,228,279,261,240,0,274,250,263,237],
[221,230,267,210,254,225,242,227,0,233,191,207],
[239,256,268,247,272,288,262,251,268,0,240,231],
[287,272,285,256,286,281,270,238,310,261,0,256],
[256,273,291,240,280,265,263,264,294,270,245,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 146, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,240,211,249,253,203,252,239,225,258,271,275],
[261,0,243,246,267,246,220,242,234,283,302,261],
[290,258,0,257,233,233,274,262,272,282,300,294],
[252,255,244,0,244,210,251,229,197,286,308,279],
[248,234,268,257,0,229,260,238,260,307,320,289],
[298,255,268,291,272,0,256,233,226,263,278,292],
[249,281,227,250,241,245,0,228,234,291,289,260],
[262,259,239,272,263,268,273,0,241,290,323,296],
[276,267,229,304,241,275,267,260,0,264,329,299],
[243,218,219,215,194,238,210,211,237,0,280,236],
[230,199,201,193,181,223,212,178,172,221,0,234],
[226,240,207,222,212,209,241,205,202,265,267,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 147, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,245,235,249,236,253,253,249,253,224,241,241],
[256,0,253,269,248,251,250,283,266,255,257,268],
[266,248,0,258,241,252,248,271,259,251,239,245],
[252,232,243,0,234,246,250,252,257,217,234,254],
[265,253,260,267,0,255,248,270,275,243,256,257],
[248,250,249,255,246,0,254,252,253,226,251,252],
[248,251,253,251,253,247,0,265,253,245,264,269],
[252,218,230,249,231,249,236,0,245,245,246,240],
[248,235,242,244,226,248,248,256,0,234,252,246],
[277,246,250,284,258,275,256,256,267,0,274,256],
[260,244,262,267,245,250,237,255,249,227,0,255],
[260,233,256,247,244,249,232,261,255,245,246,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 148, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,282,168,181,167,308,263,211,240,237,218,214],
[219,0,207,194,129,294,253,135,261,237,172,200],
[333,294,0,211,263,340,319,255,291,267,230,240],
[320,307,290,0,228,308,281,250,331,312,316,237],
[334,372,238,273,0,403,286,322,339,325,285,301],
[193,207,161,193,98,0,186,159,228,238,218,126],
[238,248,182,220,215,315,0,220,245,223,235,289],
[290,366,246,251,179,342,281,0,286,277,262,255],
[261,240,210,170,162,273,256,215,0,239,268,242],
[264,264,234,189,176,263,278,224,262,0,214,236],
[283,329,271,185,216,283,266,239,233,287,0,214],
[287,301,261,264,200,375,212,246,259,265,287,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 149, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,247,280,289,263,243,289,285,272,277,291,276],
[254,0,231,296,224,217,248,269,264,220,274,269],
[221,270,0,243,210,231,246,234,238,273,262,226],
[212,205,258,0,190,206,236,216,213,217,222,229],
[238,277,291,311,0,278,286,287,280,248,308,300],
[258,284,270,295,223,0,267,240,301,270,270,268],
[212,253,255,265,215,234,0,235,247,228,288,233],
[216,232,267,285,214,261,266,0,239,237,281,261],
[229,237,263,288,221,200,254,262,0,208,253,225],
[224,281,228,284,253,231,273,264,293,0,273,260],
[210,227,239,279,193,231,213,220,248,228,0,265],
[225,232,275,272,201,233,268,240,276,241,236,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 150, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,253,268,253,288,248,266,246,278,288,256,259],
[248,0,237,232,254,226,219,250,252,251,233,230],
[233,264,0,252,242,263,251,257,260,274,252,257],
[248,269,249,0,274,243,250,255,269,280,250,245],
[213,247,259,227,0,232,238,237,235,238,260,212],
[253,275,238,258,269,0,232,253,268,276,256,253],
[235,282,250,251,263,269,0,234,275,262,267,264],
[255,251,244,246,264,248,267,0,254,271,250,253],
[223,249,241,232,266,233,226,247,0,254,262,234],
[213,250,227,221,263,225,239,230,247,0,224,218],
[245,268,249,251,241,245,234,251,239,277,0,229],
[242,271,244,256,289,248,237,248,267,283,272,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 151, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,264,253,256,264,266,240,255,263,248,255,259],
[237,0,236,230,239,234,235,235,240,217,230,234],
[248,265,0,258,281,258,256,246,271,261,263,259],
[245,271,243,0,259,244,254,240,254,248,251,243],
[237,262,220,242,0,229,239,244,239,231,255,250],
[235,267,243,257,272,0,255,242,254,242,269,252],
[261,266,245,247,262,246,0,243,251,259,257,266],
[246,266,255,261,257,259,258,0,263,269,271,258],
[238,261,230,247,262,247,250,238,0,245,248,256],
[253,284,240,253,270,259,242,232,256,0,267,265],
[246,271,238,250,246,232,244,230,253,234,0,233],
[242,267,242,258,251,249,235,243,245,236,268,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 152, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,272,244,268,254,267,264,279,282,280,253,242],
[229,0,225,240,224,239,257,262,270,262,246,252],
[257,276,0,261,247,260,282,270,280,296,252,268],
[233,261,240,0,228,252,263,249,255,254,237,252],
[247,277,254,273,0,261,291,291,280,272,268,249],
[234,262,241,249,240,0,264,248,271,254,250,240],
[237,244,219,238,210,237,0,239,250,247,229,227],
[222,239,231,252,210,253,262,0,275,252,272,235],
[219,231,221,246,221,230,251,226,0,246,222,250],
[221,239,205,247,229,247,254,249,255,0,240,228],
[248,255,249,264,233,251,272,229,279,261,0,253],
[259,249,233,249,252,261,274,266,251,273,248,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 153, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,226,214,221,224,219,229,225,234,245,219,253],
[275,0,267,223,241,250,246,234,263,278,278,271],
[287,234,0,249,250,241,274,228,247,277,248,264],
[280,278,252,0,249,270,243,255,285,288,265,289],
[277,260,251,252,0,252,263,244,257,284,254,263],
[282,251,260,231,249,0,266,262,263,294,258,245],
[272,255,227,258,238,235,0,236,252,255,250,249],
[276,267,273,246,257,239,265,0,249,288,238,252],
[267,238,254,216,244,238,249,252,0,286,250,259],
[256,223,224,213,217,207,246,213,215,0,213,219],
[282,223,253,236,247,243,251,263,251,288,0,266],
[248,230,237,212,238,256,252,249,242,282,235,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 154, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,267,273,242,256,252,287,236,267,287,242,225],
[234,0,225,191,231,218,231,251,251,255,214,198],
[228,276,0,196,216,250,268,269,249,261,233,220],
[259,310,305,0,231,284,278,274,302,267,272,275],
[245,270,285,270,0,283,260,276,274,264,260,236],
[249,283,251,217,218,0,244,264,253,254,254,240],
[214,270,233,223,241,257,0,232,240,279,197,202],
[265,250,232,227,225,237,269,0,253,265,243,204],
[234,250,252,199,227,248,261,248,0,272,235,206],
[214,246,240,234,237,247,222,236,229,0,208,218],
[259,287,268,229,241,247,304,258,266,293,0,238],
[276,303,281,226,265,261,299,297,295,283,263,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 155, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,278,250,296,254,278,258,260,258,244,262,248],
[223,0,238,253,222,237,241,181,252,218,236,217],
[251,263,0,263,217,259,246,171,248,213,253,239],
[205,248,238,0,229,231,248,214,217,190,223,244],
[247,279,284,272,0,288,299,187,249,218,262,238],
[223,264,242,270,213,0,257,202,257,212,201,255],
[243,260,255,253,202,244,0,183,264,215,208,198],
[241,320,330,287,314,299,318,0,273,302,293,324],
[243,249,253,284,252,244,237,228,0,228,246,265],
[257,283,288,311,283,289,286,199,273,0,290,262],
[239,265,248,278,239,300,293,208,255,211,0,275],
[253,284,262,257,263,246,303,177,236,239,226,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 156, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,254,262,242,244,242,264,245,261,238,246,249],
[247,0,263,254,250,255,266,264,260,241,273,241],
[239,238,0,236,222,235,250,241,255,228,253,234],
[259,247,265,0,235,259,263,251,258,253,265,260],
[257,251,279,266,0,247,273,262,257,251,270,250],
[259,246,266,242,254,0,255,257,268,244,264,254],
[237,235,251,238,228,246,0,232,242,228,265,241],
[256,237,260,250,239,244,269,0,253,247,261,248],
[240,241,246,243,244,233,259,248,0,229,250,233],
[263,260,273,248,250,257,273,254,272,0,250,252],
[255,228,248,236,231,237,236,240,251,251,0,229],
[252,260,267,241,251,247,260,253,268,249,272,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 157, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,281,247,303,292,223,290,319,291,252,276,289],
[220,0,246,233,243,235,268,263,263,252,260,267],
[254,255,0,260,246,237,288,299,240,248,244,270],
[198,268,241,0,269,220,253,291,261,252,227,223],
[209,258,255,232,0,215,288,296,255,244,265,248],
[278,266,264,281,286,0,322,318,249,253,309,257],
[211,233,213,248,213,179,0,278,227,189,220,214],
[182,238,202,210,205,183,223,0,213,227,227,188],
[210,238,261,240,246,252,274,288,0,251,272,256],
[249,249,253,249,257,248,312,274,250,0,265,255],
[225,241,257,274,236,192,281,274,229,236,0,243],
[212,234,231,278,253,244,287,313,245,246,258,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 158, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,233,252,293,302,227,234,257,282,260,196,319],
[268,0,272,295,328,240,288,286,277,323,251,305],
[249,229,0,250,237,207,228,228,251,240,214,277],
[208,206,251,0,282,208,200,231,250,251,193,234],
[199,173,264,219,0,192,206,210,239,238,215,248],
[274,261,294,293,309,0,229,259,323,278,233,278],
[267,213,273,301,295,272,0,240,245,264,197,242],
[244,215,273,270,291,242,261,0,244,242,225,291],
[219,224,250,251,262,178,256,257,0,254,222,274],
[241,178,261,250,263,223,237,259,247,0,248,277],
[305,250,287,308,286,268,304,276,279,253,0,277],
[182,196,224,267,253,223,259,210,227,224,224,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 159, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,210,230,257,250,187,391,268,214,215,302,277],
[291,0,202,236,214,282,390,313,235,186,285,249],
[271,299,0,299,202,305,314,242,212,258,339,307],
[244,265,202,0,217,281,418,303,253,275,273,298],
[251,287,299,284,0,369,372,295,358,206,332,280],
[314,219,196,220,132,0,354,281,241,221,257,260],
[110,111,187,83,129,147,0,185,150,118,147,113],
[233,188,259,198,206,220,316,0,298,196,286,287],
[287,266,289,248,143,260,351,203,0,192,287,191],
[286,315,243,226,295,280,383,305,309,0,315,334],
[199,216,162,228,169,244,354,215,214,186,0,265],
[224,252,194,203,221,241,388,214,310,167,236,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 160, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,247,239,236,258,259,258,254,261,248,255,245],
[254,0,240,241,241,248,243,250,254,259,251,236],
[262,261,0,239,269,263,244,249,282,257,250,240],
[265,260,262,0,266,260,260,257,263,246,259,241],
[243,260,232,235,0,259,247,266,246,245,247,247],
[242,253,238,241,242,0,236,240,252,273,262,242],
[243,258,257,241,254,265,0,251,252,247,257,240],
[247,251,252,244,235,261,250,0,257,242,264,255],
[240,247,219,238,255,249,249,244,0,246,251,228],
[253,242,244,255,256,228,254,259,255,0,239,244],
[246,250,251,242,254,239,244,237,250,262,0,241],
[256,265,261,260,254,259,261,246,273,257,260,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 161, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,253,232,263,238,248,230,237,264,245,234,277],
[248,0,249,244,248,252,240,247,265,248,240,260],
[269,252,0,266,248,243,233,243,284,266,260,254],
[238,257,235,0,268,248,228,237,253,256,242,250],
[263,253,253,233,0,248,254,256,253,254,240,262],
[253,249,258,253,253,0,244,243,252,266,248,262],
[271,261,268,273,247,257,0,253,287,268,248,264],
[264,254,258,264,245,258,248,0,256,251,260,266],
[237,236,217,248,248,249,214,245,0,259,234,239],
[256,253,235,245,247,235,233,250,242,0,250,251],
[267,261,241,259,261,253,253,241,267,251,0,237],
[224,241,247,251,239,239,237,235,262,250,264,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 162, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,261,230,222,227,231,244,261,227,247,235,243],
[240,0,213,231,239,222,225,244,227,246,233,234],
[271,288,0,238,277,275,250,272,248,276,254,264],
[279,270,263,0,247,255,248,273,269,271,256,271],
[274,262,224,254,0,252,226,244,261,266,260,264],
[270,279,226,246,249,0,251,272,264,256,267,272],
[257,276,251,253,275,250,0,278,254,260,265,264],
[240,257,229,228,257,229,223,0,240,272,243,255],
[274,274,253,232,240,237,247,261,0,263,251,257],
[254,255,225,230,235,245,241,229,238,0,238,255],
[266,268,247,245,241,234,236,258,250,263,0,277],
[258,267,237,230,237,229,237,246,244,246,224,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 163, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,242,261,218,245,242,270,224,241,219,258,246],
[259,0,264,242,240,269,259,275,258,264,245,265],
[240,237,0,224,233,262,254,252,257,258,252,259],
[283,259,277,0,248,259,287,246,265,260,245,289],
[256,261,268,253,0,246,284,252,262,261,269,264],
[259,232,239,242,255,0,256,255,245,258,235,227],
[231,242,247,214,217,245,0,251,219,252,253,247],
[277,226,249,255,249,246,250,0,257,265,261,254],
[260,243,244,236,239,256,282,244,0,261,245,252],
[282,237,243,241,240,243,249,236,240,0,257,261],
[243,256,249,256,232,266,248,240,256,244,0,255],
[255,236,242,212,237,274,254,247,249,240,246,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 164, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,221,255,246,236,230,246,282,276,225,210,270],
[280,0,287,290,265,268,250,267,273,283,248,307],
[246,214,0,299,261,304,253,272,256,286,229,248],
[255,211,202,0,261,222,164,250,272,263,234,241],
[265,236,240,240,0,271,191,241,271,272,204,249],
[271,233,197,279,230,0,198,227,275,207,206,236],
[255,251,248,337,310,303,0,269,275,253,263,310],
[219,234,229,251,260,274,232,0,278,270,224,242],
[225,228,245,229,230,226,226,223,0,203,180,212],
[276,218,215,238,229,294,248,231,298,0,234,272],
[291,253,272,267,297,295,238,277,321,267,0,277],
[231,194,253,260,252,265,191,259,289,229,224,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 165, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,227,215,221,247,220,242,259,243,230,236,232],
[274,0,234,259,260,228,261,265,263,229,234,276],
[286,267,0,244,266,255,268,262,262,235,244,271],
[280,242,257,0,258,249,263,249,275,256,239,246],
[254,241,235,243,0,230,249,235,258,245,221,251],
[281,273,246,252,271,0,269,259,265,241,244,275],
[259,240,233,238,252,232,0,278,252,240,238,222],
[242,236,239,252,266,242,223,0,274,246,229,259],
[258,238,239,226,243,236,249,227,0,233,212,255],
[271,272,266,245,256,260,261,255,268,0,254,289],
[265,267,257,262,280,257,263,272,289,247,0,265],
[269,225,230,255,250,226,279,242,246,212,236,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 166, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,231,318,252,298,292,298,296,282,232,256,294],
[270,0,325,291,258,276,343,291,313,332,257,248],
[183,176,0,218,250,227,259,292,311,231,205,259],
[249,210,283,0,206,295,316,263,268,252,233,233],
[203,243,251,295,0,291,370,259,299,253,275,217],
[209,225,274,206,210,0,292,251,274,284,200,196],
[203,158,242,185,131,209,0,229,243,223,153,132],
[205,210,209,238,242,250,272,0,223,249,245,223],
[219,188,190,233,202,227,258,278,0,216,191,183],
[269,169,270,249,248,217,278,252,285,0,173,255],
[245,244,296,268,226,301,348,256,310,328,0,252],
[207,253,242,268,284,305,369,278,318,246,249,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 167, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,227,274,240,225,288,297,270,225,301,283,292],
[274,0,283,273,284,293,310,238,251,321,312,256],
[227,218,0,260,261,248,260,226,224,260,249,271],
[261,228,241,0,234,286,310,252,231,282,279,276],
[276,217,240,267,0,238,264,297,230,293,253,303],
[213,208,253,215,263,0,256,222,212,264,234,268],
[204,191,241,191,237,245,0,229,204,272,208,233],
[231,263,275,249,204,279,272,0,248,260,232,273],
[276,250,277,270,271,289,297,253,0,314,253,274],
[200,180,241,219,208,237,229,241,187,0,215,221],
[218,189,252,222,248,267,293,269,248,286,0,268],
[209,245,230,225,198,233,268,228,227,280,233,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 168, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,274,269,244,264,243,265,267,244,239,252,256],
[227,0,250,252,261,222,245,241,230,244,244,240],
[232,251,0,231,248,238,244,255,221,225,209,234],
[257,249,270,0,253,249,254,264,243,244,249,255],
[237,240,253,248,0,250,242,266,223,238,220,229],
[258,279,263,252,251,0,273,261,249,240,245,237],
[236,256,257,247,259,228,0,239,231,241,228,241],
[234,260,246,237,235,240,262,0,228,229,226,245],
[257,271,280,258,278,252,270,273,0,252,254,247],
[262,257,276,257,263,261,260,272,249,0,259,266],
[249,257,292,252,281,256,273,275,247,242,0,260],
[245,261,267,246,272,264,260,256,254,235,241,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 169, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,231,234,254,255,254,246,232,242,258,252,274],
[270,0,260,275,256,255,267,266,247,260,256,261],
[267,241,0,240,261,253,248,245,246,251,261,261],
[247,226,261,0,241,264,249,220,236,247,239,253],
[246,245,240,260,0,245,263,246,262,257,245,278],
[247,246,248,237,256,0,246,246,237,243,250,260],
[255,234,253,252,238,255,0,227,253,241,238,262],
[269,235,256,281,255,255,274,0,252,280,273,274],
[259,254,255,265,239,264,248,249,0,250,255,278],
[243,241,250,254,244,258,260,221,251,0,241,271],
[249,245,240,262,256,251,263,228,246,260,0,262],
[227,240,240,248,223,241,239,227,223,230,239,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 170, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,268,263,218,257,274,247,262,273,247,270,242],
[233,0,235,259,228,244,229,237,248,234,256,253],
[238,266,0,230,241,248,238,238,274,234,250,248],
[283,242,271,0,276,277,264,274,264,269,283,268],
[244,273,260,225,0,238,254,239,241,235,267,276],
[227,257,253,224,263,0,237,242,231,236,269,243],
[254,272,263,237,247,264,0,274,277,247,270,267],
[239,264,263,227,262,259,227,0,238,243,262,265],
[228,253,227,237,260,270,224,263,0,251,260,254],
[254,267,267,232,266,265,254,258,250,0,277,262],
[231,245,251,218,234,232,231,239,241,224,0,222],
[259,248,253,233,225,258,234,236,247,239,279,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 171, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,256,245,255,256,230,254,217,258,253,236,246],
[245,0,249,263,253,243,233,219,256,264,237,249],
[256,252,0,242,276,252,258,236,267,255,249,260],
[246,238,259,0,254,248,265,214,236,254,239,222],
[245,248,225,247,0,229,239,224,262,249,244,247],
[271,258,249,253,272,0,270,233,270,284,268,264],
[247,268,243,236,262,231,0,224,247,253,242,255],
[284,282,265,287,277,268,277,0,271,289,267,246],
[243,245,234,265,239,231,254,230,0,255,236,237],
[248,237,246,247,252,217,248,212,246,0,240,251],
[265,264,252,262,257,233,259,234,265,261,0,268],
[255,252,241,279,254,237,246,255,264,250,233,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 172, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,266,283,243,256,255,254,253,262,283,249,232],
[235,0,243,222,245,272,230,240,251,324,263,226],
[218,258,0,228,227,219,209,234,262,252,228,186],
[258,279,273,0,262,271,206,259,290,298,298,291],
[245,256,274,239,0,239,210,247,284,271,237,196],
[246,229,282,230,262,0,195,189,247,261,259,221],
[247,271,292,295,291,306,0,290,225,304,284,240],
[248,261,267,242,254,312,211,0,303,285,251,230],
[239,250,239,211,217,254,276,198,0,267,230,227],
[218,177,249,203,230,240,197,216,234,0,234,210],
[252,238,273,203,264,242,217,250,271,267,0,246],
[269,275,315,210,305,280,261,271,274,291,255,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 173, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,181,182,192,249,236,186,189,238,258,233,210],
[320,0,283,277,321,330,236,307,302,256,275,245],
[319,218,0,213,267,281,236,282,318,245,283,237],
[309,224,288,0,351,266,266,365,305,216,301,309],
[252,180,234,150,0,219,154,271,285,209,221,222],
[265,171,220,235,282,0,227,294,272,211,267,263],
[315,265,265,235,347,274,0,307,310,298,321,280],
[312,194,219,136,230,207,194,0,246,195,269,265],
[263,199,183,196,216,229,191,255,0,176,185,191],
[243,245,256,285,292,290,203,306,325,0,228,234],
[268,226,218,200,280,234,180,232,316,273,0,234],
[291,256,264,192,279,238,221,236,310,267,267,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 174, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,271,236,234,261,239,231,235,247,233,235,250],
[230,0,242,233,246,254,232,238,246,238,234,236],
[265,259,0,249,247,247,240,229,254,230,232,238],
[267,268,252,0,248,245,257,254,259,253,255,261],
[240,255,254,253,0,240,237,252,251,234,237,254],
[262,247,254,256,261,0,252,276,253,245,255,265],
[270,269,261,244,264,249,0,267,259,259,244,263],
[266,263,272,247,249,225,234,0,240,246,233,245],
[254,255,247,242,250,248,242,261,0,242,232,240],
[268,263,271,248,267,256,242,255,259,0,240,250],
[266,267,269,246,264,246,257,268,269,261,0,247],
[251,265,263,240,247,236,238,256,261,251,254,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 175, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,225,254,250,234,246,247,248,237,228,246,256],
[276,0,262,266,249,239,255,256,253,250,263,277],
[247,239,0,249,252,246,255,263,246,249,228,259],
[251,235,252,0,224,260,269,251,239,233,238,266],
[267,252,249,277,0,264,253,249,262,248,263,264],
[255,262,255,241,237,0,254,248,259,252,258,296],
[254,246,246,232,248,247,0,260,246,250,234,245],
[253,245,238,250,252,253,241,0,275,247,239,263],
[264,248,255,262,239,242,255,226,0,230,224,255],
[273,251,252,268,253,249,251,254,271,0,253,268],
[255,238,273,263,238,243,267,262,277,248,0,271],
[245,224,242,235,237,205,256,238,246,233,230,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 176, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,256,264,235,248,256,251,264,273,292,272,260],
[245,0,230,235,232,236,250,253,285,259,253,244],
[237,271,0,252,244,259,255,265,261,274,259,255],
[266,266,249,0,252,261,266,264,256,292,249,262],
[253,269,257,249,0,266,238,255,264,280,249,263],
[245,265,242,240,235,0,232,264,257,275,264,255],
[250,251,246,235,263,269,0,257,267,274,269,288],
[237,248,236,237,246,237,244,0,256,275,261,246],
[228,216,240,245,237,244,234,245,0,257,265,270],
[209,242,227,209,221,226,227,226,244,0,257,231],
[229,248,242,252,252,237,232,240,236,244,0,247],
[241,257,246,239,238,246,213,255,231,270,254,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 177, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,253,231,265,271,272,275,270,274,275,246,282],
[248,0,244,269,295,272,254,254,252,272,284,272],
[270,257,0,254,284,288,266,252,235,272,270,274],
[236,232,247,0,249,247,250,252,232,242,246,246],
[230,206,217,252,0,265,241,250,238,248,245,260],
[229,229,213,254,236,0,234,244,252,252,226,259],
[226,247,235,251,260,267,0,238,238,251,248,256],
[231,247,249,249,251,257,263,0,258,265,254,262],
[227,249,266,269,263,249,263,243,0,252,248,268],
[226,229,229,259,253,249,250,236,249,0,229,252],
[255,217,231,255,256,275,253,247,253,272,0,262],
[219,229,227,255,241,242,245,239,233,249,239,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 178, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,231,241,224,235,231,237,257,230,227,239,226],
[270,0,273,242,269,243,253,261,253,251,269,246],
[260,228,0,235,241,245,237,255,233,240,254,231],
[277,259,266,0,249,245,238,267,265,242,258,242],
[266,232,260,252,0,244,259,259,248,239,264,250],
[270,258,256,256,257,0,255,268,262,243,259,234],
[264,248,264,263,242,246,0,262,263,254,253,235],
[244,240,246,234,242,233,239,0,242,234,234,236],
[271,248,268,236,253,239,238,259,0,238,276,256],
[274,250,261,259,262,258,247,267,263,0,268,252],
[262,232,247,243,237,242,248,267,225,233,0,231],
[275,255,270,259,251,267,266,265,245,249,270,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 179, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,243,256,243,261,275,267,277,286,279,270,252],
[258,0,263,242,266,239,240,285,306,244,280,249],
[245,238,0,240,256,236,248,290,268,238,264,231],
[258,259,261,0,253,269,236,268,305,259,292,220],
[240,235,245,248,0,236,251,270,279,266,253,249],
[226,262,265,232,265,0,262,296,261,236,296,244],
[234,261,253,265,250,239,0,293,294,241,269,244],
[224,216,211,233,231,205,208,0,236,208,241,203],
[215,195,233,196,222,240,207,265,0,211,271,208],
[222,257,263,242,235,265,260,293,290,0,288,206],
[231,221,237,209,248,205,232,260,230,213,0,236],
[249,252,270,281,252,257,257,298,293,295,265,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 180, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,264,244,279,249,254,247,262,257,252,274,249],
[237,0,229,231,240,245,254,261,233,218,259,234],
[257,272,0,268,243,274,260,267,249,249,292,264],
[222,270,233,0,217,233,240,240,231,220,259,232],
[252,261,258,284,0,262,267,286,241,239,276,233],
[247,256,227,268,239,0,259,250,222,225,262,232],
[254,247,241,261,234,242,0,263,206,217,249,245],
[239,240,234,261,215,251,238,0,194,225,248,231],
[244,268,252,270,260,279,295,307,0,262,283,263],
[249,283,252,281,262,276,284,276,239,0,276,270],
[227,242,209,242,225,239,252,253,218,225,0,223],
[252,267,237,269,268,269,256,270,238,231,278,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 181, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,196,326,256,236,276,296,240,262,250,254,280],
[305,0,290,257,252,254,305,228,255,258,284,282],
[175,211,0,216,245,243,304,220,266,193,238,271],
[245,244,285,0,214,276,324,221,230,249,256,306],
[265,249,256,287,0,282,267,229,280,267,283,271],
[225,247,258,225,219,0,306,190,259,213,264,274],
[205,196,197,177,234,195,0,182,196,199,231,288],
[261,273,281,280,272,311,319,0,276,250,260,302],
[239,246,235,271,221,242,305,225,0,232,254,258],
[251,243,308,252,234,288,302,251,269,0,258,272],
[247,217,263,245,218,237,270,241,247,243,0,265],
[221,219,230,195,230,227,213,199,243,229,236,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 182, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,241,250,241,249,234,243,241,253,251,257,260],
[260,0,242,245,266,239,257,252,257,246,246,266],
[251,259,0,258,271,244,236,254,267,266,266,273],
[260,256,243,0,274,257,245,254,259,257,245,264],
[252,235,230,227,0,228,228,253,240,255,244,248],
[267,262,257,244,273,0,265,273,271,264,268,264],
[258,244,265,256,273,236,0,252,266,264,251,248],
[260,249,247,247,248,228,249,0,252,258,253,253],
[248,244,234,242,261,230,235,249,0,257,250,249],
[250,255,235,244,246,237,237,243,244,0,258,256],
[244,255,235,256,257,233,250,248,251,243,0,241],
[241,235,228,237,253,237,253,248,252,245,260,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 183, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,314,263,300,270,247,281,313,214,298,299,288],
[187,0,169,202,226,205,238,275,205,262,255,208],
[238,332,0,284,330,292,242,292,231,288,285,271],
[201,299,217,0,294,213,269,313,230,297,276,263],
[231,275,171,207,0,201,249,243,230,250,254,251],
[254,296,209,288,300,0,245,254,271,245,293,275],
[220,263,259,232,252,256,0,338,246,280,314,295],
[188,226,209,188,258,247,163,0,154,238,270,234],
[287,296,270,271,271,230,255,347,0,288,323,301],
[203,239,213,204,251,256,221,263,213,0,280,253],
[202,246,216,225,247,208,187,231,178,221,0,298],
[213,293,230,238,250,226,206,267,200,248,203,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 184, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,252,237,240,245,258,245,237,240,240,245,251],
[249,0,257,243,246,247,253,240,234,244,241,250],
[264,244,0,264,262,252,252,262,253,252,246,250],
[261,258,237,0,254,248,253,251,256,240,243,251],
[256,255,239,247,0,241,255,242,239,251,225,274],
[243,254,249,253,260,0,248,266,267,256,247,266],
[256,248,249,248,246,253,0,243,251,248,251,258],
[264,261,239,250,259,235,258,0,250,262,251,264],
[261,267,248,245,262,234,250,251,0,251,248,275],
[261,257,249,261,250,245,253,239,250,0,249,265],
[256,260,255,258,276,254,250,250,253,252,0,245],
[250,251,251,250,227,235,243,237,226,236,256,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 185, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,252,218,253,248,254,246,232,258,249,268,268],
[249,0,224,236,257,255,228,242,243,256,270,232],
[283,277,0,260,266,270,265,235,264,227,273,256],
[248,265,241,0,235,247,233,234,238,248,236,232],
[253,244,235,266,0,257,258,248,243,262,257,252],
[247,246,231,254,244,0,234,219,223,243,258,237],
[255,273,236,268,243,267,0,259,247,257,260,220],
[269,259,266,267,253,282,242,0,266,254,280,238],
[243,258,237,263,258,278,254,235,0,242,276,230],
[252,245,274,253,239,258,244,247,259,0,289,220],
[233,231,228,265,244,243,241,221,225,212,0,209],
[233,269,245,269,249,264,281,263,271,281,292,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 186, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,245,259,240,243,251,253,246,273,248,267,239],
[256,0,264,261,275,254,268,259,275,255,259,247],
[242,237,0,241,252,231,253,224,245,238,235,241],
[261,240,260,0,257,241,257,239,253,249,248,251],
[258,226,249,244,0,253,250,237,253,241,241,240],
[250,247,270,260,248,0,252,261,246,240,254,231],
[248,233,248,244,251,249,0,238,255,228,238,240],
[255,242,277,262,264,240,263,0,266,247,268,241],
[228,226,256,248,248,255,246,235,0,246,264,257],
[253,246,263,252,260,261,273,254,255,0,263,265],
[234,242,266,253,260,247,263,233,237,238,0,249],
[262,254,260,250,261,270,261,260,244,236,252,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 187, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,138,264,269,158,252,162,130,165,154,130,182],
[363,0,283,309,188,321,279,169,348,300,291,341],
[237,218,0,264,248,334,278,171,292,173,236,281],
[232,192,237,0,115,228,203,183,206,228,261,202],
[343,313,253,386,0,347,269,266,322,248,337,264],
[249,180,167,273,154,0,184,201,248,199,142,244],
[339,222,223,298,232,317,0,177,256,240,307,218],
[371,332,330,318,235,300,324,0,243,267,268,252],
[336,153,209,295,179,253,245,258,0,177,253,265],
[347,201,328,273,253,302,261,234,324,0,315,220],
[371,210,265,240,164,359,194,233,248,186,0,254],
[319,160,220,299,237,257,283,249,236,281,247,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 188, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,247,294,275,271,252,286,271,239,232,265,275],
[254,0,253,208,225,232,240,231,267,262,235,225],
[207,248,0,240,242,204,222,207,253,241,207,240],
[226,293,261,0,253,285,260,211,280,245,253,256],
[230,276,259,248,0,283,231,229,285,243,237,233],
[249,269,297,216,218,0,251,220,258,251,232,267],
[215,261,279,241,270,250,0,248,292,292,262,259],
[230,270,294,290,272,281,253,0,255,283,270,308],
[262,234,248,221,216,243,209,246,0,228,214,233],
[269,239,260,256,258,250,209,218,273,0,263,227],
[236,266,294,248,264,269,239,231,287,238,0,258],
[226,276,261,245,268,234,242,193,268,274,243,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 189, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,256,256,246,258,246,250,247,246,247,253,259],
[245,0,254,246,265,252,242,240,257,248,253,247],
[245,247,0,233,257,253,245,242,255,250,238,252],
[255,255,268,0,266,249,255,247,256,253,259,251],
[243,236,244,235,0,232,262,243,245,241,242,250],
[255,249,248,252,269,0,261,250,265,259,248,251],
[251,259,256,246,239,240,0,258,245,246,266,249],
[254,261,259,254,258,251,243,0,255,249,254,248],
[255,244,246,245,256,236,256,246,0,259,247,251],
[254,253,251,248,260,242,255,252,242,0,261,249],
[248,248,263,242,259,253,235,247,254,240,0,257],
[242,254,249,250,251,250,252,253,250,252,244,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 190, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,264,257,244,241,258,284,266,255,245,260,247],
[237,0,237,219,223,225,259,253,250,228,237,241],
[244,264,0,235,230,242,261,250,245,241,241,243],
[257,282,266,0,233,253,271,260,261,260,253,254],
[260,278,271,268,0,270,273,262,256,241,256,255],
[243,276,259,248,231,0,270,257,252,246,257,241],
[217,242,240,230,228,231,0,245,241,233,243,247],
[235,248,251,241,239,244,256,0,246,232,249,265],
[246,251,256,240,245,249,260,255,0,235,243,253],
[256,273,260,241,260,255,268,269,266,0,254,269],
[241,264,260,248,245,244,258,252,258,247,0,265],
[254,260,258,247,246,260,254,236,248,232,236,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 191, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,256,305,277,309,294,273,247,259,263,238,318],
[245,0,256,305,318,305,300,294,257,265,259,260],
[196,245,0,249,281,290,254,263,226,251,225,276],
[224,196,252,0,315,292,263,243,261,279,225,264],
[192,183,220,186,0,228,206,194,228,206,205,224],
[207,196,211,209,273,0,246,240,211,204,167,221],
[228,201,247,238,295,255,0,283,187,202,186,242],
[254,207,238,258,307,261,218,0,217,253,199,262],
[242,244,275,240,273,290,314,284,0,249,194,259],
[238,236,250,222,295,297,299,248,252,0,222,277],
[263,242,276,276,296,334,315,302,307,279,0,318],
[183,241,225,237,277,280,259,239,242,224,183,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 192, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,258,254,251,272,265,260,240,250,258,271,257],
[243,0,246,232,269,247,249,247,250,236,264,265],
[247,255,0,247,269,267,263,256,245,242,284,273],
[250,269,254,0,290,260,267,261,277,249,287,280],
[229,232,232,211,0,217,236,232,231,219,245,239],
[236,254,234,241,284,0,257,247,247,239,264,263],
[241,252,238,234,265,244,0,241,246,241,257,259],
[261,254,245,240,269,254,260,0,250,244,284,265],
[251,251,256,224,270,254,255,251,0,239,269,257],
[243,265,259,252,282,262,260,257,262,0,280,269],
[230,237,217,214,256,237,244,217,232,221,0,244],
[244,236,228,221,262,238,242,236,244,232,257,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 193, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,312,258,254,267,317,283,217,351,297,275,224],
[189,0,229,160,220,244,205,171,234,166,242,220],
[243,272,0,234,261,315,167,264,292,310,277,260],
[247,341,267,0,295,326,226,162,262,231,243,263],
[234,281,240,206,0,191,138,215,244,228,250,259],
[184,257,186,175,310,0,152,114,264,127,150,254],
[218,296,334,275,363,349,0,270,303,255,269,315],
[284,330,237,339,286,387,231,0,351,293,233,322],
[150,267,209,239,257,237,198,150,0,165,200,221],
[204,335,191,270,273,374,246,208,336,0,228,219],
[226,259,224,258,251,351,232,268,301,273,0,288],
[277,281,241,238,242,247,186,179,280,282,213,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 194, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,219,214,256,244,236,261,242,240,250,249,220],
[282,0,264,258,236,279,263,271,236,287,273,249],
[287,237,0,263,248,269,275,273,224,272,270,255],
[245,243,238,0,257,279,270,251,237,277,274,246],
[257,265,253,244,0,285,280,266,267,284,284,259],
[265,222,232,222,216,0,272,242,234,269,277,228],
[240,238,226,231,221,229,0,237,229,249,258,247],
[259,230,228,250,235,259,264,0,245,269,261,249],
[261,265,277,264,234,267,272,256,0,279,265,264],
[251,214,229,224,217,232,252,232,222,0,246,239],
[252,228,231,227,217,224,243,240,236,255,0,224],
[281,252,246,255,242,273,254,252,237,262,277,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 195, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,254,238,261,255,263,244,266,257,241,257,246],
[247,0,255,268,239,264,242,253,247,243,256,226],
[263,246,0,265,263,254,240,259,246,251,262,239],
[240,233,236,0,238,257,242,252,245,228,237,257],
[246,262,238,263,0,256,265,249,239,237,240,252],
[238,237,247,244,245,0,230,260,259,241,243,244],
[257,259,261,259,236,271,0,276,254,249,253,245],
[235,248,242,249,252,241,225,0,247,249,249,225],
[244,254,255,256,262,242,247,254,0,243,244,265],
[260,258,250,273,264,260,252,252,258,0,262,251],
[244,245,239,264,261,258,248,252,257,239,0,231],
[255,275,262,244,249,257,256,276,236,250,270,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 196, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,240,285,247,212,236,226,231,250,236,222,250],
[261,0,276,244,229,244,230,242,264,256,243,252],
[216,225,0,219,220,214,213,219,236,231,237,223],
[254,257,282,0,235,258,292,269,276,258,242,262],
[289,272,281,266,0,261,269,259,287,250,270,292],
[265,257,287,243,240,0,237,217,269,260,263,265],
[275,271,288,209,232,264,0,251,241,214,223,265],
[270,259,282,232,242,284,250,0,258,281,257,292],
[251,237,265,225,214,232,260,243,0,245,232,266],
[265,245,270,243,251,241,287,220,256,0,232,264],
[279,258,264,259,231,238,278,244,269,269,0,259],
[251,249,278,239,209,236,236,209,235,237,242,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 197, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,246,216,202,248,226,206,252,263,230,247,244],
[255,0,246,260,269,261,242,247,241,274,273,262],
[285,255,0,235,270,223,225,281,268,244,260,284],
[299,241,266,0,275,264,251,257,249,279,254,276],
[253,232,231,226,0,227,219,233,229,257,261,251],
[275,240,278,237,274,0,246,282,257,254,269,261],
[295,259,276,250,282,255,0,300,290,269,276,272],
[249,254,220,244,268,219,201,0,262,241,234,258],
[238,260,233,252,272,244,211,239,0,247,265,263],
[271,227,257,222,244,247,232,260,254,0,266,267],
[254,228,241,247,240,232,225,267,236,235,0,241],
[257,239,217,225,250,240,229,243,238,234,260,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 198, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,256,287,251,247,283,299,284,248,287,308,195],
[245,0,260,239,254,300,285,241,277,276,311,246],
[214,241,0,240,220,280,256,278,264,271,254,223],
[250,262,261,0,219,325,274,289,289,228,283,269],
[254,247,281,282,0,293,324,249,290,317,284,208],
[218,201,221,176,208,0,260,243,231,213,257,194],
[202,216,245,227,177,241,0,220,223,252,251,179],
[217,260,223,212,252,258,281,0,269,252,255,247],
[253,224,237,212,211,270,278,232,0,244,278,236],
[214,225,230,273,184,288,249,249,257,0,281,238],
[193,190,247,218,217,244,250,246,223,220,0,203],
[306,255,278,232,293,307,322,254,265,263,298,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 199, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

##############################################################
om = np.array([
[0,244,238,253,250,235,231,241,239,228,244,212],
[257,0,266,259,258,245,247,253,260,251,256,247],
[263,235,0,235,243,240,232,235,246,254,237,230],
[248,242,266,0,249,237,241,229,244,234,251,237],
[251,243,258,252,0,242,241,230,245,259,244,231],
[266,256,261,264,259,0,249,247,262,269,253,245],
[270,254,269,260,260,252,0,247,273,256,276,243],
[260,248,266,272,271,254,254,0,268,248,265,255],
[262,241,255,257,256,239,228,233,0,250,254,248],
[273,250,247,267,242,232,245,253,251,0,245,230],
[257,245,264,250,257,248,225,236,247,256,0,230],
[289,254,271,264,270,256,258,246,253,271,271,0]])



times = np.zeros(rep)
for i in range(rep):
    # Algorithm with Condorcet winner
    algorithm = alg.AzziniMunda5(om) 
    start_time = time.time()
    d = alg.dRP(sc.ranking_to_lineal(sc.borda(om)), om)
    algorithm.best_dist = d
    sol = algorithm.execute()
    t = (time.time() - start_time)
    times[i] = t
    #print(t)
exec_time = np.median(times)
result = np.append(np.array([12, 501, 200, "ME-BBd", exec_time, sol.shape[0], algorithm.ntentative], dtype=np.dtype(object)), times)
print(result[:7])
results = np.vstack((results, result))

 
pd.DataFrame(results).to_csv("/Users/noeliarico/Desktop/folder-kemeny/2021EJOR/results/mebbd/mebbd_12_501.csv", index=False, header=False)