#include <bits/stdc++.h>
using namespace std;
long solve(vector<vector<int>>& grid) {
    long long  prev = 0;
    long long  connections = 0;
    for (vector<int>& row : grid) {
        int sum = 0;
        for (int n : row) {
            sum += n;
        }

        if (sum > 0) {
            connections += prev * sum;
            prev = sum;
        }
    }

    return connections;
}

#include <bits/stdc++.h>
using namespace std;

using ll = long long; 
const ll INF = LLONG_MAX;

vector<ll> dijkstra(int n, int src, const vector<vector<pair<int, int>>>& adj) {
    vector<ll> dist(n, INF);
    dist[src] = 0;
    priority_queue<pair<ll, int>, vector<pair<ll, int>>, greater<>> pq;
    pq.push({0, src});

    while (!pq.empty()) {
        auto [d, u] = pq.top();
        pq.pop();

        if (d > dist[u]) continue;

        for (auto [v, cost] : adj[u]) {
            if (dist[u] + cost < dist[v]) {
                dist[v] = dist[u] + cost;
                pq.push({dist[v], v});
            }
        }
    }

    return dist;
}

vector<vector<ll>> shortest(int nodes, const vector<int>& deliveries, const vector<vector<pair<int, int>>>& adj) {
    int k = deliveries.size();
    vector<vector<ll>> dist(k, vector<ll>(nodes));

    for (int i = 0; i < k; ++i) {
        dist[i] = dijkstra(nodes, deliveries[i], adj);
    }

    return dist;
}

ll minTime(int nodes, int k, const vector<ll>& startDist, const vector<vector<ll>>& dist, const vector<int>& deliveries) {
    vector<vector<ll>> dp(1 << k, vector<ll>(k, INF));

    for (int i = 0; i < k; ++i) {
        dp[1 << i][i] = startDist[deliveries[i]];
    }

    for (int mask = 0; mask < (1 << k); ++mask) {
        for (int i = 0; i < k; ++i) {
            if (mask & (1 << i)) {
                for (int j = 0; j < k; ++j) {
                    if (!(mask & (1 << j))) {
                        dp[mask | (1 << j)][j] = min(dp[mask | (1 << j)][j], dp[mask][i] + dist[i][deliveries[j]]);
                    }
                }
            }
        }
    }

    ll minTime = INF;
    for (int i = 0; i < k; ++i) {
        minTime = min(minTime, dp[(1 << k) - 1][i] + dist[i][0]);
    }

    return minTime;
}

int main() {
    int n, e, c;
    cin >> n >> e;

    vector<int> from(e), to(e), cost(e);
    for (int i = 0; i < e; ++i) {
        cin >> from[i] >> to[i] >> cost[i];
    }

    cin >> c;
    vector<int> deliveries(c);
    for (int i = 0; i < c; ++i) {
        cin >> deliveries[i];
    }

    vector<vector<pair<int, int>>> adj(n);
    for (int i = 0; i < e; ++i) {
        adj[from[i]].emplace_back(to[i], cost[i]);
        adj[to[i]].emplace_back(from[i], cost[i]);
    }

    vector<ll> start = dijkstra(n, 0, adj);
    vector<vector<ll>> dist = shortest(n, deliveries, adj);

    ll mini = minTime(n ,c, start, dist, deliveries);
    cout << mini << endl;

    return 0;
}

def dfs(node, par, depth, graph, signal_speed):
    global cnt
    if depth % signal_speed == 0 and depth != 0:
        cnt += 1
    for neighbor, weight in graph[node]:
        if neighbor == par:
            continue
        dfs(neighbor, node, depth + weight, graph, signal_speed)

def getNumPairs(server_nodes, server_from, server_to, server_weight, signal_speed):
    graph = {}
    for i in range(server_nodes - 1):
        if server_from[i] not in graph:
            graph[server_from[i]] = []
        if server_to[i] not in graph:
            graph[server_to[i]] = []
        graph[server_from[i]].append((server_to[i], server_weight[i]))
        graph[server_to[i]].append((server_from[i], server_weight[i]))
    result = []
    for i in range(1, server_nodes + 1):
        global cnt
        cnt = 0
        dfs(i, i, 0, graph, signal_speed)
        result.append(cnt * (cnt - 1))
    return result

def split_text_to_sms(text, limit):
    def suffix_length(x, y):
        return len(f"<{x}/{y}>")
    for y in range(1, len(text) + 1):
        max_content_length = limit - suffix_length(1, y)
        if max_content_length <= 0:
            continue
        
        messages = []
        current_start = 0
        
        while current_start < len(text):
            if current_start + max_content_length > len(text):
                end = len(text)
            else:
                end = current_start + max_content_length
            
            message_content = text[current_start:end]
            message_suffix = f"<{len(messages) + 1}/{y}>"
            
            if len(message_content) + len(message_suffix) > limit:
                break
            
            messages.append(message_content + message_suffix)
            current_start = end
        
        if len(messages) == y:
            return messages
    
    return []