# Solving the Traveling Salesman Problem with Python: A Brute Force Algorithm Example

An algorithm is a set of instructions that a computer follows to solve a problem. It is a step-by-step procedure that takes an input and produces an output. Algorithms are used in many areas of computer science, including artificial intelligence, machine learning, and data analysis.

## Traveling Salesman Problem

The Traveling Salesman Problem (TSP) is a classic problem in computer science. It is a problem of finding the shortest possible route that visits every city exactly once and returns to the starting point. The problem is NP-hard, which means that there is no known polynomial-time solution for it.

## Example Code

Here’s a simple example code in Python that solves the TSP using brute force. The code generates all possible permutations of cities and calculates the cost of each permutation. It then returns the permutation with the minimum cost.

Here’s a pseudocode version of the algorithm:

``````function tsp(cities):
min_cost = infinity
min_path = null
for path in permutations(cities):
cost = 0
for i in range(len(path)-1):
cost += distance(path[i], path[i+1])
if cost < min_cost:
min_cost = cost
min_path = path
return min_path, min_cost

function distance(city1, city2):
x1, y1 = city1
x2, y2 = city2
return sqrt((x1-x2)^2 + (y1-y2)^2)

cities = [(0,0), (1,0), (1,1), (0,1)]
path, cost = tsp(cities)
print("Shortest path:", path, "Cost:", cost)
``````

Here is the Python version of the algorithm:

``````import itertools

def tsp(cities):
min_cost = float('inf')
min_path = None
for path in itertools.permutations(cities):
cost = sum(distance(path[i], path[i+1]) for i in range(len(path)-1))
if cost < min_cost:
min_cost = cost
min_path = path
return min_path, min_cost

def distance(city1, city2):
x1, y1 = city1
x2, y2 = city2
return ((x1-x2)**2 + (y1-y2)**2)**0.5

cities = [(0,0), (1,0), (1,1), (0,1)]
path, cost = tsp(cities)
print(f"Shortest path: {path}, Cost: {cost}")
``````

In this example, we have four cities located at (0,0), (1,0), (1,1), and (0,1). The code generates all possible permutations of these cities and calculates the cost of each permutation. It then returns the permutation with the minimum cost, which is the shortest possible route that visits every city exactly once and returns to the starting point.