在从上海（S）到天津（T）的公路网中。从S到T有多中路线：S到A1为6，S到A2为3，S到A3为3，A1到B1为6，A1到B2为5，A2到B1为6，A2道B2为6，A3到B1为7，A3到B2为4，B1到C1为7，B1到C2为7，B2到C1为8，B2到C2为9，C1到T为5，C2到T为6。 （1）若货车要从上海（S）到天津（T）如何选择行驶路线可以使得距离最短？ （2）求解通过所有城市到达目的地的最短距离？ 给出数学建模代码

1. 货车要从上海（S）到天津（T）选择行驶路线可以使得距离最短的方法是使用迪杰斯特拉算法（Dijkstra algorithm）。

我们可以将每个城市看作图中的节点，每条道路看作图中的边，然后使用迪杰斯特拉算法求出从S到T的最短路径。

具体步骤如下：
1）初始化：将S到所有节点的距离初始化为无穷大，S到S的距离为0。
2）对于S到所有相邻节点的距离进行更新，即将S到A1、A2、A3的距离更新为6、3、3。
3）选择距离最小的节点A2，并将其标记为已访问。
4）对于A2到所有相邻节点的距离进行更新，即将A2到B1、B2的距离更新为6、6。
5）选择距离最小的节点B1，并将其标记为已访问。
6）对于B1到所有相邻节点的距离进行更新，即将B1到C1、C2的距离更新为7、7。
7）选择距离最小的节点C1，并将其标记为已访问。
8）对于C1到T的距离进行更新，即将C1到T的距离更新为5。
9）此时已经找到了从S到T的最短路径，路径长度为6+3+6+7+5=27。

因此，货车要从上海（S）到天津（T）选择行驶路线可以使得距离最短的路线为S-A2-B1-C1-T，路线长度为27。

2. 求解通过所有城市到达目的地的最短距离的方法是使用旅行商问题（TSP）的算法。

我们可以将每个城市看作图中的节点，每条道路看作图中的边，然后使用TSP算法求出经过所有城市的最短路径。

具体步骤如下：
1）初始化：将所有城市的状态设置为未访问，设置起始城市为S。
2）对于当前城市，从所有未访问的相邻城市中选择距离最小的城市进行访问，并将其标记为已访问。
3）重复步骤2，直到所有城市都被访问。
4）在所有经过所有城市的路径中选择距离最短的路径作为最终路径。

因为TSP问题是NP-hard问题，因此我们可以使用遗传算法、模拟退火等启发式算法来求解。

以下是使用遗传算法求解TSP问题的Python代码示例（假设城市数为10）：

import random

# 定义城市数和城市距离矩阵
num_cities = 10
distances = [[0, 6, 3, 3, 0, 0, 0, 0, 0, 0],
             [6, 0, 0, 0, 5, 6, 0, 0, 0, 0],
             [3, 0, 0, 0, 0, 6, 0, 0, 7, 4],
             [3, 0, 0, 0, 0, 0, 0, 0, 0, 0],
             [0, 5, 0, 0, 0, 0, 7, 7, 0, 0],
             [0, 6, 6, 0, 0, 0, 0, 0, 0, 0],
             [0, 0, 0, 0, 7, 0, 0, 0, 5, 6],
             [0, 0, 0, 0, 7, 0, 0, 0, 0, 0],
             [0, 0, 7, 0, 0, 0, 5, 0, 0, 0],
             [0, 0, 4, 0, 0, 0, 6, 0, 0, 0]]

# 定义遗传算法参数
pop_size = 50  # 种群大小
num_generations = 500  # 迭代次数
mutation_prob = 0.1  # 变异概率

# 初始化种群
population = []
for i in range(pop_size):
    individual = list(range(num_cities))
    random.shuffle(individual)
    population.append(individual)

# 定义适应度函数
def fitness(individual):
    distance = 0
    for i in range(num_cities-1):
        distance += distances[individual[i]][individual[i+1]]
    distance += distances[individual[-1]][individual[0]]
    return 1/distance

# 定义选择函数
def selection(population):
    fitness_values = [fitness(individual) for individual in population]
    total_fitness = sum(fitness_values)
    probabilities = [fitness_value/total_fitness for fitness_value in fitness_values]
    selected = random.choices(population, weights=probabilities, k=2)
    return selected[0], selected[1]

# 定义交叉函数
def crossover(parent1, parent2):
    point1 = random.randint(0, num_cities-1)
    point2 = random.randint(0, num_cities-1)
    if point1 > point2:
        point1, point2 = point2, point1
    child1 = parent1[point1:point2]
    child2 = [city for city in parent2 if city not in child1]
    child = child1 + child2
    return child

# 定义变异函数
def mutation(individual):
    if random.random() < mutation_prob:
        point1 = random.randint(0, num_cities-1)
        point2 = random.randint(0, num_cities-1)
        individual[point1], individual[point2] = individual[point2], individual[point1]

# 进行遗传算法迭代
for i in range(num_generations):
    new_population = []
    for j in range(pop_size//2):
        parent1, parent2 = selection(population)
        child1 = crossover(parent1, parent2)
        child2 = crossover(parent2, parent1)
        mutation(child1)
        mutation(child2)
        new_population.append(child1)
        new_population.append(child2)
    population = new_population

# 选择适应度最高的个体作为最优解
best_individual = max(population, key=fitness)
best_distance = 1/fitness(best_individual)
print("最短距离为:", best_distance)
print("最优解为:", best_individual)