#include <bits/stdc++.h>
using namespace std;
#define int long long
int inf = 1e18;
int n,k,m;
vector<int> imp;
vector<pair<int,int>> g[200005];
int dp[200005][16];
vector<int> d[5];
vector<int> dijkstra(int nod0)
{
vector<int> dist(n + 1);
for (int i = 1; i <= n; i++)
dist[i] = inf;
priority_queue<pair<int,int>> pq;
pq.push({0,nod0});
while (!pq.empty())
{
int nod = pq.top().second,cost = -pq.top().first;
pq.pop();
if (dist[nod] == inf)
{
dist[nod] = cost;
for (auto vecin : g[nod])
{
pq.push({-(vecin.second + cost),vecin.first});
}
}
}
return dist;
}
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k >> m;
for (int i = 1; i <= k; i++)
{
int x;
cin >> x;
imp.push_back(x);
}
for (int i = 1; i <= m; i++)
{
int x,y,z;
cin >> x >> y >> z;
g[x].push_back({y,z});
g[y].push_back({x,z});
}
k--;
for (int i = 0; i <= k; i++)
d[i] = dijkstra(imp[i]);
for (int mask = 1; mask < (1 << k); mask++)
{
for (int nod = 1; nod <= n; nod++)
{
dp[nod][mask] = inf;
for (int mask2 = 1; mask2 <= mask; mask2++)
{
if ((mask & mask2) != mask2)
continue;
int lft = 0;
for (int bit = 0; bit < k; bit++)
{
if ((1 << bit) & mask2)
lft += d[bit][nod];
}
dp[nod][mask] = min(dp[nod][mask],dp[nod][mask - mask2] + lft);
}
}
for (int nod = 1; nod <= n; nod++)
{
vector<vector<int>> dpp;
dpp.resize(g[nod].size());
for (int i = 0; i < g[nod].size(); i++)
dpp[i].resize((1 << k));
for (int i = 0; i < g[nod].size(); i++)
for (int j = 0; j < (1 << k); j++)
dpp[i][j] = inf;
for (int i = 0; i < g[nod].size(); i++)
{
if (i == 0)
{
for (int j = 0; j < (1 << k); j++)
{
if ((j & mask) != j or (j == mask))
continue;
if (j != 0)
dpp[i][j] = dp[g[nod][0].first][j] + g[nod][0].second;
}
}
else
{
for (int j = 0; j < (1 << k); j++)
{
if ((j & mask) != j)
continue;
dpp[i][j] = dpp[i - 1][j];
if (j != 0)
{
for (int jj = 1; jj < (1 << k); jj++)
{
if ((j & jj) != jj or (jj == mask))
continue;
dpp[i][j] = min(dpp[i][j],dpp[i - 1][j - jj] + g[nod][i].second + dp[g[nod][i].first][jj]);
}
}
}
}
}
dp[nod][mask] = min(dp[nod][mask],dpp[(int)g[nod].size() - 1][mask]);
}
set<pair<int,int>> s;
for (int nod = 1; nod <= n; nod++)
s.insert({dp[nod][mask],nod});
vector<bool> scos(n + 1);
while (!s.empty())
{
pair<int,int> idk = *s.begin();
s.erase(idk);
scos[idk.second] = true;
for (auto it : g[idk.second])
{
if (!scos[it.first])
{
s.erase({dp[it.first][mask],it.first});
int new_cost = min(dp[it.first][mask],idk.first + it.second);
dp[it.first][mask] = new_cost;
s.insert({new_cost,it.first});
}
}
}
}
int ans = dp[imp[k]][(1 << k) - 1];
//for (int i = 1; i <= n; i++)
// ans = min(ans,d[k][i] + dp[i][(1 << k) - 1]);
//if (ans < dp[imp[k]][(1 << k) - 1])
// assert(false);
cout << ans;
return 0;
}
/*
4 2 6
1 3
1 2 4
1 3 9
1 4 6
2 3 2
2 4 5
3 4 8
*/
/**
as vrea sa imi fac un dp[nod][mask] = presupunand ca am plecat din imp[0] si am drum spre nod, cat imi mai ia ca sa ma conectez cu nod de mask
1.dp[nod][mask] ar putea fi dp[nod][mask2], mask2 inclus in mask cu tranzitia dp[nod][mask2] + sum(dist(nd,nod)) cu nd special in mask - mask2
acum sa presupun ca nu leg nodul nod de cnv in mod direct
2.dp[nod][mask] ar putea fi sum(dp[vec][mask_vec] + cost_edge_nod_vec) cu reuniune(mask_vec) = mask, mask_vec disjuncte (caz pe care iau macar 2 vecini)
3.dp[nod][mask] = cost_edge_nod_vec + dp[vec][mask], pe care ordinea in care calculez e gen dupa dp-uri inainte de a lua cazul asta
Complexitate: O(intra in timp)
**/
Compilation message
cities.cpp: In function 'int main()':
cities.cpp:82:31: warning: comparison of integer expressions of different signedness: 'long long int' and 'std::vector<std::pair<long long int, long long int> >::size_type' {aka 'long unsigned int'} [-Wsign-compare]
82 | for (int i = 0; i < g[nod].size(); i++)
| ~~^~~~~~~~~~~~~~~
cities.cpp:84:31: warning: comparison of integer expressions of different signedness: 'long long int' and 'std::vector<std::pair<long long int, long long int> >::size_type' {aka 'long unsigned int'} [-Wsign-compare]
84 | for (int i = 0; i < g[nod].size(); i++)
| ~~^~~~~~~~~~~~~~~
cities.cpp:87:31: warning: comparison of integer expressions of different signedness: 'long long int' and 'std::vector<std::pair<long long int, long long int> >::size_type' {aka 'long unsigned int'} [-Wsign-compare]
87 | for (int i = 0; i < g[nod].size(); i++)
| ~~^~~~~~~~~~~~~~~
| # |
결과 |
실행 시간 |
메모리 |
Grader output |
| 1 |
Correct |
1 ms |
5212 KB |
Output is correct |
| 2 |
Correct |
1 ms |
5212 KB |
Output is correct |
| 3 |
Correct |
1 ms |
5212 KB |
Output is correct |
| 4 |
Correct |
1 ms |
5212 KB |
Output is correct |
| 5 |
Correct |
2 ms |
5212 KB |
Output is correct |
| # |
결과 |
실행 시간 |
메모리 |
Grader output |
| 1 |
Correct |
705 ms |
38372 KB |
Output is correct |
| 2 |
Correct |
702 ms |
37576 KB |
Output is correct |
| 3 |
Correct |
236 ms |
33716 KB |
Output is correct |
| 4 |
Correct |
379 ms |
29248 KB |
Output is correct |
| 5 |
Correct |
303 ms |
37508 KB |
Output is correct |
| 6 |
Correct |
199 ms |
29512 KB |
Output is correct |
| 7 |
Correct |
6 ms |
5724 KB |
Output is correct |
| 8 |
Correct |
3 ms |
5468 KB |
Output is correct |
| # |
결과 |
실행 시간 |
메모리 |
Grader output |
| 1 |
Correct |
8 ms |
5724 KB |
Output is correct |
| 2 |
Correct |
8 ms |
5724 KB |
Output is correct |
| 3 |
Correct |
4 ms |
5468 KB |
Output is correct |
| 4 |
Correct |
7 ms |
5724 KB |
Output is correct |
| # |
결과 |
실행 시간 |
메모리 |
Grader output |
| 1 |
Correct |
1416 ms |
39384 KB |
Output is correct |
| 2 |
Correct |
1383 ms |
38368 KB |
Output is correct |
| 3 |
Correct |
562 ms |
34552 KB |
Output is correct |
| 4 |
Correct |
1047 ms |
25904 KB |
Output is correct |
| 5 |
Correct |
847 ms |
29524 KB |
Output is correct |
| 6 |
Correct |
655 ms |
31052 KB |
Output is correct |
| # |
결과 |
실행 시간 |
메모리 |
Grader output |
| 1 |
Correct |
3352 ms |
39912 KB |
Output is correct |
| 2 |
Incorrect |
3169 ms |
40028 KB |
Output isn't correct |
| 3 |
Halted |
0 ms |
0 KB |
- |
