【问题描述】 给定n个城市（从0到n-1），3元组[A, B, C]表示城市A和城市B之间存在道路，且成本为C。计算从0号城市出发，旅行完每个城市一遍，最后回到0号城市的最小成本与路径。如果不存在最优方案，输出-1. 【输入形式】 第一行有两个数n、m表示n个城市，m条边。 接下来的m行均为空格隔开的三个整数A B C，表示城市A和B之间的成本为C 【输出形式】 最小成本 最小成本对应的路径

这是一个求解旅行商问题（TSP）的问题，可以使用动态规划来解决。以下是代码实现：

INF = float('inf')

n, m = map(int, input().split())
# 初始化邻接矩阵
graph = [[INF] * n for _ in range(n)]

for i in range(m):
    a, b, c = map(int, input().split())
    graph[a][b] = c
    graph[b][a] = c

# dp数组初始化，dp[i][j]表示从0出发经过i、j、...且以j结尾的最小成本
dp = [[INF] * n for _ in range(1 << n)]
dp[1][0] = 0

# 遍历每个状态
for state in range(1, 1 << n):
    for j in range(n):
        # 如果状态中包含j
        if state & (1 << j):
            # 遍历状态中的其他节点k
            for k in range(n):
                # 如果状态中包含k且不等于j，更新dp数组
                if state & (1 << k) and k != j:
                    dp[state][j] = min(dp[state][j], dp[state ^ (1 << j)][k] + graph[k][j])

ans = INF
path = []

# 遍历所有状态，找到最小成本
for j in range(1, n):
    # 如果从j到0有路，并且从所有节点出发经过所有节点最后回到0的成本最小
    if graph[j][0] != INF and dp[(1 << n) - 1][j] != INF:
        if dp[(1 << n) - 1][j] + graph[j][0] < ans:
            ans = dp[(1 << n) - 1][j] + graph[j][0]
            path = [0, j]
            state = (1 << n) - 1

            # 回溯路径
            while state:
                for k in range(n):
                    if state & (1 << k) and k != j and dp[state][j] == dp[state ^ (1 << j)][k] + graph[k][j]:
                        path.append(k)
                        j, state = k, state ^ (1 << j)
                        break

# 输出结果
if ans == INF:
    print(-1)
else:
    print(ans)
    print('->'.join(str(p) for p in path))

注：本代码使用了状态压缩。状态压缩可以将某些状态用一个整数表示，可以减少空间复杂度和时间复杂度。