20210820

1. 第一步，floyd算出所有点间的最短距离
2. 第二步，新建图，将起点S，餐厅，送货地点,最多11个点建立起来新图
   餐厅R1，对应送货地点a1, … , a4
   餐厅R2，对应送货地点a5, … , a8

   建边关系：
    >   S-->R1,R2 ； 
	>   R1<--  -->R2;  
 	>   R1,R2 -->a1,...,a8
	>   a1,...,a4 --> R2; 
	>   a5,...,a8 --> R1;
	>   a1,...,a4 <-- --> a5,...,a8

3. 第三步，dfs遍历所有点，求最短遍历路径和
   注意：餐厅R1或者R2没有被遍历到前，不访问其下面的送货点

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
import java.util.ArrayList;
import java.util.Arrays;

public class Solution {

    public static void main(String[] args) throws IOException {
        for (int i = 0; i <= 300; i++) {
            adj.add(new ArrayList<>());
        }
        in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        int T = nextInt();
        for (int tc = 1; tc <= T; tc++) {
            readCase();
            floyd();
            ans = INF;
            dfs(S, 0, 0, 1);
            System.out.println("#" + tc + " " + ans);
            for (int i = 1; i <= N; i++) adj.get(i).clear();
            Arrays.fill(vis, false);
        }
    }

    static void floyd() {
        for (int k = 1; k <= N; k++)
            for (int i = 1; i <= N; i++)
                for (int j = 1; j <= N; j++)
                    f[i][j] = Math.min(f[i][j], f[i][k] + f[k][j]);
    }

    static void dfs(int cur, int sum, int fa, int cnt) {
        if (cnt == E) {
            ans = Math.min(ans, sum);
        } else {
            vis[cur] = true;
            for (int to : adj.get(cur)) {
                if (to == fa) continue;
                if (vis[to]) continue;
                //餐厅被访问后，下面的点才可以访问
                if (vis[p[to]] && (p[to] == R1 || p[to] == R2)) continue;
                dfs(to, sum + f[cur][to], cur, cnt + 1);
            }
            vis[cur] = false;
        }
    }

    static void readCase() throws IOException {
        N = nextInt();
        M = nextInt();
        Q = nextInt();
        tmp.add(R1 = nextInt());
        tmp.add(R2 = nextInt());
        S = nextInt();
        for (int i = 1; i <= N; i++) {
            p[i] = i;
            Arrays.fill(f[i], INF);
        }
        for (int i = 0; i < M; i++) {
            int a = nextInt();
            int b = nextInt();
            int c = nextInt();
            f[a][b] = f[b][a] = c;
        }
        //创建新图，for DFS
        adj.get(S).add(R1);//S 与餐厅1 单项边
        adj.get(S).add(R2);//S 与餐厅2 单项边
        for (int i = 0; i < Q; i++) {
            int a = nextInt();
            int b = nextInt();
            adj.get(b).add(a);
            p[b] = a;
            tmp.add(a);
        }
        for (int i = 0; i < tmp.size(); i++) {
            for (int j = i + 1; j < tmp.size(); j++) {
                adj.get(i).add(j);
                adj.get(j).add(i);
            }
        }
        tmp.clear();
        E = 3 + Q;
    }

    static int nextInt() throws IOException {
        in.nextToken();
        return (int) in.nval;
    }

    static final int INF = Integer.MAX_VALUE >> 1;
    static final int[][] f = new int[303][303];
    static final int[] p = new int[303];
    static final boolean[] vis = new boolean[303];
    static final ArrayList<ArrayList<Integer>> adj = new ArrayList<>();
    static final ArrayList<Integer> tmp = new ArrayList<>();
    static StreamTokenizer in;
    static int N, M, Q, R1, R2, S, E;
    static long ans;
}