




'''simple docstring'''


import argparse
import copy
def 						snake_case_       (UpperCamelCase			:    Tuple ):





							'''simple docstring'''


							_a      	=							{}

							with open(UpperCamelCase ) as f:
														for line in f:
																					if line.split()[0] not in dict_of_neighbours:
																												_a      	=							[]
																												_list.append([line.split()[1], line.split()[2]] )
																												_a      	=							_list
																					else:
																												dict_of_neighbours[line.split()[0]].append(
																												    [line.split()[1], line.split()[2]] )
																					if line.split()[1] not in dict_of_neighbours:
																												_a      	=							[]
																												_list.append([line.split()[0], line.split()[2]] )
																												_a      	=							_list
																					else:
																												dict_of_neighbours[line.split()[1]].append(
																												    [line.split()[0], line.split()[2]] )

							return dict_of_neighbours
def 						snake_case_       (UpperCamelCase			:    List[Any]					,		UpperCamelCase			:    List[str] ):





							'''simple docstring'''


							with open(UpperCamelCase ) as f:
														_a      	=							f.read(1 )
							_a      	=							start_node

							_a      	=							[]

							_a      	=							start_node

							_a      	=							0
							while visiting not in first_solution:
														_a      	=							1_0000
														for k in dict_of_neighbours[visiting]:
																					if int(k[1] ) < int(UpperCamelCase ) and k[0] not in first_solution:
																												_a      	=							k[1]
																												_a      	=							k[0]

														first_solution.append(UpperCamelCase )
														_a      	=							distance_of_first_solution + int(UpperCamelCase )
														_a      	=							best_node

							first_solution.append(UpperCamelCase )

							_a      	=							0
							for k in dict_of_neighbours[first_solution[-2]]:
														if k[0] == start_node:
																					break
														position += 1

							_a      	=							(
							    distance_of_first_solution
							    + int(dict_of_neighbours[first_solution[-2]][position][1] )
							    - 1_0000
							)
							return first_solution, distance_of_first_solution
def 						snake_case_       (UpperCamelCase			:    Tuple					,		UpperCamelCase			:    List[str] ):





							'''simple docstring'''


							_a      	=							[]

							for n in solution[1:-1]:
														_a      	=							solution.index(UpperCamelCase )
														for kn in solution[1:-1]:
																					_a      	=							solution.index(UpperCamelCase )
																					if n == kn:
																												continue

																					_a      	=							copy.deepcopy(UpperCamelCase )
																					_a      	=							kn
																					_a      	=							n

																					_a      	=							0

																					for k in _tmp[:-1]:
																												_a      	=							_tmp[_tmp.index(UpperCamelCase ) + 1]
																												for i in dict_of_neighbours[k]:
																																			if i[0] == next_node:
																																										_a      	=							distance + int(i[1] )
																					_tmp.append(UpperCamelCase )

																					if _tmp not in neighborhood_of_solution:
																												neighborhood_of_solution.append(_tmp )

							_a      	=							len(neighborhood_of_solution[0] ) - 1

							neighborhood_of_solution.sort(key=lambda UpperCamelCase : x[index_of_last_item_in_the_list] )
							return neighborhood_of_solution
def 						snake_case_       (UpperCamelCase			:    List[Any]					,		UpperCamelCase			:    List[Any]					,		UpperCamelCase			:    Union[str, Any]					,		UpperCamelCase			:    Union[str, Any]					,		UpperCamelCase			:    Dict ):





							'''simple docstring'''


							_a      	=							1
							_a      	=							first_solution
							_a      	=							[]
							_a      	=							distance_of_first_solution
							_a      	=							solution

							while count <= iters:
														_a      	=							find_neighborhood(UpperCamelCase					,		UpperCamelCase )
														_a      	=							0
														_a      	=							neighborhood[index_of_best_solution]
														_a      	=							len(UpperCamelCase ) - 1

														_a      	=							False
														while not found:
																					_a      	=							0
																					while i < len(UpperCamelCase ):
																												if best_solution[i] != solution[i]:
																																			_a      	=							best_solution[i]
																																			_a      	=							solution[i]
																																			break
																												_a      	=							i + 1

																					if [first_exchange_node, second_exchange_node] not in tabu_list and [
																					    second_exchange_node,
																					    first_exchange_node,
																					] not in tabu_list:
																												tabu_list.append([first_exchange_node, second_exchange_node] )
																												_a      	=							True
																												_a      	=							best_solution[:-1]
																												_a      	=							neighborhood[index_of_best_solution][best_cost_index]
																												if cost < best_cost:
																																			_a      	=							cost
																																			_a      	=							solution
																					else:
																												_a      	=							index_of_best_solution + 1
																												_a      	=							neighborhood[index_of_best_solution]

														if len(UpperCamelCase ) >= size:
																					tabu_list.pop(0 )

														_a      	=							count + 1

							return best_solution_ever, best_cost
def 						snake_case_       (UpperCamelCase			:    str=None ):





							'''simple docstring'''


							_a      	=							generate_neighbours(args.File )

							_a	,				_a      	=							generate_first_solution(
							    args.File					,		UpperCamelCase )

							_a	,				_a      	=							tabu_search(
							    UpperCamelCase					,		UpperCamelCase					,		UpperCamelCase					,		args.Iterations					,		args.Size					,		)

							print(f'Best solution: {best_sol}, with total distance: {best_cost}.' )


if __name__ == "__main__":
				_snake_case : Dict  				=						argparse.ArgumentParser(description='Tabu Search')
				parser.add_argument(
				    '-f',
				    '--File',
				    type=str,
				    help='Path to the file containing the data',
				    required=True,
				)
				parser.add_argument(
				    '-i',
				    '--Iterations',
				    type=int,
				    help='How many iterations the algorithm should perform',
				    required=True,
				)
				parser.add_argument(
				    '-s', '--Size', type=int, help='Size of the tabu list', required=True
				)

				# Pass the arguments to main method
				main(parser.parse_args())




"""simple docstring"""
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_A							=  {"""configuration_sew""": ["""SEW_PRETRAINED_CONFIG_ARCHIVE_MAP""", """SEWConfig"""]}

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _A							=  [
        """SEW_PRETRAINED_MODEL_ARCHIVE_LIST""",
        """SEWForCTC""",
        """SEWForSequenceClassification""",
        """SEWModel""",
        """SEWPreTrainedModel""",
    ]

if TYPE_CHECKING:
    from .configuration_sew import SEW_PRETRAINED_CONFIG_ARCHIVE_MAP, SEWConfig

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_sew import (
            SEW_PRETRAINED_MODEL_ARCHIVE_LIST,
            SEWForCTC,
            SEWForSequenceClassification,
            SEWModel,
            SEWPreTrainedModel,
        )


else:
    import sys

    _A							=  _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

