text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const long long dx[] = {1, 0, -1, 0};
const long long dy[] = {0, 1, 0, -1};
long long ans;
int a[300005], b[300005];
long long c[300005];
vector<vector<pair<int, long long>>> adj(300005);
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a[i] >> b[i] >> c[i];
adj[a[i]].push_back({b[i], c[i]});
adj[b[i]].push_back({a[i], c[i]});
}
int src;
cin >> src;
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
pq;
vector<long long> dist(300005, 1000000000000000148);
pq.push({0, src});
dist[src] = 0;
while (!pq.empty()) {
int u = pq.top().second;
pq.pop();
for (auto i : adj[u]) {
int v = i.first;
long long w = i.second;
if (dist[v] > dist[u] + w) {
dist[v] = dist[u] + w;
pq.push({dist[v], v});
}
}
}
int best[300005];
for (int i = 0; i <= n; i++) best[i] = -1;
for (int i = 0; i < m; i++) {
if (dist[a[i]] + c[i] == dist[b[i]]) {
if (best[b[i]] == -1 or c[best[b[i]]] > c[i]) best[b[i]] = i;
}
}
for (int i = 0; i < m; i++) {
if (dist[a[i]] == dist[b[i]] + c[i]) {
if (best[a[i]] == -1 or c[best[a[i]]] > c[i]) best[a[i]] = i;
}
}
int visited[300005];
memset(visited, 0, sizeof visited);
for (int i = 1; i <= n; i++) {
if (i == src) continue;
visited[best[i]] = 1;
}
for (int i = 0; i < m; i++) {
if (visited[i]) ans += c[i];
}
cout << ans << endl;
for (int i = 0; i < m; i++) {
if (visited[i]) cout << i + 1 << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 100;
const long long INF = 1LL << 60;
struct edge {
int from, to, num, cost;
edge(int from = 0, int to = 0, int num = 0, int cost = 0)
: from(from), to(to), num(num), cost(cost) {}
};
vector<edge> E;
vector<int> t, V[maxn];
long long d[maxn];
long long cost[maxn];
long long Dijkstra(int u, int n) {
priority_queue<pair<pair<long long, int>, pair<long long, int> >,
vector<pair<pair<long long, int>, pair<long long, int> > >,
greater<pair<pair<long long, int>, pair<long long, int> > > >
q;
fill(cost + 1, cost + n + 1, INF);
fill(d + 1, d + n + 1, INF);
d[u] = cost[u] = 0;
q.push(pair<pair<long long, int>, pair<long long, int> >(
pair<long long, int>(0, 0), pair<long long, int>(-1, u)));
long long res = 0;
while (!q.empty()) {
pair<pair<long long, int>, pair<long long, int> > p = q.top();
q.pop();
int v = p.second.second;
if (p.first.second != cost[v]) {
continue;
}
res += cost[v];
if (p.second.first != -1) {
t.push_back(p.second.first + 1);
}
for (int i = 0; i < V[v].size(); ++i) {
edge e = E[V[v][i]];
int k = v == e.from ? e.to : e.from;
if ((d[k] > d[v] + e.cost) ||
(d[k] == d[v] + e.cost && cost[k] > e.cost)) {
cost[k] = e.cost;
d[k] = d[v] + e.cost;
q.push(pair<pair<long long, int>, pair<long long, int> >(
pair<long long, int>(d[k], cost[k]),
pair<long long, int>(e.num, k)));
}
}
}
return res;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int x, y, l;
cin >> x >> y >> l;
E.push_back(edge(x, y, i, l));
V[x].push_back(i);
V[y].push_back(i);
}
int u;
cin >> u;
cout << Dijkstra(u, n) << endl;
for (int i = 0; i < t.size(); ++i) {
cout << t[i] << (i != t.size() ? ' ' : '\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 20;
const long long inf = 1e18;
set<pair<long long, long long>> q;
vector<pair<long long, pair<long long, long long>>> adj[N], gr[N];
pair<long long, pair<long long, long long>> par[N];
long long dis[N];
vector<long long> yal, ed;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
long long u, v, w;
cin >> u >> v >> w;
ed.push_back(w);
gr[u].push_back({v, {w, i + 1}});
gr[v].push_back({u, {w, i + 1}});
}
int u;
cin >> u;
for (int i = 0; i <= n; i++)
dis[i] = inf, par[u].first = -1, par[u].second.first = inf;
dis[u] = 0;
q.insert({dis[u], u});
while (!q.empty()) {
int f = q.begin()->second;
q.erase(q.begin());
for (auto x : gr[f]) {
if (dis[x.first] > (dis[f] + x.second.first)) {
q.erase({dis[x.first], x.first});
dis[x.first] = dis[f] + x.second.first;
q.insert({dis[x.first], x.first});
par[x.first].first = f;
par[x.first].second.first = x.second.first;
par[x.first].second.second = x.second.second;
} else if (dis[x.first] == (dis[f] + x.second.first)) {
if (x.second.first < par[x.first].second.first)
par[x.first].first = f, par[x.first].second.first = x.second.first,
par[x.first].second.second = x.second.second;
}
}
}
long long sum = 0;
for (int i = 1; i <= n; i++) {
if (i != u) sum += par[i].second.first;
}
cout << sum << endl;
for (int i = 1; i <= n; i++) {
if (i != u) cout << par[i].second.second << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, u, v, w, st;
vector<int> g[300005], e[300005];
vector<int> id[300005];
queue<int> q;
int inq[300005], pre[300005], from[300005];
long long dis[300005], sum;
int lst[300005], tot = 0;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &u, &v, &w);
g[u].push_back(v);
e[u].push_back(w);
id[u].push_back(i);
g[v].push_back(u);
e[v].push_back(w);
id[v].push_back(i);
}
scanf("%d", &st);
memset(dis, 0x3f, sizeof(dis));
inq[st] = 1;
dis[st] = 0LL;
q.push(st);
while (!q.empty()) {
u = q.front();
q.pop();
inq[u] = 0;
for (int i = 0; i < g[u].size(); i++)
if (dis[u] + (long long)e[u][i] < dis[g[u][i]]) {
dis[g[u][i]] = dis[u] + (long long)e[u][i];
pre[g[u][i]] = id[u][i];
from[g[u][i]] = e[u][i];
if (!inq[g[u][i]]) {
inq[g[u][i]] = 1;
q.push(g[u][i]);
}
} else if (dis[u] + (long long)e[u][i] == dis[g[u][i]] &&
e[u][i] < from[g[u][i]]) {
pre[g[u][i]] = id[u][i];
from[g[u][i]] = e[u][i];
}
}
for (int i = 1; i <= n; i++) {
if (i != st) {
lst[++tot] = pre[i];
sum += (long long)from[i];
}
}
printf("%I64d\n", sum);
for (int i = 1; i <= tot; i++) printf("%d ", lst[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
int pai[300300];
vector<pair<long long int, long long int> > adj[300300], edge;
long long int dist[300300], in[300300];
void dijkstra(int u) {
int v, d;
for (int i = 0; i < 300300; ++i) in[i] = dist[i] = (1LL << 50), pai[i] = i;
dist[u] = in[u] = 0;
priority_queue<pair<long long int, long long int>,
vector<pair<long long int, long long int> >,
greater<pair<long long int, long long int> > >
pq;
pq.push(pair<long long int, long long int>(0, u));
while (pq.size()) {
u = pq.top().second, d = pq.top().first, pq.pop();
for (int i = 0; i < adj[u].size(); ++i) {
v = adj[u][i].second;
if (dist[v] - dist[u] > adj[u][i].first) {
pai[v] = u;
in[v] = adj[u][i].first;
dist[v] = dist[u] + adj[u][i].first;
pq.push(pair<long long int, long long int>(dist[v], v));
} else if (dist[v] == dist[u] + adj[u][i].first) {
if (in[v] > adj[u][i].first) {
in[v] = adj[u][i].first;
pai[v] = u;
}
}
}
}
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
pair<long long int, long long int> ed;
long long int ans = 0;
long long int n, m, a, b, c;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
cin >> a >> b >> c;
edge.push_back(pair<long long int, long long int>(a, b));
adj[a].push_back(pair<long long int, long long int>(c, b));
adj[b].push_back(pair<long long int, long long int>(c, a));
}
cin >> a;
dijkstra(a);
for (int i = 1; i <= n; ++i) ans += in[i];
cout << ans << "\n";
for (int i = 0; i < m; ++i) {
ed = edge[i];
if (pai[ed.first] == ed.second || pai[ed.second] == ed.first)
cout << i + 1 << " ";
}
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300010;
const int mod = 1e9 + 7;
const long double PI = acos(-1.0);
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
template <class T>
inline void gmax(T &A, T B) {
(A < B) && (A = B);
}
template <class T>
inline void gmin(T &A, T B) {
(A > B) && (A = B);
}
template <class T>
inline bool re(T &ret) {
char c;
int sgn;
if (c = getchar(), c == EOF) return 0;
while (c != '-' && (c < '0' || c > '9')) c = getchar();
sgn = (c == '-') ? -1 : 1;
ret = (c == '-') ? 0 : (c - '0');
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c - '0');
ret *= sgn;
return 1;
}
struct edge {
int to, w, id;
edge(int to, int w, int id) : to(to), w(w), id(id) {}
};
int n, m, u;
long long ans;
long long d[N];
int pre[N], c[N];
vector<edge> g[N];
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
q;
void dij() {
memset(d, 0x3f, sizeof(d));
memset(c, 0x3f, sizeof(c));
q.push({0, u});
d[u] = 0;
while ((int)(q).size()) {
pair<long long, long long> u = q.top();
q.pop();
if (d[u.second] < u.first) continue;
for (auto x : g[u.second]) {
if (d[x.to] > d[u.second] + x.w) {
d[x.to] = d[u.second] + x.w;
q.push({d[x.to], x.to});
pre[x.to] = x.id;
c[x.to] = x.w;
} else if (d[x.to] == d[u.second] + x.w && x.w < c[x.to]) {
pre[x.to] = x.id;
c[x.to] = x.w;
}
}
}
}
int main() {
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
};
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v, c;
cin >> u >> v >> c;
g[u].push_back(edge(v, c, i));
g[v].push_back(edge(u, c, i));
}
cin >> u;
dij();
for (int i = 1; i <= n; i++)
if (i != u) ans += c[i];
cout << ans << endl;
for (int i = 1; i <= n; i++)
if (i != u) cout << pre[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 1e6 + 10;
const long long inf = 1e18;
vector<pair<int, int>> adj[max_n];
set<pair<long long, int>> q;
long long d[max_n];
int b[max_n];
set<int> ans;
map<pair<int, int>, int> mp;
map<pair<int, int>, int> e;
map<int, long long> z;
long long p;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v, c;
cin >> u >> v >> c;
u--;
v--;
adj[u].push_back({c, v});
mp[make_pair(u, v)] = c;
mp[make_pair(v, u)] = c;
e[make_pair(u, v)] = i + 1;
e[make_pair(v, u)] = i + 1;
z[i + 1] = c;
z[i + 1] = c;
adj[v].push_back({c, u});
}
int h;
cin >> h;
h--;
for (int i = 0; i < n; i++)
if (i != h) d[i] = inf;
q.insert({0, h});
while (q.size()) {
int v = (*q.begin()).second;
q.erase(q.begin());
for (auto j : adj[v]) {
if (d[j.second] > d[v] + j.first) {
ans.erase(e[{b[j.second], j.second}]);
b[j.second] = v;
q.erase({d[j.second], j.second});
q.insert({d[j.second] = d[v] + j.first, j.second});
ans.insert(e[{j.second, v}]);
} else if (d[j.second] == d[v] + j.first &&
mp[{b[j.second], j.second}] > j.first) {
ans.erase(e[{b[j.second], j.second}]);
b[j.second] = v;
q.erase({d[j.second], j.second});
q.insert({d[j.second] = d[v] + j.first, j.second});
ans.insert(e[{j.second, v}]);
}
}
}
for (auto i : ans) p += z[i];
cout << p << endl;
for (auto i : ans) cout << i << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000001;
int main() {
int N, M, a;
scanf("%d %d", &N, &M);
long long edges[M][3], dist[N], par[N], chk[N];
vector<int> paths[N];
for (int i = 0; i < N; i++) {
dist[i] = 1e18;
chk[i] = 0;
}
for (int i = 0; i < M; i++) {
scanf("%lld %lld %lld", &edges[i][0], &edges[i][1], &edges[i][2]);
paths[--edges[i][0]].push_back(i);
paths[--edges[i][1]].push_back(i);
}
scanf("%d", &a);
a--;
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
pq;
pq.push({0, a});
dist[a] = 0;
chk[a] = 1;
pair<long long, int> cur;
long long ans = 0;
vector<int> fin;
while (!pq.empty()) {
cur = pq.top();
pq.pop();
if (cur.first != dist[cur.second]) continue;
if (!chk[cur.second]) {
ans += edges[par[cur.second]][2];
fin.push_back(par[cur.second]);
chk[cur.second] = 1;
}
for (int i : paths[cur.second]) {
a = edges[i][0] ^ edges[i][1] ^ cur.second;
if (dist[cur.second] + edges[i][2] < dist[a] ||
(dist[cur.second] + edges[i][2] == dist[a] &&
edges[i][2] < edges[par[a]][2])) {
dist[a] = dist[cur.second] + edges[i][2];
par[a] = i;
pq.push({dist[a], a});
}
}
}
printf("%lld\n", ans);
for (int i : fin) {
printf("%d ", i + 1);
}
}
|
#include <bits/stdc++.h>
using namespace std;
string vow = "aeiou";
int month[] = {-1, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const int dxhorse[] = {-2, -2, -1, -1, 1, 1, 2, 2};
const int dyhorse[] = {1, -1, 2, -2, 2, -2, 1, -1};
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
const long double pie = 3.1415926535897932384626;
const long long mod = 1e9 + 7;
const int N = 3e5 + 10;
vector<pair<int, int> > g[N];
long long dis[N];
int weight[N];
int n, m, src;
void read() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int a, b, w;
cin >> a >> b >> w;
g[a].push_back({i, b});
g[b].push_back({i, a});
weight[i] = w;
}
cin >> src;
}
struct comp {
bool operator()(const pair<long long, pair<int, int> > &a,
const pair<long long, pair<int, int> > &b) {
if (a.first < b.first) return false;
if (a.first > b.first) return true;
if (a.first == b.first) {
if (weight[a.second.first] < weight[b.second.first]) return false;
return true;
}
}
};
vector<int> ans;
long long tot_cost = 0;
bool vis[N];
void dijk(int node) {
priority_queue<pair<long long, pair<int, int> >,
vector<pair<long long, pair<int, int> > >, comp>
q;
const long long inf = 1e15;
for (int i = 1; i <= n; i++) dis[i] = inf;
dis[node] = 0;
q.push({0, {0, node}});
while (q.empty() == false) {
auto temp = q.top();
q.pop();
node = temp.second.second;
if (vis[node]) continue;
;
vis[node] = 1;
int edge_number = temp.second.first;
long long d = temp.first;
if (edge_number) {
ans.push_back(edge_number);
tot_cost += weight[edge_number];
}
for (auto &temp : g[node]) {
int i = temp.second;
if (vis[i]) continue;
;
long long relax_dis = d + weight[temp.first];
if (relax_dis <= dis[i]) {
dis[i] = relax_dis;
q.push({relax_dis, {temp.first, i}});
}
}
}
}
void solve(int test_case) {
read();
dijk(src);
cout << tot_cost;
cout << "\n";
;
for (auto &i : ans) cout << i << " ";
cout << "\n";
;
}
int main() {
int t = 1;
for (int i = 1; i <= t; i++) solve(i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace minmax {
template <class T>
T max(T&& A) {
return A;
}
template <class T>
T min(T&& A) {
return A;
}
template <class T>
T max(T&& A, T&& B) {
return A > B ? A : B;
}
template <class T>
T min(T&& A, T&& B) {
return A < B ? A : B;
}
template <class T, class... Ts>
T max(T&& A, Ts&&... ts) {
T B = max(ts...);
return A > B ? A : B;
}
template <class T, class... Ts>
T min(T&& A, Ts&&... ts) {
T B = min(ts...);
return A < B ? A : B;
}
template <class T, class... Ts>
T chmax(T&& A, Ts&&... ts) {
A = max(A, ts...);
return A;
}
template <class T, class... Ts>
T chmin(T&& A, Ts&&... ts) {
A = min(A, ts...);
return A;
}
} // namespace minmax
namespace input {
template <class T>
void re(T&& Xx) {
cin >> Xx;
}
template <class T1, class T2>
void re(pair<T1, T2>& Pp) {
re(Pp.first);
re(Pp.second);
}
template <class T>
void re(vector<T>& Aa) {
for (int i = 0; i < (int)(Aa).size(); i++) re(Aa[i]);
}
template <class T1, class T2>
void rea(T1&& Aa, T2 t) {
for (int i = 0; i < t; i++) re(Aa[i]);
}
template <class T1, class T2, class... Ts>
void rea(T1&& Aa, T2 t, Ts&&... ts) {
rea(Aa, t);
rea(ts...);
}
template <class T1, class T2>
void rea1(T1&& Aa, T2 t) {
for (int i = 1; i <= t; i++) re(Aa[i]);
}
template <class T1, class T2, class... Ts>
void rea1(T1&& Aa, T2 t, Ts&... ts) {
rea1(Aa, t);
rea1(ts...);
}
template <class T, class... Ts>
void re(T&& t, Ts&... ts) {
re(t);
re(ts...);
}
} // namespace input
namespace output {
void pr(int Xx) { cout << Xx; }
void pr(bool Xx) { cout << Xx; }
void pr(long long Xx) { cout << Xx; }
void pr(long long unsigned Xx) { cout << Xx; }
void pr(double Xx) { cout << Xx; }
void pr(char Xx) { cout << Xx; }
void pr(const string& Xx) { cout << Xx; }
void pr(const char* Xx) { cout << Xx; }
void pr(const char* Xx, size_t len) { cout << string(Xx, len); }
void ps() { cout << "\n"; }
void pn() {}
void pw() { pr(" "); }
void pc() {
pr("]");
ps();
}
template <class T1, class T2>
void pr(const pair<T1, T2>& Xx) {
pr(Xx.first);
pw();
pr(Xx.second);
}
template <class T>
void pr(const T&);
bool parse(const char* t) {
if (t == "\n") return true;
return false;
}
template <class T>
bool parse(T&& t) {
return false;
}
template <class T1, class T2>
bool parsepair(const pair<T1, T2>& Xx) {
return true;
}
template <class T>
bool parsepair(T&& t) {
return false;
}
template <class T1, class T2>
void psa(T1&& Aa, T2 t) {
for (int i = 0; i < t; i++) pr(Aa[i]), pw();
ps();
}
template <class T1, class T2>
void pna(T1&& Aa, T2 t) {
for (int i = 0; i < t; i++) pr(Aa[i]), ps();
}
template <class T1, class T2>
void psa2(T1&& Aa, T2 t1, T2 t2) {
for (int i = 0; i < t1; i++) {
for (int j = 0; j < t2; j++) pr(Aa[i][j]), pw();
ps();
}
}
template <class T>
void pr(const T& Xx) {
if (!(int)(Xx).size()) return;
bool fst = 1;
bool op = 0;
if (parsepair(*Xx.begin())) op = 1;
for (const auto& Aa : Xx) {
if (!fst) pw();
if (op) pr("{");
pr(Aa), fst = 0;
if (op) pr("}");
}
}
template <class T, class... Ts>
void pr(const T& t, const Ts&... ts) {
pr(t);
pr(ts...);
}
template <class T, class... Ts>
void ps(const T& t, const Ts&... ts) {
pr(t);
if (sizeof...(ts)) {
if (!parse(t)) pw();
}
ps(ts...);
}
template <class T>
void pn(const T& t) {
for (const auto& Aa : t) ps(Aa);
}
template <class T, class... Ts>
void pw(const T& t, const Ts&... ts) {
pr(t);
if (sizeof...(ts)) pw();
pw(ts...);
}
template <class T, class... Ts>
void pc(const T& t, const Ts&... ts) {
bool op = 0;
if (parsepair(t)) op = 1;
if (op) pr("{");
pr(t);
if (op) pr("}");
if (sizeof...(ts)) pr(", ");
pc(ts...);
}
namespace trace {
template <class T1, class T2>
void __f(const char* name, const T1& Xx, const T2& y) {
pr("[", y, "] = ");
ps(Xx);
}
template <class T1, class T2, class... Ts>
void __f(const char* name, const T1& Xx, const T2& y, const Ts&... rest) {
const char* open = strchr(name, '[');
pr("[", y, "]");
__f(open + 1, Xx, rest...);
}
template <class T1, class T2, class... Ts>
void __f0(const char* name, const T1& Xx, const T2& y, const Ts&... rest) {
const char* open = strchr(name, '[');
pr(name, size_t(open - name));
__f(name, Xx, y, rest...);
}
template <class T>
void __fn(int n, const char* name, const T& Xx) {
for (int i = 0; i < n; i++) pr(name), __f(name, Xx[i], i);
}
} // namespace trace
} // namespace output
using namespace minmax;
using namespace input;
using namespace output;
using namespace output::trace;
using pii = pair<long long, long long>;
const long long N = 3e5 + 5;
long long n, m, wt, d[N], p[N];
set<pair<long long, pii>> g[N];
vector<long long> ans;
void makeG() {
for (long long i = 0; i < m; i++) {
long long u, v, w;
re(u, v, w);
u--, v--;
g[u].insert(make_pair(v, make_pair(w, i + 1)));
g[v].insert(make_pair(u, make_pair(w, i + 1)));
}
}
void dijkstra(long long root) {
long long i;
set<pii> q;
memset(p, -1, sizeof(p));
for (i = 0; i < n; i++) d[i] = 1000000000000000000;
d[root] = 0;
q.insert({0, root});
while (!q.empty()) {
auto v = *q.begin();
q.erase(q.begin());
for (auto& x : g[v.second]) {
bool equal = (d[x.first] == (d[v.second] + x.second.first)) and
(d[v.second] < d[x.first]);
if (equal or (d[x.first] > d[v.second] + x.second.first)) {
q.erase({d[x.first], x.first});
d[x.first] = d[v.second] + x.second.first;
q.insert({d[x.first], x.first});
p[x.first] = v.second;
}
}
}
for (i = 0; i < n; i++) assert(d[i] < 1000000000000000000);
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long i, root;
re(n, m);
makeG();
re(root);
dijkstra(--root);
for (i = 0; i < n; i++) {
if (~p[i]) {
auto it = g[i].lower_bound(make_pair(p[i], make_pair(-1, -1)));
ans.emplace_back(it->second.second);
wt += it->second.first;
p[i] = -1;
}
}
ps(wt, "\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast", "unroll-loops", "omit-frame-pointer", "inline")
#pragma GCC option("arch=native", "tune=native", "no-zero-upper")
#pragma GCC target("avx2")
using namespace std;
const long long INF = 1e18;
const int maxn = 1e6 + 700;
const int mod = 311021;
inline bool read(long long &num) {
char in;
bool IsN = false;
in = getchar();
if (in == EOF) return false;
while (in != '-' && (in < '0' || in > '9')) in = getchar();
if (in == '-') {
IsN = true;
num = 0;
} else
num = in - '0';
while (in = getchar(), in >= '0' && in <= '9') {
num *= 10, num += in - '0';
}
if (IsN) num = -num;
return true;
}
long long n, m, p, S, T;
struct node {
int e, next;
long long w;
} edge[maxn];
long long cnt = 0;
int head[maxn];
void addedge(int u, int v, long long w) {
edge[cnt] = node{v, head[u], w};
head[u] = cnt++;
}
long long dis[maxn];
struct N {
int id;
long long w;
};
struct Edge {
int u, v, w;
} q[maxn];
int res[maxn], id[maxn];
bool operator<(const N &a, const N &b) { return a.w > b.w; }
void bfs(int s) {
priority_queue<N> q;
for (int i = 1; i <= n; i++) dis[i] = INF;
dis[s] = 0;
q.push(N{s, 0});
while (!q.empty()) {
N u = q.top();
q.pop();
if (u.w > dis[u.id]) continue;
for (int i = head[u.id]; ~i; i = edge[i].next) {
int e = edge[i].e;
if (dis[e] > dis[u.id] + edge[i].w) {
dis[e] = dis[u.id] + edge[i].w;
q.push(N{e, dis[e]});
}
}
}
}
int main() {
memset(head, -1, sizeof(head));
read(n);
read(m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &q[i].u, &q[i].v, &q[i].w);
addedge(q[i].u, q[i].v, q[i].w);
addedge(q[i].v, q[i].u, q[i].w);
}
for (int i = 1; i <= n; i++) res[i] = 2e9 + 7;
int s;
scanf("%d", &s);
bfs(s);
for (int i = 1; i <= m; i++) {
if (dis[q[i].u] > dis[q[i].v]) swap(q[i].u, q[i].v);
if (dis[q[i].u] + q[i].w == dis[q[i].v]) {
if (res[q[i].v] > q[i].w) {
id[q[i].v] = i;
res[q[i].v] = q[i].w;
}
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
if (i == s) continue;
ans += res[i];
}
printf("%lld\n", ans);
for (int i = 1; i <= n; i++) {
if (i == s) continue;
printf("%d ", id[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300100;
int head[N], tot;
struct edge {
int v, nx, d;
edge(int v = 0, int nx = 0, int d = 0) : v(v), nx(nx), d(d) {}
} e[N * 2];
void add(int u, int v, int d) {
e[tot] = edge(v, head[u], d);
head[u] = tot++;
}
struct data {
long long len;
int id, u;
data() {}
data(long long len, int id, int u) : len(len), id(id), u(u) {}
bool operator<(data a) const {
return a.len < len || (a.len == len && e[a.id].d < e[id].d);
}
};
const long long INF = 1LL << 60;
long long d[N];
int vis[N], n, m, res[N * 2];
void dij(int u) {
priority_queue<data> q;
for (int i = 1; i <= n; i++) d[i] = INF;
memset(vis, 0, sizeof vis);
d[u] = 0;
long long ans = 0;
q.push(data(0, -1, u));
while (!q.empty()) {
data x = q.top();
q.pop();
int id = x.id, u = x.u;
if (vis[u]) continue;
if (id >= 0) {
res[id] = 1;
ans += e[id].d;
}
vis[u] = 1;
for (int i = head[u]; ~i; i = e[i].nx) {
int v = e[i].v;
if (d[v] >= d[u] + e[i].d) {
d[v] = d[u] + e[i].d;
q.push(data(d[v], i, v));
}
}
}
cout << ans << endl;
for (int i = 0; i < 2 * m; i++) {
if (res[i]) printf("%d ", i / 2 + 1);
}
}
int main() {
cin >> n >> m;
memset(head, -1, sizeof head);
tot = 0;
int u, v, d;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &u, &v, &d);
add(u, v, d);
add(v, u, d);
}
cin >> u;
dij(u);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 600010;
const long long inf = 1e17;
int n, m, st, head[N], e, ans[300010];
long long dis[300010];
struct edge {
int u, w, next, p;
} edge[N];
void init() {
memset(head, -1, sizeof head);
for (int i = 1; i <= n; ++i) dis[i] = inf;
e = 1;
}
void add(int u, int v, int w, int i) {
edge[e].u = v, edge[e].w = w, edge[e].p = i;
edge[e].next = head[u];
head[u] = e++;
}
void dij() {
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
q.push(pair<long long, int>(0, st));
long long l;
int v, u;
dis[st] = 0;
while (!q.empty()) {
u = q.top().second;
q.pop();
for (int i = head[u]; i != -1; i = edge[i].next) {
l = dis[u] + edge[i].w;
v = edge[i].u;
if (l < dis[v]) {
dis[v] = l;
q.push(pair<long long, int>(l, v));
}
}
}
}
void solve() {
dij();
int num = 1, now, id;
long long sum = 0, tp;
for (int i = 1; i <= n; ++i) {
if (i == st) continue;
tp = inf;
for (int j = head[i]; j != -1; j = edge[j].next) {
now = edge[j].u;
if (dis[i] == dis[now] + edge[j].w && tp > edge[j].w) {
tp = edge[j].w;
id = edge[j].p;
}
}
sum += tp;
ans[num++] = id;
}
printf("%I64d\n", sum);
for (--num; num; --num) printf(num != 1 ? "%d " : "%d\n", ans[num]);
}
int main() {
while (~scanf("%d%d", &n, &m)) {
init();
int u, v, w;
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d", &u, &v, &w);
add(u, v, w, i);
add(v, u, w, i);
}
scanf("%d", &st);
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
vector<pair<pair<int, int>, int>> gr[N];
long long dist[N];
int par[N];
int l[N];
set<pair<long long, int>> st;
int main() {
int n, m, a, b, c, w;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d", &a, &b, &c);
l[i] = c;
gr[a].push_back({{b, c}, i});
gr[b].push_back({{a, c}, i});
}
l[m + 1] = 1e9;
scanf("%d", &w);
for (int i = 1; i <= n; ++i) {
if (i != w) {
dist[i] = 1e18;
par[i] = m + 1;
}
st.insert({dist[i], i});
}
long long ans = 0;
while (!st.empty()) {
pair<long long, int> cur = *(st.begin());
st.erase(st.begin());
ans += l[par[cur.second]];
for (auto &x : gr[cur.second]) {
long long t = cur.first + x.first.second;
if (dist[x.first.first] > t ||
(dist[x.first.first] == t && l[par[x.first.first]] > l[x.second])) {
st.erase({dist[x.first.first], x.first.first});
dist[x.first.first] = t;
par[x.first.first] = x.second;
st.insert({dist[x.first.first], x.first.first});
}
}
}
cout << ans << endl;
for (int i = 1; i <= n; ++i) {
if (i != w) printf("%d ", par[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
Edge() {}
Edge(int u, int v, int w) : u(u), v(v), w(w) {}
int u, v, w;
};
vector<vector<Edge> > ve;
map<pair<int, int>, int> edges;
int main() {
int n, m;
scanf("%d %d", &n, &m);
ve.resize(n);
for (int i = 0; i < m; ++i) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
--u;
--v;
ve[u].push_back(Edge(u, v, w));
ve[v].push_back(Edge(v, u, w));
edges[make_pair(u, v)] = i + 1;
edges[make_pair(v, u)] = i + 1;
}
int io;
scanf("%d", &io);
--io;
vector<long long> d(n, 999999999999999LL);
vector<int> h(n, -1);
vector<int> w(n, 999999999);
d[io] = 0;
w[io] = 0;
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
q;
q.push(make_pair(0, io));
while (!q.empty()) {
int u = q.top().second;
q.pop();
for (int i = 0; i < ve[u].size(); ++i) {
int v = ve[u][i].v;
if ((d[u] + ve[u][i].w < d[v]) ||
(d[u] + ve[u][i].w == d[v] && ve[u][i].w < w[v])) {
d[v] = d[u] + ve[u][i].w;
h[v] = u;
w[v] = ve[u][i].w;
q.push(make_pair(d[v], v));
}
}
}
long long sum = 0;
for (int i = 0; i < n; ++i) sum += w[i];
cout << sum << "\n";
for (int i = 0; i < n; ++i)
if (i != io) printf("%d ", edges[make_pair(i, h[i])]);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename V>
inline void bugp(const pair<T, V> &x) {
cerr << '{' << x.first << ", " << x.second << '}' << endl;
}
template <typename T, typename U, typename V>
inline void bugpp(const pair<T, pair<U, V> > &x) {
cerr << '{' << x.first << ", {" << x.second.first << ", " << x.second.second
<< "}}" << endl;
}
const int N = 300003;
int n;
long long d[N], ans = 0;
vector<int> res;
pair<int, int> pi[N];
vector<pair<int, pair<int, int> > > G[N];
void dijkstra(int src) {
fill(d + 1, d + n + 1, 1e15);
fill(pi + 1, pi + n + 1, pair<int, int>(1e9 + 7, 0));
d[src] = 0;
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
pq;
pq.push({0, src});
int u, x, id, w;
long long du;
while (pq.size()) {
u = pq.top().second;
du = pq.top().first;
pq.pop();
if (du != d[u]) continue;
if (u != src) {
ans += pi[u].first;
res.push_back(pi[u].second);
}
for (pair<int, pair<int, int> > &v : G[u]) {
id = v.first;
w = v.second.first;
x = v.second.second;
if (d[x] > du + w) {
pi[x] = {w, id};
pq.push({d[x] = du + w, x});
} else if (d[x] == du + w && w < pi[x].first)
pi[x] = {w, id};
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int m, u, v, w;
cin >> n >> m;
for (int i = 1, _n = (m); i <= _n; ++i) {
cin >> u >> v >> w;
G[u].push_back({i, {w, v}});
G[v].push_back({i, {w, u}});
}
cin >> u;
dijkstra(u);
cout << ans << '\n';
for (int i = 0, _n = (res.size()); i < _n; ++i) cout << res[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 100;
const long long INF = 1LL << 60;
struct edge {
int from, to, num, cost;
edge(int from = 0, int to = 0, int num = 0, int cost = 0)
: from(from), to(to), num(num), cost(cost) {}
};
vector<edge> E;
vector<int> t, V[maxn];
long long d[maxn];
long long cost[maxn];
long long Tree(int u, int n) {
priority_queue<pair<pair<long long, int>, pair<long long, int> >,
vector<pair<pair<long long, int>, pair<long long, int> > >,
greater<pair<pair<long long, int>, pair<long long, int> > > >
q;
fill(cost + 1, cost + n + 1, INF);
cost[u] = 0;
long long res = 0;
for (int i = 0; i < V[u].size(); ++i) {
edge e = E[V[u][i]];
int k = u == e.from ? e.to : e.from;
cost[k] = e.cost;
q.push(pair<pair<long long, int>, pair<long long, int> >(
pair<long long, int>(d[k], e.cost), pair<long long, int>(e.num, k)));
}
while (!q.empty()) {
pair<pair<long long, int>, pair<long long, int> > p = q.top();
q.pop();
int v = p.second.second;
if (p.first.second != cost[v]) {
continue;
}
res += cost[v];
t.push_back(p.second.first + 1);
for (int i = 0; i < V[v].size(); ++i) {
edge e = E[V[v][i]];
int k = v == e.from ? e.to : e.from;
if (d[k] == d[v] + e.cost && cost[k] > e.cost) {
cost[k] = e.cost;
q.push(pair<pair<long long, int>, pair<long long, int> >(
pair<long long, int>(d[k], cost[k]),
pair<long long, int>(e.num, k)));
}
}
}
return res;
}
void Dijkstra(int u, int n) {
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
fill(d + 1, d + n + 1, INF);
d[u] = 0;
q.push(pair<long long, int>(0, u));
while (!q.empty()) {
pair<long long, int> p = q.top();
q.pop();
int v = p.second;
if (d[v] != p.first) {
continue;
}
for (int i = 0; i < V[v].size(); ++i) {
edge e = E[V[v][i]];
int k = v == e.from ? e.to : e.from;
if (d[k] > d[v] + e.cost) {
d[k] = d[v] + e.cost;
q.push(pair<long long, int>(d[k], k));
}
}
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int x, y, l;
cin >> x >> y >> l;
E.push_back(edge(x, y, i, l));
V[x].push_back(i);
V[y].push_back(i);
}
int u;
cin >> u;
Dijkstra(u, n);
cout << Tree(u, n) << endl;
for (int i = 0; i < t.size(); ++i) {
cout << t[i] << (i != t.size() ? ' ' : '\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
edge(int a, int b, int _num) {
to = a;
cost = b;
num = _num;
}
int to, cost, num;
};
typedef pair<long long, int> P;
vector<edge> G[300005];
long long d[300005];
int V;
int before[300005];
int Val[300005];
void dijkstra(int s) {
memset(d, 0x3f, sizeof(d));
d[s] = 0;
priority_queue<P, vector<P>, greater<P> > que;
que.push(make_pair(0, s));
memset(before, -1, sizeof(before));
while (!que.empty()) {
P p = que.top();
que.pop();
int v = p.second;
if (d[v] < p.first) continue;
for (int i = 0; i < G[v].size(); ++i) {
edge &e = G[v][i];
if (d[e.to] >= d[v] + e.cost) {
if (before[e.to] == -1)
before[e.to] = e.num;
else {
if (Val[before[e.to]] > Val[e.num]) {
before[e.to] = e.num;
}
}
if (d[e.to] > d[v] + e.cost) {
d[e.to] = d[v] + e.cost;
que.push(make_pair(d[e.to], e.to));
}
}
}
}
long long res = 0;
for (int i = 0; i < V; ++i) {
if (before[i] != -1) {
res += Val[before[i]];
}
}
cout << res << endl;
bool first = 0;
for (int i = 0; i < V; ++i) {
if (before[i] != -1) {
if (first) cout << " ";
first = 1;
cout << before[i];
}
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int m;
cin >> V >> m;
int a, b, c;
for (int i = 0; i < m; ++i) {
cin >> a >> b >> c;
a--;
b--;
G[a].push_back(edge(b, c, i + 1));
G[b].push_back(edge(a, c, i + 1));
Val[i + 1] = c;
}
int temp;
cin >> temp;
temp--;
dijkstra(temp);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0xffffffffffffff;
const int maxn = (int)3e5 + 5e4;
int n, m, cnt = 0;
long long d[maxn];
long long cost[maxn];
int Ed[maxn];
unsigned long long W = 0;
struct E {
int to, id;
long long cost;
E() {}
E(int to, long long cost, int id) : to(to), cost(cost), id(id) {}
};
vector<E> G[maxn];
struct P {
long long d;
int id;
P(){};
P(long long d, int id) : d(d), id(id){};
bool operator<(const P& p) const { return p.d < d; }
};
void dijkstra(int U) {
fill(cost, cost + n + 1, inf);
fill(d, d + n + 1, inf);
d[U] = 0LL;
priority_queue<P> que;
P p = P(0LL, U);
que.push(p);
while (que.size()) {
P p = que.top();
que.pop();
if (d[p.id] < p.d) continue;
for (int i = 0; i < G[p.id].size(); i++) {
E v = G[p.id][i];
if (d[v.to] > d[p.id] + v.cost ||
(d[v.to] == d[p.id] + v.cost && cost[v.to] > v.cost)) {
int F = (d[v.to] > d[p.id] + v.cost) ? 1 : 0;
Ed[v.to] = v.id;
cost[v.to] = v.cost;
d[v.to] = d[p.id] + v.cost;
if (F) que.push(P(d[v.to], v.to));
}
}
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int x, y;
long long z;
scanf("%d %d %I64d", &x, &y, &z);
G[x].push_back(E(y, z, i + 1));
G[y].push_back(E(x, z, i + 1));
}
int u;
scanf("%d", &u);
dijkstra(u);
for (int i = 1; i <= n; i++) {
if (i != u) W += cost[i];
}
printf("%I64u\n", W);
for (int i = 1; i <= n; i++) {
if (i != u) printf("%d ", Ed[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 5;
struct Edge {
long long u, v, w, id;
};
struct Node {
long long d;
long long p;
bool operator<(const Node &rhs) const { return d > rhs.d; }
};
long long n, m;
vector<long long> g[N];
vector<Edge> edges;
long long vis[N], dis[N], pre[N];
signed main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (long long i = 1; i <= m; i++) {
long long u, v, w;
cin >> u >> v >> w;
g[u].push_back(edges.size());
edges.push_back({u, v, w, i});
g[v].push_back(edges.size());
edges.push_back({v, u, w, i});
}
long long s;
cin >> s;
priority_queue<Node> que;
memset(dis, 0x3f, sizeof dis);
dis[s] = 0;
que.push({0, s});
while (que.size()) {
auto [d, p] = que.top();
que.pop();
if (vis[p]) continue;
vis[p] = 1;
for (auto i : g[p]) {
auto [_, q, w, id] = edges[i];
if (dis[q] > dis[p] + w) {
dis[q] = dis[p] + w;
pre[q] = i;
que.push({dis[q], q});
} else if (dis[q] == dis[p] + w && w < edges[pre[q]].w) {
pre[q] = i;
}
}
}
vector<long long> ans;
long long ansval = 0;
for (long long i = 1; i <= n; i++) {
if (i == s) continue;
ans.push_back(edges[pre[i]].id);
ansval += edges[pre[i]].w;
}
sort(ans.begin(), ans.end());
cout << ansval << endl;
for (auto i : ans) cout << i << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int n, m, u, v;
long long w, d;
cin >> n >> m;
vector<vector<pair<pair<int, long long>, int> > > G(n + 1);
for (int i = 0; i < m; ++i) {
cin >> u >> v >> w;
G[u].push_back(make_pair(make_pair(v, w), i + 1));
G[v].push_back(make_pair(make_pair(u, w), i + 1));
}
cin >> u;
priority_queue<pair<long long, pair<int, pair<int, int> > > > Q;
Q.push(make_pair(0, make_pair(0, make_pair(u, -1))));
vector<long long> D(n + 1, -1);
vector<long long> S(n + 1, 0x3fffffffffffffff);
S[u] = 0;
int trees = n, edge;
vector<int> ans;
long long total = 0;
while (!Q.empty() && trees > 0) {
d = -Q.top().first;
w = -Q.top().second.first;
u = Q.top().second.second.first;
edge = Q.top().second.second.second;
Q.pop();
if (D[u] == -1) {
--trees;
total += w;
if (edge != -1) ans.push_back(edge);
D[u] = d;
for (int i = 0; i < G[u].size(); ++i) {
v = G[u][i].first.first, w = G[u][i].first.second;
if (d + w <= S[v]) {
S[v] = d + w;
Q.push(make_pair(-S[v], make_pair(-w, make_pair(v, G[u][i].second))));
}
}
}
}
cout << total << '\n';
for (int i = 0; i < ans.size(); ++i) {
if (i) cout << ' ';
cout << ans[i];
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 3e5 + 10;
int n, m;
long long d[maxN];
int par[maxN], edge[maxN];
vector<pair<int, int> > adj[maxN];
void dijkstra(int source) {
fill(d, d + maxN, 1e18);
d[source] = 0;
par[source] = -1;
set<pair<int, int> > s;
s.insert(make_pair(d[source], source));
while (!s.empty()) {
int v = s.begin()->second;
s.erase(s.begin());
for (int i = 0; i < adj[v].size(); i++) {
int u = adj[v][i].first, edge_num = adj[v][i].second;
int w = edge[edge_num];
if (d[u] > d[v] + w) {
s.erase(make_pair(d[u], u));
d[u] = d[v] + w;
par[u] = edge_num;
s.insert(make_pair(d[u], u));
} else if (d[u] == d[v] + w && edge[par[u]] > w)
par[u] = edge_num;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int v, u, w;
cin >> v >> u >> w;
adj[v].push_back(make_pair(u, i));
adj[u].push_back(make_pair(v, i));
edge[i] = w;
}
int source;
cin >> source;
dijkstra(source);
vector<int> res;
long long ans = 0;
for (int i = 1; i <= n; ++i)
if (par[i] != -1) ans += edge[par[i]], res.push_back(par[i]);
sort(res.begin(), res.end());
cout << ans << '\n';
for (int i = 0; i < res.size(); i++) cout << res[i] + 1 << " ";
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int e, w, idx;
node(int ee, int ww, int ii) { e = ee, w = ww, idx = ii; }
node() {}
};
struct p {
int idx;
long long d;
p() {}
p(long long dd, int ii) { d = dd, idx = ii; }
bool operator<(const p &a) const { return d > a.d; }
};
int n, m, u;
vector<node> g[300010];
bool v[300010];
int now[300010], pre[300010];
long long dis[300010], ans;
void init() {
memset(now, -1, sizeof(now));
memset(pre, -1, sizeof(pre));
for (int i = 0; i <= n; i++) {
g[i].clear();
}
ans = 0;
}
void slove() {
int i, j, k;
priority_queue<p> mq;
for (i = 0; i <= n; i++) {
dis[i] = 0x5f5f5f5f5f5f5f5f;
}
dis[u] = 0;
mq.push(p(0, u));
memset(v, false, sizeof(v));
while (!mq.empty()) {
int mark = (mq.top()).idx;
mq.pop();
for (j = 0; j < g[mark].size(); j++) {
node s = g[mark][j];
if (!v[s.e] && dis[s.e] > dis[mark] + s.w) {
dis[s.e] = dis[mark] + s.w;
if (now[s.e] == -1)
ans += s.w;
else {
ans -= pre[s.e];
ans += s.w;
}
now[s.e] = s.idx;
pre[s.e] = s.w;
mq.push(p(dis[s.e], s.e));
} else if (!v[s.e] && dis[s.e] == dis[mark] + s.w && s.w < pre[s.e]) {
ans -= pre[s.e];
ans += s.w;
pre[s.e] = s.w;
now[s.e] = s.idx;
}
}
}
}
int main() {
int i, j, k;
int a, b, c;
while (~scanf("%d%d", &n, &m)) {
init();
for (i = 1; i <= m; i++) {
scanf("%d%d%d", &a, &b, &c);
g[a].push_back(node(b, c, i));
g[b].push_back(node(a, c, i));
}
scanf("%d", &u);
slove();
printf("%I64d\n", ans);
bool flag = false;
for (i = 1; i <= n; i++) {
if (now[i] != -1) {
if (flag) printf(" ");
printf("%d", now[i]);
flag = true;
}
}
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
const int maxm = 4e5 + 10;
const long long mod = 1e9 + 7;
const long long inf = 1e18;
const double eps = 1e-5;
struct edge {
long long to, dis, next;
} e[maxn << 1];
long long head[maxn], dis[maxn], cnt;
bool vis[maxn];
int pre[maxn];
int n, m, s;
map<pair<long long, long long>, long long> mp;
map<long long, long long> m1;
inline void add_edge(long long u, long long v, long long d) {
cnt++;
e[cnt].dis = d;
e[cnt].to = v;
e[cnt].next = head[u];
head[u] = cnt;
}
struct node {
long long dis, pos;
bool operator<(const node &x) const { return x.dis < dis; }
};
priority_queue<node> q;
inline void Dijkstra() {
q.push(node{0, s});
fill(dis + 1, dis + 1 + n, inf);
dis[s] = 0;
while (!q.empty()) {
node temp = q.top();
q.pop();
int x = temp.pos, d = temp.dis;
if (vis[x]) continue;
vis[x] = 1;
for (int i = head[x]; i; i = e[i].next) {
long long y = e[i].to;
if (dis[y] > dis[x] + e[i].dis) {
dis[y] = dis[x] + e[i].dis;
pre[y] = x;
q.push(node{dis[y], y});
} else if (dis[y] == dis[x] + e[i].dis) {
int t = pre[y];
if (dis[x] > dis[t]) pre[y] = x;
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
long long u, v, d;
cin >> u >> v >> d;
add_edge(u, v, d);
add_edge(v, u, d);
mp[make_pair(u, v)] = i;
mp[make_pair(v, u)] = i;
m1[i] = d;
}
cin >> s;
Dijkstra();
long long ans = 0;
vector<int> res;
for (int i = 1; i <= n; i++) {
ans += m1[mp[make_pair(pre[i], i)]];
if (i != s) res.push_back(mp[make_pair(pre[i], i)]);
}
cout << ans << endl;
sort(res.begin(), res.end());
for (int i = 0; i < res.size(); i++) cout << res[i] << " ";
return ~~(0 - 0);
}
|
#include <bits/stdc++.h>
using namespace std;
long long dist[300010], weight[300010], pre[300010];
vector<pair<long long, long long>> g[300010];
void solve() {
long long n, m;
cin >> n >> m;
memset(dist, 63, sizeof dist);
for (long long i = 1; i <= m; i++) {
long long a, b, c;
cin >> a >> b >> c;
g[a].push_back({b, i});
g[b].push_back({a, i});
weight[i] = c;
}
long long src;
cin >> src;
set<pair<long long, long long>> q;
dist[src] = 0;
q.insert({0, src});
while (!q.empty()) {
long long node = q.begin()->second;
q.erase(q.begin());
for (auto x : g[node]) {
if (dist[x.first] > dist[node] + weight[x.second]) {
q.erase({dist[x.first], x.first});
dist[x.first] = dist[node] + weight[x.second];
pre[x.first] = x.second;
q.insert({dist[x.first], x.first});
} else if (dist[x.first] == dist[node] + weight[x.second]) {
if (weight[pre[x.first]] > weight[x.second]) pre[x.first] = x.second;
}
}
}
long long ans = 0;
for (long long i = 1; i <= n; i++)
if (i != src) ans += weight[pre[i]];
cout << ans << '\n';
for (long long i = 1; i <= n; i++) {
if (i != src) {
cout << pre[i] << " ";
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
long long t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
vector<pair<int, int>> g[N];
long long dist[N];
vector<pair<int, pair<int, int>>> e;
map<pair<int, pair<int, int>>, int> f;
int color[N];
int repr(int x) { return color[x] = ((x == color[x]) ? x : repr(color[x])); }
void join(int x, int y) { color[repr(x)] = repr(y); }
int used[N];
set<pair<int, pair<int, int>>> all;
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
--a;
--b;
g[a].push_back({b, c});
g[b].push_back({a, c});
f[{c, {a, b}}] = i + 1;
f[{c, {b, a}}] = i + 1;
}
int s;
scanf("%d", &s);
--s;
memset(dist, -1, sizeof(dist));
dist[s] = 0;
priority_queue<pair<long long, int>> q;
q.push({0, s});
while (q.size()) {
auto top = q.top();
q.pop();
top.first *= -1;
if (dist[top.second] != top.first) continue;
for (auto p : g[top.second]) {
long long ndist = top.first + p.second;
if (dist[p.first] == -1 || dist[p.first] > ndist) {
dist[p.first] = ndist;
q.push({-ndist, p.first});
}
}
}
for (int i = 0; i < n; ++i) {
for (auto p : g[i]) {
if (dist[i] + p.second == dist[p.first]) {
e.push_back({p.second, {i, p.first}});
}
}
}
sort(e.begin(), e.end());
for (int i = 0; i < n; ++i) color[i] = i;
vector<int> ans;
long long len = 0;
vector<pair<long long, int>> qq;
for (int i = 0; i < n; ++i) qq.push_back({dist[i], i});
sort(qq.begin(), qq.end());
used[s] = true;
for (auto top : qq) {
if (!used[top.second]) {
int mnlen = 2e+9;
for (auto p : g[top.second]) {
if (used[p.first] && dist[p.first] + p.second == dist[top.second]) {
mnlen = min(mnlen, p.second);
}
}
for (auto p : g[top.second]) {
if (used[p.first] && dist[p.first] + p.second == dist[top.second] &&
p.second == mnlen) {
used[top.second] = true;
len += p.second;
ans.push_back(f[{p.second, {top.second, p.first}}]);
break;
}
}
}
}
printf("%lld\n", len);
for (int x : ans) {
printf("%d ", x);
}
if (ans.size()) printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pli = pair<ll, int>;
const ll inf = 2e18;
vector<vector<pii>> adj;
vector<ll> wei, dist;
vector<int> ans;
void dijkstra(int s) {
set<pli> q;
int n = adj.size();
dist.assign(n, inf);
dist[s] = 0;
for (int i = 0; i < n; i++) q.insert({dist[i], i});
while (!q.empty()) {
int v = q.begin()->second;
q.erase(q.begin());
for (pii u : adj[v]) {
if (dist[v] + wei[u.second] > dist[u.first]) continue;
if (dist[v] + wei[u.second] == dist[u.first] &&
wei[u.second] >= wei[ans[u.first]])
continue;
q.erase({dist[u.first], u.first});
dist[u.first] = dist[v] + wei[u.second];
ans[u.first] = u.second;
q.insert({dist[u.first], u.first});
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
adj.resize(n);
wei.resize(m);
ans.assign(n, m);
for (int i = 0; i < m; i++) {
int ui, vi, w;
cin >> ui >> vi >> w;
ui--;
vi--;
wei[i] = w;
pii u = {ui, i};
pii v = {vi, i};
adj[ui].emplace_back(v);
adj[vi].emplace_back(u);
}
int s;
cin >> s;
s--;
dijkstra(s);
ll tot = 0;
for (int i = 0; i < n; i++)
if (i != s) tot += wei[ans[i]];
cout << tot << endl;
for (int i = 0; i < n; i++)
if (i != s) cout << ans[i] + 1 << " ";
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 3e5 + 10;
const long long inf = 1e17;
long long n, m, ans;
long long dis[maxn];
vector<pair<long long, pair<long long, long long>>> g[maxn];
set<pair<long long, long long>> q;
bool mark[maxn];
void HHH(long long u) {
memset(dis, 63, sizeof dis);
dis[u] = 0;
for (long long i = 1; i <= n; i++) q.insert({dis[i], i});
while (q.size()) {
auto it = q.begin();
long long s = it->second;
mark[s] = 1;
q.erase(it);
for (auto K : g[s]) {
long long k = K.second.first, w = K.second.second;
if (mark[k]) continue;
q.erase({dis[k], k});
dis[k] = min(dis[k], dis[s] + w);
q.insert({dis[k], k});
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (long long i = 1; i <= m; i++) {
long long u, v, w;
cin >> u >> v >> w;
g[u].push_back({i, {v, w}});
g[v].push_back({i, {u, w}});
}
long long u;
cin >> u;
HHH(u);
vector<long long> pans;
for (long long i = 1; i <= n; i++) {
if (i == u) continue;
long long mn = 1e18, idx;
for (auto v : g[i]) {
if (dis[i] == v.second.second + dis[v.second.first] &&
mn > v.second.second)
mn = v.second.second, idx = v.first;
}
ans += mn;
pans.push_back(idx);
}
cout << ans << '\n';
for (long long i : pans) cout << i << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
Edge() {}
Edge(int u, int v, int w) : u(u), v(v), w(w) {}
int u, v, w;
};
vector<vector<Edge> > ve;
map<pair<int, int>, int> edges;
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
ve.resize(n);
for (int i = 0; i < m; ++i) {
int u, v, w;
cin >> u >> v >> w;
--u;
--v;
ve[u].push_back(Edge(u, v, w));
ve[v].push_back(Edge(v, u, w));
edges[make_pair(u, v)] = i + 1;
edges[make_pair(v, u)] = i + 1;
}
int io;
cin >> io;
--io;
vector<long long> d(n, 999999999999999LL);
vector<int> h(n, -1);
vector<int> w(n, 999999999);
d[io] = 0;
w[io] = 0;
priority_queue<pair<long long, int> > q;
q.push(make_pair(0, io));
while (!q.empty()) {
int u = q.top().second;
q.pop();
for (int i = 0; i < ve[u].size(); ++i) {
int v = ve[u][i].v;
if ((d[u] + ve[u][i].w < d[v]) ||
(d[u] + ve[u][i].w == d[v] && ve[u][i].w < w[v])) {
d[v] = d[u] + ve[u][i].w;
h[v] = u;
w[v] = ve[u][i].w;
q.push(make_pair(-d[v], v));
}
}
}
long long sum = 0;
for (int i = 0; i < n; ++i) sum += w[i];
cout << sum << "\n";
for (int i = 0; i < n; ++i)
if (i != io) cout << edges[make_pair(i, h[i])] << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
clock_t startTime;
double getCurrentTime() {
return (double)(clock() - startTime) / CLOCKS_PER_SEC;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const pair<T, U> &_p) {
_out << _p.first << " " << _p.second;
return _out;
}
template <typename T, typename U>
inline istream &operator>>(istream &_in, pair<T, U> &_p) {
_in >> _p.first >> _p.second;
return _in;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const vector<T> &_v) {
if (_v.empty()) return _out;
_out << _v.front();
for (auto _it = ++_v.begin(); _it != _v.end(); ++_it) _out << ' ' << *_it;
return _out;
}
template <typename T>
inline istream &operator>>(istream &_in, vector<T> &_v) {
for (auto &_i : _v) _in >> _i;
return _in;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const set<T> &_s) {
if (_s.empty()) return _out;
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) _out << ' ' << *_it;
return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const multiset<T> &_s) {
if (_s.empty()) return _out;
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) _out << ' ' << *_it;
return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const unordered_set<T> &_s) {
if (_s.empty()) return _out;
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) _out << ' ' << *_it;
return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const unordered_multiset<T> &_s) {
if (_s.empty()) return _out;
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) _out << ' ' << *_it;
return _out;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const map<T, U> &_m) {
if (_m.empty()) return _out;
_out << "{\"" << _m.begin()->first << "\", \"" << _m.begin()->second << "\"}";
for (auto _it = ++_m.begin(); _it != _m.end(); ++_it)
_out << ", { \"" << _it->first << "\", \"" << _it->second << "\"}";
return _out;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const unordered_map<T, U> &_m) {
if (_m.empty()) return _out;
_out << '(' << _m.begin()->first << ": " << _m.begin()->second << ')';
for (auto _it = ++_m.begin(); _it != _m.end(); ++_it)
_out << ", (" << _it->first << ": " << _it->second << ')';
return _out;
}
template <typename T>
void out(const vector<T> &a, int n) {
for (int i = 1; i <= n; ++i) {
cout << a[i] << ' ';
}
cout << "\n";
}
template <typename T>
void out(const vector<vector<T>> &a, int n, int m) {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
cout << a[i][j] << ' ';
}
cout << '\n';
}
}
struct item {
long long d, i;
};
struct Compare {
bool operator()(const item &i1, const item &i2) { return i1.d > i2.d; }
};
struct Edge {
int i, j, w, id;
};
bool cmp(const Edge &e1, const Edge &e2) { return e1.w < e2.w; }
const long long INF = 1e17;
void solve() {
int n, m;
cin >> n >> m;
vector<vector<pair<int, int>>> v(n);
vector<Edge> edges;
vector<bool> edgesTaken(m);
map<pair<int, int>, int> mp;
for (int i = 0; i < m; ++i) {
int a, b, c;
cin >> a >> b >> c;
--a, --b;
v[a].push_back({b, c}), v[b].push_back({a, c});
edges.push_back(Edge{a, b, c, i});
mp[{min(a, b), max(a, b)}] = i;
}
int u;
cin >> u;
--u;
vector<long long> dis(n, INF), par(n, -1);
dis[u] = 0;
priority_queue<item, vector<item>, Compare> pq;
pq.push(item{0, u});
vector<int> wts(n);
while (!pq.empty()) {
auto it = pq.top();
pq.pop();
if (it.d > dis[it.i]) continue;
int j, w;
for (auto &p : v[it.i]) {
j = p.first, w = p.second;
if (dis[j] > dis[it.i] + w) {
dis[j] = dis[it.i] + w;
par[j] = it.i;
wts[j] = w;
pq.push(item{dis[j], j});
}
}
}
long long cst = accumulate(wts.begin(), wts.end(), 0LL);
for (long long i = 0; i < n; ++i) {
if (par[i] != -1) edgesTaken[mp[{min(i, par[i]), max(i, par[i])}]] = true;
}
sort(edges.begin(), edges.end(), cmp);
for (Edge &e : edges) {
int i = e.i, j = e.j;
int pi = par[e.i], pj = par[e.j];
if (dis[i] + e.w == dis[j] && wts[j] > e.w) {
cst = cst - wts[j] + e.w;
edgesTaken[mp[{min(j, pj), max(j, pj)}]] = false;
edgesTaken[mp[{min(j, i), max(j, i)}]] = true;
wts[j] = e.w;
par[j] = i;
}
if (dis[j] + e.w == dis[i] && wts[i] > e.w) {
cst = cst - wts[i] + e.w;
edgesTaken[mp[{min(i, pi), max(i, pi)}]] = false;
edgesTaken[mp[{min(j, i), max(j, i)}]] = true;
wts[i] = e.w;
par[i] = j;
}
}
cout << cst << "\n";
for (int i = 0; i < m; ++i) {
if (edgesTaken[i]) cout << i + 1 << ' ';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
startTime = clock();
int T = 1;
while (T--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void chmax(T& l, const T r) {
l = max(l, r);
}
template <class T>
void chmin(T& l, const T r) {
l = min(l, r);
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
T extgcd(T a, T b, T& x, T& y) {
for (T u = y = 1, v = x = 0; a;) {
T q = b / a;
swap(x -= q * u, u);
swap(y -= q * v, v);
swap(b -= q * a, a);
}
return b;
}
template <class T>
T mod_inv(T a, T m) {
T x, y;
extgcd(a, m, x, y);
return (m + x % m) % m;
}
long long mod_pow(long long a, long long n, long long mod) {
long long ret = 1;
long long p = a % mod;
while (n) {
if (n & 1) ret = ret * p % mod;
p = p * p % mod;
n >>= 1;
}
return ret;
}
void reader(int& x) {
int k, m = 0;
x = 0;
for (;;) {
(k) = getchar_unlocked();
if (k == '-') {
m = 1;
break;
}
if ('0' <= k && k <= '9') {
x = k - '0';
break;
}
}
for (;;) {
(k) = getchar_unlocked();
if (k < '0' || k > '9') break;
x = x * 10 + k - '0';
}
if (m) x = -x;
}
void reader(long long& x) {
int k, m = 0;
x = 0;
for (;;) {
(k) = getchar_unlocked();
if (k == '-') {
m = 1;
break;
}
if ('0' <= k && k <= '9') {
x = k - '0';
break;
}
}
for (;;) {
(k) = getchar_unlocked();
if (k < '0' || k > '9') break;
x = x * 10 + k - '0';
}
if (m) x = -x;
}
int reader(char c[]) {
int i, s = 0;
for (;;) {
(i) = getchar_unlocked();
if (i != ' ' && i != '\n' && i != '\r' && i != '\t' && i != EOF) break;
}
c[s++] = i;
for (;;) {
(i) = getchar_unlocked();
if (i == ' ' || i == '\n' || i == '\r' || i == '\t' || i == EOF) break;
c[s++] = i;
}
c[s] = '\0';
return s;
}
template <class T, class S>
void reader(T& x, S& y) {
reader(x);
reader(y);
}
template <class T, class S, class U>
void reader(T& x, S& y, U& z) {
reader(x);
reader(y);
reader(z);
}
template <class T, class S, class U, class V>
void reader(T& x, S& y, U& z, V& w) {
reader(x);
reader(y);
reader(z);
reader(w);
}
void writer(int x, char c) {
int s = 0, m = 0;
char f[10];
if (x < 0) m = 1, x = -x;
while (x) f[s++] = x % 10, x /= 10;
if (!s) f[s++] = 0;
if (m) putchar_unlocked('-');
while (s--) putchar_unlocked(f[s] + '0');
putchar_unlocked(c);
}
void writer(long long x, char c) {
int s = 0, m = 0;
char f[20];
if (x < 0) m = 1, x = -x;
while (x) f[s++] = x % 10, x /= 10;
if (!s) f[s++] = 0;
if (m) putchar_unlocked('-');
while (s--) putchar_unlocked(f[s] + '0');
putchar_unlocked(c);
}
void writer(const char c[]) {
int i;
for (i = 0; c[i] != '\0'; i++) putchar_unlocked(c[i]);
}
void writer(const char x[], char c) {
int i;
for (i = 0; x[i] != '\0'; i++) putchar_unlocked(x[i]);
putchar_unlocked(c);
}
template <class T>
void writerLn(T x) {
writer(x, '\n');
}
template <class T, class S>
void writerLn(T x, S y) {
writer(x, ' ');
writer(y, '\n');
}
template <class T, class S, class U>
void writerLn(T x, S y, U z) {
writer(x, ' ');
writer(y, ' ');
writer(z, '\n');
}
template <class T>
void writerArr(T x[], int n) {
if (!n) {
putchar_unlocked('\n');
return;
}
for (int i = 0; i < (n - 1); i++) writer(x[i], ' ');
writer(x[n - 1], '\n');
}
const long long INF = numeric_limits<long long>::max() / 10;
struct edge {
int to;
long long cost;
edge() {}
edge(int to, long long cost) : to(to), cost(cost) {}
};
void dijkstra(int s, vector<pair<long long, int>::first_type>& cost_table,
vector<vector<edge>>& edges, vector<int>* _prev = NULL) {
cost_table.resize((int)edges.size());
fill(cost_table.begin(), cost_table.end(),
pair<long long, int>::first_type(INF));
if (_prev) _prev->resize((int)edges.size());
if (_prev) fill(_prev->begin(), _prev->end(), -1);
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
q;
q.push(pair<long long, int>(0, s));
cost_table[s] = 0;
while (!q.empty()) {
pair<long long, int> p = q.top();
q.pop();
int v = p.second;
if (cost_table[v] < p.first) continue;
for (int i = 0; i < (int)edges[v].size(); i++) {
edge& e = edges[v][i];
if (cost_table[e.to] > cost_table[v] + e.cost) {
cost_table[e.to] = cost_table[v] + e.cost;
if (_prev) (*_prev)[e.to] = v;
q.push(pair<long long, int>(cost_table[e.to], e.to));
}
}
}
}
vector<vector<edge>> e;
map<pair<int, int>, int> e2id;
class UnionFind {
private:
int n;
vector<int> a;
public:
UnionFind(int n) : n(n), a(n, -1) {}
int find(int x) { return a[x] < 0 ? x : (a[x] = find(a[x])); }
bool same(int x, int y) { return find(x) == find(y); }
bool same(pair<int, int>& p) { return same(p.first, p.second); }
bool unite(int x, int y) {
x = find(x), y = find(y);
if (x == y) return false;
if (a[x] > a[y]) swap(x, y);
a[x] += a[y];
a[y] = x;
n--;
return true;
}
bool unite(pair<int, int>& p) { return unite(p.first, p.second); }
int size() const { return n; }
int size(int x) { return -a[find(x)]; }
};
int main() {
int n, m;
reader(n, m);
e.resize(n);
vector<tuple<long long, int, int>> es;
for (int i = 0; i < (m); i++) {
int a, b, c;
reader(a, b, c);
a--;
b--;
e[a].emplace_back(b, c);
e[b].emplace_back(a, c);
es.emplace_back(c, a, b);
e2id[pair<int, int>(a, b)] = i + 1;
e2id[pair<int, int>(b, a)] = i + 1;
}
sort(es.begin(), es.end());
int s;
reader(s);
s--;
vector<pair<long long, int>::first_type> cost_table;
dijkstra(s, cost_table, e);
static bool connect_low[((int)1e5) * 3];
UnionFind uf(n);
long long ans = 0;
vector<int> anses;
for (auto& p : es) {
long long cst;
int from, to;
tie(cst, from, to) = p;
if (uf.same(from, to)) continue;
if (cost_table[from] > cost_table[to]) swap(from, to);
if (connect_low[to]) continue;
if (cost_table[to] - cost_table[from] == cst) {
connect_low[to] = true;
uf.unite(from, to);
ans += cst;
anses.push_back(e2id[pair<int, int>(from, to)]);
}
}
writerLn(ans);
if (((int)(anses).size())) writerArr(&anses[0], ((int)(anses).size()));
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 600010;
struct Edge {
int u, v, w, id, next;
bool operator<(const Edge &other) const { return w < other.w; }
} edge[N];
int n, m, cnt;
int head[N], U;
void add(int u, int v, int w, int id) {
edge[cnt].u = u;
edge[cnt].v = v;
edge[cnt].w = w;
edge[cnt].id = id;
edge[cnt].next = head[u];
head[u] = cnt++;
}
int val[N];
int vis[N];
int path[N];
long long dis[N];
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
void dijstra(int be) {
memset(vis, 0, sizeof(vis));
for (int i = 0; i <= n; i++) dis[i] = (i == be ? 0 : 1LL << 60);
q.push(make_pair(dis[be], be));
while (!q.empty()) {
pair<long long, int> u = q.top();
q.pop();
int x = u.second;
if (vis[x]) continue;
vis[x] = 1;
for (int i = head[x]; ~i; i = edge[i].next) {
int v = edge[i].v, w = edge[i].w, id = edge[i].id;
if (dis[v] > dis[x] + w) {
path[v] = id;
dis[v] = dis[x] + w;
q.push(make_pair(dis[v], v));
} else if (dis[v] == dis[x] + w && val[path[v]] > val[id]) {
path[v] = id;
}
}
}
}
int main() {
cnt = 0;
scanf("%d%d", &n, &m);
memset(head, -1, sizeof(head));
for (int i = 0; i < m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
val[i] = w;
add(u, v, w, i);
add(v, u, w, i);
}
memset(path, 0, sizeof(path));
scanf("%d", &U);
dijstra(U);
long long ans = 0;
for (int i = 1; i <= n; i++) {
if (i == U) continue;
ans += val[path[i]];
}
cout << ans << endl;
for (int i = 1; i <= n; i++) {
if (i == U) continue;
cout << path[i] + 1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
vector<pair<int, pair<int, int> > > A[N];
long long d[N];
int E[N];
vector<int> G;
long long maxd;
long long dij(int u) {
priority_queue<pair<pair<long long, long long>, pair<int, int> >,
vector<pair<pair<long long, long long>, pair<int, int> > >,
greater<pair<pair<long long, long long>, pair<int, int> > > >
PQ;
PQ.push(make_pair(make_pair(0, 0), make_pair(u, 0)));
long long sum = 0;
while (!PQ.empty()) {
pair<pair<long long, long long>, pair<int, int> > po = PQ.top();
PQ.pop();
long long dist = po.first.first;
int v = po.second.first;
int ed = po.second.second;
long long sh = po.first.second;
if (d[v] > dist) {
d[v] = dist;
sum += sh;
G.push_back(ed);
for (int i = 0; i < A[v].size(); i++) {
if (dist + A[v][i].second.first < d[A[v][i].first]) {
PQ.push(make_pair(
make_pair(dist + A[v][i].second.first, A[v][i].second.first),
make_pair(A[v][i].first, A[v][i].second.second)));
}
}
}
}
return sum;
}
const long long INF = 1e18;
inline int inp() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int ret = 0;
while (c >= '0' && c <= '9') {
ret = (ret << 3) + (ret << 1) + c - 48;
c = getchar();
}
return ret;
}
int main() {
int n, m;
n = inp();
m = inp();
for (int i = 0; i < m; i++) {
int u, v, w;
u = inp();
v = inp();
w = inp();
u--;
v--;
A[u].push_back(make_pair(v, make_pair(w, i + 1)));
A[v].push_back(make_pair(u, make_pair(w, i + 1)));
E[i + 1] = w;
}
int u = inp() - 1;
for (int i = 0; i < n; i++) d[i] = INF;
maxd = -1;
long long ans = dij(u);
int y = (int)G.size();
printf("%I64d\n", ans);
for (int i = 1; i < y; i++) {
printf("%d ", G[i]);
}
printf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1e6 + 5;
long long int n, m;
vector<pair<pair<long long int, long long int>, long long int> > g[N];
long long int s, d[N];
long long int edge[N], vis[N];
long long int on[N];
multiset<pair<pair<long long int, long long int>,
pair<long long int, long long int> > >
pq;
long long int cnt = 0;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
for (long long int i = 1; i < N; i++) d[i] = 9e18;
cin >> n >> m;
for (long long int i = 1; i <= m; ++i) {
long long int u, v, w;
cin >> u >> v >> w;
g[u].push_back({{v, w}, i});
g[v].push_back({{u, w}, i});
edge[i] = w;
on[i] = 0;
}
cin >> s;
d[s] = 0;
for (long long int i = 1; i <= n; ++i) {
pq.insert({{d[i], 0}, {i, -1}});
}
while (!pq.empty()) {
pair<pair<long long int, long long int>,
pair<long long int, long long int> >
from = *pq.begin();
pq.erase(pq.begin());
long long int u = from.second.first, e = from.second.second;
if (vis[u]) continue;
vis[u] = 1;
if (e != -1) on[e] = 1, cnt++;
for (pair<pair<long long int, long long int>, long long int> to : g[u]) {
long long int v = to.first.first, w = to.first.second, e = to.second;
if (vis[v]) continue;
if (d[v] >= d[u] + w) {
d[v] = d[u] + w;
pq.insert({{d[v], w}, {v, e}});
}
}
}
long long int res = 0;
for (long long int i = 1; i <= m; ++i) {
if (on[i]) {
res += edge[i];
}
}
cout << res << '\n';
for (long long int i = 1; i <= m; ++i) {
if (on[i]) cout << i << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct data {
int v;
long long w;
data(int a, long long b) {
v = a;
w = b;
}
bool operator<(const data& p) const { return w > p.w; }
};
map<pair<int, int>, pair<int, long long> > mp;
vector<data> adj[300005];
long long dis[300005];
int node, edge;
priority_queue<data> qu;
void func(int u) {
for (int i = 0; i <= node; i++) dis[i] = 500000000000000000ll;
dis[u] = 0ll;
while (!qu.empty()) qu.pop();
qu.push(data(u, 0ll));
while (!qu.empty()) {
int u = qu.top().v;
long long w = qu.top().w;
qu.pop();
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i].v;
long long tw = adj[u][i].w + w;
if (dis[v] > tw) {
dis[v] = tw;
qu.push(data(v, tw));
}
}
}
}
vector<int> res;
int main() {
scanf("%d%d", &node, &edge);
for (int i = 1; i <= edge; i++) {
int u, v;
long long w;
scanf("%d %d %I64d", &u, &v, &w);
adj[u].push_back(data(v, w));
adj[v].push_back(data(u, w));
mp[make_pair(u, v)] = make_pair(i, w);
mp[make_pair(v, u)] = make_pair(i, w);
}
int u;
scanf("%d", &u);
func(u);
long long total = 0;
for (int i = 1; i <= node; i++) {
int u = -1;
long long w = 500000000000000000ll;
for (int j = 0; j < adj[i].size(); j++) {
long long tw = adj[i][j].w;
int v = adj[i][j].v;
if (dis[v] + tw == dis[i] && w > tw) {
w = tw;
u = v;
}
}
if (u != -1) {
res.push_back(mp[make_pair(i, u)].first);
total += mp[make_pair(i, u)].second;
}
}
sort(res.begin(), res.end());
printf("%I64d\n", total);
for (int i = 0; i < res.size(); i++) printf("%d ", res[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, s;
struct edge {
int from;
int to;
int w;
};
edge e[600020];
vector<int> adj[300010];
long long sum, d[300010];
int tag[600010], pre[300010], vis[300010];
queue<int> Q;
void init() {
int i;
for (i = 0; i <= n; i++) adj[i].clear();
}
void spfa() {
while (!Q.empty()) Q.pop();
memset(tag, 0, sizeof(tag));
for (int i = 1; i <= n; i++) {
d[i] = 0x7fffffffffffffff;
pre[i] = -1;
}
d[s] = 0;
memset(vis, 0, sizeof(vis));
Q.push(s);
while (!Q.empty()) {
int x = Q.front();
Q.pop();
vis[x] = 0;
for (int i = 0; i < adj[x].size(); i++) {
int t = adj[x][i];
int v = e[t].to;
if (d[v] > d[x] + e[t].w && d[x] < 0x7fffffffffffffff) {
pre[v] = t;
d[v] = d[x] + e[t].w;
if (!vis[v]) {
vis[v] = 1;
Q.push(v);
}
} else if (d[v] == d[x] + e[t].w && d[x] < 0x7fffffffffffffff &&
e[pre[v]].w > e[t].w)
pre[v] = t;
}
}
}
int main() {
int i, j, a, b, c;
while (scanf("%d%d", &n, &m) == 2) {
init();
for (i = 1; i <= m; i++) {
scanf("%d %d %d", &a, &b, &c);
e[i] = {a, b, c};
e[i + m] = {b, a, c};
adj[a].push_back(i);
adj[b].push_back(i + m);
}
scanf("%d", &s);
spfa();
sum = 0;
for (i = 1; i <= n; i++) {
sum += e[pre[i]].w;
tag[pre[i]] = 1;
}
int count = 0;
printf("%I64d\n", sum);
for (i = 1; i <= 2 * m; i++) {
if (tag[i]) {
if (count)
printf(" %d", i > m ? i - m : i);
else
printf("%d", i > m ? i - m : i);
count++;
}
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
int n, m, st, vis[maxn], fre[maxn];
long long dis[maxn], ans;
int head[maxn], cnt = -1;
struct edge {
int to, next, w;
} e[maxn << 1];
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
void adde(int u, int v, int w) {
e[++cnt].to = v;
e[cnt].w = w;
e[cnt].next = head[u];
head[u] = cnt;
}
int read() {
int res = 0, f = 1;
char ch;
do {
ch = getchar();
if (ch == '-') f = -1;
} while (!isdigit(ch));
do {
res = res * 10 + ch - '0';
ch = getchar();
} while (isdigit(ch));
return res * f;
}
void Dijkstra() {
dis[st] = 0;
fre[st] = -1;
q.push(make_pair(dis[st], st));
while (!q.empty()) {
int u = q.top().second;
q.pop();
if (vis[u]) continue;
vis[u] = 1;
for (int i = head[u]; i != -1; i = e[i].next) {
int v = e[i].to;
if (dis[v] == dis[u] + e[i].w) {
if (e[fre[v]].w > e[i].w) {
fre[v] = i;
if (!vis[v]) q.push(make_pair(dis[v], v));
}
}
if (dis[v] > dis[u] + e[i].w) {
dis[v] = dis[u] + e[i].w;
fre[v] = i;
if (!vis[v]) q.push(make_pair(dis[v], v));
}
}
}
}
int main() {
n = read();
m = read();
memset(head, -1, sizeof(head));
for (int i = (0); i <= (n); ++i) dis[i] = 1e18;
for (int i = (1); i <= (m); ++i) {
int u = read(), v = read(), w = read();
adde(u, v, w);
adde(v, u, w);
}
st = read();
Dijkstra();
for (int i = (1); i <= (n); ++i)
if (fre[i] != -1) ans += e[fre[i]].w;
printf("%lld\n", ans);
for (int i = (1); i <= (n); ++i)
if (fre[i] != -1) printf("%d ", fre[i] / 2 + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 100;
const long long inf = 0x3f3f3f3f3f3f3f3f;
int n, m;
struct Edge {
int u, v, w;
} edges[maxn];
vector<pair<pair<int, int>, int>> g[maxn];
long long dist[maxn], ans = 0;
bool mark[maxn];
int edge_pai[maxn];
void dijkstra(int s) {
for (int i = (1); i < (n + 1); i++) dist[i] = inf;
dist[s] = 0ll;
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
q;
q.push({0ll, s});
while (!q.empty()) {
int u = q.top().second;
q.pop();
if (mark[u]) continue;
mark[u] = 1;
for (auto pp : g[u]) {
int v = pp.first.first;
int w = pp.first.second;
int id = pp.second;
if (dist[v] == dist[u] + w && edges[edge_pai[v]].w > w) {
ans += w - edges[edge_pai[v]].w;
edge_pai[v] = id;
}
if (dist[v] > dist[u] + w) {
ans += w - (edges[edge_pai[v]].w ? edges[edge_pai[v]].w : 0);
edge_pai[v] = id;
dist[v] = dist[u] + w;
q.push({dist[u] + w, v});
}
}
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = (1); i < (m + 1); i++) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
g[u].push_back({{v, w}, i});
g[v].push_back({{u, w}, i});
edges[i] = {u, v, w};
}
int s;
scanf("%d", &s);
dijkstra(s);
printf("%lld\n", ans);
for (int i = (1); i < (n + 1); i++)
if (i != s) printf("%d%c", edge_pai[i], " \n"[i == n]);
if (s == n) puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
const int INFint = 2147483647;
const long long INF = 9223372036854775807ll;
const long long MOD = 1000000009ll;
const long double EPS = 1e-9;
vector<vector<pair<pair<int, int>, int> > > g;
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
g.resize(n);
vector<long long> cc(m);
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
a--, b--;
cc[i] = c;
g[a].push_back(make_pair(make_pair(b, c), i));
g[b].push_back(make_pair(make_pair(a, c), i));
}
long long res = 0;
vector<int> ans(n, -1);
int u;
cin >> u;
u--;
vector<long long> d(n, INF);
d[u] = 0;
priority_queue<pair<long long, int> > q;
q.push(make_pair(0, u));
while (!q.empty()) {
long long dist = -q.top().first;
int v = q.top().second;
q.pop();
if (dist != d[v]) continue;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i].first.first;
int w = g[v][i].first.second;
int num = g[v][i].second;
if (d[to] > d[v] + w || (d[to] == d[v] + w && cc[ans[to]] > w)) {
ans[to] = num;
d[to] = d[v] + w;
q.push(make_pair(-d[to], to));
}
}
}
for (int i = 0; i < n; i++)
if (ans[i] != -1) res += cc[ans[i]];
cout << res << endl;
for (int i = 0; i < n; i++)
if (ans[i] != -1) cout << ans[i] + 1 << ' ';
fprintf(stderr, "\nTIME = %lf\n", 1.0 * clock() / CLOCKS_PER_SEC);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') {
f = -1;
}
c = getchar();
}
while (c <= '9' && c >= '0') {
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
}
return x * f;
}
const long long INF = 0x3f3f3f3f3f3f3f3f;
const long long Maxn = 3e5 + 5;
const long long Maxm = 6e5 + 5;
long long n, m, s, cnt, head[Maxn], dis[Maxn], pre[Maxn], ans[Maxn];
bool vis[Maxn];
struct Line {
long long to;
long long w;
long long next;
} edges[Maxm];
inline void Add(long long a, long long b, long long w) {
++cnt;
edges[cnt].to = b;
edges[cnt].w = w;
edges[cnt].next = head[a];
head[a] = cnt;
return;
}
struct Node {
long long id;
long long dist;
bool operator<(const Node &cur) const { return dist > cur.dist; }
};
inline void Dijkstra(long long start) {
priority_queue<Node> pq;
for (register long long i = 1; i <= n; ++i) {
dis[i] = INF;
vis[i] = false;
}
dis[start] = 0;
Node Start = {s, 0};
pq.push(Start);
while (!pq.empty()) {
Node now = pq.top();
pq.pop();
long long u = now.id;
if (vis[u] == true) {
continue;
}
vis[u] = true;
for (register long long i = head[u]; i != 0; i = edges[i].next) {
long long next = edges[i].to, w = edges[i].w;
if (dis[next] > dis[u] + w) {
dis[next] = dis[u] + w;
Node nxt = {next, dis[next]};
pq.push(nxt);
pre[next] = i;
}
if (dis[next] == dis[u] + edges[i].w && edges[i].w < edges[pre[next]].w) {
pre[next] = i;
}
}
}
return;
}
signed main() {
n = read(), m = read();
for (register long long i = 1; i <= m; ++i) {
long long x = read(), y = read(), w = read();
Add(x, y, w), Add(y, x, w);
}
s = read();
Dijkstra(s);
long long sum = 0, tot = 0;
for (register long long i = 1; i <= n; ++i) {
if (i == s) {
continue;
}
long long id = pre[i];
long long w = edges[id].w;
sum += w;
ans[++tot] = id;
}
sort(ans + 1, ans + tot + 1);
printf("%lld\n", sum);
for (register long long i = 1; i <= tot; ++i) {
printf("%lld ", (ans[i] + 1) / 2);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> graph[300000 + 10], cost[300000 + 10], id[300000 + 10];
int n, m;
bool visit[300000 + 10];
struct node {
long long edge, id, u, w;
};
class cmp {
public:
bool operator()(node &a, node &b) {
if (a.w == b.w) {
if (a.edge > b.edge)
return true;
else
return false;
}
if (a.w > b.w)
return true;
else
return false;
}
};
void Dijkstra(long long source) {
priority_queue<node, vector<node>, cmp> Q;
node N;
N.u = source;
N.w = 0;
N.id = -1;
long long total = 0;
Q.push(N);
vector<long long> V;
while (Q.size() != 0) {
N = Q.top();
Q.pop();
long long u = N.u, w = N.w, idc = N.id;
if (visit[u]) continue;
visit[u] = true;
if (idc != -1) {
V.push_back(idc);
total = total + N.edge;
}
for (int i = 0; i < graph[u].size(); i++) {
long long v = graph[u][i];
if (visit[v] == false) {
N.u = v;
N.w = w + cost[u][i];
N.id = id[u][i];
N.edge = cost[u][i];
Q.push(N);
}
}
}
sort(V.begin(), V.end());
cout << total << endl;
for (int i = 0; i < V.size(); i++) cout << V[i] << ' ';
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
long long u, v, w;
scanf("%lld%lld%lld", &u, &v, &w);
graph[u].push_back(v);
cost[u].push_back(w);
id[u].push_back(i);
graph[v].push_back(u);
cost[v].push_back(w);
id[v].push_back(i);
}
long long u;
cin >> u;
Dijkstra(u);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1e6 + 9;
const long long oo = 1e18;
set<pair<long long, pair<long long, long long> > > st;
long long par[Maxn];
long long dis[Maxn], wei[Maxn], vis[Maxn], len[Maxn];
vector<pair<long long, long long> > al[Maxn];
long long ans = 0;
void relax(int v) {
vis[v] = 1;
for (int i = 0; i < al[v].size(); i++) {
int u = al[v][i].first, id = al[v][i].second, w = len[id];
if (vis[u]) continue;
st.erase(make_pair(dis[u], make_pair(wei[u], u)));
if (dis[u] > dis[v] + w || dis[u] == dis[v] + w && w < wei[u]) {
par[u] = id;
wei[u] = w;
dis[u] = dis[v] + w;
}
st.insert(make_pair(dis[u], make_pair(wei[u], u)));
}
return;
}
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) dis[i] = oo;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v >> len[i];
--u, --v;
al[u].push_back(make_pair(v, i));
al[v].push_back(make_pair(u, i));
}
int source;
cin >> source;
source--;
par[source] = Maxn;
dis[source] = 0;
relax(source);
while (st.size()) {
pair<long long, pair<long long, long long> > cur = *(st.begin());
st.erase(cur);
long long v = cur.second.second, w = cur.second.first;
if (vis[v]) continue;
relax(v);
ans += w;
}
cout << ans << endl;
for (int i = 0; i < n; i++) {
if (i != source) {
cout << par[i] + 1 << ' ';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10000;
const long long mod = 1e9 + 7;
int n, m;
vector<int> G[maxn];
int edge[maxn][2];
long long dp[maxn];
int par[maxn];
void Dijkstra(int src) {
memset(dp, 63, sizeof(dp));
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
pq;
dp[src] = 0LL;
pq.push({0LL, src});
while (!pq.empty()) {
auto u = pq.top();
pq.pop();
if (u.first > dp[u.second]) continue;
for (auto g : G[u.second]) {
int ver = edge[g][0] ^ u.second;
int wei = edge[g][1];
if (dp[ver] > dp[u.second] + wei) {
dp[ver] = dp[u.second] + wei;
par[ver] = g;
pq.push({dp[ver], ver});
} else if (dp[ver] == dp[u.second] + wei && edge[par[ver]][1] > wei) {
par[ver] = g;
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v, w;
cin >> u >> v >> w;
edge[i][0] = u ^ v;
edge[i][1] = w;
G[u].push_back(i);
G[v].push_back(i);
}
int start;
cin >> start;
Dijkstra(start);
long long sum = 0;
for (int i = 1; i <= n; i++) {
if (i == start) continue;
sum += edge[par[i]][1];
}
cout << sum << endl;
for (int i = 1; i <= n; i++) {
if (i == start) continue;
cout << par[i] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
const int maxl = 1e9 + 5;
const long long inf = 1e15;
int ui, vi, wi;
int S;
vector<int> isIn;
long long cost;
struct node {
int v, w, number;
node(int vv, int ww, int nn) { v = vv, w = ww, number = nn; }
};
vector<node> G[maxn];
long long d1[maxn];
int lastedge[maxn];
bool solved[maxn];
int weight[maxn];
void dijkstra() {
fill(d1, d1 + maxn, inf);
fill(lastedge, lastedge + maxn, 0);
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
d1[S] = 0;
q.push(pair<long long, int>(d1[S], S));
while (!q.empty()) {
pair<long long, int> cur = q.top();
q.pop();
long long d = cur.first;
int u = cur.second;
if (solved[u] == true) {
continue;
} else {
if (u != S) {
cost += weight[lastedge[u]];
isIn.push_back(lastedge[u]);
}
solved[u] = true;
for (int i = 0; i < G[u].size(); i++) {
node &e = G[u][i];
if (solved[e.v] == true) {
continue;
}
long long td = d + e.w;
if (d1[e.v] > td) {
swap(td, d1[e.v]);
lastedge[e.v] = e.number;
q.push(pair<long long, int>(d1[e.v], e.v));
} else if (d1[e.v] == td) {
if (weight[e.number] < weight[lastedge[e.v]]) {
lastedge[e.v] = e.number;
q.push(pair<long long, int>(d1[e.v], e.v));
}
}
}
}
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
memset(G, 0, sizeof(G));
;
weight[0] = maxl;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &ui, &vi, &wi);
G[ui].push_back(node(vi, wi, i));
G[vi].push_back(node(ui, wi, i));
weight[i] = wi;
}
scanf("%d", &S);
dijkstra();
printf("%lld\n", cost);
for (int i = 0; i < isIn.size(); i++) {
printf("%d%c", isIn[i], (i == isIn.size() - 1) ? '\n' : ' ');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v[400000];
priority_queue<pair<long long int, int> > pq;
int reach[400000];
long long int dis[400000];
vector<pair<int, pair<int, int> > > e;
map<pair<int, int>, int> mp;
int main() {
int i, n, m, x, y, u, z;
cin >> n >> m;
fill(dis, dis + n + 1, 1e18 + 10);
int cnt = 1;
while (m--) {
cin >> x >> y >> z;
x--;
y--;
mp[make_pair(x, y)] = mp[make_pair(y, x)] = cnt++;
v[x].push_back(make_pair(y, z));
v[y].push_back(make_pair(x, z));
e.push_back(make_pair(z, make_pair(x, y)));
e.push_back(make_pair(z, make_pair(y, x)));
}
cin >> u;
u--;
pq.push(make_pair(0, u));
dis[u] = 0;
while (!pq.empty()) {
int cn = pq.top().second;
long long int cdis = -pq.top().first;
pq.pop();
for (i = 0; i < (int)v[cn].size(); i++) {
int nn = v[cn][i].first;
long long int ndis = cdis + v[cn][i].second;
if (ndis >= dis[nn]) continue;
dis[nn] = ndis;
pq.push(make_pair(-ndis, nn));
}
}
sort(e.begin(), e.end());
vector<int> fans;
long long int ans = 0;
for (i = 0; i < (int)e.size(); i++) {
int x = e[i].second.first;
int y = e[i].second.second;
if (dis[x] + e[i].first == dis[y] && reach[y] == 0) {
reach[y] = 1;
ans += e[i].first;
fans.push_back(mp[make_pair(x, y)]);
}
}
cout << ans << endl;
for (i = 0; i < (int)fans.size(); i++) cout << fans[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, m, vertex_start;
vector<pair<int, pair<int, int>>> graph[3 * N];
long long dist[3 * N];
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
q;
pair<int, int> ans[3 * N];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int from, to, weight;
cin >> from >> to >> weight;
graph[from].push_back({to, {weight, i}});
graph[to].push_back({from, {weight, i}});
}
for (int i = 1; i <= n; i++) {
dist[i] = 1e18;
}
cin >> vertex_start;
dist[vertex_start] = 0;
q.push({0, vertex_start});
bool usd[N * 3] = {};
while (!q.empty()) {
pair<long long, int> cur = q.top();
int v = cur.second;
long long value = cur.first;
q.pop();
if (usd[v]) {
continue;
}
if (value > dist[v]) {
continue;
}
usd[v] = true;
for (int i = 0; i < graph[v].size(); i++) {
int child = graph[v][i].first;
int weight = graph[v][i].second.first;
int id = graph[v][i].second.second;
long long res = dist[v] + 1LL * weight;
if (dist[child] >= res) {
dist[child] = res;
q.push({res, child});
ans[child] = {id, weight};
}
}
}
long long edge_sum = 0;
for (int i = 1; i <= n; i++) {
if (i != vertex_start) {
edge_sum = edge_sum + 1LL * ans[i].second;
}
}
cout << edge_sum << endl;
for (int i = 1; i <= n; i++) {
if (i != vertex_start) {
cout << ans[i].first << " ";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3 * 1e5 + 10;
vector<int> grafo[MAXN], resposta;
int e1[MAXN], e2[MAXN], e3[MAXN], N, M, U, processado[MAXN];
long long somatorio;
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
cin >> N >> M;
for (int i = 1; i <= M; i++) {
cin >> e1[i] >> e2[i] >> e3[i];
grafo[e1[i]].push_back(i);
grafo[e2[i]].push_back(i);
}
cin >> U;
priority_queue<tuple<long long, long long, int, int>,
vector<tuple<long long, long long, int, int> >,
greater<tuple<long long, long long, int, int> > >
pq;
pq.push(make_tuple(0, 0, 0, U));
while (!pq.empty()) {
tuple<long long, long long, int, int> davez = pq.top();
pq.pop();
long long dist = get<0>(davez), peso = get<1>(davez), idx = get<2>(davez),
v = get<3>(davez);
if (processado[v]) continue;
processado[v] = 1;
if (v != U) {
resposta.push_back(idx);
somatorio += peso;
}
for (int i : grafo[v]) {
int u = (e1[i] != v) ? (e1[i]) : (e2[i]);
long long w = e3[i];
pq.push(make_tuple(dist + w, w, i, u));
}
}
cout << somatorio << endl;
for (int i : resposta) cout << i << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
struct node {
int u, v, w;
bool operator<(const node& a) const { return w < a.w; }
} a[300010];
int v[300010], p[300010];
vector<int> g[300010];
long long d[300010];
int main() {
clock_t start = clock();
int T, i, j, k, m = 0, n;
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d%d%d", &a[i].u, &a[i].v, &a[i].w);
g[a[i].u].push_back(i);
g[a[i].v].push_back(i);
}
int s;
scanf("%d", &s);
queue<int> q;
for (i = 1; i <= n; i++) d[i] = (long long)1e15;
d[s] = 0;
q.push(s);
while (!q.empty()) {
int u = q.front();
q.pop();
v[u] = 0;
for (i = 0; i < g[u].size(); i++) {
j = g[u][i];
k = a[j].u + a[j].v - u;
if (d[k] > d[u] + a[j].w ||
(d[k] == d[u] + a[j].w && a[j].w < a[p[k]].w)) {
d[k] = d[u] + a[j].w;
p[k] = j;
if (!v[k]) v[k] = 1, q.push(k);
}
}
}
vector<int> ans;
long long sum = 0;
for (i = 1; i <= n; i++)
if (i != s) ans.push_back(p[i]), sum += a[p[i]].w;
sort(ans.begin(), ans.end());
printf("%I64d\n", sum);
for (i = 0; i < ans.size(); i++) printf("%d ", ans[i] + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> e[300010], w[300010], z[300010];
priority_queue<pair<long long, long long> > pq;
long long vis[300010], a[300010], ans[300010], s[300010], g[300010];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
long long n, m, u, v, wi, t;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> u >> v >> wi;
e[u].push_back(v);
e[v].push_back(u);
w[u].push_back(wi);
w[v].push_back(wi);
z[u].push_back(i);
z[v].push_back(i);
g[i] = wi;
}
cin >> t;
memset(a, 0x3f3f3f3f, sizeof(a));
memset(ans, -1, sizeof(ans));
a[t] = 0;
pq.push(make_pair(0, t));
while (!pq.empty()) {
int k = pq.top().second;
pq.pop();
if (vis[k]) continue;
vis[k] = 1;
for (int i = 0; i < e[k].size(); i++) {
int x = e[k][i];
if (vis[x]) continue;
if (a[x] >= a[k] + w[k][i]) {
a[x] = a[k] + w[k][i];
if (ans[x] != -1) s[ans[x]] = 0;
ans[x] = z[k][i];
s[ans[x]] = 1;
pq.push(make_pair(-a[x], x));
}
}
}
long long tot = 0;
for (int i = 0; i < m; i++) {
if (s[i]) tot += g[i];
}
cout << tot << endl;
for (int i = 0; i < m; i++)
if (s[i]) cout << i + 1 << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
const long long INFL = 1e18;
const int N = 3e5;
int n, m, R;
vector<int> adj[N + 5];
pair<int, int> E[2 * N + 5];
long long d[N + 5];
struct cmp {
bool operator()(pair<int, long long> x, pair<int, long long> y) {
return (x.second > y.second);
}
};
priority_queue<pair<int, long long>, vector<pair<int, long long> >, cmp> H;
int tr[N + 5];
void Dijkstra() {
for (int i = (1), _b = (n); i <= _b; ++i) d[i] = INFL;
d[R] = 0;
H.push(make_pair(R, d[R]));
while (!H.empty()) {
int u = H.top().first;
long long oldDist = H.top().second;
H.pop();
if (oldDist != d[u]) continue;
for (int i = (0), _b = (((int)(adj[u]).size())); i < _b; ++i) {
int v = E[adj[u][i]].first, w = E[adj[u][i]].second;
if (d[u] + w < d[v] ||
d[u] + w == d[v] && E[adj[u][i]].second < E[tr[v]].second) {
d[v] = d[u] + w;
H.push(make_pair(v, d[v]));
tr[v] = adj[u][i];
}
}
}
}
vector<int> pth;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
int cntE = 0;
while (m--) {
int u, v, w;
cin >> u >> v >> w;
E[++cntE] = make_pair(v, w);
adj[u].push_back(cntE);
E[++cntE] = make_pair(u, w);
adj[v].push_back(cntE);
}
cin >> R;
Dijkstra();
long long res = 0;
for (int i = (1), _b = (n); i <= _b; ++i)
if (i != R) {
res += E[tr[i]].second;
pth.push_back(tr[i]);
}
cout << res << '\n';
for (int i = (0), _b = (((int)(pth).size())); i < _b; ++i)
cout << (pth[i] + 1) / 2 << ' ';
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
template <typename T>
T pow(T a, T b, long long m) {
T ans = 1;
while (b > 0) {
if (b % 2 == 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans % m;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, m;
cin >> n >> m;
vector<vector<pair<pair<long long, long long>, long long> > > g(n + 1);
for (long long i = 0; i < m; i++) {
long long a, b, w;
cin >> a >> b >> w;
g[a].push_back(make_pair(make_pair(w, b), i + 1));
g[b].push_back(make_pair(make_pair(w, a), i + 1));
}
long long source;
cin >> source;
set<pair<pair<long long, long long>, pair<long long, long long> > > s2;
vector<long long> dist(n + 1, LLONG_MAX);
dist[source] = 0;
s2.insert(make_pair(make_pair(0, source), make_pair(0, 0)));
long long ans = 0;
vector<long long> ans2;
vector<long long> vis(n + 1, 0);
long long count = 0;
for (auto it : s2) {
long long w = it.second.first;
long long node = it.first.second;
if (vis[node]) continue;
vis[node] = 1;
count++;
ans += w;
long long edge = it.second.second;
if (edge != 0) ans2.push_back(edge);
if (count == n) break;
for (auto i : g[node]) {
long long v = i.first.second;
long long u = node;
w = i.first.first;
if (dist[v] >= dist[u] + w) {
s2.erase(make_pair(make_pair(dist[v], v), make_pair(w, i.second)));
dist[v] = dist[u] + w;
s2.insert(make_pair(make_pair(dist[v], v), make_pair(w, i.second)));
}
}
}
cout << ans << "\n";
for (auto it : ans2) {
cout << it << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using lli = long long int;
using llf = long double;
struct Edge {
int from;
int to;
int cost;
int idx;
Edge() {}
Edge(int f, int t) : from(f), to(t) {}
inline int next(int v) const { return v ^ from ^ to; }
};
struct Graph {
Graph() {}
Graph(const vector<vector<Edge>>& g) : g(g) {}
Graph(int n, const vector<Edge>& edges, bool unordered = true) : g(n) {
for (const auto& e : edges) {
g[e.from].push_back(e);
if (unordered) {
g[e.to].push_back(e);
}
}
}
inline int N() const { return g.size(); }
vector<vector<Edge>> g;
};
vector<Edge> ReadEdges(int m) {
vector<Edge> edges(m);
for (auto& e : edges) {
cin >> e.from >> e.to;
--e.from;
--e.to;
}
return edges;
}
vector<Edge> ReadWeightedEdges(int m) {
vector<Edge> edges(m);
for (int i = 0; i < m; ++i) {
auto& e = edges[i];
cin >> e.from >> e.to >> e.cost;
e.idx = i;
--e.from;
--e.to;
}
return edges;
}
Graph* ReadGraph(bool unordered = true) {
int n, m;
cin >> n >> m;
return new Graph(n, ReadEdges(m), unordered);
}
Graph* ReadWeightedGraph(bool unordered = true) {
int n, m;
cin >> n >> m;
return new Graph(n, ReadWeightedEdges(m), unordered);
}
template <typename T = lli>
struct SumF {
static T MaxValue() { return std::numeric_limits<T>::max() / 2; }
static T Default() { return 0ll; }
static T Sum(const T& from, const Edge& e) { return from + e.cost; }
};
template <typename T = lli>
struct SumLastF {
using TCost = pair<T, int>;
static TCost MaxValue() {
return make_pair(std::numeric_limits<T>::max() / 2, -1);
}
static TCost Default() { return make_pair(static_cast<T>(0), 0); }
static TCost Sum(const TCost& from, const Edge& e) {
return make_pair(from.first + e.cost, e.cost);
}
};
template <typename DType = lli, typename TSum = SumF<lli>>
struct Dijkstra {
using QT = pair<DType, int>;
Dijkstra(const Graph* g, int source)
: graph_(g),
source_(source),
distances(g->N(), TSum::MaxValue()),
parents(g->N(), nullptr) {
priority_queue<QT, vector<QT>, std::greater<QT>> q;
distances[source_] = TSum::Default();
q.emplace(distances[source_], source_);
while (!q.empty()) {
auto [cost, v] = q.top();
q.pop();
if (cost > distances[v]) continue;
for (const auto& e : graph_->g[v]) {
int to = e.next(v);
auto total = TSum::Sum(cost, e);
if (total < distances[to]) {
distances[to] = total;
parents[to] = &e;
q.emplace(total, to);
}
}
}
}
const Graph* graph_;
int source_;
vector<DType> distances;
vector<const Edge*> parents;
};
const lli M = 1e9 + 7;
const int N = 2e5 + 30;
const int L = 19;
const int D = 5 * 101;
const int INF = 1 << 30;
const lli INFL = (1 << 30) * 1ll * (1 << 30);
using CostF = SumLastF<lli>;
int main() {
ios_base::sync_with_stdio(false);
Graph* g = ReadWeightedGraph();
int source;
cin >> source;
auto helper = Dijkstra<CostF::TCost, CostF>(g, source - 1);
lli result = 0;
for (auto e : helper.parents) {
result += (e == nullptr ? 0 : e->cost);
}
cout << result << endl;
for (auto e : helper.parents) {
if (e != nullptr) cout << e->idx + 1 << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int u, v, id, next;
long long int w;
} edges[610000];
int n, m;
int head[610000], nCount = 1;
void AddEdge(int U, int V, long long int W, int ID) {
edges[++nCount].u = U;
edges[nCount].v = V;
edges[nCount].w = W;
edges[nCount].id = ID;
edges[nCount].next = head[U];
head[U] = nCount;
}
long long int dist[610000];
bool vis[610000];
bool used[610000];
int pre[610000];
struct Info {
int u;
long long int w;
long long int dis;
Info(int _u, long long int _d, long long int _w) : u(_u), dis(_d), w(_w) {}
};
bool operator<(Info a, Info b) {
if (a.dis == b.dis) return a.w < b.w;
return a.dis < b.dis;
}
bool operator>(Info a, Info b) {
if (a.dis == b.dis) return a.w > b.w;
return a.dis > b.dis;
}
priority_queue<Info, vector<Info>, greater<Info> > heap;
void heapdij(int S) {
memset(dist, 0x3f, sizeof(dist));
dist[S] = 0;
heap.push(Info(S, 0, 0));
while (!heap.empty()) {
Info now = heap.top();
heap.pop();
int u = now.u;
if (vis[u]) continue;
vis[u] = true;
for (int p = head[u]; p != -1; p = edges[p].next) {
int v = edges[p].v;
if (dist[u] + edges[p].w <= dist[v]) {
if (pre[v] != -1) used[pre[v]] = false;
pre[v] = edges[p].id;
used[edges[p].id] = true;
dist[v] = dist[u] + edges[p].w;
heap.push(Info(v, dist[v], edges[p].w));
}
}
}
}
int main() {
memset(head, -1, sizeof(head));
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
long long int w;
scanf("%d%d%I64d", &u, &v, &w);
AddEdge(u, v, w, i);
AddEdge(v, u, w, i);
}
int S;
scanf("%d", &S);
heapdij(S);
long long int tot = 0;
for (int i = 1; i <= m; i++)
if (used[i]) tot += (long long int)edges[i * 2].w;
printf("%I64d\n", tot);
for (int i = 1; i <= m; i++)
if (used[i]) printf("%d ", i);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, z, k, w, pt, init;
int l[300005], ed[600005], LINK[600005];
long long cost[600005];
long long ans, A[300005];
int B[300005], C[300005], ANS[300005];
void build(int x, int y, int z) {
LINK[w] = l[x];
l[x] = w;
ed[w] = y;
cost[w++] = (long long)(z);
}
struct node {
int x;
long long val;
bool operator<(node const& T) const { return T.val < val; }
} tmp, a;
priority_queue<node> Q;
int main() {
memset(l, -1, sizeof(l));
scanf("%d%d", &n, &m);
for (int i = (0); i < (m); i++) {
scanf("%d%d%d", &x, &y, &z);
build(x, y, z);
build(y, x, z);
}
scanf("%d", &k);
init = k;
tmp.x = k;
tmp.val = 0LL;
Q.push(tmp);
memset(A, -1LL, sizeof(A));
A[k] = 0LL;
k = 0;
while (!Q.empty()) {
tmp = Q.top();
Q.pop();
if (tmp.val != A[tmp.x]) continue;
ans += (long long)(B[tmp.x]);
if (tmp.x != init) ANS[k++] = C[tmp.x] / 2 + 1;
pt = l[tmp.x];
while (pt != -1) {
if (A[ed[pt]] == -1LL || A[ed[pt]] > A[tmp.x] + cost[pt]) {
A[ed[pt]] = A[tmp.x] + cost[pt];
a.x = ed[pt];
a.val = A[ed[pt]];
Q.push(a);
B[ed[pt]] = cost[pt];
C[ed[pt]] = pt;
}
if (A[tmp.x] + cost[pt] == A[ed[pt]]) {
if (B[ed[pt]] == 0) {
B[ed[pt]] = cost[pt];
C[ed[pt]] = pt;
} else if (B[ed[pt]] > cost[pt]) {
B[ed[pt]] = cost[pt];
C[ed[pt]] = pt;
}
}
pt = LINK[pt];
}
}
printf("%I64d\n", ans);
for (int i = (0); i < (k); i++)
if (i == k - 1)
printf("%d\n", ANS[i]);
else
printf("%d ", ANS[i]);
return 0;
}
|
#include <bits/stdc++.h>
struct heap_t {
long long w;
int data, edge_index;
} heap[300000 + 10];
int heap_len;
int N, M;
void heap_print() {
int i;
printf("Heap:");
for (i = 0; i < heap_len; i++)
printf(" %d(%d)", heap[i].data + 1, heap[i].edge_index);
printf("\n");
}
void heap_swap(int i, int j) {
struct heap_t tmp;
tmp = heap[i];
heap[i] = heap[j];
heap[j] = tmp;
}
void heap_add(long long w, int data, int edge_index) {
int i;
if (w < 0) {
printf("Error: negative weight heap_add(%I64d,%d,%d)\n", w, data,
edge_index);
exit(0);
}
if (heap_len >= 300000 + 10) {
printf("Error: maximum heap length exceeded\n");
exit(0);
}
heap[heap_len].w = w;
heap[heap_len].data = data;
heap[heap_len].edge_index = edge_index;
i = heap_len;
heap_len++;
while (i && heap[i].w < heap[(i - 1) / 2].w) {
heap_swap(i, (i - 1) / 2);
i = (i - 1) / 2;
}
}
void heap_get(long long *w, int *data) {
int i, i1, i2;
*w = heap[0].w;
*data = heap[0].data;
heap_len--;
heap[0] = heap[heap_len];
for (i = 0;;) {
i1 = 2 * i + 1;
i2 = 2 * i + 2;
if (i2 < heap_len && heap[i2].w < heap[i1].w) i1 = i2;
if (i1 < heap_len && heap[i1].w < heap[i].w) {
heap_swap(i, i1);
i = i1;
} else
break;
}
}
struct neighlist_t {
int neighbour;
int len;
int index;
struct neighlist_t *next;
} * neighlist[300000];
char test_negative() {
return 0;
int i;
struct neighlist_t *n;
for (i = 0; i < N; i++)
for (n = neighlist[i]; n; n = n->next)
if (n->len < 0) {
printf("Error: Negative edge %d(%d) between %d and %d\n", n->index,
n->len, i + 1, n->neighbour + 1);
return 1;
}
return 0;
}
void add_edge(int a, int b, int len, int index) {
struct neighlist_t *n;
if (test_negative()) {
printf("before add_edge [%d] %d-%d (%d)\n", index, a + 1, b + 1, len);
exit(0);
}
n = (struct neighlist_t *)malloc(sizeof(struct neighlist_t));
n->next = neighlist[a];
n->neighbour = b;
n->len = len;
n->index = index;
if (test_negative()) {
printf("before add_edge [%d] %d->%d (%d)\n", index, a + 1, b + 1, len);
exit(0);
}
neighlist[a] = n;
if (test_negative()) {
printf("after add_edge [%d] %d->%d (%d)\n", index, a + 1, b + 1, len);
exit(0);
}
n = (struct neighlist_t *)malloc(sizeof(struct neighlist_t));
n->next = neighlist[b];
n->neighbour = a;
n->len = len;
n->index = index;
if (test_negative()) {
printf("before add_edge [%d] %d<-%d (%d)\n", index, a + 1, b + 1, len);
exit(0);
}
neighlist[b] = n;
if (test_negative()) {
printf("after add_edge [%d] %d<-%d (%d)\n", index, a + 1, b + 1, len);
exit(0);
}
}
long long dist[300000];
int main() {
int i;
int a, b, len, U, V;
int ans[300000];
int ans_len;
long long ans_weight, d;
struct neighlist_t *n, *best;
scanf("%d %d\n", &N, &M);
for (i = 0; i < N; i++) {
neighlist[i] = NULL;
dist[i] = -1;
}
for (i = 0; i < M; i++) {
scanf("%d %d %d\n", &a, &b, &len);
a--;
b--;
if (a < 0 || a >= N || b < 0 || b >= N || len < 0) {
printf("Error: a = %d, b = %d, len = %d\n", a + 1, b + 1);
return 0;
}
add_edge(a, b, len, i + 1);
}
scanf("%d\n", &U);
U--;
ans_len = ans_weight = 0;
heap_len = 0;
heap_add(0, U, 0);
while (heap_len) {
heap_get(&d, &V);
if (V < 0 || V >= N) {
printf("Error: V = %d\n", V);
return 0;
}
if (d < 0) {
printf("Error: negative distance %I64d at the vertex %d\n", d, V + 1);
return 0;
}
if (dist[V] >= 0) continue;
dist[V] = d;
best = NULL;
for (n = neighlist[V]; n; n = n->next) {
if (dist[n->neighbour] < 0) {
if (d + n->len < 0) {
printf("Error: negative distance: %I64d+%d = %I64d\n", d, n->len,
d + n->len);
return 0;
}
heap_add(d + n->len, n->neighbour, n->index);
} else if (dist[n->neighbour] + n->len == d &&
(!best || best->len > n->len))
best = n;
}
if (best) {
ans_weight += best->len;
ans[ans_len++] = best->index;
}
}
printf("%I64d\n", ans_weight);
for (i = 0; i < ans_len; i++) printf("%d ", ans[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300030;
const int maxm = 300030;
int n, m;
struct edge {
int v, next;
long long w;
} e[maxm << 1];
int p[maxn], eid;
inline void init() {
memset(p, -1, sizeof(p));
eid = 0;
}
inline void insert(int u, int v, long long w) {
e[eid].v = v;
e[eid].w = w;
e[eid].next = p[u];
p[u] = eid++;
}
long long dis[maxn];
bool vis[maxn];
struct node {
int id;
long long d;
node() {}
node(int _id, long long _d) {
id = _id;
d = _d;
}
bool operator<(const node &A) const { return d > A.d; }
};
long long ans = 0;
int pre[maxn];
vector<int> edid;
void dijkstra(int st) {
memset(dis, 0x3f, sizeof(dis));
dis[st] = 0;
priority_queue<node> pq;
pq.push((node){st, 0LL});
pre[st] = -1;
while (!pq.empty()) {
node now = pq.top();
int u = now.id;
pq.pop();
if (vis[u]) continue;
if (pre[u] != -1) {
ans += e[pre[u]].w;
edid.push_back(pre[u]);
}
vis[u] = 1;
for (int i = p[u]; ~i; i = e[i].next) {
int v = e[i].v;
long long w = e[i].w;
if (!vis[v] && dis[u] + w < dis[v]) {
dis[v] = dis[u] + w;
pre[v] = i;
pq.push(node(v, dis[v]));
} else if (!vis[v] && dis[u] + w == dis[v]) {
long long pw = e[pre[v]].w;
if (w < pw) pre[v] = i;
}
}
}
}
int main() {
init();
scanf("%d%d", &n, &m);
for (register int i = 1; i <= m; i++) {
int u, v;
long long w;
scanf("%d%d%lld", &u, &v, &w);
insert(u, v, w);
insert(v, u, w);
}
int start;
scanf("%d", &start);
dijkstra(start);
printf("%lld\n", ans);
for (register int i = 0; i < (int)edid.size(); i++) {
int id = edid[i];
if (id & 1) {
id ^= 1;
}
printf("%d ", (id / 2) + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 * 3 + 5;
const long long INF = 1e15;
long long sum, d[maxn];
int n, m, pre[maxn][2], flag[maxn], ans[maxn], len;
struct node {
int x, w, id;
node(int x1, int w1, int id1) {
x = x1;
w = w1;
id = id1;
}
};
vector<node> vec[maxn];
void inint() {
for (int i = 1; i <= n; i++) d[i] = INF;
for (int i = 1; i <= m; i++) vec[i].clear();
}
void bfs(int s) {
queue<int> v;
v.push(s);
while (!v.empty()) {
int l = v.front();
v.pop();
for (int i = 0; i < vec[l].size(); i++) {
int r = vec[l][i].x;
if (d[r] > d[l] + vec[l][i].w) {
d[r] = d[l] + vec[l][i].w;
pre[r][0] = l;
pre[r][1] = vec[l][i].w;
v.push(r);
} else if (d[r] == d[l] + vec[l][i].w) {
if (pre[r][1] > vec[l][i].w) {
pre[r][1] = vec[l][i].w;
pre[r][0] = l;
}
}
}
}
}
void bfs1(int s) {
queue<int> v;
v.push(s);
len = 0;
sum = 0;
while (!v.empty()) {
int l = v.front();
v.pop();
for (int i = 0; i < vec[l].size(); i++) {
int r = vec[l][i].x;
if (pre[r][0] == l) {
ans[len++] = vec[l][i].id;
sum += pre[r][1];
v.push(r);
}
}
}
}
int main() {
while (scanf("%d%d", &n, &m) != EOF) {
inint();
for (int i = 1; i <= m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
vec[u].push_back(node(v, w, i));
vec[v].push_back(node(u, w, i));
}
int s;
scanf("%d", &s);
d[s] = 0;
bfs(s);
bfs1(s);
printf("%I64d\n", sum);
if (len) {
printf("%d", ans[0]);
for (int i = 1; i < len; i++) printf(" %d", ans[i]);
puts("");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300007;
vector<pair<int, int>> graph[maxn];
const long long int INF = 1ll << 59;
void add_edge(int u, int v, int c) {
graph[v].push_back({u, c});
graph[u].push_back({v, c});
}
long long int D[maxn];
int P[maxn];
void dijsktra(int sr) {
for (int i = 0; i < maxn; i++) D[i] = INF;
D[sr] = 0;
P[sr] = sr;
set<pair<long long int, long long int>> s;
s.insert({D[sr], sr});
while (!s.empty()) {
int u = s.begin()->second;
s.erase(s.begin());
sort(graph[u].begin(), graph[u].end());
for (auto pr : graph[u]) {
int v = pr.first;
int c = pr.second;
if (D[v] < D[u] + c) continue;
s.erase({D[v], v});
D[v] = D[u] + c;
P[v] = u;
s.insert({D[v], v});
}
}
}
map<pair<int, int>, int> mp;
int main() {
int n, m, u, v, c, first;
cin >> n >> m;
int key = 0;
vector<int> cost(m);
for (int i = 0; i < m; i++) {
cin >> u >> v >> c;
if (!mp.count({u, v})) {
mp[{u, v}] = key;
mp[{v, u}] = key++;
}
cost[i] = c;
add_edge(u, v, c);
}
cin >> first;
dijsktra(first);
vector<int> ans;
long long int cont = 0;
for (int i = 1; i <= n; i++) {
if (P[i] == i || P[i] == 0) continue;
ans.push_back(mp[{i, P[i]}] + 1);
cont += cost[mp[{i, P[i]}]];
}
cout << cont << endl;
for (auto c : ans) cout << c << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long val, len;
bool operator<(const node &x) const { return x.len < len; }
};
priority_queue<node> q;
struct Edge {
long long to, next, len;
} edge[300010 << 1];
long long num, head[300010], n, m, rt, vis[300010], dis[300010], pre[300010];
inline long long read() {
long long s = 0, w = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') w = -1;
for (; isdigit(c); c = getchar()) s = (s << 1) + (s << 3) + (c ^ 48);
return s * w;
}
void addedge(long long x, long long y, long long z) {
edge[++num] = (Edge){y, head[x], z};
head[x] = num;
}
signed main() {
n = read(), m = read();
for (long long i = 1; i <= m; ++i) {
long long x = read(), y = read(), z = read();
addedge(x, y, z);
addedge(y, x, z);
}
rt = read();
for (long long i = 1; i <= n; ++i) dis[i] = 1e18;
dis[rt] = 0;
q.push((node){rt, 0});
while (!q.empty()) {
node tmp = q.top();
q.pop();
long long u = tmp.val, len = tmp.len;
if (vis[u]) continue;
vis[u] = 1;
for (long long i = head[u]; i; i = edge[i].next) {
long long v = edge[i].to;
if (dis[v] >= len + edge[i].len) {
dis[v] = len + edge[i].len, pre[v] = i;
if (!vis[v]) q.push((node){v, dis[v]});
}
}
}
long long ans = 0;
for (long long i = 1; i <= n; ++i)
if (i != rt) ans += edge[pre[i]].len;
printf("%lld\n", ans);
for (long long i = 1; i <= n; ++i)
if (i != rt) printf("%lld ", (pre[i] + 1) >> 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int M = 3e5 + 5, LG = 500, inf = 1e18, mod = 1e9 + 7;
long long int n, m, s;
long long int yaluv[M], yalw[M];
vector<long long int> g[M];
long long int d[M];
long long int par[M];
bool mark[M];
void dij() {
fill(d, d + n, inf);
d[s] = 0;
set<pair<long long int, long long int> > se;
se.insert({d[s], s});
while (((long long int)se.size()) > 0) {
long long int x = se.begin()->second;
se.erase(se.begin());
if (mark[x]) {
continue;
}
mark[x] = 1;
for (long long int id : g[x]) {
long long int y = yaluv[id] ^ x;
if (d[y] >= d[x] + yalw[id]) {
par[y] = id;
}
if (d[y] > d[x] + yalw[id]) {
d[y] = d[x] + yalw[id];
se.insert({d[y], y});
}
}
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
long long int u, v;
cin >> u >> v >> yalw[i];
u--;
v--;
yaluv[i] = u ^ v;
g[u].push_back(i);
g[v].push_back(i);
}
cin >> s;
s--;
dij();
long long int res = 0;
for (int i = 0; i < n; i++) {
if (i == s) {
continue;
}
res += yalw[par[i]];
}
cout << res << '\n';
for (int i = 0; i < n; i++) {
if (i == s) {
continue;
}
cout << par[i] + 1 << ' ';
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, pair<long long, long long> > > adj[1000005];
priority_queue<pair<pair<long long, long long>, long long>,
vector<pair<pair<long long, long long>, long long> >,
greater<pair<pair<long long, long long>, long long> > >
pq;
pair<pair<long long, long long>, long long> d[1000003];
bool visited[1000003];
vector<long long> answer;
void djikstra(long long st, long long n) {
for (int i = 0; i < n; ++i) {
visited[i] = 0;
if (i != st) {
d[i] = make_pair(make_pair(1e17, 1e17), 1e17);
pq.push(make_pair(d[i].first, i));
} else {
d[i] = make_pair(make_pair(0, 0), -1);
pq.push(make_pair(d[i].first, i));
}
}
pair<pair<long long, long long>, long long> p;
while (!pq.empty()) {
visited[pq.top().second] = 1;
for (int i = 0; i < adj[pq.top().second].size(); ++i) {
p = make_pair(make_pair(d[pq.top().second].first.first +
adj[pq.top().second][i].second.first,
adj[pq.top().second][i].second.first),
adj[pq.top().second][i].second.second);
if (d[adj[pq.top().second][i].first] > p) {
d[adj[pq.top().second][i].first] = p;
pq.push(make_pair(d[adj[pq.top().second][i].first].first,
adj[pq.top().second][i].first));
}
}
while (!pq.empty() && visited[pq.top().second] == 1) pq.pop();
}
}
int main(int argc, char const *argv[]) {
long long i, n, m, j, u, v, w, st, tot;
cin >> n >> m;
for (i = 0; i < m; ++i) {
cin >> u >> v >> w;
--u;
--v;
adj[u].push_back(make_pair(v, make_pair(w, i)));
adj[v].push_back(make_pair(u, make_pair(w, i)));
}
cin >> st;
--st;
djikstra(st, n);
tot = 0;
for (int i = 0; i < n; ++i) {
if (i != st) {
answer.push_back(d[i].second);
tot += d[i].first.second;
}
}
cout << tot << "\n";
for (int i = 0; i < answer.size(); ++i) {
cout << 1 + answer[i] << " ";
}
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, o, re = 0;
long long res = 0;
int a[300010], print[300010];
bool chk[300010];
vector<pair<int, int> > ve[300010];
struct comp {
bool operator()(pair<long long, pair<int, int> > x,
pair<long long, pair<int, int> > y) {
if (x.first != y.first)
return x > y;
else
return a[x.second.first] > a[y.second.first];
}
};
priority_queue<pair<long long, pair<int, int> >,
vector<pair<long long, pair<int, int> > >, comp>
myq;
int main() {
memset(chk, 0, sizeof(chk));
int i, j, k, l;
long long ll, rr, mid;
scanf("%d %d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d %d %d", &j, &k, &a[i]);
ve[j].push_back(pair<int, int>(k, i));
ve[k].push_back(pair<int, int>(j, i));
}
scanf("%d", &k);
myq.push(pair<long long, pair<int, int> >(0, pair<int, int>(0, k)));
pair<long long, pair<int, int> > p;
while (!myq.empty()) {
p = myq.top();
myq.pop();
k = p.second.second;
if (chk[k]) continue;
chk[k] = 1;
if (p.first != 0) {
res += a[p.second.first];
print[re++] = p.second.first;
}
for (vector<pair<int, int> >::iterator it = ve[k].begin();
it != ve[k].end(); it++) {
myq.push(pair<long long, pair<int, int> >(
p.first + a[it->second], pair<int, int>(it->second, it->first)));
}
}
printf("%I64d\n", res);
for (i = 0; i < re; i++) {
printf("%d ", print[i] + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
template <class T>
typename T::value_type arr_sum(const T& v, int n) {
typename T::value_type sum = 0;
for (int i = (0); i < (n); ++i) sum += v[i];
return sum;
}
struct Sync_stdio {
Sync_stdio() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
}
} _sync_stdio;
struct Z {
int a;
long long w;
int operator<(const Z& a) const { return w > a.w; };
};
vector<vector<Z>> g;
vector<long long> d;
void dijkstra(int x) {
priority_queue<Z> pq;
pq.push({x, 0});
while (pq.size()) {
Z t = pq.top();
pq.pop();
if (t.w != d[t.a]) {
continue;
}
for (auto i : g[t.a]) {
if (d[t.a] + i.w < d[i.a]) {
d[i.a] = d[t.a] + i.w;
pq.push({i.a, d[i.a]});
}
}
}
}
int main() {
int n, m;
cin >> n >> m;
map<pair<int, int>, int> s;
d.assign(n, LLONG_MAX);
g.resize(n);
for (int i = (0); i < (m); ++i) {
int a, b, c;
cin >> a >> b >> c;
--a, --b;
g[a].push_back({b, c});
g[b].push_back({a, c});
s[{min(a, b), max(a, b)}] = i;
}
int x;
cin >> x;
--x;
d[x] = 0;
dijkstra(x);
vector<int> ans;
long long res = 0;
for (int i = (0); i < (n); ++i) {
if (i == x) {
continue;
}
int minc = INT_MAX;
int mini = -1;
for (auto j : g[i]) {
if (d[j.a] + j.w == d[i]) {
if (j.w < minc) {
minc = j.w;
mini = j.a;
}
}
}
ans.push_back(s[{min(i, mini), max(i, mini)}]);
res += minc;
}
cout << res << "\n";
for (auto i : ans) {
cout << i + 1 << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sqr(T x) {
return x * x;
}
template <class T>
T gcd(T a, T b) {
return (b != 0 ? gcd<T>(b, a % b) : a);
}
template <class T>
T lcm(T a, T b) {
return (a / gcd<T>(a, b) * b);
}
template <class T>
inline T bigmod(T p, T e, T M) {
if (e == 0) return 1;
if (e % 2 == 0) {
long long int t = bigmod(p, e / 2, M);
return (T)((t * t) % M);
}
return (T)((long long int)bigmod(p, e - 1, M) * (long long int)p) % M;
}
template <class T>
inline T bigexp(T p, T e) {
if (e == 0) return 1;
if (e % 2 == 0) {
long long int t = bigexp(p, e / 2);
return (T)((t * t));
}
return (T)((long long int)bigexp(p, e - 1) * (long long int)p);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
int dx4[] = {1, 0, -1, 0};
int dy4[] = {0, 1, 0, -1};
int dx8[] = {1, 1, 0, -1, -1, -1, 0, 1};
int dy8[] = {0, 1, 1, 1, 0, -1, -1, -1};
int month[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
struct TT {
int city;
long long int dist;
};
int n, m, u, v, w, src, t, id[300005];
long long int d[300005], res[300005];
vector<int> edges[300005], cost[300005], no[300005];
bool bl[300005];
void bfs(int src) {
for (int i = 1; i <= n; i++) d[i] = 2000000000000007;
queue<TT> q;
TT u, v;
u.city = src;
u.dist = 0;
d[src] = 0;
q.push(u);
while (!q.empty()) {
u = q.front();
q.pop();
for (int i = 0; i < edges[u.city].size(); i++) {
v.city = edges[u.city][i];
v.dist = u.dist + cost[u.city][i];
if (d[v.city] > v.dist) {
d[v.city] = v.dist;
q.push(v);
}
}
}
}
void bfs1(int src) {
for (int i = 1; i <= n; i++) res[i] = 2000000000000007;
queue<TT> q;
TT u, v;
u.city = src;
u.dist = 0;
q.push(u);
bl[src] = true;
res[src] = 0;
while (!q.empty()) {
u = q.front();
q.pop();
for (int i = 0; i < edges[u.city].size(); i++) {
v.city = edges[u.city][i];
v.dist = u.dist + cost[u.city][i];
if (v.dist == d[v.city]) {
if (bl[v.city] == false) {
q.push(v);
bl[v.city] = true;
}
if ((long long int)cost[u.city][i] < res[v.city]) {
res[v.city] = (long long int)cost[u.city][i];
id[v.city] = no[u.city][i];
}
}
}
}
}
int main() {
scanf("%d %d", &n, &m);
for (__typeof(m) i = (1); i <= (m); i++) {
scanf("%d %d %d", &u, &v, &w);
edges[u].push_back(v);
edges[v].push_back(u);
cost[u].push_back(w);
cost[v].push_back(w);
no[u].push_back(i);
no[v].push_back(i);
}
scanf("%d", &src);
bfs(src);
bfs1(src);
long long int ans = 0;
for (__typeof(n) i = (1); i <= (n); i++) ans += res[i];
printf("%I64d\n", ans);
for (int i = 1; i <= n; i++) {
if (id[i] != 0) printf("%d ", id[i]);
}
for (__typeof(n) i = (1); i <= (n); i++)
edges[i].clear(), no[i].clear(), cost[i].clear();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T gcd(T a, T b) {
return (b) == 0 ? (a) : gcd((b), ((a) % (b)));
}
template <class T>
inline T lcm(T a, T b) {
return ((a) / gcd((a), (b)) * (b));
}
template <class T>
inline T BigMod(T Base, T power, T M = 1000000007) {
if (power == 0) return 1;
if (power & 1)
return ((Base % M) * (BigMod(Base, power - 1, M) % M)) % M;
else {
T y = BigMod(Base, power / 2, M) % M;
return (y * y) % M;
}
}
template <class T>
inline T ModInv(T A, T M = 1000000007) {
return BigMod(A, M - 2, M);
}
int fx[] = {-1, +0, +1, +0, +1, +1, -1, -1, +0};
int fy[] = {+0, -1, +0, +1, +1, -1, +1, -1, +0};
int day[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int n, m, k, start;
vector<pair<long long, pair<int, int> > > v[300005];
vector<int> edge;
long long ans, dis[300005], pk[300005];
int vis[300005];
void dij() {
for (int i = 1; i <= n; i++) dis[i] = 1e17;
dis[start] = 0;
priority_queue<pair<pair<long long, long long>, pair<int, int> >,
vector<pair<pair<long long, long long>, pair<int, int> > >,
greater<pair<pair<long long, long long>, pair<int, int> > > >
pq;
pq.push(pair<pair<long long, long long>, pair<int, int> >(
pair<long long, long long>(0, 0), pair<int, int>(start, -1)));
while (!pq.empty()) {
pair<pair<long long, long long>, pair<int, int> > x = pq.top();
pq.pop();
if (vis[x.second.first]) continue;
vis[x.second.first] = 1;
if (x.second.second != -1) edge.push_back(x.second.second);
ans += x.first.second;
for (auto it : v[x.second.first]) {
if (vis[it.second.first] == 0 &&
dis[it.second.first] >= dis[x.second.first] + it.first) {
dis[it.second.first] = dis[x.second.first] + it.first;
pq.push(pair<pair<long long, long long>, pair<int, int> >(
pair<long long, long long>(dis[it.second.first], it.first),
pair<int, int>(it.second.first, it.second.second)));
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
long long a, b, c;
cin >> a >> b >> c;
pk[i + 1] = c;
v[a].push_back(
pair<long long, pair<int, int> >(c, pair<int, int>(b, i + 1)));
v[b].push_back(
pair<long long, pair<int, int> >(c, pair<int, int>(a, i + 1)));
}
cin >> start;
dij();
cout << ans << endl;
for (auto it : edge) cout << it << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 3e5 + 5;
vector<tuple<long long, long long, long long> > adj[maxn];
bool vis[maxn];
long long d[maxn];
void solve(long long x) {
long long sum = 0;
static priority_queue<
tuple<long long, long long, long long, long long>,
vector<tuple<long long, long long, long long, long long> >,
greater<tuple<long long, long long, long long, long long> > >
pq;
pq.push(make_tuple(0, 0, x, 0));
while (!pq.empty()) {
auto i = pq.top();
pq.pop();
long long dis = get<0>(i), w = get<1>(i), pos = get<2>(i), e = get<3>(i);
if (dis >= d[pos]) continue;
vis[get<3>(i)] = true;
d[pos] = dis;
sum += get<1>(i);
for (auto i : adj[pos]) {
if ((!vis[get<2>(i)]) and dis + get<0>(i) <= d[get<1>(i)])
pq.push(make_tuple(dis + get<0>(i), get<0>(i), get<1>(i), get<2>(i)));
}
}
cout << sum << '\n';
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
memset(d, 0x3f, sizeof(d));
long long n, m;
cin >> n >> m;
for (long long i = 1; i <= m; i++) {
long long u, v, w;
cin >> u >> v >> w;
adj[u].push_back(make_tuple(w, v, i));
adj[v].push_back(make_tuple(w, u, i));
}
long long start;
cin >> start;
solve(start);
for (long long i = 1; i <= m; i++)
if (vis[i]) cout << i << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 * 1000 + 10;
const int maxn5 = 5 * 1000 * 100 + 10;
const int maxnJ = 1000 + 10;
const long long mod = 1000 * 1000 * 1000 + 7;
const long long inf = 1LL * 2 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000 + 10;
vector<pair<int, long long>> adj[maxn5];
long long h[maxn5], ans = 0, val[maxn5];
set<pair<long long, int>> av;
map<pair<int, int>, int> edge;
int par[maxn5];
int n, m;
void dijkstra(int st) {
fill(h, h + maxn5, inf);
fill(val, val + maxn5, inf);
val[st] = 0;
h[st] = 0;
par[st] = -1;
for (int i = 1; i <= n; i++) av.insert({h[i], i});
for (int i = 0; i < n; i++) {
int v = av.begin()->second;
av.erase(av.begin());
for (auto [u, len] : adj[v])
if (h[u] > h[v] + len or (h[u] == h[v] + len and val[u] > len)) {
if (val[u] < inf) ans -= val[u];
val[u] = len;
ans += len;
av.erase({h[u], u});
h[u] = h[v] + len;
av.insert({h[u], u});
par[u] = v;
}
}
return;
}
void out() {
for (int i = 1; i <= n; i++)
if (par[i] != -1) cout << edge[{i, par[i]}] << ' ';
cout << endl;
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b, len;
cin >> a >> b >> len;
adj[a].push_back({b, len});
adj[b].push_back({a, len});
edge[{a, b}] = i + 1;
edge[{b, a}] = i + 1;
}
int u;
cin >> u;
dijkstra(u);
cout << ans << endl;
out();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int m, n, i, f = 0, j, ans = 0, k, x, r, l, t, u, v;
cin >> n >> m;
vector<vector<pair<long long int, long long int>>> adj(n + 1);
map<pair<long long int, long long int>, long long int> edges;
for (i = 0; i < m; ++i) {
cin >> u >> v >> x;
adj[u].push_back({v, x});
adj[v].push_back({u, x});
if (u < v)
edges[{u, v}] = i + 1;
else
edges[{v, u}] = i + 1;
}
long long int start;
cin >> start;
priority_queue<pair<long long int, long long int>> q;
vector<long long int> d(n + 1, 1e18), addw(n + 1, 1e18), parent(n + 1, -1);
d[start] = 0;
addw[start] = 0;
q.push({0, start});
pair<long long int, long long int> temp;
while (!q.empty()) {
temp = q.top();
q.pop();
for (auto h : adj[temp.second]) {
if (d[h.first] > d[temp.second] + h.second) {
d[h.first] = d[temp.second] + h.second;
q.push({-d[h.first], h.first});
addw[h.first] = h.second;
parent[h.first] = temp.second;
} else if (d[h.first] == d[temp.second] + h.second) {
if (addw[h.first] > h.second) {
addw[h.first] = h.second;
parent[h.first] = temp.second;
}
}
}
}
vector<long long int> res;
for (i = 1; i <= n; ++i) {
ans += addw[i];
if (parent[i] != -1) {
if (i < parent[i]) {
res.push_back(edges[{i, parent[i]}]);
} else {
res.push_back(edges[{parent[i], i}]);
}
}
}
cout << ans << endl;
for (i = 0; i < res.size(); ++i) cout << res[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> v[300009];
long long edges[3][300009], each_vertex[2][300009], taken[300009];
set<vector<long long> > st;
set<vector<long long> >::iterator it, erase_it;
int main() {
long long t, n, m, a, b, u, weight, edge_idx, i, j, max_weight;
max_weight = 1000000;
max_weight *= max_weight;
max_weight *= 1000;
for (i = 0; i < 300009; ++i) v[i].clear();
memset(edges, 0, sizeof(edges));
memset(each_vertex, 0, sizeof(each_vertex));
memset(taken, 0, sizeof(taken));
st.clear();
cin >> n >> m;
for (i = 1; i <= m; ++i) {
cin >> edges[0][i] >> edges[1][i] >> edges[2][i];
v[edges[0][i]].push_back(i);
v[edges[1][i]].push_back(i);
}
cin >> u;
for (i = 1; i <= n; ++i) {
vector<long long> temp;
if (i == u)
temp.push_back(0);
else
temp.push_back(max_weight);
temp.push_back(0);
temp.push_back(i);
for (j = 0; j < 2; ++j) each_vertex[j][i] = temp[j];
st.insert(temp);
}
while (!st.empty()) {
it = st.begin();
long long weight_till_now = (*it)[0];
long long this_vertex = (*it)[2];
taken[this_vertex] = 1;
for (vector<long long>::iterator it_vector = v[this_vertex].begin();
it_vector != v[this_vertex].end(); ++it_vector) {
long long other_vertex =
(this_vertex != edges[0][*it_vector] ? edges[0][*it_vector]
: edges[1][*it_vector]);
if (taken[other_vertex] == 0) {
bool flag = false;
if ((weight_till_now + edges[2][*it_vector]) <
each_vertex[0][other_vertex]) {
flag = true;
} else if (((weight_till_now + edges[2][*it_vector]) ==
each_vertex[0][other_vertex]) &&
(edges[2][*it_vector] <
edges[2][each_vertex[1][other_vertex]])) {
flag = true;
}
if (flag) {
vector<long long> temp;
temp.push_back(each_vertex[0][other_vertex]);
temp.push_back(each_vertex[1][other_vertex]);
temp.push_back(other_vertex);
erase_it = st.find(temp);
st.erase(erase_it);
temp.clear();
temp.push_back((weight_till_now + edges[2][*it_vector]));
temp.push_back(*it_vector);
temp.push_back(other_vertex);
st.insert(temp);
each_vertex[0][other_vertex] = weight_till_now + edges[2][*it_vector];
each_vertex[1][other_vertex] = *it_vector;
}
}
}
st.erase(it);
}
long long sum = 0;
for (i = 1; i <= n; ++i) {
if (each_vertex[1][i] != 0) sum += edges[2][each_vertex[1][i]];
}
cout << sum << "\n";
for (i = 1; i <= n; ++i) {
if (each_vertex[1][i] != 0) cout << each_vertex[1][i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 412345, inf = 1e18;
vector<pair<pair<long long, long long>, long long> > adj[N];
set<pair<long long, long long> > s;
long long n, m, u, r, ans, a, b;
long long w[N], par[N], dis[N];
pair<long long, long long> k;
void input() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a >> b >> w[i];
adj[a - 1].push_back(make_pair(make_pair(b - 1, w[i]), i));
adj[b - 1].push_back(make_pair(make_pair(a - 1, w[i]), i));
}
cin >> r;
}
void init() {
for (int i = 0; i < n; i++) {
if (i != r - 1) dis[i] = inf;
s.insert(make_pair(dis[i], i));
}
}
void dij() {
for (int i = 0; i < n; i++) {
k = *s.begin();
s.erase(k);
for (int j = 0; j < adj[k.second].size(); j++) {
u = adj[k.second][j].first.first;
if ((dis[u] > k.first + adj[k.second][j].first.second) ||
(dis[u] == k.first + adj[k.second][j].first.second &&
w[par[u]] > adj[k.second][j].first.second)) {
s.erase(make_pair(dis[u], u));
s.insert(make_pair(k.first + adj[k.second][j].first.second, u));
dis[u] = k.first + adj[k.second][j].first.second;
par[u] = adj[k.second][j].second;
}
}
}
for (int i = 0; i < n; i++) {
if (i != r - 1) ans += w[par[i]];
}
}
void output() {
cout << ans << endl;
for (int i = 0; i < n; i++) {
if (i != r - 1) cout << par[i] + 1 << " ";
}
}
int main() {
input();
init();
dij();
output();
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18 + 7;
const long long MOD = 1e9 + 7;
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << "\n"; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H) << "\n";
debug_out(T...);
}
const int N = 3e5 + 8;
vector<tuple<long long, long long, long long>> g[N];
long long dist[N];
int n, m;
void dijkstra(int u) {
for (int i = 1; i <= n; i++) {
dist[i] = INF;
}
dist[u] = 0;
set<pair<long long, long long>> st;
for (int i = 1; i <= n; i++) {
st.insert({dist[i], i});
}
while (!st.empty()) {
auto it = st.begin();
long long d = it->first;
int v = it->second;
st.erase(it);
for (auto edge : g[v]) {
int child = get<0>(edge);
long long w = get<1>(edge);
if (dist[child] > d + w) {
st.erase(st.find({dist[child], child}));
dist[child] = d + w;
st.insert({dist[child], child});
}
}
}
}
void solve() {
cin >> n >> m;
vector<long long> weights(m + 1);
for (int i = 1; i <= m; i++) {
int u, v;
long long w;
cin >> u >> v >> w;
g[u].emplace_back(v, w, i);
g[v].emplace_back(u, w, i);
weights[i] = w;
}
int u;
cin >> u;
dijkstra(u);
vector<int> indegree(n + 1, 0);
vector<multiset<pair<long long, long long>>> incoming(n + 1);
vector<bool> taken(m + 1, false);
for (int i = 1; i <= n; i++) {
for (auto e : g[i]) {
int c = get<0>(e);
long long w = get<1>(e);
int id = get<2>(e);
if (dist[c] == dist[i] + w) {
incoming[c].insert({weights[id], id});
indegree[c]++;
taken[id] = 1;
}
}
}
priority_queue<pair<int, int>> pq;
for (int i = 1; i <= n; i++) {
pq.push(make_pair(indegree[i], i));
}
vector<bool> removed(m + 1, false);
for (int i = 1; i <= m; i++) {
if (taken[i] == 1) continue;
removed[i] = 1;
}
while (!pq.empty()) {
auto tp = pq.top();
int indeg = tp.first;
int ver = tp.second;
if (indeg <= 1) {
break;
}
indegree[ver]--;
auto it = prev(incoming[ver].end());
removed[it->second] = 1;
incoming[ver].erase(it);
pq.pop();
pq.emplace(indegree[ver], ver);
}
long long minimum_weight = 0;
vector<int> ans;
for (int i = 1; i <= m; i++) {
if (removed[i] == 1) continue;
minimum_weight += weights[i];
ans.push_back(i);
}
cout << minimum_weight << endl;
for (int i = 0; i < int(ans.size()); i++) {
if (i > 0) cout << ' ';
cout << ans[i];
}
cout << '\n';
}
int main() {
ios ::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int tt = 1;
for (int tc = 1; tc <= tt; tc++) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 3e5 + 7;
int n, m, u, par[NMAX], prew[NMAX], inedg[NMAX], zares[NMAX];
long long d[NMAX], ans;
vector<pair<pair<int, int>, int> > g[NMAX];
vector<int> a;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
g[a].push_back(make_pair(make_pair(b, c), i));
g[b].push_back(make_pair(make_pair(a, c), i));
}
scanf("%d", &u);
for (int i = 1; i <= n; i++) d[i] = (i == u) ? 0 : 1e18;
set<pair<long long, int> > s;
s.insert(make_pair(0, u));
ans = 0;
while (!s.empty()) {
int nxt = s.begin()->second;
s.erase(s.begin());
ans += prew[nxt];
a.push_back(zares[nxt]);
for (vector<pair<pair<int, int>, int> >::iterator it = g[nxt].begin();
it != g[nxt].end(); it++) {
int w = it->first.second;
int nxxt = it->first.first;
if (d[nxxt] > d[nxt] + w || (d[nxxt] == d[nxt] + w && prew[nxxt] > w)) {
s.erase(make_pair(d[nxxt], nxxt));
d[nxxt] = d[nxt] + w;
par[nxxt] = nxt;
prew[nxxt] = w;
zares[nxxt] = it->second;
s.insert(make_pair(d[nxxt], nxxt));
}
}
}
cout << ans << endl;
for (int i = 1; i < a.size(); i++) cout << a[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, val[300010], par[300010], from, to, stat[300010];
string s;
vector<pair<long long, long long> > adj[300010];
priority_queue<pair<long long, long long> > pq;
map<pair<long long, long long>, long long> mpp, mpp2;
int comp(pair<long long, long long> a, pair<long long, long long> b) {
return a.second < b.second;
}
long long dijkstra(long long src) {
for (long long i = 1LL; i <= n; i++) val[i] = 999999999999999LL;
memset(stat, 0LL, sizeof(stat));
while (!pq.empty()) {
pq.pop();
}
pq.push(make_pair(src, 0LL));
long long ret = 0LL;
val[src] = 0LL;
par[src] = -1LL;
while (!pq.empty()) {
pair<long long, long long> tp;
long long u = pq.top().first;
ret += pq.top().second;
pq.pop();
for (long long i = 0LL; i < adj[u].size(); i++) {
long long v = adj[u][i].first;
if (val[v] > val[u] + adj[u][i].second) {
val[v] = val[u] + adj[u][i].second;
par[v] = u;
pq.push(make_pair(v, val[v]));
} else if (val[v] == val[u] + adj[u][i].second &&
adj[u][i].second < val[v] - val[par[v]])
par[v] = u;
}
}
return ret;
}
int main() {
long long in, i, cost, res;
cin >> n >> m;
for (i = 1LL; i <= m; i++) {
scanf(" %I64d %I64d %I64d", &from, &to, &cost);
adj[from].push_back(make_pair(to, cost));
adj[to].push_back(make_pair(from, cost));
mpp[make_pair(min(from, to), max(from, to))] = i;
mpp2[make_pair(min(from, to), max(from, to))] = cost;
}
cin >> in;
dijkstra(in);
res = 0LL;
vector<long long> vc;
vc.clear();
for (i = 1LL; i <= n; i++) {
if (in == i) continue;
res += mpp2[make_pair(min(i, par[i]), max(i, par[i]))];
vc.push_back(mpp[make_pair(min(i, par[i]), max(i, par[i]))]);
}
printf("%I64d\n", res);
for (i = 0; i < vc.size(); i++) cout << vc[i] << " \n"[i == (vc.size() - 1)];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class Edge {
public:
int neighbour;
int edge_number;
int weight;
Edge(int neigh, int edge_no, int weig) {
neighbour = neigh;
edge_number = edge_no;
weight = weig;
}
};
int main() {
int n, m;
cin >> n >> m;
vector<vector<Edge> > adj_list(n + 1);
for (int i = 1; i <= m; i++) {
int vertex1, vertex2, weight;
cin >> vertex1 >> vertex2 >> weight;
Edge temp = Edge(vertex2, i, weight);
adj_list[vertex1].push_back(temp);
temp = Edge(vertex1, i, weight);
adj_list[vertex2].push_back(temp);
}
int source;
cin >> source;
vector<bool> check_list(n + 1, false);
priority_queue<pair<long long int, int> > pq;
vector<pair<int, int> > parent(n + 1, make_pair(0, 0));
for (int i = 1; i <= n; i++) {
if (i != source)
pq.push(make_pair(LLONG_MIN, i));
else
pq.push(make_pair(0, i));
}
vector<pair<long long int, int> > dist(n + 1, make_pair(LLONG_MAX, 0));
dist[source].first = 0;
while (!pq.empty()) {
int vertex = pq.top().second;
pq.pop();
if (check_list[vertex] == false) {
check_list[vertex] = true;
for (int i = 0; i < adj_list[vertex].size(); i++) {
if (dist[adj_list[vertex][i].neighbour].first >
dist[vertex].first + adj_list[vertex][i].weight) {
parent[adj_list[vertex][i].neighbour].first =
adj_list[vertex][i].edge_number;
parent[adj_list[vertex][i].neighbour].second =
adj_list[vertex][i].weight;
dist[adj_list[vertex][i].neighbour].first =
dist[vertex].first + adj_list[vertex][i].weight;
dist[adj_list[vertex][i].neighbour].second =
adj_list[vertex][i].weight;
pq.push(make_pair((-1) * (dist[adj_list[vertex][i].neighbour].first),
adj_list[vertex][i].neighbour));
} else if (dist[adj_list[vertex][i].neighbour].first ==
dist[vertex].first + adj_list[vertex][i].weight) {
if (dist[adj_list[vertex][i].neighbour].second >
adj_list[vertex][i].weight) {
parent[adj_list[vertex][i].neighbour].first =
adj_list[vertex][i].edge_number;
parent[adj_list[vertex][i].neighbour].second =
adj_list[vertex][i].weight;
dist[adj_list[vertex][i].neighbour].second =
adj_list[vertex][i].weight;
}
}
}
}
}
long long int ans = 0;
for (int i = 1; i <= n; i++) {
ans += parent[i].second;
}
cout << ans << endl;
for (int i = 1; i <= n; i++) {
if (source != i) cout << parent[i].first << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long double eps = 1e-9;
const long long maxn = 1e5 + 1;
const long long inf = 5e18;
const long long minf = -inf;
bool solve() {
long long n, m, start, cost = 0;
cin >> n >> m;
vector<vector<pair<long long, long long>>> adj(n + 1);
map<pair<long long, long long>, long long> id;
vector<long long> used, vis(n + 1, 0);
for (long long i = 0; i < m; ++i) {
long long x, y, w;
cin >> x >> y >> w;
adj[x].push_back({y, w});
adj[y].push_back({x, w});
id[{x, y}] = id[{y, x}] = i + 1;
}
cin >> start;
priority_queue<vector<long long>> pq;
pq.push({0, 0, start, 0});
while (!pq.empty()) {
auto curr = pq.top();
pq.pop();
long long dis = curr[0];
long long last = curr[1];
long long node = curr[2];
long long idx = curr[3];
if (vis[node])
continue;
else {
vis[node] = 1;
if (idx) {
used.push_back(idx);
cost -= last;
}
for (auto x : adj[node]) {
pq.push({dis - x.second, -x.second, x.first, id[{node, x.first}]});
}
}
}
cout << cost << "\n";
for (auto x : used) cout << x << " ";
return true;
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) {
if (solve()) {
} else {
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long ans = 0;
long long edge[300100], dist[300100], wt[300100];
bool visited[300100];
set<pair<long long, long long> > st;
vector<pair<pair<long long, long long>, long long> > g[300100];
void mst() {
long long i, k;
while (!st.empty()) {
long long u = (*st.begin()).second;
visited[u] = 1;
st.erase(st.begin());
k = g[u].size();
for (i = 0; i < k; i++) {
long long v = g[u][i].first.first;
if (!visited[v] && dist[v] >= g[u][i].first.second + dist[u]) {
if (dist[v] == g[u][i].first.second + dist[u] &&
wt[edge[v]] <= wt[g[u][i].second])
continue;
st.erase(st.find(pair<long long, long long>(dist[v], v)));
edge[v] = g[u][i].second;
dist[v] = g[u][i].first.second + dist[u];
st.insert(pair<long long, long long>(dist[v], v));
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
long long n, m, i, j, k, l;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> j >> k >> l;
wt[i + 1] = l;
g[j].push_back(pair<pair<long long, long long>, long long>(
pair<long long, long long>(k, l), i + 1));
g[k].push_back(pair<pair<long long, long long>, long long>(
pair<long long, long long>(j, l), i + 1));
}
for (i = 1; i <= n; i++) dist[i] = 1e18;
cin >> j;
dist[j] = 0;
for (i = 1; i <= n; i++) st.insert(pair<long long, long long>(dist[i], i));
edge[j] = INT_MAX;
mst();
for (i = 1; i <= n; i++)
if (i != j) ans += wt[edge[i]];
cout << ans << "\n";
sort(edge + 1, edge + n + 1);
for (i = 1; i < n; i++) cout << edge[i] << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, m, vertex_start;
vector<pair<int, pair<int, int>>> graph[3 * N];
long long dist[3 * N];
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
q;
pair<int, int> ans[3 * N];
bool used[3 * N];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int from, to, weight;
cin >> from >> to >> weight;
graph[from].push_back({to, {weight, i}});
graph[to].push_back({from, {weight, i}});
}
for (int i = 1; i <= n; i++) {
dist[i] = 1e18;
}
cin >> vertex_start;
dist[vertex_start] = 0;
q.push({0, vertex_start});
while (!q.empty()) {
pair<long long, int> cur = q.top();
int v = cur.second;
long long value = cur.first;
q.pop();
if (used[v] == true) {
continue;
}
if (value > dist[v]) {
continue;
}
used[v] = true;
for (int i = 0; i < graph[v].size(); i++) {
int child = graph[v][i].first;
int weight = graph[v][i].second.first;
int id = graph[v][i].second.second;
long long res = dist[v] + 1LL * weight;
if (dist[child] >= res) {
dist[child] = res;
q.push({res, child});
ans[child] = {id, weight};
}
}
}
long long edge_sum = 0;
for (int i = 1; i <= n; i++) {
if (i != vertex_start) {
edge_sum = edge_sum + 1LL * ans[i].second;
}
}
cout << edge_sum << endl;
for (int i = 1; i <= n; i++) {
if (i != vertex_start) {
cout << ans[i].first << " ";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 100;
const long long INF = 1LL << 60;
struct P {
long long d, cost;
int num, v;
P(long long d = 0, long long cost = 0, int num = 0, int v = 0)
: d(d), cost(cost), num(num), v(v) {}
friend bool operator>(const P a, const P b) {
if (a.d != b.d) {
return a.d > b.d;
}
return a.cost > b.cost;
}
};
struct edge {
int to, num, cost;
edge(int to = 0, int num = 0, int cost = 0) : to(to), num(num), cost(cost) {}
};
vector<edge> E[maxn];
vector<int> t;
long long d[maxn];
long long cost[maxn];
long long solve(int u, int n) {
priority_queue<P, vector<P>, greater<P> > q;
fill(cost + 1, cost + n + 1, INF);
fill(d + 1, d + n + 1, INF);
d[u] = cost[u] = 0;
q.push(P(0, 0, -1, u));
long long res = 0;
while (!q.empty()) {
P p = q.top();
q.pop();
int v = p.v;
if (d[v] != p.d || cost[v] != p.cost) {
continue;
}
res += cost[v];
if (p.num != -1) {
t.push_back(p.num + 1);
}
for (int i = 0; i < E[v].size(); ++i) {
edge e = E[v][i];
if ((d[e.to] > d[v] + e.cost) ||
(d[e.to] == d[v] + e.cost && cost[e.to] > e.cost)) {
cost[e.to] = e.cost;
d[e.to] = d[v] + e.cost;
q.push(P(d[e.to], cost[e.to], e.num, e.to));
}
}
}
return res;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int x, y, l;
cin >> x >> y >> l;
E[x].push_back(edge(y, i, l));
E[y].push_back(edge(x, i, l));
}
int u;
cin >> u;
cout << solve(u, n) << endl;
for (int i = 0; i < t.size(); ++i) {
cout << t[i] << (i != t.size() ? ' ' : '\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') {
f = -1;
}
c = getchar();
}
while (c <= '9' && c >= '0') {
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
}
return x * f;
}
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int Maxn = 3e5 + 5;
const int Maxm = 6e5 + 5;
int n, m, s, cnt = 0, head[Maxn], pre[Maxn];
long long dis[Maxn], ans[Maxn];
bool vis[Maxn];
struct Line {
int to;
int w;
long long next;
} edges[Maxm];
inline void Add(int a, int b, long long w) {
++cnt;
edges[cnt].to = b;
edges[cnt].w = w;
edges[cnt].next = head[a];
head[a] = cnt;
return;
}
struct Node {
int id;
long long dist;
bool operator<(const Node &cur) const { return dist > cur.dist; }
};
inline void Dijkstra(int start) {
priority_queue<Node> pq;
for (register int i = 1; i <= n; ++i) {
dis[i] = INF;
vis[i] = false;
}
dis[start] = 0;
Node Start = {s, 0};
pq.push(Start);
while (!pq.empty()) {
Node now = pq.top();
pq.pop();
int u = now.id;
if (vis[u] == true) {
continue;
}
vis[u] = true;
for (register int i = head[u]; i != 0; i = edges[i].next) {
int next = edges[i].to;
long long w = edges[i].w;
if (dis[next] > dis[u] + w) {
dis[next] = dis[u] + w;
Node nxt = {next, dis[next]};
pq.push(nxt);
pre[next] = i;
}
if (dis[next] == dis[u] + edges[i].w && edges[i].w < edges[pre[next]].w) {
pre[next] = i;
}
}
}
return;
}
signed main() {
n = read(), m = read();
for (register int i = 1; i <= m; ++i) {
int x = read(), y = read();
long long w = read();
Add(x, y, w), Add(y, x, w);
}
s = read();
Dijkstra(s);
long long sum = 0, tot = 0;
for (register int i = 1; i <= n; ++i) {
if (i == s) {
continue;
}
int id = pre[i];
long long w = edges[id].w;
sum += w;
ans[++tot] = id;
}
sort(ans + 1, ans + tot + 1);
printf("%lld\n", sum);
for (register int i = 1; i <= tot; ++i) {
printf("%lld ", (ans[i] + 1) / 2);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
long long end, w, number;
};
vector<Edge> g[300000];
struct Elem {
long long node, dist, add, number;
bool operator<(const Elem& e) const {
if (dist == e.dist)
return add > e.add;
else
return dist > e.dist;
}
};
int main() {
int n, m, u, i;
vector<int> res;
long long res2 = 0;
cin >> n >> m;
for (i = 0; i < m; i++) {
int a, b, w;
scanf("%d%d%d", &a, &b, &w);
a--, b--;
Edge ea, eb;
ea.end = b, ea.w = w, ea.number = i + 1;
eb.end = a, eb.w = w, eb.number = i + 1;
g[a].push_back(ea);
g[b].push_back(eb);
}
cin >> u;
u--;
priority_queue<Elem, vector<Elem> > pq;
set<int> used;
used.insert(u);
for (Edge e : g[u]) {
Elem el;
el.node = e.end;
el.dist = e.w;
el.add = e.w;
el.number = e.number;
pq.push(el);
}
while ((int)used.size() < n) {
Elem el = pq.top();
pq.pop();
if (!(used.find(el.node) != used.end())) {
res.push_back(el.number);
res2 += el.add;
used.insert(el.node);
for (Edge e : g[el.node]) {
if (!(used.find(e.end) != used.end())) {
Elem el2;
el2.add = e.w;
el2.dist = el.dist + e.w;
el2.node = e.end;
el2.number = e.number;
pq.push(el2);
}
}
}
}
cout << res2 << endl;
for (int e : res) cout << e << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > adj[300005];
long long we[300005];
long long d[300005];
long long par[300005];
int main() {
long long n, m;
cin >> n >> m;
for (long long i = 1; i <= n; i++) d[i] = 1e18;
for (long long i = 1; i <= m; i++) {
long long a, b, w;
cin >> a >> b >> w;
adj[a].push_back(make_pair(b, i));
adj[b].push_back(make_pair(a, i));
we[i] = w;
}
long long s;
cin >> s;
par[s] = 0;
we[0] = 0;
d[s] = 0;
d[0] = 0;
priority_queue<pair<long long, long long> > q;
q.push(make_pair(0, s));
while (!q.empty()) {
pair<long long, long long> z = q.top();
q.pop();
long long u = z.second;
for (long long i = 0; i < adj[u].size(); i++) {
long long v = adj[u][i].first;
long long id = adj[u][i].second;
if (d[v] > d[u] + we[id]) {
d[v] = d[u] + we[id];
q.push(make_pair(-d[v], v));
par[v] = id;
} else if (d[v] == d[u] + we[id]) {
if (we[par[v]] > we[id]) par[v] = id;
}
}
}
long long ans = 0;
for (long long i = 1; i <= n; i++) ans += we[par[i]];
cout << ans << endl;
for (long long i = 1; i <= n; i++)
if (i != s) cout << par[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, int> > adj[300005], ne[300010];
priority_queue<pair<long long, int> > pq;
long long dis[300005];
int flag[300005];
map<pair<int, int>, int> mp;
vector<int> an;
int main() {
int n, m, u;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) dis[i] = 1ll << 60;
for (int i = 1; i <= m; i++) {
int x, y;
long long w;
scanf("%d %d %lld", &x, &y, &w);
adj[x].push_back(pair<long long, int>(w, y));
adj[y].push_back(pair<long long, int>(w, x));
mp[make_pair(x, y)] = i;
mp[make_pair(y, x)] = i;
}
scanf("%d", &u);
pq.push(pair<long long, int>(0, u));
dis[u] = 0;
while (!pq.empty()) {
int x = pq.top().second;
pq.pop();
if (flag[x]) continue;
flag[x] = 1;
for (pair<long long, int> p : adj[x]) {
long long w = p.first;
int y = p.second;
if (dis[y] > dis[x] + w) {
dis[y] = dis[x] + w;
pq.push(pair<long long, int>(-dis[y], y));
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < adj[i].size(); j++) {
int x = i;
int y = adj[i][j].second;
long long w = adj[i][j].first;
if (dis[x] > dis[y]) swap(x, y);
if (dis[y] - dis[x] == w) ne[y].push_back(pair<long long, int>(w, x));
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
if (ne[i].size() == 0) continue;
sort(ne[i].begin(), ne[i].end());
ans += ne[i][0].first;
an.push_back(mp[make_pair(i, ne[i][0].second)]);
}
printf("%lld\n", ans);
for (int x : an) printf("%d ", x);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 9;
const long long inf = (long long)1e18;
int n, m, u;
vector<vector<pair<int, int>>> g;
vector<pair<long long, long long>> d;
vector<long long> sel_e;
set<pair<pair<int, int>, pair<int, int>>> st;
void prim(void) {
d[u].first = 0;
set<pair<long long, int>> q;
q.insert(make_pair(d[u].first, u));
for (int i = 0; i < n; ++i) {
int v = q.begin()->second;
q.erase(q.begin());
set<pair<pair<int, int>, pair<int, int>>>::iterator it;
for (size_t j = 0; j < g[v].size(); ++j) {
int to = g[v][j].first, len = g[v][j].second;
it = st.lower_bound(make_pair(make_pair(v, to), make_pair(0, 0)));
int reb = (*it).second.second;
if (d[v].first + len < d[to].first ||
d[v].first + len == d[to].first && d[to].second > reb) {
q.erase(make_pair(d[to].first, to));
d[to].first = d[v].first + len;
d[to].second = reb;
sel_e[to] = v;
q.insert(make_pair(d[to].first, to));
}
}
}
}
int main() {
scanf("%d %d", &n, &m);
d.resize(n + 1, make_pair(inf, inf));
sel_e.resize(n + 1, -1);
g.resize(n + 1);
for (int i = 0; i < m; i++) {
int x, y, z;
scanf("%d %d %d", &x, &y, &z);
g[x].push_back(make_pair(y, z));
g[y].push_back(make_pair(x, z));
st.insert(make_pair(make_pair(x, y), make_pair(i + 1, z)));
st.insert(make_pair(make_pair(y, x), make_pair(i + 1, z)));
}
scanf("%d", &u);
prim();
vector<int> ans;
long long sum = 0;
for (int i = 1; i < n + 1; i++) {
if (sel_e[i] != -1) {
set<pair<pair<int, int>, pair<int, int>>>::iterator it =
st.lower_bound(make_pair(make_pair(i, sel_e[i]), make_pair(0, 0)));
if (it != st.end() && (*it).first.first == i &&
(*it).first.second == sel_e[i]) {
ans.push_back((*it).second.first);
sum += (*it).second.second;
}
}
}
printf("%I64d\n", sum);
for (int i = 0; i < (int)ans.size(); i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct ee {
int x, y, w;
};
vector<int> ke[300010], kq;
int n, m, s, c[300010] = {0}, p[300010], b[300010];
ee e[300010];
priority_queue<pair<long long, int> > Q;
long long d[300010];
void enter() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d", &e[i].x, &e[i].y, &e[i].w);
ke[e[i].x].push_back(i);
ke[e[i].y].push_back(-i);
}
scanf("%d", &s);
}
void dijkstra() {
for (int i = 1; i <= n; ++i) d[i] = 1e18;
d[s] = 0;
Q.push(pair<long long, int>(0, s));
int u, v;
long long w;
while (!Q.empty()) {
u = Q.top().second;
w = -Q.top().first;
Q.pop();
if (d[u] != w) continue;
for (vector<int>::iterator i = ke[u].begin(); i != ke[u].end(); ++i) {
v = (*i > 0 ? e[*i].y : e[-*i].x);
if (w + e[abs(*i)].w < d[v]) {
d[v] = w + e[abs(*i)].w;
Q.push(pair<long long, int>(-d[v], v));
p[v] = abs(*i);
} else if (w + e[abs(*i)].w == d[v] && e[abs(*i)].w < e[p[v]].w)
p[v] = abs(*i);
}
}
}
bool compare(int i, int j) { return e[i].w < e[j].w; }
int Find(int u) {
if (p[u] < 0) return u;
return p[u] = Find(p[u]);
}
void process() {
long long ans = 0;
int t;
for (int i = 1; i <= m; ++i)
if (abs(d[e[i].x] - d[e[i].y]) != e[i].w)
continue;
else {
t = (d[e[i].x] > d[e[i].y] ? e[i].x : e[i].y);
if (i != p[t]) continue;
ans += e[i].w;
kq.push_back(i);
}
cout << ans << '\n';
for (vector<int>::iterator i = kq.begin(); i != kq.end(); ++i)
printf("%d ", *i);
}
int main() {
enter();
dijkstra();
process();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 300 * 1000 + 7;
const int INF = 1000 * 1000 * 1000;
const long long LINF = 1LL * INF * INF;
const int MOD = 998244353;
const double PI = acos(-1.);
vector<pair<pair<int, int>, int>> edges;
vector<pair<pair<int, int>, int>> g[MAX];
long long d[MAX];
long long answ;
vector<long long> ans;
int from[MAX];
int n, m;
void path(int v) {
set<pair<long long, long long>> q;
for (int i = (1); i < (n + 1); ++i) {
d[i] = LINF;
if (i != v) q.insert(make_pair(d[i], i));
}
from[v] = -1;
d[v] = 0;
q.insert(make_pair(0, v));
while ((int)q.size()) {
v = q.begin()->second;
q.erase(q.begin());
if (from[v] != -1) {
answ += edges[from[v] - 1].second;
ans.push_back(from[v]);
}
for (int i = (0); i < ((int)g[v].size()); ++i) {
int to = g[v][i].first.first;
long long w = g[v][i].first.second;
if (d[to] > d[v] + w) {
q.erase(make_pair(d[to], to));
d[to] = d[v] + w;
from[to] = g[v][i].second;
q.insert(make_pair(d[to], to));
}
if (d[to] == d[v] + w) {
int w1 = edges[from[to] - 1].second;
if (w1 > w) from[to] = g[v][i].second;
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = (0); i < (m); ++i) {
int a, b, c;
cin >> a >> b >> c;
if (b < a) swap(a, b);
edges.push_back(make_pair(make_pair(a, b), c));
g[a].push_back(make_pair(make_pair(b, c), i + 1));
g[b].push_back(make_pair(make_pair(a, c), i + 1));
}
int u;
cin >> u;
answ = 0;
path(u);
cout << answ << endl;
sort(ans.begin(), ans.end());
for (int i = (0); i < ((int)ans.size()); ++i)
cout << ans[i] << " \n"[i + 1 == (int)ans.size()];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 1e6 + 10;
const long long inf = 1e18;
vector<pair<int, int>> adj[max_n];
set<pair<long long, int>> q;
long long d[max_n];
int b[max_n];
set<int> ans;
map<pair<int, int>, int> mp;
map<pair<int, int>, int> e;
map<int, long long> z;
long long p;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v, c;
cin >> u >> v >> c;
u--;
v--;
adj[u].push_back({c, v});
mp[make_pair(u, v)] = c;
mp[make_pair(v, u)] = c;
e[make_pair(u, v)] = i + 1;
e[make_pair(v, u)] = i + 1;
z[i + 1] = c;
z[i + 1] = c;
adj[v].push_back({c, u});
}
int h;
cin >> h;
h--;
for (int i = 0; i < n; i++)
if (i != h) d[i] = inf;
q.insert({0, h});
while (q.size()) {
int v = (*q.begin()).second;
q.erase(q.begin());
for (auto j : adj[v]) {
if (d[j.second] > d[v] + j.first) {
ans.erase(e[{b[j.second], j.second}]);
b[j.second] = v;
q.erase({d[j.second], j.second});
q.insert({d[j.second] = d[v] + j.first, j.second});
ans.insert(e[{j.second, v}]);
} else if (d[j.second] == d[v] + j.first &&
mp[{b[j.second], j.second}] > j.first) {
ans.erase(e[{b[j.second], j.second}]);
b[j.second] = v;
q.erase({d[j.second], j.second});
q.insert({d[j.second] = d[v] + j.first, j.second});
ans.insert(e[{j.second, v}]);
}
}
}
for (auto i : ans) p += z[i];
cout << p << endl;
for (auto i : ans) cout << i << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long int, long long int> > v[300001];
vector<pair<pair<long long int, long long int>, long long int> > edge;
long long int dist[300001], parent[300001], in[300001];
int main() {
ios::sync_with_stdio(false);
;
long long int i, j, n, m, x, y, z, sum = 0, src;
cin >> n >> m;
for (i = 1; i <= m; i++) {
cin >> x >> y >> z;
v[x].push_back(make_pair(y, z));
v[y].push_back(make_pair(x, z));
edge.push_back(make_pair(make_pair(x, y), z));
}
for (i = 1; i <= n; i++) dist[i] = 1000000000000000000;
cin >> src;
dist[src] = 0;
priority_queue<pair<long long int, long long int>,
vector<pair<long long int, long long int> >,
greater<pair<long long int, long long int> > >
pq;
pq.push(make_pair(0, src));
while (!pq.empty()) {
x = pq.top().second;
pq.pop();
for (i = 0; i < v[x].size(); i++) {
y = v[x][i].first;
z = v[x][i].second;
if (dist[y] > dist[x] + z) {
dist[y] = dist[x] + z;
in[y] = z;
parent[y] = x;
pq.push(make_pair(dist[y], y));
} else if (dist[y] == dist[x] + z) {
if (in[y] > z) {
in[y] = z;
parent[y] = x;
pq.push(make_pair(dist[y], y));
}
}
}
}
for (i = 1; i <= n; i++) sum += in[i];
cout << sum << endl;
for (i = 0; i < edge.size(); i++) {
x = edge[i].first.first;
y = edge[i].first.second;
if (parent[x] == y || parent[y] == x) cout << i + 1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 300005;
long long n, m, cnt, sta;
long long head[maxn], ans[maxn], dis[maxn];
bool vis[maxn];
struct edge {
long long v, nxt, val;
} a[maxn << 1];
void add(long long x, long long y, long long val) {
++cnt;
a[cnt].v = y;
a[cnt].val = val;
a[cnt].nxt = head[x];
head[x] = cnt;
}
inline long long read() {
long long ret = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -f;
ch = getchar();
}
while (isdigit(ch)) {
ret = ret * 10 + ch - '0';
ch = getchar();
}
return ret * f;
}
void scan() {
n = read();
m = read();
cnt = 1;
for (long long k = 1; k <= m; k++) {
long long x, y, val;
x = read();
y = read();
val = read();
add(x, y, val);
add(y, x, val);
}
sta = read();
}
void dijkstra() {
long long sum = 0;
memset(dis, 0x3f, sizeof(dis));
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
q;
while (!q.empty()) q.pop();
q.push(make_pair(dis[sta] = 0, sta));
while (!q.empty()) {
pair<long long, long long> t;
long long x, d;
do {
t = q.top();
q.pop();
x = t.second;
d = t.first;
} while (vis[x] && !q.empty());
if (vis[x]) break;
vis[x] = 1;
sum += a[ans[x] << 1].val;
for (long long k = head[x]; k; k = a[k].nxt) {
long long v = a[k].v, val = a[k].val;
if (d + val <= dis[v]) ans[v] = k >> 1;
if (d + val < dis[v]) q.push(make_pair(dis[v] = d + val, v));
}
}
printf("%lld\n", sum);
for (long long k = 1; k <= n; k++)
if (k != sta) printf("%lld ", ans[k]);
puts("");
}
signed main() {
scan();
dijkstra();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
int n, m, a, b, w;
cin >> n >> m;
long long d[n + 1];
int p[n + 1];
for (int i = 1; i <= n; ++i) d[i] = 3e14, p[i] = -1;
vector<vector<int>> graph(n + 1);
map<pair<int, int>, int> wei, ind, mini;
for (int i = 1; i <= m; ++i) {
cin >> a >> b >> w;
graph[a].push_back(b);
graph[b].push_back(a);
wei[{a, b}] = w;
wei[{b, a}] = w;
ind[{a, b}] = i;
ind[{b, a}] = i;
}
int source;
cin >> source;
d[source] = 0, p[source] = source;
priority_queue<pair<long long, int>> pq;
map<int, bool> visited;
pq.push({0, source});
while (!pq.empty()) {
int tmp = pq.top().second;
pq.pop();
visited[tmp] = 1;
for (int x : graph[tmp]) {
if (d[x] > wei[{x, tmp}] + d[tmp]) {
d[x] = wei[{x, tmp}] + d[tmp];
p[x] = tmp;
if (!visited[x]) pq.push({-d[x], x});
} else if (p[x] != -1 && d[x] == wei[{x, tmp}] + d[tmp] &&
wei[{x, p[x]}] > wei[{x, tmp}])
p[x] = tmp;
}
}
long long dis = 0;
vector<int> ans;
for (int i = 1; i <= n; ++i) {
if (i != source) ans.push_back(ind[{i, p[i]}]), dis += wei[{i, p[i]}];
}
cout << dis << endl;
for (int x : ans) cout << x << " ";
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
using Edge = tuple<int, int, int>;
using Graph = vector<vector<Edge>>;
int N, M;
cin >> N >> M;
Graph graph(N);
for (int i = 0; i < M; i++) {
int u, v, w;
cin >> u >> v >> w;
u--;
v--;
graph[u].push_back(make_tuple(v, w, i));
graph[v].push_back(make_tuple(u, w, i));
}
int source;
cin >> source;
source--;
using Node = tuple<int, long long, int>;
auto comp = [](Node L, Node R) {
long long dl;
int el;
tie(std::ignore, dl, el) = L;
long long dr;
int er;
tie(std::ignore, dr, er) = R;
if (dl != dr)
return dl > dr;
else
return el > er;
};
priority_queue<Node, vector<Node>, decltype(comp)> heap(comp);
constexpr auto MAX = numeric_limits<long long>::max() / 2;
vector<long long> dist(N, MAX);
vector<int> edge_weight(N);
vector<int> edge_id(N, -1);
dist[source] = 0;
edge_weight[source] = 0;
heap.push(make_tuple(source, dist[source], edge_weight[source]));
while (!heap.empty()) {
auto _node = heap.top();
heap.pop();
int node;
tie(node, std::ignore, std::ignore) = _node;
for (auto edge : graph[node]) {
int v, w, id;
tie(v, w, id) = edge;
if (dist[v] > dist[node] + w ||
(dist[v] == dist[node] + w && w < edge_weight[v])) {
dist[v] = dist[node] + w;
edge_weight[v] = w;
edge_id[v] = id;
heap.push(make_tuple(v, dist[v], edge_weight[v]));
}
}
}
long long total_cost = 0;
for (int x : edge_weight) total_cost += x;
cout << total_cost << "\n";
for (int i = 0; i < N; i++)
if (edge_id[i] != -1) cout << edge_id[i] + 1 << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 10;
struct edge {
int w, y, num;
};
int n, m, s;
vector<edge> d[MAXN];
int num[MAXN];
long long dist[MAXN];
int pr[MAXN];
long long ans = 0;
set<int> res;
inline edge make_edge(int y, int z, int num) {
edge e;
e.y = y, e.w = z, e.num = num;
return e;
}
void dijkstra(int x) {
priority_queue<pair<long long, int> > o;
o.push(make_pair(0, x));
while (!o.empty()) {
x = o.top().second;
long long y = o.top().first;
o.pop();
if (-y != dist[x]) continue;
for (int i = 0; i < d[x].size(); i++) {
int to = d[x][i].y;
if (dist[to] > dist[x] + d[x][i].w) {
dist[to] = dist[x] + d[x][i].w;
pr[to] = d[x][i].num;
o.push(make_pair(-dist[to], to));
} else if (dist[to] == dist[x] + d[x][i].w)
if (num[pr[to]] > d[x][i].w) pr[to] = d[x][i].num;
}
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x, y, z;
scanf("%d %d %d", &x, &y, &z);
d[x].push_back(make_edge(y, z, i));
d[y].push_back(make_edge(x, z, i));
num[i] = z;
}
cin >> s;
memset(dist, 63, sizeof(dist));
memset(pr, false, sizeof(pr));
dist[s] = 0;
dijkstra(s);
for (int i = 1; i <= n; i++)
if (i != s) {
res.insert(pr[i]);
}
for (set<int>::iterator it = res.begin(); it != res.end(); it++) {
int x = *it;
ans += num[x];
}
cout << ans << endl;
for (set<int>::iterator it = res.begin(); it != res.end(); it++) {
cout << *it << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct are {
int x, y;
long long int p;
int id;
are() { x = y = p = 0; }
are(int a, int b, long long int c) {
x = a;
y = b;
p = c;
id = a + 1;
}
bool operator<(are a) const {
if (p != a.p) return p > a.p;
if (x != a.x) return x < a.x;
if (y != a.y) return y < a.y;
return id < a.id;
}
} v[300005];
vector<are> G[300005];
int grupo[300005];
long long int dist[300005];
int esta[300005];
int marca[300005];
map<are, int> mapa;
void iniciar(int n) {
mapa.clear();
memset(esta, 0, sizeof esta);
memset(marca, 0, sizeof marca);
for (int i = 0; i <= n; i++) {
grupo[i] = i;
dist[i] = 20000000000000000LL;
G[i].clear();
}
}
int achar(int i) { return (grupo[i] == i) ? i : (grupo[i] = achar(grupo[i])); }
bool igual(int i, int j) { return achar(i) == achar(j); }
void unir(int i, int j) { grupo[achar(i)] = achar(j); }
void D(int s) {
priority_queue<are> fila;
dist[s] = 0;
fila.push(are(0, s, 0));
are t;
while (fila.size() > 0) {
t = fila.top();
fila.pop();
int v = t.y;
long long int p = t.p;
if (dist[v] < p) continue;
for (int i = 0; i < G[v].size(); i++) {
int r = G[v][i].y;
if (dist[r] > p + G[v][i].p) {
dist[r] = p + G[v][i].p;
fila.push(are(0, r, dist[r]));
}
}
}
}
int main() {
int n, m;
int i, j;
int a, b, c;
long long int ans, menor;
scanf("%d %d", &n, &m);
iniciar(n);
for (i = 0; i < m; i++) {
cin >> v[i].x >> v[i].y >> v[i].p;
if (v[i].x > v[i].y) swap(v[i].x, v[i].y);
G[v[i].x].push_back(are(v[i].x, v[i].y, v[i].p));
G[v[i].y].push_back(are(v[i].y, v[i].x, v[i].p));
v[i].id = (i + 1);
mapa[are(v[i].x, v[i].y, v[i].p)] = (i + 1);
}
scanf("%d", &a);
D(a);
ans = 0;
for (i = 1; i <= n; i++)
if (i != a) {
menor = 20000000000000000LL;
for (j = 0; j < G[i].size(); j++)
if (dist[i] - G[i][j].p == dist[G[i][j].y] && menor > G[i][j].p) {
menor = G[i][j].p;
b = G[i][j].y;
}
esta[mapa[are(min(i, b), max(i, b), menor)]] = 1;
ans += menor;
}
cout << ans << endl;
for (i = 1; i <= m; i++)
if (esta[i]) printf("%d ", i);
printf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
vector<vector<pair<long long, long long>>> adj;
set<pair<long long, int>> S;
vector<long long> d, p;
map<pair<int, int>, pair<int, int>> M;
int main() {
ios::sync_with_stdio(false);
long long n, m;
cin >> n >> m;
d.resize(n, inf);
p.resize(n, -1);
adj.resize(n);
for (int i = 0; i < m; i++) {
int v, u, w;
cin >> v >> u >> w;
v--;
u--;
adj[v].push_back({u, w});
adj[u].push_back({v, w});
M[{v, u}] = {i, w};
M[{u, v}] = {i, w};
}
long long s;
cin >> s;
s--;
d[s] = 0;
for (int i = 0; i < n; i++) {
S.insert({d[i], i});
}
while (S.size()) {
long long x = (*S.begin()).second;
S.erase({d[x], x});
for (auto P : adj[x]) {
if (d[P.first] >= d[x] + P.second) {
S.erase({d[P.first], P.first});
d[P.first] = d[x] + P.second;
p[P.first] = x;
S.insert({d[P.first], P.first});
}
}
}
long long sum = 0;
vector<int> V;
for (int i = 0; i < n; i++) {
if (i != s) {
pair<int, int> P = {p[i], i};
sum += M[P].second;
V.push_back(M[P].first);
}
}
cout << sum << '\n';
for (auto v : V) cout << v + 1 << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e15;
long long q[300005];
long long d[300005];
long long dd[300005];
struct st {
long long x, w, id;
};
vector<st> v[300005];
st t;
vector<long long> ans;
long long sum;
long long n, m;
long long x, y, z;
inline void dij(long long st) {
for (long long i = 1; i <= n; ++i) d[i] = inf;
set<pair<long long, long long> > s;
d[st] = 0;
s.insert(make_pair(0, st));
while (!s.empty()) {
long long x = s.begin()->second;
s.erase(s.begin());
for (long long i = 0; i < v[x].size(); ++i) {
long long to = v[x][i].x;
long long len = d[x] + v[x][i].w;
if (d[to] > len) {
s.erase(make_pair(d[to], to));
d[to] = len;
s.insert(make_pair(d[to], to));
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (long long i = 1; i <= m; ++i) {
cin >> x >> y >> z;
t.x = y;
t.w = z;
t.id = i;
v[x].push_back(t);
t.x = x;
v[y].push_back(t);
}
long long stt;
cin >> stt;
dij(stt);
for (long long i = 1; i <= n; ++i) {
long long mx = 1e9;
for (long long j = 0; j < v[i].size(); ++j) {
long long to = v[i][j].x;
if (d[to] != d[i] - v[i][j].w) continue;
mx = min(mx, v[i][j].w);
}
for (long long j = 0; j < v[i].size(); ++j) {
long long to = v[i][j].x;
if (d[to] != d[i] - v[i][j].w) continue;
if (v[i][j].w == mx) {
ans.push_back(v[i][j].id);
sum += v[i][j].w;
break;
}
}
}
cout << sum << '\n';
for (long long i = 0; i < ans.size(); ++i) cout << ans[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
typedef struct edge {
int index, st, en;
long long length, dist;
bool operator<(edge a) const {
return dist > a.dist || (dist == a.dist && length > a.length);
}
};
int main() {
int n, k;
scanf("%d %d", &n, &k);
int path[n + 5];
bool check[n + 5];
memset(check, false, sizeof(check));
long long ans = 0;
vector<edge> V[n + 1];
for (int i = 0; i < k; i++) {
int a, b;
long long c;
scanf("%d %d %I64d", &a, &b, &c);
edge temp;
temp.length = c;
temp.st = a;
temp.en = b;
temp.index = i + 1;
temp.dist = 1e10;
V[a].push_back(temp);
temp.st = b;
temp.en = a;
V[b].push_back(temp);
}
priority_queue<edge> Q;
int start;
scanf("%d", &start);
int sz = V[start].size();
for (int i = 0; i < sz; i++) {
edge temp = V[start][i];
temp.dist = temp.length;
Q.push(temp);
}
check[start] = true;
int c = 0;
while (!Q.empty()) {
if (!check[Q.top().en]) {
ans += Q.top().length;
path[c++] = Q.top().index;
long long a = Q.top().dist;
check[Q.top().en] = true;
int nn = Q.top().en;
Q.pop();
int t = V[nn].size();
for (int i = 0; i < t; i++) {
edge temp = V[nn][i];
temp.dist = temp.length + a;
Q.push(temp);
}
} else
Q.pop();
}
printf("%I64d\n", ans);
for (int i = 0; i < c; i++) printf("%d ", path[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
struct q {
int i, to, le;
long long int tt;
} qt;
bool operator<(const q& a, const q& b) {
if (a.tt != b.tt) return a.tt > b.tt;
return a.le > b.le;
}
int n, m, u;
int ta, tb, tc;
bool v[300005];
long long int d[300005];
long long int ans;
vector<int> aa;
vector<int> ed[300005], to[300005], le[300005];
priority_queue<q> qq;
int main() {
scanf("%d", &n);
scanf("%d", &m);
for (int a = 1; a <= m; a++) {
scanf("%d", &ta);
scanf("%d", &tb);
scanf("%d", &tc);
ed[ta].push_back(a);
ed[tb].push_back(a);
to[ta].push_back(tb);
to[tb].push_back(ta);
le[ta].push_back(tc);
le[tb].push_back(tc);
}
scanf("%d", &u);
v[u] = 1;
for (int a = 0; a < ed[u].size(); a++)
qq.push((q){ed[u][a], to[u][a], le[u][a], le[u][a]});
while (!qq.empty()) {
qt = qq.top();
qq.pop();
if (v[qt.to]) continue;
v[qt.to] = 1;
aa.push_back(qt.i);
ans += qt.le;
d[qt.to] = qt.tt;
for (int a = 0; a < ed[qt.to].size(); a++) {
if (!v[to[qt.to][a]])
qq.push((q){ed[qt.to][a], to[qt.to][a], le[qt.to][a],
d[qt.to] + le[qt.to][a]});
}
}
printf("%I64d\n", ans);
for (int a = 0; a < aa.size(); a++)
printf("%d%c", aa[a], a == aa.size() - 1 ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long infinity = 1000000000000000000;
const int inf = 1e9 + 5;
bool do_debug = false;
template <typename T>
ostream& operator<<(ostream& os, vector<T>& v) {
for (auto element : v) {
os << element << " ";
}
return os;
}
template <typename T, typename S>
ostream& operator<<(ostream& os, pair<T, S>& p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, set<T>& v) {
if (v.size() == 0) {
os << "empty set\n";
return os;
}
auto endit = v.end();
endit--;
os << "[";
for (auto it = v.begin(); it != v.end(); it++) {
os << *it;
if (it != endit) {
os << ", ";
}
}
os << "]";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, multiset<T>& v) {
if (v.size() == 0) {
os << "empty multiset\n";
return os;
}
auto endit = v.end();
endit--;
os << "[";
for (auto it = v.begin(); it != v.end(); it++) {
os << *it;
if (it != endit) {
os << ", ";
}
}
os << "]";
return os;
}
template <typename T, typename S>
ostream& operator<<(ostream& os, map<T, S>& v) {
if (v.size() == 0) {
os << "empty map\n";
return os;
}
auto endit = v.end();
endit--;
os << "{";
for (auto it = v.begin(); it != v.end(); it++) {
os << "(" << (*it).first << " : " << (*it).second << ")";
if (it != endit) {
os << ", ";
}
}
os << "}";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, vector<vector<T>>& v) {
for (auto& subv : v) {
for (auto& e : subv) {
os << e << " ";
}
os << "\n";
}
return os;
}
const int maxn = 3e5 + 5;
int n_nodes, n_edges, target;
vector<vector<int>> adj;
vector<array<int, 4>> edges;
long long dist[maxn];
long long depth[maxn];
int incoming[maxn];
int added[maxn];
set<int> ans;
long long ans_w;
void dijkstra() {
int node = target;
priority_queue<pair<long long, long long>> pq;
pq.push(make_pair(0, target));
while (!pq.empty()) {
long long w = -pq.top().first;
node = pq.top().second;
pq.pop();
if (w > dist[node]) {
continue;
}
for (int e : adj[node]) {
int next = edges[e][1];
if (next == node) next = edges[e][2];
if (dist[node] + edges[e][0] < dist[next]) {
if (incoming[next] != -1) {
ans_w -= edges[incoming[next]][0];
ans.erase(incoming[next]);
}
incoming[next] = e;
ans_w += edges[incoming[next]][0];
ans.insert(incoming[next]);
dist[next] = dist[node] + edges[e][0];
pq.push(make_pair(-dist[next], next));
} else if (dist[node] + edges[e][0] == dist[next]) {
if (edges[e][0] < edges[incoming[next]][0]) {
ans_w -= edges[incoming[next]][0];
ans.erase(incoming[next]);
incoming[next] = e;
ans_w += edges[incoming[next]][0];
ans.insert(incoming[next]);
}
}
}
}
}
void mst() {
int node = target;
priority_queue<pair<long long, long long>> pq;
for (int e : adj[node]) {
int u = edges[e][1], v = edges[e][2];
if (u != node) swap(u, v);
depth[v] = edges[e][0];
incoming[v] = e;
ans_w += edges[e][0];
ans.insert(e);
pq.push(make_pair(-edges[e][0], v));
}
while (!pq.empty()) {
long long d = -pq.top().first;
node = pq.top().second;
pq.pop();
for (int e : adj[node]) {
long long w = edges[e][0];
int u = edges[e][1], v = edges[e][2];
if (u != node) swap(u, v);
if (depth[u] + w == dist[v]) {
if (incoming[v] == -1) {
ans_w += w;
ans.insert(e);
incoming[v] = e;
} else {
if (w < edges[incoming[v]][0]) {
ans_w -= edges[incoming[v]][0];
ans.erase(incoming[v]);
incoming[v] = e;
ans_w += edges[incoming[v]][0];
ans.insert(incoming[v]);
}
}
depth[v] = dist[v];
}
}
}
}
void solve() {
for (int i = 0; i < maxn; i++) {
incoming[i] = -1;
dist[i] = infinity;
depth[i] = infinity;
added[i] = 0;
}
cin >> n_nodes >> n_edges;
adj.resize(n_nodes);
for (int i = 0; i < n_edges; i++) {
int w, u, v;
cin >> u >> v >> w;
u--;
v--;
adj[u].push_back(i);
adj[v].push_back(i);
edges.push_back({w, u, v, i});
}
cin >> target;
target--;
dist[target] = 0;
depth[target] = 0;
ans_w = 0;
dijkstra();
cout << ans_w << "\n";
for (int a : ans) {
cout << a + 1 << " ";
}
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int q = 1;
while (q-- > 0) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
vector<pair<int, pair<long long, int> > > g[N];
bool vis[N];
void solve() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v, c;
cin >> u >> v >> c;
g[u].push_back(make_pair(v, make_pair(c, i + 1)));
g[v].push_back(make_pair(u, make_pair(c, i + 1)));
}
long long dis = 0;
int s;
cin >> s;
priority_queue<pair<pair<long long, long long>, pair<int, int> > > q;
q.push(make_pair(make_pair(0, 0), make_pair(s, 0)));
vector<int> res;
while (q.size() > 0) {
pair<pair<long long, long long>, pair<int, int> > u = q.top();
q.pop();
if (vis[u.second.first]) continue;
vis[u.second.first] = true;
if (u.second.second > 0) res.push_back(u.second.second);
dis -= u.first.second;
for (int i = 0; i < g[u.second.first].size(); i++) {
pair<int, pair<long long, int> > v = g[u.second.first][i];
q.push(
make_pair(make_pair(u.first.first - v.second.first, -v.second.first),
make_pair(v.first, v.second.second)));
}
}
cout << dis << endl;
for (int i = 0; i < res.size(); i++) {
cout << res[i] << ' ';
}
cout << endl;
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> adj[300000 + 1000];
long long dist[300000 + 1000], from[300000 + 1000];
long long mindist[300000 + 1000];
bool vis[300000 + 1000];
map<pair<int, int>, pair<int, long long> > bcc;
int main() {
long long int n, m, source;
long long int x, y;
long long weight;
vector<pair<long long int, pair<long long int, long long> > > edge;
cin >> n >> m;
for (long long int i = 0; i < m; i++) {
cin >> x >> y >> weight;
adj[x].push_back(y);
adj[y].push_back(x);
edge.push_back(make_pair(x, make_pair(y, weight)));
bcc[make_pair(x, y)] = make_pair(i, weight);
bcc[make_pair(y, x)] = make_pair(i, weight);
}
for (int i = 0; i <= n; i++) {
dist[i] = LLONG_MAX;
mindist[i] = LLONG_MAX;
}
long long int cnt = 0LL;
priority_queue<pair<long long, long long int>,
vector<pair<long long, long long int> >,
greater<pair<long long, long long int> > >
pq;
cin >> source;
dist[source] = 0;
from[source] = source;
bcc[make_pair(source, source)] = make_pair(0, 0LL);
vector<long long int> answ;
for (long long int i = 0; i < (long long int)adj[source].size(); i++) {
long long int dest = adj[source][i];
long long weit = bcc[make_pair(source, dest)].second;
if (dist[source] + weit < dist[dest]) {
dist[dest] = dist[source] + weit;
from[dest] = source;
pq.push(make_pair(dist[dest], dest));
}
}
cnt = 0;
while (pq.empty() == 0) {
pair<long long int, long long int> topp = pq.top();
pq.pop();
cnt++;
int source, dest;
long long weit;
source = topp.second;
for (long long int i = 0; i < (long long int)adj[source].size(); i++) {
dest = adj[source][i];
weit = bcc[make_pair(source, dest)].second;
if (dist[source] + weit < dist[dest]) {
dist[dest] = dist[source] + weit;
from[dest] = source;
pq.push(make_pair(dist[dest], dest));
mindist[dest] = weit;
} else if (dist[source] + weit == dist[dest] && mindist[dest] > weit) {
dist[dest] = dist[source] + weit;
from[dest] = source;
mindist[dest] = weit;
}
}
}
long long cost = 0;
for (long long int i = 1; i <= n; i++) {
if (i != source) {
answ.push_back(bcc[make_pair(i, from[i])].first);
cost += bcc[make_pair(i, from[i])].second;
}
}
cout << cost << "\n";
for (long long int i = 0; i < (long long int)edge.size(); i++) {
int u, v;
u = edge[i].first;
v = edge[i].second.first;
if (from[u] == v || from[v] == u) {
cout << i + 1LL << " ";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 3 * 1e5 + 100;
long long dis[MAXN], par[MAXN], a[MAXN], n, m, t, sum;
vector<pair<long long, long long> > adj[MAXN];
bool mark[MAXN];
set<pair<long long, long long> > s;
vector<long long> ans;
pair<long long, long long> pr;
map<pair<long long, long long>, long long> mp, np;
void Dij(long long x) {
a[t] = 0;
dis[x] = 0;
for (long long i = 1; i <= n; i++) {
s.insert(make_pair(dis[i], i));
}
while (s.size() > 0) {
pr = *s.begin();
long long y = pr.second;
long long d = pr.first;
s.erase(pr);
mark[y] = 1;
for (long long i = 0; i < adj[y].size(); i++) {
if (dis[adj[y][i].first] >= d + adj[y][i].second &&
a[adj[y][i].first] > adj[y][i].second) {
s.erase(make_pair(dis[adj[y][i].first], adj[y][i].first));
dis[adj[y][i].first] = d + adj[y][i].second;
s.insert(make_pair(dis[adj[y][i].first], adj[y][i].first));
par[adj[y][i].first] = y;
a[adj[y][i].first] = adj[y][i].second;
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
fill(par, par + MAXN, 1e18);
fill(dis, dis + MAXN, 1e18);
fill(a, a + MAXN, 1e18);
cin >> n >> m;
for (long long i = 1; i <= m; i++) {
long long x, y, w;
cin >> x >> y >> w;
adj[x].push_back(make_pair(y, w));
adj[y].push_back(make_pair(x, w));
mp[make_pair(x, y)] = i;
mp[make_pair(y, x)] = i;
np[make_pair(x, y)] = w;
np[make_pair(y, x)] = w;
}
cin >> t;
Dij(t);
for (long long i = 1; i <= n; i++) {
if (i != t) {
ans.push_back(mp[make_pair(i, par[i])]);
sum += (np[make_pair(i, par[i])]);
}
}
cout << sum << endl;
for (long long i = 0; i < ans.size(); i++) cout << ans[i] << " ";
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.