给定n个城市（从0到n-1），3元组[A, B, C]表示城市A和城市B之间存在道路，且成本为C。计算从0号城市出发，旅行完每个城市一遍，最后回到0号城市的最小成本与路径。如果不存在最优方案，输出-1 用回溯法给出完整代码

下面是使用回溯法求解TSP问题的完整代码：

from typing import List

def tsp(n: int, graph: List[List[int]]) -> List[int]:
    """
    求解TSP问题，返回最小成本和路径
    :param n: 城市数量
    :param graph: 城市之间的距离矩阵
    :return: 最小成本和路径
    """
    # 初始化访问状态和路径
    visited = [False] * n
    path = [0] * (n + 1)
    path[0] = path[-1] = 0  # 起点和终点为0
    min_cost = float('inf')
    cur_cost = 0
    
    def backtrack(cur_pos: int, depth: int):
        """
        回溯函数
        :param cur_pos: 当前位置
        :param depth: 当前深度
        """
        nonlocal min_cost, cur_cost
        # 如果已经遍历完所有城市，更新最小成本和路径
        if depth == n:
            min_cost = min(min_cost, cur_cost + graph[cur_pos][0])
            return

        for i in range(1, n):
            if not visited[i]:
                visited[i] = True
                path[depth] = i
                cur_cost += graph[cur_pos][i]
                # 剪枝：如果当前成本已经大于最小成本，就不需要再搜索了
                if cur_cost < min_cost:
                    backtrack(i, depth + 1)
                cur_cost -= graph[cur_pos][i]
                visited[i] = False

    visited[0] = True
    backtrack(0, 1)
    if min_cost == float('inf'):
        return -1, []
    else:
        return min_cost, path

在上述代码中，我们首先使用一个 `visited` 数组记录每个城市是否已经访问过，然后使用一个 `path` 数组记录当前路径，同时也是一个状态。在回溯函数中，我们首先判断是否已经遍历完所有城市，如果是，则更新最小成本和路径；否则，对于每个未访问过的城市，我们先将其标记为已访问，然后更新路径和当前成本，并递归搜索下一层。注意，我们在递归前进行了剪枝，即只有当当前成本小于最小成本时才会继续搜索。最后，如果最小成本仍然是无穷大，则说明不存在最优方案，返回-1；否则，返回最小成本和路径。