text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 300005;
const long long INF = 1LL << 60;
struct edge {
int u, v, w, id;
} e[MAX];
struct edge2 {
int to, w, next, id;
} e2[MAX * 2];
int n, m, ec, ec2, first[MAX], p[MAX];
long long d[MAX];
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
vector<int> r;
void dijkstra(int s) {
fill(d + 1, d + n + 1, INF);
d[s] = 0;
q.push(make_pair(0, s));
while (!q.empty()) {
pair<long long, int> x = q.top();
q.pop();
int u = x.second;
if (x.first != d[u]) continue;
for (int i = first[u]; i != -1; i = e2[i].next) {
int v = e2[i].to;
if (d[v] > x.first + e2[i].w) {
d[v] = x.first + e2[i].w;
q.push(make_pair(d[v], v));
}
}
}
}
inline void addedge(int u, int v, int w, int id) {
e2[ec2] = (edge2){v, w, first[u], id};
first[u] = ec2++;
}
int find(int x) { return p[x] == x ? x : p[x] = find(p[x]); }
bool cmp(edge a, edge b) {
return d[a.v] != d[b.v] ? d[a.v] < d[b.v] : a.w < b.w;
}
int main() {
memset(first, -1, sizeof(first));
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
addedge(u, v, w, i + 1);
addedge(v, u, w, i + 1);
}
int s;
scanf("%d", &s);
dijkstra(s);
for (int u = 1; u <= n; u++)
for (int i = first[u]; i != -1; i = e2[i].next) {
int v = e2[i].to;
if (d[u] + e2[i].w == d[v]) e[ec++] = (edge){u, v, e2[i].w, e2[i].id};
}
long long ans = 0;
for (int i = 1; i <= n; i++) p[i] = i;
sort(e, e + ec, cmp);
for (int i = 0; i < ec; i++) {
int x = find(e[i].u), y = find(e[i].v);
if (x != y) {
p[x] = y;
ans += e[i].w;
r.push_back(e[i].id);
}
}
printf("%I64d\n", ans);
for (int i = 0; i < r.size(); i++) printf("%d ", r[i]);
return 0;
}
|
#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 long long inf = 0x3f3f3f3f;
const int size = 300000;
class cmp {
public:
bool operator()(const pair<int, long long>& lhs,
const pair<int, long long>& rhs) const {
return lhs.second > rhs.second;
}
};
priority_queue<pair<int, long long>, vector<pair<int, long long> >, cmp> pq;
vector<pair<int, pair<long long, int> > > ve[size + 10];
vector<long long> res;
long long dist[size + 10];
bool vis[size + 10];
long long var[size + 10];
int flag[size + 10];
long long sum;
void dij(int st) {
while (!pq.empty()) {
pq.pop();
}
pq.emplace(st, 0LL);
while (!pq.empty()) {
auto now = pq.top();
pq.pop();
int u = now.first;
if (vis[u]) {
continue;
} else {
vis[u] = true;
}
if (u != st) {
sum += var[flag[u]];
res.push_back(flag[u]);
}
for (auto it : ve[u]) {
int v = it.first;
long long w = it.second.first;
int q = it.second.second;
if (!vis[v] && dist[v] >= dist[u] + w) {
dist[v] = dist[u] + w;
flag[v] = q;
pq.emplace(v, dist[v]);
}
}
}
}
int main() {
cin.sync_with_stdio(false);
int n, m;
while (cin >> n >> m) {
int u, v;
long long w;
for (int i = 0; i <= n; ++i) {
ve[i].clear();
}
for (int i = 1; i <= m; ++i) {
cin >> u >> v >> w;
var[i] = w;
ve[u].push_back(make_pair(v, make_pair(w, i)));
ve[v].push_back(make_pair(u, make_pair(w, i)));
}
int st;
cin >> st;
memset(dist, inf, sizeof(dist));
dist[st] = 0;
sum = 0;
res.clear();
dij(st);
cout << sum << endl;
for (auto it : res) {
cout << it << " ";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, S;
long long dis[300000 + 2];
int pre[300000 + 2];
bool vis[300000 + 2];
struct edge {
int from, to, dis;
};
vector<edge> E;
vector<int> G[300000 + 2];
vector<int> result;
void addedge(int from, int to, int dis) {
E.push_back((edge){from, to, dis});
E.push_back((edge){to, from, dis});
G[from].push_back((E).size() - 2);
G[to].push_back((E).size() - 1);
}
void SPFA() {
for (int i = 1; i <= n; i++) dis[i] = 0x7fffffffffffffff, vis[i] = 0;
dis[S] = 0, vis[S] = 1;
queue<int> Q;
Q.push(S);
while (!Q.empty()) {
int x = Q.front();
Q.pop();
vis[x] = 0;
for (int i = 0; i < (G[x]).size(); ++i) {
edge &e = E[G[x][i]];
if (dis[e.to] > dis[e.from] + e.dis) {
dis[e.to] = dis[e.from] + e.dis;
pre[e.to] = G[x][i];
if (!vis[e.to]) Q.push(e.to), vis[e.to] = 1;
} else if (dis[e.to] == dis[e.from] + e.dis) {
if (E[pre[e.to]].dis > e.dis) pre[e.to] = G[x][i];
}
}
}
long long ans = 0;
for (int i = 1; i <= n; i++)
if (i != S) ans += E[pre[i]].dis;
printf("%I64d\n", ans);
result.clear();
for (int i = 1; i <= n; i++)
if (i != S) result.push_back(pre[i]);
sort(result.begin(), result.end());
for (int i = 0; i < n - 1; ++i)
printf("%d ",
(result[i] & 1) ? (result[i] - 1) / 2 + 1 : result[i] / 2 + 1);
printf("\n");
}
void init() {
for (int i = 1; i <= n; i++) G[i].clear();
E.clear();
}
void solve() {
init();
for (int i = 1; i <= m; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
addedge(a, b, c);
}
scanf("%d", &S);
SPFA();
}
int main() {
while (~scanf("%d%d", &n, &m)) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b, c, s, edge[300005];
long long d[300005];
vector<vector<pair<int, int>>> adjList;
vector<int> weight, edgeList;
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
pq;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
adjList.resize(n + 5);
for (int i = 0; i < m; i++) {
cin >> a >> b >> c;
adjList[a].push_back({b, i});
adjList[b].push_back({a, i});
weight.push_back(c);
}
cin >> s;
for (int i = 1; i <= n; i++) {
d[i] = 1e18;
edge[i] = 1e9;
}
pq.push({0, s});
d[s] = 0;
edge[s] = 0;
while (!pq.empty()) {
int w = pq.top().first, u = pq.top().second;
pq.pop();
if (w > d[u]) {
continue;
}
for (int i = 0; i < adjList[u].size(); i++) {
pair<int, int> v = adjList[u][i];
if (d[u] + weight[v.second] < d[v.first]) {
d[v.first] = d[u] + weight[v.second];
edge[v.first] = v.second;
pq.push({d[v.first], v.first});
} else if (d[u] + weight[v.second] == d[v.first] &&
weight[edge[v.first]] > weight[v.second]) {
edge[v.first] = v.second;
}
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
if (i == s) {
continue;
}
ans += weight[edge[i]];
edgeList.push_back(edge[i]);
}
cout << ans << '\n';
for (int i = 0; i < edgeList.size(); i++) {
if (i) {
cout << " ";
}
cout << edgeList[i] + 1;
}
cout << '\n';
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;
long long n, m, st, dis[300005], used[300005], v1[300005], g[300005], null;
vector<pair<long long, pair<long long, long long> > > edge[300005];
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
q;
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
long long x, y, d;
cin >> x >> y >> d;
edge[x].push_back(make_pair(y, make_pair(d, i + 1)));
edge[y].push_back(make_pair(x, make_pair(d, i + 1)));
}
cin >> st;
q.push(make_pair(null, st));
for (int i = 1; i <= n; i++) dis[i] = 300000000000007, g[i] = 300000000000007;
dis[st] = 0;
while (!q.empty()) {
long long v, t;
v = q.top().second;
t = q.top().first;
q.pop();
for (int i = 0; i < edge[v].size(); i++) {
long long u = edge[v][i].first, d = edge[v][i].second.first;
if (dis[u] > dis[v] + d) {
dis[u] = dis[v] + d;
q.push(make_pair(dis[u], u));
g[u] = d;
v1[u] = edge[v][i].second.second;
} else if (dis[u] == dis[v] + d)
if (g[u] > d) g[u] = d, v1[u] = edge[v][i].second.second;
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
if (i != st) ans += g[i];
}
cout << ans << endl;
for (int i = 1; i <= n; i++) {
if (i != st) cout << v1[i] << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int target;
int weight;
int o;
};
struct vertice {
long long time;
int city;
int edge_ID;
int edge_W;
};
struct mysort {
bool operator()(const vertice &l, const vertice &r) {
if (l.time == r.time)
return l.edge_W < r.edge_W;
else
return l.time < r.time;
}
};
bool sort_pair(const pair<int, long long> &l, const pair<int, long long> &r) {
return l.first < r.first;
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<edge> > E(n + 1);
for (int i = 0; i < m; i++) {
edge a, b;
cin >> a.target >> b.target >> a.weight;
b.weight = a.weight;
a.o = b.o = i + 1;
E[a.target].push_back(b);
E[b.target].push_back(a);
}
vertice v;
cin >> v.city;
v.time = 0;
v.edge_ID = 0;
v.edge_W = 0;
vector<pair<int, long long> > used_edges;
vector<int> visited(n + 1, 0);
int counter = 0;
multiset<vertice, mysort> S;
S.insert(v);
while (counter < n) {
multiset<vertice, mysort>::iterator it = S.begin();
if (visited[it->city] == 0) {
visited[it->city] = 1;
counter++;
used_edges.push_back(pair<int, long long>(it->edge_ID, it->edge_W));
for (int i = 0; i < E[it->city].size(); i++) {
vertice c;
c.time = it->time + E[it->city][i].weight;
c.city = E[it->city][i].target;
c.edge_ID = E[it->city][i].o;
c.edge_W = E[it->city][i].weight;
S.insert(c);
}
}
S.erase(it);
}
sort(used_edges.begin(), used_edges.end(), sort_pair);
long long ans = 0;
for (int i = 1; i < used_edges.size(); i++) ans += used_edges[i].second;
cout << ans << endl;
for (int i = 1; i < used_edges.size(); i++)
cout << used_edges[i].first << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, pair<int, int> > > > adj;
int n, m;
int main() {
cin >> n >> m;
adj.resize(n + 1);
int u, v, w;
for (int i = 0; i < m; i++) {
cin >> u >> v >> w;
adj[u].push_back({w, {v, i + 1}});
adj[v].push_back({w, {u, i + 1}});
}
int st;
cin >> st;
priority_queue<pair<pair<long long, long long>, pair<long long, long long> > >
pq;
vector<bool> taken(n + 5, 0);
vector<int> res;
long long mst_cost = 0;
pq.push({{0, 0}, {st, 0}});
while (pq.size()) {
auto cur = pq.top();
pq.pop();
if (taken[cur.second.first]) continue;
taken[cur.second.first] = true;
if (cur.second.second) res.push_back(cur.second.second);
mst_cost -= cur.first.second;
for (auto v : adj[cur.second.first]) {
if (taken[v.second.first]) continue;
pq.push({{cur.first.first - v.first, -v.first},
{v.second.first, v.second.second}});
}
}
sort(res.begin(), res.end());
cout << mst_cost << '\n';
for (auto v : res) cout << v << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int f, s, idx;
};
long long dist[300001];
vector<edge> vec[300001];
int minedge[300001], antman[300001];
bitset<300001> vis;
void dijkstra(int a) {
dist[a] = 0;
set<pair<long long, int>> se;
se.insert({0, a});
while (!se.empty()) {
int r = se.begin()->second;
se.erase(se.begin());
if (vis[r]) continue;
vis[r] = true;
for (int i = 0; i < vec[r].size(); i++) {
int e = vec[r][i].f, q = vec[r][i].s;
if (dist[e] > dist[r] + q || (dist[e] == dist[r] + q && minedge[e] > q)) {
minedge[e] = q;
dist[e] = dist[r] + q;
antman[e] = vec[r][i].idx;
se.insert({dist[e], e});
}
}
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int x, y, a, b, c;
cin >> x >> y;
for (int i = 1; i <= x; i++) {
dist[i] = (long long)2e18;
minedge[i] = (int)2e9;
}
for (int i = 0; i < y; i++) {
cin >> a >> b >> c;
vec[a].push_back({b, c, i});
vec[b].push_back({a, c, i});
}
cin >> a;
dijkstra(a);
long long ans = 0;
for (int i = 1; i <= x; i++) {
if (i != a) ans += minedge[i];
}
cout << ans << endl;
for (int i = 1; i <= x; i++) {
if (i != a) cout << (antman[i] + 1) << ' ';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 0x3f3f3f3f3f3f3f3fll;
int N, M, S;
struct T_Edge {
int u, v, l;
T_Edge() {}
T_Edge(int u, int v, int l) : u(u), v(v), l(l) {}
inline int other(int x) { return x == u ? v : u; }
} es[300009];
vector<int> tab[300009];
long long dis[300009];
vector<int> ans;
int main() {
scanf("%d%d", &N, &M);
for (int i = 0; i < M; i++) {
scanf("%d%d%d", &es[i].u, &es[i].v, &es[i].l);
tab[es[i].u].push_back(i);
tab[es[i].v].push_back(i);
}
scanf("%d", &S);
memset(dis, 0x3f, sizeof(dis));
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
q.push(make_pair(0ll, S));
static bool used[300009];
memset(used, 0, sizeof(used));
while (!q.empty()) {
pair<long long, int> h = q.top();
q.pop();
int &u = h.second;
long long &d = h.first;
if (used[u]) continue;
dis[u] = d;
used[u] = true;
for (size_t i = 0; i < tab[u].size(); i++) {
T_Edge &e = es[tab[u][i]];
int v = e.other(u);
if (!used[v] && d + e.l < dis[v]) {
dis[v] = d + e.l;
q.push(make_pair(d + e.l, v));
}
}
}
long long weight = 0;
for (int u = 1; u <= N; u++)
if (u != S) {
pair<int, int> tans = make_pair(0x3f3f3f3f, 0);
for (size_t i = 0; i < tab[u].size(); i++) {
T_Edge &e = es[tab[u][i]];
int v = e.other(u);
if (dis[u] == dis[v] + e.l) tans = min(tans, make_pair(e.l, tab[u][i]));
}
weight += tans.first;
ans.push_back(tans.second);
}
printf("%I64d\n", weight);
if (ans.size()) {
for (size_t i = 0; i < ans.size(); i++) {
if (i != 0) printf(" ");
printf("%d", ans[i] + 1);
}
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)3e5 + 5;
bool res[N];
bool vis[N];
struct edge {
int f, to, w1;
long long w2;
int idx;
bool operator<(const edge &e) const {
if (w2 != e.w2) return w2 < e.w2;
return w1 < e.w1;
}
};
int n, m, u;
vector<multiset<edge>> g(N);
long long sm = 0;
void relax(edge &e) {
for (auto &it : g[e.to]) {
auto tmp = it;
if (!vis[tmp.to]) {
tmp.w2 += e.w2;
g[u].insert(tmp);
}
}
}
void solve() {
int edges = 0;
vis[u] = 1;
while (edges < n - 1) {
edge tmp = *g[u].begin();
g[u].erase(g[u].begin());
if (vis[tmp.to]) continue;
res[tmp.idx] = 1;
vis[tmp.to] = 1;
sm += tmp.w1;
++edges;
relax(tmp);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int f, t, w;
scanf("%d%d%d", &f, &t, &w);
g[f].insert({f, t, w, w, i + 1});
g[t].insert({t, f, w, w, i + 1});
}
scanf("%d", &u);
solve();
cout << sm << '\n';
for (int i = 1; i <= m; ++i)
if (res[i]) printf("%d ", i);
return 0;
}
|
#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()) {
while (pq.size()) {
u = pq.top().second, d = pq.top().first, pq.pop();
if (dist[u] < d) continue;
break;
}
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;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
vector<vector<vector<long long>>> g(n);
vector<vector<long long>> store(m);
for (long long i = 0; i < m; i++) {
long long a, b, c;
cin >> a >> b >> c;
--a;
b--;
g[a].push_back({b, c});
g[b].push_back({a, c});
store[i] = {a, b, c};
}
long long s;
cin >> s;
s--;
vector<long long> d(n, LONG_LONG_MAX);
vector<long long> parent(n), dd(n, LONG_LONG_MAX);
for (long long i = 0; i < n; i++) {
parent[i] = i;
}
d[s] = dd[s] = 0;
set<pair<long long, long long>> q;
q.insert({d[s], s});
while (!q.empty()) {
long long v = q.begin()->second;
q.erase(q.begin());
for (long long i = 0; i < g[v].size(); i++) {
long long to = g[v][i][0], len = g[v][i][1];
if (d[v] + len < d[to]) {
if (q.find({d[to], to}) != q.end()) {
q.erase({d[to], to});
}
parent[to] = v;
d[to] = d[v] + len;
dd[to] = len;
q.insert(make_pair(d[to], to));
} else if (d[v] + len == d[to]) {
if (dd[to] > len) {
dd[to] = len;
parent[to] = v;
}
}
}
}
long long ans = 0;
for (long long i = 0; i < n; i++) {
ans += dd[i];
}
cout << ans << endl;
for (long long i = 0; i < m; i++) {
long long a = store[i][0];
long long b = store[i][1];
if (parent[a] == b || parent[b] == a) {
cout << i + 1 << " ";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 600005;
const long long maxN = 1000000000000007;
int n, m, s, cs[maxn], u[maxn], v[maxn];
long long res, d[maxn], d1[maxn], c[maxn];
bool dau[maxn];
vector<int> G[maxn];
vector<long long> G1[maxn];
struct TNode {
int u;
long long c;
};
bool operator<(TNode a, TNode b) { return a.c > b.c; }
void Dijkstra() {
int i, v, u;
for (i = 1; i <= n; i++) d[i] = maxN, d1[i] = maxN;
d[s] = 0;
d1[s] = 0;
dau[s] = true;
priority_queue<TNode> q;
q.push((TNode){s, 0});
while (!q.empty()) {
TNode p = q.top();
q.pop();
u = p.u;
for (i = 0; i < G[u].size(); i++) {
v = G[u][i];
if (d[v] > d[u] + G1[u][i]) {
d[v] = d[u] + G1[u][i];
q.push((TNode){v, d[v]});
}
}
}
}
int main() {
int i;
cin >> n >> m;
for (i = 1; i <= m; i++) {
cin >> u[i] >> v[i] >> c[i];
G[u[i]].push_back(v[i]);
G[v[i]].push_back(u[i]);
G1[u[i]].push_back(c[i]);
G1[v[i]].push_back(c[i]);
}
cin >> s;
res = 0;
Dijkstra();
for (i = 1; i <= m; i++)
if (d[u[i]] - d[v[i]] == c[i]) {
if (d1[u[i]] > c[i]) d1[u[i]] = min(d1[u[i]], c[i]), cs[u[i]] = i;
} else if (d[v[i]] - d[u[i]] == c[i]) {
if (d1[v[i]] > c[i]) d1[v[i]] = min(d1[v[i]], c[i]), cs[v[i]] = i;
}
for (i = 1; i <= n; i++) res += d1[i];
cout << res << "\n";
for (i = 1; i <= n; i++)
if (cs[i] != 0) cout << cs[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300005;
struct graph_node {
long long next, to, va, num;
} graph[maxn * 2];
long long head[maxn], tot_len = 0;
void addedge(long long p1, long long p2, long long va, long long num) {
graph[tot_len].to = p2;
graph[tot_len].next = head[p1];
graph[tot_len].va = va;
graph[tot_len].num = num;
head[p1] = tot_len++;
}
struct NODE {
long long u, dis;
bool operator<(NODE a) const { return a.dis < dis; }
};
long long dis[maxn];
priority_queue<NODE> Q;
bool used[maxn];
void Dij(long long s) {
NODE h, p;
memset(dis, -1, sizeof(dis));
memset(used, false, sizeof(used));
h.u = s, dis[h.u] = h.dis = 0, Q.push(h);
while (!Q.empty()) {
h = Q.top(), Q.pop();
if (used[h.u]) continue;
used[h.u] = true;
for (long long k = head[h.u]; k != -1; k = graph[k].next)
if (dis[graph[k].to] == -1 ||
dis[graph[k].to] > dis[h.u] + (long long)graph[k].va) {
dis[graph[k].to] = dis[h.u] + (long long)graph[k].va;
p.u = graph[k].to;
p.dis = dis[graph[k].to];
Q.push(p);
}
}
}
queue<long long> ans;
long long res = 0;
struct len_node {
long long p1, p2, va, num;
} len[maxn];
bool operator<(const len_node &a, const len_node &b) {
long long t1 = max(dis[a.p1], dis[a.p2]);
long long t2 = max(dis[b.p1], dis[b.p2]);
if (t1 == t2)
return a.va < b.va;
else
return t1 < t2;
}
long long fa[maxn];
long long getfa(long long p) {
if (fa[p] == -1) return p;
fa[p] = getfa(fa[p]);
return fa[p];
}
int main() {
long long n, m;
cin >> n >> m;
memset(head, -1, sizeof(head));
for (long long i = 0; i < m; i++) {
long long p1, p2, va;
scanf("%I64d %I64d %I64d ", &p1, &p2, &va);
p1--, p2--;
len[i].p1 = p1;
len[i].p2 = p2;
len[i].va = va;
len[i].num = i + 1;
addedge(p1, p2, va, len[i].num);
addedge(p2, p1, va, len[i].num);
}
long long st;
cin >> st;
Dij(st - 1);
sort(len, len + m);
memset(fa, -1, sizeof(fa));
for (long long i = 0; i < m; i++) {
long long u = len[i].p1, v = len[i].p2;
if (dis[u] + (long long)len[i].va == dis[v] ||
dis[v] + (long long)len[i].va == dis[u]) {
if (getfa(u) == getfa(v)) continue;
fa[getfa(u)] = getfa(v);
res += (long long)len[i].va;
ans.push(len[i].num);
}
}
cout << res << endl;
if (n == 1) {
cout << endl;
return 0;
}
cout << ans.front();
ans.pop();
while (!ans.empty()) {
printf(" %I64d", ans.front());
ans.pop();
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
vector<vector<pair<long long, long long>>> g;
vector<vector<pair<long long, long long>>> par;
vector<long long> mindist;
long long n, m;
void dijkstra(long long source) {
mindist.assign(n, (long long)1e15);
mindist[source] = 0;
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
q;
q.emplace(0, source);
while (!q.empty()) {
pair<long long, long long> p = q.top();
q.pop();
long long u = p.second, dist = p.first;
if (mindist[u] < dist) continue;
for (pair<long long, long long>& e : g[u]) {
long long v = e.second, w = e.first;
if (mindist[v] > dist + w) {
par[v].clear();
par[v].push_back({w, u});
mindist[v] = dist + w;
q.emplace(mindist[v], v);
} else if (mindist[v] == dist + w) {
par[v].push_back({w, u});
}
}
}
}
map<pair<long long, long long>, long long> mp;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
g.assign(n, vector<pair<long long, long long>>());
par.assign(n, vector<pair<long long, long long>>());
for (long long i = 0; i < m; ++i) {
long long u, v, w;
cin >> u >> v >> w;
u--, v--;
mp[{min(u, v), max(u, v)}] = i + 1;
g[u].push_back({w, v});
g[v].push_back({w, u});
}
long long u;
cin >> u;
u--;
dijkstra(u);
long long ans = 0;
set<long long> edg;
for (long long j = 0; j < n; ++j) {
sort((par[j]).begin(), (par[j]).end());
if (j != u && par[j].size()) {
ans += par[j][0].first;
edg.insert(mp[{min(j, par[j][0].second), max(j, par[j][0].second)}]);
}
}
cout << ans << "\n";
for (long long e : edg) cout << e << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
template <typename T_container, typename T = typename enable_if<
!is_same<T_container, string>::value,
typename T_container::value_type>::type>
ostream &operator<<(ostream &os, const T_container &v) {
os << '{';
string sep;
for (const T &x : v) os << sep << x, sep = ", ";
return os << '}';
}
void dbg_out() { cerr << "\n"; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
vector<pair<long long, long long>> v[300001];
long long dist[300001];
long long par[300001];
map<pair<long long, long long>, long long> e;
map<pair<long long, long long>, long long> wt;
void dfs(long long node) {
for (auto &c : dist) c = 1e18;
dist[node] = 0;
set<pair<long long, long long>> second;
second.insert({0, node});
while (!second.empty()) {
long long vt = second.begin()->second;
second.erase(second.begin());
for (auto c : v[vt]) {
if (dist[c.first] > dist[vt] + c.second ||
(dist[c.first] == dist[vt] + c.second &&
c.second < wt[{c.first, par[c.first]}])) {
if (second.count({dist[c.first], c.first}))
second.erase({dist[c.first], c.first});
par[c.first] = vt;
dist[c.first] = dist[vt] + c.second;
second.insert({dist[c.first], c.first});
}
}
}
}
void solve() {
long long n, m;
cin >> n >> m;
long long second = 1;
while (m--) {
long long a, b, w;
cin >> a >> b >> w;
e[{a, b}] = e[{b, a}] = second;
wt[{a, b}] = wt[{b, a}] = w;
second++;
v[a].push_back({b, w});
v[b].push_back({a, w});
}
long long u;
cin >> u;
dfs(u);
vector<long long> ans;
long long tot = 0;
for (long long i = 1; i <= n; i++) {
if (i != u) {
ans.push_back(e[{i, par[i]}]);
tot += wt[{i, par[i]}];
}
}
cout << tot << "\n";
for (auto c : ans) cout << c << " ";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
pair<long long, vector<vector<pair<long long, long long> > > > Graph;
vector<pair<long long, long long> > x;
vector<long long> parent;
map<pair<long long, long long>, long long> mp;
map<pair<long long, long long>, long long> cst;
vector<long long> vt;
void dijikstra(long long src) {
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq;
long long sum = 0;
pair<long long, long long> P;
vector<long long> dist;
vector<long long> visited;
long long i, distance, v;
for (i = 0; i < Graph.first; i++) {
dist.push_back(999999999999999);
visited.push_back(0);
parent.push_back(-1);
}
pq.push(make_pair(0, src));
dist[src] = 0;
parent[src] = -1;
int f = 0;
while (!pq.empty()) {
long long u = pq.top().second;
long long dt = pq.top().first;
pq.pop();
if (visited[u] == 1)
continue;
else {
visited[u] = 1;
if (!f)
f = 1;
else {
long long y = parent[u];
if (y < u)
vt.push_back(cst[make_pair(y, u)]);
else
vt.push_back(cst[make_pair(u, y)]);
for (i = 0; i < Graph.second[u].size(); i++) {
if (Graph.second[u][i].first == y) {
sum += Graph.second[u][i].second;
break;
}
}
}
for (i = 0; i < Graph.second[u].size(); i++) {
v = Graph.second[u][i].first;
distance = Graph.second[u][i].second;
if (dist[v] >= dist[u] + distance) {
dist[v] = dist[u] + distance;
parent[v] = u;
pq.push(make_pair(dist[v], v));
}
}
}
}
cout << sum << "\n";
for (i = 0; i < vt.size(); i++) cout << vt[i] << " ";
}
int main() {
long long E, V, i, to, from, cost, src;
cin >> V >> E;
Graph.first = V;
for (i = 0; i < V; i++) Graph.second.push_back(x);
for (i = 0; i < E; i++) {
cin >> to >> from >> cost;
to--;
from--;
if (to < from) {
mp[make_pair(to, from)] = 0;
cst[make_pair(to, from)] = i + 1;
} else {
mp[make_pair(from, to)] = 0;
cst[make_pair(from, to)] = i + 1;
}
Graph.second[to].push_back(make_pair(from, cost));
Graph.second[from].push_back(make_pair(to, cost));
}
cin >> src;
src--;
dijikstra(src);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 3, M = 6e5 + 3;
int he[N], to[M], ne[M], e[N];
long long len[M], d[N];
bool b[N];
priority_queue<pair<long long, int> > q;
int main() {
int n, m, i, j, k, t = 1;
long long l;
scanf("%d%d", &n, &m);
while (m--) {
scanf("%d%d%lld", &j, &k, &l);
ne[++t] = he[j], to[t] = k, len[t] = l, he[j] = t;
ne[++t] = he[k], to[t] = j, len[t] = l, he[k] = t;
}
scanf("%d", &i), q.push({0, i}), memset(d, 9, sizeof d), d[i] = 0;
while (!q.empty()) {
i = q.top().second, q.pop();
if (b[i]) continue;
for (b[i] = 1, j = he[i]; j; j = ne[j])
if (d[k = to[j]] >= (l = d[i] + len[j])) {
d[k] = l, e[k] = j, q.push({-l, k});
}
}
for (l = 0, i = 1; i <= n; ++i) l += len[e[i]];
printf("%lld\n", l);
for (i = 1; i <= n; ++i)
if (e[i]) printf("%d ", e[i] / 2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
long long INF = 1e18;
int n, s;
vector<int> ans;
long long ansV = 0;
long long dis[N];
int edge[N], val[N];
vector<pair<int, int> > adj[N];
void solve() {
for (int i = 1; i <= n; i++) dis[i] = INF;
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
pq;
dis[s] = 0;
pq.push({dis[s], s});
while (!pq.empty()) {
int u = pq.top().second;
long long Cost = pq.top().first;
pq.pop();
if (Cost > dis[u]) continue;
if (u != s) {
ans.push_back(edge[u]);
ansV += val[edge[u]];
}
for (auto P : adj[u]) {
int v = P.first, idx = P.second;
if (Cost + val[idx] < dis[v]) {
dis[v] = Cost + val[idx];
edge[v] = idx;
pq.push({dis[v], v});
} else if (Cost + val[idx] == dis[v] && val[idx] < val[edge[v]])
edge[v] = idx;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v >> val[i];
adj[u].push_back({v, i});
adj[v].push_back({u, i});
}
cin >> s;
solve();
sort(ans.begin(), ans.end());
cout << ansV << endl;
for (auto v : ans) cout << v + 1 << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct comp {
inline bool operator()(const pair<int64_t, int64_t>& p1,
const pair<int64_t, int64_t>& p2) const {
if (p1.second != p2.second) return p1.second < p2.second;
return p1.first < p2.first;
}
};
void dijkstra(vector<vector<pair<int64_t, pair<int64_t, int64_t> > > >& edges,
vector<int64_t>& edgeWts, vector<int64_t>& dis,
vector<pair<int64_t, int64_t> >& par, vector<bool>& visited,
set<pair<int64_t, int64_t>, comp>& myset, vector<int64_t>& ans,
int64_t& sum) {
while (myset.size()) {
set<pair<int64_t, int64_t> >::iterator it = myset.begin();
pair<int64_t, int64_t> p = (*it);
myset.erase(it);
int64_t node = p.first;
if (par[node].second > -1) {
sum += edgeWts[par[node].second];
ans.push_back(par[node].second);
}
visited[node] = true;
for (int64_t i = 0; i < edges[node].size(); ++i) {
int64_t child = edges[node][i].first;
int64_t edgeWt = edges[node][i].second.first;
int64_t edgeId = edges[node][i].second.second;
if (!visited[child] && (dis[child] > dis[node] + edgeWt ||
(dis[child] == dis[node] + edgeWt &&
edgeWts[par[child].second] > edgeWt))) {
it = myset.find({child, dis[child]});
if (it != myset.end()) {
myset.erase(it);
}
dis[child] = dis[node] + edgeWt;
par[child] = {node, edgeId};
myset.insert({child, dis[child]});
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int64_t n, m;
cin >> n >> m;
vector<vector<pair<int64_t, pair<int64_t, int64_t> > > > edges(n + 1);
vector<int64_t> edgeWts(m + 1);
for (int64_t i = 0; i < m; ++i) {
int64_t x, y, w;
cin >> x >> y >> w;
edges[x].push_back({y, {w, i + 1}});
edges[y].push_back({x, {w, i + 1}});
edgeWts[i + 1] = w;
}
int64_t root;
cin >> root;
vector<bool> visited(n + 1, false);
vector<pair<int64_t, int64_t> > par(n + 1, {-1, -1});
vector<int64_t> dis(n + 1, 1000000000000000000);
dis[root] = 0;
set<pair<int64_t, int64_t>, comp> myset;
for (int64_t i = 1; i <= n; ++i) {
myset.insert({i, dis[i]});
}
vector<int64_t> ans;
int64_t sum = 0;
dijkstra(edges, edgeWts, dis, par, visited, myset, ans, sum);
cout << sum << endl;
for (int64_t i = 0; i < ans.size(); ++i) {
cout << ans[i] << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300005;
long long dis[MAXN], c1, ans;
bool vis[MAXN], inqq[MAXN], f[MAXN];
int s, t, q[MAXN], head, tail, tot, T, S, D, a1, b1, g[MAXN], aa[MAXN],
pre[MAXN], ll, m, n;
struct edges {
int to;
long long v;
int ki;
int next;
} e[800005];
void add_edge(int from, int to, long long v, int ki) {
e[++tot].to = to;
e[tot].v = v;
e[tot].next = g[from];
e[tot].ki = ki;
g[from] = tot;
return;
}
void cleans() {
for (int i = 0; i <= n; ++i) {
g[i] = 0;
vis[i] = false;
dis[i] = 1152921504606846976LL;
}
tot = 0;
head = 0;
tail = 0;
}
void spfa() {
q[++tail] = s;
dis[s] = 0;
vis[s] = true;
while (head != tail) {
head = head % 300001 + 1;
for (int i = g[q[head]]; i; i = e[i].next) {
if (dis[e[i].to] > dis[q[head]] + e[i].v) {
ans -= e[pre[e[i].to]].v;
ans += e[i].v;
pre[e[i].to] = i;
dis[e[i].to] = dis[q[head]] + e[i].v;
if (!vis[e[i].to]) {
tail = tail % 300001 + 1;
q[tail] = e[i].to;
vis[q[tail]] = true;
}
} else if (dis[e[i].to] == dis[q[head]] + e[i].v) {
if (e[pre[e[i].to]].v > e[i].v) {
ans -= e[pre[e[i].to]].v;
ans += e[i].v;
pre[e[i].to] = i;
}
}
}
vis[q[head]] = false;
}
return;
}
int main() {
scanf("%d %d", &n, &m);
cleans();
for (int i = 1; i <= m; ++i) {
scanf("%d %d %I64d", &a1, &b1, &c1);
add_edge(a1, b1, c1, i);
add_edge(b1, a1, c1, i);
}
scanf("%d", &s);
spfa();
for (int i = 1; i <= n; ++i) {
if (pre[i]) aa[++ll] = e[pre[i]].ki;
}
printf("%I64d\n", ans);
sort(aa + 1, aa + 1 + ll);
if (ll) {
printf("%d", aa[1]);
for (int i = 2; i <= ll; ++i) {
printf(" %d", aa[i]);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<signed long long int, signed long long int> > G[3 * 100000 + 5];
vector<signed long long int> E[3 * 100000 + 5];
int visited[3 * 100000 + 5];
signed long long int sp[300000 + 5];
priority_queue<pair<signed long long int, signed long long int> > Q;
signed long long int CE[300000 + 5], CW[300000 + 5];
int main() {
signed long long int S, a, b, w, N, M;
cin >> N >> M;
for (int i = 1; i <= M; ++i) {
cin >> a >> b >> w;
G[a].push_back(make_pair(b, w));
G[b].push_back(make_pair(a, w));
E[a].push_back(i);
E[b].push_back(i);
}
cin >> S;
for (int i = 1; i <= N; ++i) CW[i] = sp[i] = (1000000000000000LL);
sp[S] = 0;
Q.push(make_pair(0LL, S));
while (not Q.empty()) {
signed long long int d = -Q.top().first;
signed long long int v = Q.top().second;
Q.pop();
if (visited[v]) continue;
sp[v] = d;
visited[v] = 1;
for (int i = 0; i < G[v].size(); ++i) {
int u = G[v][i].first;
Q.push(make_pair(-d - G[v][i].second, u));
}
}
Q.push(make_pair(0LL, S));
while (not Q.empty()) {
signed long long int v = Q.top().second;
Q.pop();
if (visited[v] == 3) continue;
visited[v] = 3;
for (int i = 0; i < G[v].size(); ++i) {
signed long long int u = G[v][i].first;
signed long long int w = G[v][i].second;
if (visited[u] == 3) continue;
if (sp[v] + w == sp[u]) {
if (w < CW[u]) {
CW[u] = w;
CE[u] = E[v][i];
}
Q.push(make_pair(-sp[u], u));
}
}
}
signed long long int ans = 0;
for (int i = 1; i <= N; ++i) {
if (i == S) continue;
ans += CW[i];
}
cout << ans << endl;
for (int i = 1; i <= N; ++i) {
if (i == S) continue;
cout << CE[i] << ' ';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const int MAXN = 3000005;
vector<pair<int, int> > adj[MAXN];
vector<int> ids[MAXN];
int n;
vector<long long> dist;
int used[MAXN];
int mycost[MAXN];
struct mypair {
long long first;
int second;
mypair(long long x, long long y) : first(x), second(y) {}
};
bool operator<(const mypair& m1, const mypair& m2) {
if (m1.first < m2.first) return true;
if (m1.first == m2.first) return m1.second < m2.second;
return false;
}
void dijkstra(int s) {
long long huge = INF;
huge *= huge;
dist.assign(n + 1, huge);
set<mypair> q;
dist[s] = 0LL;
q.insert(mypair(0LL, s));
while (!q.empty()) {
mypair top = *q.begin();
q.erase(q.begin());
int v = top.second;
long long d = top.first;
for (int i = 0; i < (int)adj[v].size(); ++i) {
int v2 = adj[v][i].second;
int cost = adj[v][i].first;
if (dist[v2] > dist[v] + cost ||
((dist[v2] == dist[v] + cost) &&
(mycost[used[v2]] > mycost[ids[v][i]]))) {
if (dist[v2] != huge) q.erase(q.find(mypair(dist[v2], v2)));
dist[v2] = dist[v] + cost;
used[v2] = ids[v][i];
q.insert(mypair(dist[v2], v2));
}
}
}
}
int main() {
int m;
while (scanf(" %d %d", &n, &m) != EOF) {
for (int i = 0; i < n + 2; ++i) adj[i].clear(), ids[i].clear();
for (int i = 0; i < m; ++i) {
int u, v, w;
scanf(" %d %d %d", &u, &v, &w);
adj[u].push_back(pair<int, int>(w, v));
adj[v].push_back(pair<int, int>(w, u));
ids[u].push_back(i + 1);
ids[v].push_back(i + 1);
mycost[i + 1] = w;
}
int ini;
scanf(" %d", &ini);
for (int i = 0; i < n + 1; ++i) used[i] = -1;
dijkstra(ini);
long long res = 0LL;
for (int i = 1; i < n + 1; ++i)
if (used[i] != -1) res += mycost[used[i]];
printf("%lld\n", res);
for (int i = 1; i < n + 1; ++i)
if (used[i] != -1) printf("%d ", used[i]);
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
const long long inf = 1e18 + 1;
vector<pair<pair<int, int>, int>> G[maxn];
long long d[maxn];
int w[maxn];
bool used[maxn], v[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int a, b, c;
cin >> 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));
w[i] = c;
}
int u;
cin >> u;
fill(d, d + maxn, inf);
priority_queue<pair<pair<long long, int>, pair<int, int>>,
vector<pair<pair<long long, int>, pair<int, int>>>,
greater<pair<pair<long long, int>, pair<int, int>>>>
pq;
d[u] = 0;
pq.push(make_pair(make_pair(0, inf), make_pair(u, -1)));
while (pq.size()) {
auto p = pq.top();
pq.pop();
if (v[p.second.first]) continue;
v[p.second.first] = true;
if (p.second.second != -1) used[p.second.second] = true;
for (auto e : G[p.second.first]) {
if (d[e.first.first] >= p.first.first + e.first.second) {
d[e.first.first] = p.first.first + e.first.second;
pq.push(make_pair(make_pair(d[e.first.first], e.first.second),
make_pair(e.first.first, e.second)));
}
}
}
int edge = 0;
long long ans = 0;
for (int i = 0; i < m; ++i)
if (used[i]) ++edge, ans += w[i];
vector<int> un;
for (int i = 0; i < m; ++i) {
if (used[i])
continue;
else
un.push_back(i);
}
edge = n - 1 - edge;
sort(un.begin(), un.end(),
[](const int& a, const int& b) { return w[a] < w[b]; });
for (int i = 0; i < edge; ++i) ans += w[un[i]];
cout << ans << endl;
for (int i = 0; i < m; ++i)
if (used[i]) cout << i + 1 << ' ';
for (int i = 0; i < edge; ++i) cout << un[i] + 1 << ' ';
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool read(T &x) {
int c = getchar();
int sgn = 1;
while (~c && c<'0' | c> '9') {
if (c == '-') sgn = -1;
c = getchar();
}
for (x = 0; ~c && '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
x *= sgn;
return ~c;
}
struct debugger {
template <typename T>
debugger &operator,(const T &v) {
cerr << v << " ";
return *this;
}
} dbg;
template <class T>
void __stl_print__(T &x) {
cerr << "[";
for (__typeof((x).end()) i = (x).begin(); i != (x).end(); ++i)
cerr << (i != x.begin() ? ", " : "") << *i;
cerr << "]" << endl;
}
template <class T, class U>
inline T max(T &a, U &b) {
return a > b ? a : b;
}
template <class T, class U>
inline T min(T &a, U &b) {
return a < b ? a : b;
}
template <class T, class U>
inline T swap(T &a, U &b) {
T tmp = a;
a = b;
b = tmp;
}
const long long INF = (1ll) << 50;
const int mx = 3e5 + 7;
const int mod = 1000000007;
const double pi = 2 * acos(0.0);
int EQ(double d) {
if (fabs(d) < 1e-7) return 0;
return d > 1e-7 ? 1 : -1;
}
struct node {
int v, tt, id;
long long w;
node(int _v, long long _w, int _id, int _t) {
v = _v;
w = _w;
id = _id;
tt = _t;
}
bool operator<(const node &a) const {
if (w != a.w) return w > a.w;
return tt > a.tt;
}
};
vector<node> adj[mx];
vector<int> ans;
priority_queue<node> q;
bool flag[mx];
int wh[mx];
int main() {
int n = ({
int a;
read(a);
a;
}),
m = ({
int a;
read(a);
a;
});
for (__typeof((m)-1) i = (0); i <= ((m)-1); ++i) {
int u = ({
int a;
read(a);
a;
}),
v = ({
int a;
read(a);
a;
}),
w = ({
int a;
read(a);
a;
});
adj[u].push_back(node(v, w, i + 1, w));
adj[v].push_back(node(u, w, i + 1, w));
wh[i + 1] = w;
}
int u = ({
int a;
read(a);
a;
});
for (__typeof((adj[u]).end()) it = (adj[u]).begin(); it != (adj[u]).end();
++it) {
q.push(*it);
}
int edge = 0;
long long tot = 0;
flag[u] = 1;
while (edge < n - 1) {
node tmp = q.top();
q.pop();
if (flag[tmp.v]) continue;
flag[tmp.v] = 1;
edge++;
tot += wh[tmp.id];
ans.push_back(tmp.id);
for (__typeof((adj[tmp.v]).end()) it = (adj[tmp.v]).begin();
it != (adj[tmp.v]).end(); ++it) {
q.push(node((*it).v, (*it).w + tmp.w, (*it).id, (*it).w));
}
}
cout << tot << endl;
for (__typeof((ans).end()) it = (ans).begin(); it != (ans).end(); ++it)
cout << *it << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, z, nu, fx, fy;
struct node {
int p, f, id;
};
struct node2 {
int x, y, z;
} a[310000];
bool cmp(node2 a, node2 b) { return a.z < b.z; }
long long ans = 0;
vector<node> e[310000];
int fa[310000], b[310000], dis[310000];
queue<int> q;
long long f[310000];
bool v[310000];
int get(int x) {
if (x == fa[x]) return x;
return fa[x] = get(fa[x]);
}
void spfa() {
for (int i = 1; i <= n; i++) f[i] = 100000000000000000LL, v[i] = false;
f[nu] = 0;
q.push(nu);
while (!q.empty()) {
x = q.front();
q.pop();
v[x] = false;
for (int i = 0; i < e[x].size(); i++) {
y = e[x][i].p, z = e[x][i].f;
if (f[x] + z < f[y]) {
f[y] = f[x] + z;
if (!v[y]) {
v[y] = true;
q.push(y);
}
}
}
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d %d", &a[i].x, &a[i].y, &a[i].z);
e[a[i].x].push_back(node{a[i].y, a[i].z, i});
e[a[i].y].push_back(node{a[i].x, a[i].z, i});
}
scanf("%d", &nu);
spfa();
for (int i = 1; i <= n; i++)
if (i != nu) {
int w = 2 * 1e9, wid = 0;
for (int j = 0; j < e[i].size(); j++) {
y = e[i][j].p;
z = e[i][j].f;
if (f[y] + z == f[i]) {
if (z < w) {
w = z;
wid = e[i][j].id;
}
}
}
ans += w;
b[wid] = 1;
}
cout << ans << endl;
for (int i = 1; i <= m; i++)
if (b[i] == 1) printf("%d ", i);
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool cmp(T a, T b) {
if (a.first != b.first) return a.first < b.first;
return a.second < b.second;
}
struct pair_hash {
template <class T1, class T2>
size_t operator()(const pair<T1, T2> &pair) const {
return hash<T1>()(pair.first) ^ hash<T2>()(pair.second);
}
};
int n, m, temp, f, x, y;
long long int d;
bool complete[(int)3e5 + 10];
vector<vector<pair<long long int, int> > > adj((int)3e5 + 10);
multiset<pair<long long int, int> > s;
vector<long long int> minpath((int)3e5 + 10, (long long int)1e17 + 10);
vector<int> parent((int)3e5 + 10);
long long int acount = 0;
map<pair<int, int>, pair<int, long long int> > mi;
vector<int> ans;
void dijkstra(int u) {
for (int i = 0; i < adj[u].size(); i++) {
if (complete[adj[u][i].second]) continue;
if (minpath[adj[u][i].second] >= minpath[u] + adj[u][i].first) {
parent[adj[u][i].second] = u;
s.erase(s.find(make_pair(minpath[adj[u][i].second], adj[u][i].second)));
minpath[adj[u][i].second] = minpath[u] + adj[u][i].first;
s.insert(make_pair(minpath[adj[u][i].second], adj[u][i].second));
}
}
if (!s.empty()) {
temp = s.begin()->second;
complete[temp] = 1;
acount +=
mi[make_pair(min(temp, parent[temp]), max(temp, parent[temp]))].second;
ans.push_back(
mi[make_pair(min(temp, parent[temp]), max(temp, parent[temp]))].first);
s.erase(s.begin());
dijkstra(temp);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset(complete, 0, sizeof(complete));
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> x >> y >> d;
adj[x].push_back(make_pair(d, y));
adj[y].push_back(make_pair(d, x));
mi[make_pair(min(x, y), max(x, y))] = make_pair(i + 1, d);
}
cin >> f;
for (int i = 1; i <= n; i++)
if (i != f) s.insert(make_pair((long long int)1e17 + 10, i));
parent[f] = f;
minpath[f] = 0;
complete[f] = 1;
dijkstra(f);
sort(ans.begin(), ans.end());
cout << acount << "\n";
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
return 0;
}
|
#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() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
for (int i = 1; i <= t; i++) solve(i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, n2, x, y, c, u, v, ans, i, len;
cin >> n >> n2;
vector<long long> d(n, 1e18 + 7), pred(n, -1), upc(n, 0);
vector<pair<long long, long long> > reb;
vector<vector<pair<long long, long long> > > g(n);
for (i = 0; i < n2; i++) {
scanf("%lld", &x);
scanf("%lld", &y);
scanf("%lld", &c);
x--;
y--;
g[x].push_back({y, c});
g[y].push_back({x, c});
reb.push_back({x, y});
}
cin >> v;
v--;
d[v] = 0;
set<pair<long long, long long> > s;
s.insert({d[v], v});
u = v;
for (i = 0; i < n; i++) {
v = s.begin()->second;
s.erase(s.begin());
for (auto j : g[v]) {
len = d[v] + j.second;
if (d[j.first] > len) {
s.erase({d[j.first], j.first});
d[j.first] = len;
upc[j.first] = j.second;
pred[j.first] = v;
s.insert({d[j.first], j.first});
} else {
if (d[j.first] == len) {
if (upc[j.first] > j.second) {
pred[j.first] = v;
upc[j.first] = j.second;
}
}
}
}
}
ans = 0;
for (i = 0; i < n; i++) {
ans += upc[i];
}
printf("%lld\n", ans);
for (i = 0; i < n2; i++) {
if (reb[i].first == pred[reb[i].second] ||
reb[i].second == pred[reb[i].first])
printf("%lld ", i + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3 * 1e5 + 5;
const long long oo = 1e18;
array<int, 3> E[N];
long long f[N], g[N], to[N];
vector<int> ke[N];
void dij(int n) {
int s;
cin >> s;
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
h;
for (int i = 1; i <= n; ++i) f[i] = oo;
h.push({f[s] = 0, s});
while (!h.empty()) {
int u = h.top().second;
long long s = h.top().first;
h.pop();
if (s != f[u]) continue;
for (int j : ke[u]) {
array<int, 3> e = E[j];
int v = e[0] + e[1] - u, w = e[2];
if (s + w < f[v]) {
h.push({f[v] = s + w, v});
g[to[v]] = 0;
g[to[v] = j] = 1;
} else if (s + w == f[v] && w < E[to[v]][2])
g[to[v]] = false, g[to[v] = j] = true;
}
}
}
void solve() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
for (int j = 0; j <= 2; ++j) cin >> E[i][j];
ke[E[i][0]].push_back(i);
ke[E[i][1]].push_back(i);
}
dij(n);
long long s = 0;
for (int i = 1; i <= m; ++i) s += g[i] * E[i][2];
cout << s << "\n";
for (int i = 1; i <= m; ++i)
if (g[i]) cout << i << " ";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > ed[300005];
int n, m;
int pa[300005];
long long int vis[300005];
void solve() {
cin >> n >> m;
long long int u;
long long ww[m], pre[n + 1];
pair<long long, long long> edg[m];
for (int i = 0; i < m; i++) {
long long int u, v, w;
cin >> u >> v >> w;
ed[u].push_back(pair<long long, long long>(v, w));
ed[v].push_back(pair<long long, long long>(u, w));
edg[i] = pair<long long, long long>(u, v);
ww[i] = w;
}
cin >> u;
priority_queue<pair<long long, long long> > pq;
long long d[n + 1];
for (int i = 0; i < n; i++) pre[i + 1] = d[i + 1] = 1e18 + 1;
d[u] = 0;
pre[u] = 0;
pq.push(pair<long long, long long>(0, u));
while (!pq.empty()) {
pair<long long, long long> p = pq.top();
pq.pop();
if (vis[p.second]) continue;
vis[p.second] = 1;
for (pair<long long, long long> j : ed[p.second]) {
if (vis[j.first]) continue;
if (d[j.first] > j.second - p.first) {
d[j.first] = j.second - p.first;
pa[j.first] = p.second;
pre[j.first] = j.second;
pq.push(pair<long long, long long>(-d[j.first], j.first));
} else if (d[j.first] == j.second - p.first && j.second < pre[j.first]) {
pa[j.first] = p.second;
pre[j.first] = j.second;
}
}
}
vector<int> res;
long long wt = 0;
for (int i = 0; i < m; i++) {
long long u, v;
u = edg[i].first;
v = edg[i].second;
if (u == pa[v] || pa[u] == v) {
wt += ww[i];
res.push_back(i + 1);
}
}
cout << wt << "\n";
for (int i : res) cout << i << " ";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10, M = 6e5 + 10;
int T, n, m, s, t = 1, b[M], pre[N];
long long dis[N], ans = 0;
bool v[N];
struct edge {
int nxt, y, v;
} a[M];
inline int read() {
int sum = 0, fg = 1;
char c;
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') fg = -1;
for (; c >= '0' && c <= '9'; c = getchar())
sum = (sum << 3) + (sum << 1) + c - '0';
return sum * fg;
}
inline void add(int x, int y, int v) {
a[++t] = (edge){b[x], y, v};
b[x] = t;
return;
}
inline void dijkstra(int s) {
priority_queue<pair<long long, int> > q;
memset(dis, 127, sizeof(dis));
memset(pre, 0, sizeof(pre));
memset(v, 0, sizeof(v));
q.push(make_pair(0, s));
dis[s] = 0;
while (!q.empty()) {
int x = q.top().second;
q.pop();
if (v[x]) continue;
v[x] = 1;
for (int i = b[x]; i; i = a[i].nxt) {
int y = a[i].y;
if (dis[y] > dis[x] + a[i].v) {
dis[y] = dis[x] + a[i].v;
pre[y] = i;
q.push(make_pair(-dis[y], y));
} else if (dis[y] == dis[x] + a[i].v && a[i].v < a[pre[y]].v)
pre[y] = i;
}
}
return;
}
int main() {
n = read(), m = read();
for (int i = 1; i <= m; ++i) {
int x = read(), y = read(), v = read();
add(x, y, v);
add(y, x, v);
}
s = read();
dijkstra(s);
for (int i = 1; i <= n; ++i)
if (i ^ s) ans += a[pre[i]].v;
printf("%lld\n", ans);
for (int i = 1; i <= n; ++i)
if (i ^ s) printf("%d ", pre[i] >> 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int f, s, idx;
};
long long dist[300001];
vector<edge> vec[300001];
int minedge[300001], antman[300001];
void dijkstra(int a) {
dist[a] = 0;
set<pair<long long, int>> se;
se.insert({0, a});
while (!se.empty()) {
int r = se.begin()->second;
se.erase(se.begin());
for (int i = 0; i < vec[r].size(); i++) {
int e = vec[r][i].f, q = vec[r][i].s;
if (dist[e] > dist[r] + q || (dist[e] == dist[r] + q && minedge[e] > q)) {
se.erase({dist[e], e});
minedge[e] = q;
dist[e] = dist[r] + q;
antman[e] = vec[r][i].idx;
se.insert({dist[e], e});
}
}
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int x, y, a, b, c;
cin >> x >> y;
for (int i = 1; i <= x; i++) {
dist[i] = (long long)2e18;
minedge[i] = (int)2e9;
}
for (int i = 0; i < y; i++) {
cin >> a >> b >> c;
vec[a].push_back({b, c, i});
vec[b].push_back({a, c, i});
}
cin >> a;
dijkstra(a);
long long ans = 0;
for (int i = 1; i <= x; i++) {
if (i != a) ans += minedge[i];
}
cout << ans << endl;
for (int i = 1; i <= x; i++) {
if (i != a) cout << (antman[i] + 1) << ' ';
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int from, to, idx;
long long cost;
Node(int _f, int _t, long long _c, int _x)
: from(_f), to(_t), cost(_c), idx(_x) {}
};
const int MAX_N = 300050;
int head[MAX_N], nt[MAX_N * 2], pnt[MAX_N * 2], wei[MAX_N * 2];
int ptr;
void addedge(int u, int v, int w) {
nt[ptr] = head[u];
head[u] = ptr;
pnt[ptr] = v;
wei[ptr++] = w;
nt[ptr] = head[v];
head[v] = ptr;
pnt[ptr] = u;
wei[ptr++] = w;
}
bool operator<(const Node& a, const Node& b) {
if (a.cost != b.cost)
return a.cost > b.cost;
else
return wei[a.idx] > wei[b.idx];
}
int main() {
int n, m, u, v, to, root, w;
ptr = 0;
memset(head, -1, sizeof head);
scanf("%d %d", &n, &m);
for (int i = 0; i < m; ++i) {
scanf("%d %d %d", &u, &v, &w);
--u;
--v;
addedge(u, v, w);
}
scanf("%d", &root);
--root;
vector<bool> visited(n, false);
priority_queue<Node> q;
q.push(Node(root, root, 0, -1));
vector<long long> dis(n);
long long total = 0;
vector<int> res;
for (int i = 0; i < n; ++i) {
while (true) {
Node node = q.top();
q.pop();
if (visited[node.to]) continue;
if (node.idx >= 0) {
res.push_back(node.idx / 2);
total += wei[node.idx];
}
v = node.to;
dis[v] = node.cost;
visited[v] = true;
for (int j = head[v]; j != -1; j = nt[j]) {
to = pnt[j];
if (visited[to]) continue;
q.push(Node(v, to, dis[v] + wei[j], j));
}
break;
}
}
cout << total << endl;
for (int i = 0; i < n - 1; ++i) printf("%d ", res[i] + 1);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300000, MAXM = 300000;
const long long oo = 1000000000000000009ll;
int n, m, a[MAXM * 2 + 9], b[MAXM * 2 + 9], c[MAXM * 2 + 9], start,
par[MAXN + 9];
long long dist[MAXN + 9], ans;
vector<int> adj[MAXN + 9];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> a[i] >> b[i] >> c[i];
a[i + m] = b[i];
b[i + m] = a[i];
c[i + m] = c[i];
adj[a[i]].push_back(i);
adj[b[i]].push_back(i + m);
}
cin >> start;
fill(dist, dist + n + 1, oo);
dist[start] = 0;
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
pq;
pq.push(make_pair(0, start));
while (!pq.empty()) {
long long d = pq.top().first;
int x = pq.top().second;
pq.pop();
if (d > dist[x]) {
continue;
}
for (int i = 0; i < adj[x].size(); i++) {
int id = adj[x][i];
if (d + c[id] < dist[b[id]]) {
dist[b[id]] = d + c[id];
par[b[id]] = id;
pq.push(make_pair(dist[b[id]], b[id]));
} else if (d + c[id] == dist[b[id]] && c[id] < c[par[b[id]]]) {
par[b[id]] = id;
}
}
}
ans = 0;
for (int i = 1; i <= n; i++) {
ans += c[par[i]];
}
cout << ans << "\n";
for (int i = 1; i <= n; i++) {
if (i != start) {
if (par[i] <= m) {
cout << par[i] << " ";
} else {
cout << par[i] - m << " ";
}
}
}
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = (1LL << 60);
vector<pair<int, pair<int, int>>> g[300005];
long long res;
int e[300005], c[300005];
int main() {
int n, m, u, v, w, st;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &u, &v, &w);
c[i] = w;
g[u].push_back(make_pair(v, make_pair(w, i)));
g[v].push_back(make_pair(u, make_pair(w, i)));
}
scanf("%d", &st);
vector<long long> d(n + 1, INF);
d[st] = 0;
set<pair<long long, int>> q;
q.insert(make_pair(d[st], st));
while (!q.empty()) {
int v = q.begin()->second;
q.erase(q.begin());
for (int j = 0; j < g[v].size(); j++) {
int to = g[v][j].first, cost = g[v][j].second.first;
if (d[v] + cost < d[to] || (d[v] + cost == d[to] && cost < c[e[to]])) {
e[to] = g[v][j].second.second;
q.erase(make_pair(d[to], to));
d[to] = d[v] + cost;
q.insert(make_pair(d[to], to));
}
}
}
for (int i = 1; i <= n; i++)
if (e[i] > 0) res += c[e[i]];
printf("%I64d\n", res);
for (int i = 1; i <= n; i++)
if (e[i] > 0) printf("%d ", e[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 300005;
const int MaxM = 300005;
const long long INF = 1000000000000000LL;
struct Node {
int id;
long long val;
Node(int a = 0, long long b = 0) {
id = a;
val = b;
}
bool operator<(const Node &b) const { return val > b.val; }
};
struct Edge {
int next, to;
long long cost;
int id;
};
Edge E[MaxM * 2];
int head[MaxN], Ecou;
void init() {
memset(head, -1, sizeof(head));
Ecou = 0;
}
void addEdge(int u, int v, long long cost, int d) {
E[Ecou].cost = cost;
E[Ecou].id = d;
E[Ecou].next = head[u];
E[Ecou].to = v;
head[u] = Ecou++;
}
bool vis[MaxN];
void Dijkstra(long long lowcost[], int n, int start) {
priority_queue<Node> que;
Node temp;
int u, v;
for (int i = 1; i <= n; ++i) {
lowcost[i] = INF;
vis[i] = 0;
}
lowcost[start] = 0;
que.push(Node(start, 0));
while (!que.empty()) {
temp = que.top();
que.pop();
u = temp.id;
if (vis[u]) continue;
vis[u] = 1;
for (int i = head[u]; i != -1; i = E[i].next) {
v = E[i].to;
if (!vis[v] && lowcost[v] > lowcost[u] + E[i].cost) {
lowcost[v] = lowcost[u] + E[i].cost;
que.push(Node(v, lowcost[v]));
}
}
}
}
int ans[MaxN];
int Eu[MaxM], Ev[MaxM];
long long Ec[MaxM];
long long lowcost[MaxN];
int main() {
int n, m;
int a, b;
long long c;
ios::sync_with_stdio(false);
cin >> n >> m;
init();
for (int i = 1; i <= m; ++i) {
cin >> a >> b >> c;
addEdge(a, b, c, i);
addEdge(b, a, c, i);
Eu[i] = a;
Ev[i] = b;
Ec[i] = c;
}
cin >> a;
Dijkstra(lowcost, n, a);
for (int i = 1; i <= n; ++i) ans[i] = -1;
long long sum = 0;
for (int i = 1; i <= m; ++i)
if (lowcost[Eu[i]] + Ec[i] == lowcost[Ev[i]]) {
if (ans[Ev[i]] == -1 || Ec[ans[Ev[i]]] > Ec[i]) ans[Ev[i]] = i;
} else if (lowcost[Ev[i]] + Ec[i] == lowcost[Eu[i]]) {
if (ans[Eu[i]] == -1 || Ec[ans[Eu[i]]] > Ec[i]) ans[Eu[i]] = i;
}
for (int i = 1; i <= n; ++i)
if (i != a) sum += Ec[ans[i]];
cout << sum << endl;
for (int i = 1; i <= n; ++i)
if (i != a) cout << ans[i] << ' ';
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 300010;
const long long INF = ~0uLL >> 1;
using namespace std;
set<long long> si;
long long d[MAXN];
int p[MAXN];
bool vis[MAXN];
int n, m;
struct HeapNode {
long long d;
int u;
bool operator<(const HeapNode& rhs) const { return d > rhs.d; }
};
struct Edge {
int to, next;
long long w;
int id;
} edge[MAXN << 1];
int head[MAXN], tot;
void init() {
tot = 0;
memset(head, 0xff, sizeof(head));
}
void addedge(int u, int v, long long w, int id) {
edge[tot].to = v;
edge[tot].w = w;
edge[tot].id = id;
edge[tot].next = head[u];
head[u] = tot++;
}
void dijkstra(int s) {
priority_queue<HeapNode> q;
for (int i = 1; i <= n; ++i) d[i] = INF;
d[s] = 0;
memset(vis, false, sizeof(vis));
memset(p, 0xff, sizeof(p));
q.push((HeapNode){0, s});
while (!q.empty()) {
HeapNode x = q.top();
q.pop();
int u = x.u;
if (vis[u]) continue;
vis[u] = 1;
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].to;
long long w = edge[i].w;
if (d[v] > d[u] + w) {
d[v] = d[u] + w;
p[v] = i;
q.push((HeapNode){d[v], v});
} else if (d[v] == d[u] + w && edge[p[v]].w > w) {
p[v] = i;
}
}
}
}
void print(int s) {
long long ans = 0;
for (int i = 1; i <= n; ++i) {
if (p[i] >= 0) ans += edge[p[i]].w;
}
cout << ans << endl;
for (int i = 1; i <= n; ++i) {
if (p[i] >= 0) si.insert(edge[p[i]].id);
}
for (__typeof((si).begin()) i = (si).begin(); i != (si).end(); ++i) {
printf("%d ", *i);
}
puts("");
}
int main() {
int u, v, s;
long long w;
scanf("%d%d", &n, &m);
init();
for (int i = 1; i <= m; ++i) {
scanf("%d%d%I64d", &u, &v, &w);
addedge(u, v, w, i);
addedge(v, u, w, i);
}
scanf("%d", &s);
dijkstra(s);
print(s);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Point {
int node, number;
long long cost, edge;
Point(int n, long long c, long long e, int nu)
: node(n), cost(c), edge(e), number(nu) {}
bool operator<(const Point &x) const {
if (x.cost != cost) return cost > x.cost;
return edge > x.edge;
}
};
int p[3 * (int(1e5) + 10)], n, m;
long long d[3 * (int(1e5) + 10)];
vector<Point> G[3 * (int(1e5) + 10)];
bool seen[3 * (int(1e5) + 10)];
vector<int> ans;
long long w;
void solve(int u) {
priority_queue<Point> q;
q.push(Point(u, 0, 0, 0));
d[u] = 0;
while (!q.empty()) {
int cur = q.top().node;
long long dist = q.top().cost;
int num = q.top().number;
int v = q.top().edge;
q.pop();
if (seen[cur]) continue;
seen[cur] = true;
w = (long long)w + (long long)v;
ans.push_back(num);
for (int i = 0; i < G[cur].size(); i++) {
int next = G[cur][i].node;
long long ndist = dist + G[cur][i].cost;
int val = G[cur][i].edge;
int numb = G[cur][i].number;
if (d[next] >= ndist) {
d[next] = ndist;
q.push(Point(next, ndist, val, numb));
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n + 3; i++) d[i] = LONG_LONG_MAX / 6;
;
int from, to;
long long cost;
for (int i = 1; i <= m; i++) {
cin >> from >> to >> cost;
G[from].push_back(Point(to, cost, cost, i));
G[to].push_back(Point(from, cost, cost, i));
}
cin >> m;
solve(m);
cout << w << "\n";
for (int i = 1; i < ans.size(); i++) {
cout << ans[i] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100 * 1000 * 3 + 100;
const long long INF = 1LL << 61;
vector<pair<int, int>> graph[N];
long long dist[N];
int prev_node[N];
long long prev_node_weight[N];
void dijkstra(int start) {
for (int i = 0; i < (N); i++) {
dist[i] = INF;
prev_node_weight[i] = INF;
prev_node[i] = -1;
}
auto comp = [](const int& x, const int& y) {
if (dist[x] != dist[y]) return dist[x] < dist[y];
return x < y;
};
auto Q = set<int, decltype(comp)>(comp);
dist[start] = 0;
Q.insert(start);
while (Q.size()) {
int u = *Q.begin();
Q.erase(Q.begin());
for (auto& neigh : graph[u]) {
auto c = neigh.second;
auto v = neigh.first;
if (dist[v] > dist[u] + c) {
auto it = Q.find(v);
if (it != Q.end()) Q.erase(it);
dist[v] = dist[u] + c;
Q.insert(v);
}
if (dist[v] == dist[u] + c and prev_node_weight[v] > c) {
prev_node[v] = u;
prev_node_weight[v] = c;
}
}
}
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
vector<pair<int, int>> edges;
for (int i = 0; i < (m); i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
graph[a].push_back({b, c});
graph[b].push_back({a, c});
edges.push_back({a, b});
}
int u;
scanf("%d", &u);
dijkstra(u);
long long int total_dist = 0;
for (int i = 0; i < (n + 1); i++)
if (prev_node_weight[i] != INF) total_dist += prev_node_weight[i];
printf("%lld\n", total_dist);
for (int i = 0; i < m; i++)
if (prev_node[edges[i].first] == edges[i].second or
prev_node[edges[i].second] == edges[i].first)
printf("%d ", i + 1);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 312345;
const long long INFTY = 0x3f3f3f3f3f3f3f3fLL;
long long dist[MAXN][2];
int idpai[MAXN], N;
bool mrk[MAXN];
vector<int> resp;
vector<pair<pair<int, int>, int> > grafo[MAXN];
set<pair<long long, int> > s;
void dijkstra(int u) {
s.insert(make_pair(dist[u][0], u));
for (int i = 1; i <= N; i++) {
if (i == u) continue;
dist[i][0] = dist[i][1] = INFTY;
s.insert(make_pair(dist[i][0], i));
}
for (int q = 1; q <= N; q++) {
int v = s.begin()->second;
mrk[v] = true;
s.erase(s.begin());
int tam = grafo[v].size();
for (int i = 0; i < tam; i++) {
int w = grafo[v][i].first.first, p = grafo[v][i].second;
int id = grafo[v][i].first.second;
if (!mrk[w]) {
if (dist[w][0] > dist[v][0] + p ||
(dist[w][0] == dist[v][0] + p && dist[w][1] > p)) {
s.erase(make_pair(dist[w][0], w));
dist[w][0] = dist[v][0] + p;
dist[w][1] = p;
idpai[w] = id;
s.insert(make_pair(dist[w][0], w));
}
}
}
}
}
int main() {
int M, a, b, c, u;
scanf("%d %d", &N, &M);
for (int i = 1; i <= M; i++) {
scanf("%d %d %d", &a, &b, &c);
grafo[a].push_back(make_pair(make_pair(b, i), c));
grafo[b].push_back(make_pair(make_pair(a, i), c));
}
scanf("%d", &u);
dijkstra(u);
long long sum = 0LL;
for (int i = 1; i <= N; i++) {
if (i == u) continue;
resp.push_back(idpai[i]);
sum += dist[i][1];
}
int tam = resp.size();
printf("%I64d\n", sum);
for (int i = 0; i < tam; i++) printf("%d ", resp[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 4000000000000000;
int main() {
int N;
scanf("%d", &N);
vector<vector<pair<long long, long long> > > edges(N);
int M;
scanf("%d", &M);
map<pair<long long, long long>, int> index;
for (int j = 1; j < M + 1; j++) {
int first, second, dist;
scanf("%d%d%d", &first, &second, &dist);
edges[first - 1].push_back(make_pair(dist, second - 1));
edges[second - 1].push_back(make_pair(dist, first - 1));
index[pair<long long, long long>(first - 1, second - 1)] = j;
index[pair<long long, long long>(second - 1, first - 1)] = j;
}
int s;
scanf("%d", &s);
s--;
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
Q;
vector<long long> dist(N, INF), dad(N, -1);
Q.push(make_pair(0, s));
dist[s] = 0;
while (!Q.empty()) {
pair<long long, long long> p = Q.top();
Q.pop();
int here = p.second;
for (vector<pair<long long, long long> >::iterator it = edges[here].begin();
it != edges[here].end(); it++) {
if (dist[here] + it->first < dist[it->second]) {
dist[it->second] = dist[here] + it->first;
dad[it->second] = here;
Q.push(make_pair(dist[it->second], it->second));
}
}
}
vector<pair<long long, long long> > goodedges[N];
for (int i = 0; i < N; i++) {
for (pair<long long, long long> j : edges[i]) {
if (dist[i] + j.first == dist[j.second]) {
goodedges[j.second].push_back(make_pair(j.first, i));
}
}
}
long long res = 0;
vector<int> ans;
for (int i = 0; i < N; i++) {
if (i == s) continue;
sort(goodedges[i].begin(), goodedges[i].end());
res += goodedges[i][0].first;
ans.push_back(index[pair<long long, long long>(i, goodedges[i][0].second)]);
}
printf("%I64d \n", res);
for (int i : ans) {
printf("%d ", i);
}
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, z, s;
vector<pair<int, int> > AdjList[3 * 100009];
map<pair<pair<int, int>, int>, int> EdjList;
pair<int, int> parent[3 * 100009];
void Dijkstra() {
vector<long long> dist(n + 2, 1ll << 60);
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
pq;
dist[s] = 0;
pq.push(make_pair(0ll, s));
while (!pq.empty()) {
long long d = pq.top().first;
int u = pq.top().second;
pq.pop();
if (d > dist[u]) continue;
for (int i = 0; i < (int)AdjList[u].size(); i++) {
int v = AdjList[u][i].first;
long long cost = (long long)AdjList[u][i].second;
if (u == s) {
if (d + cost < dist[v]) {
dist[v] = d + cost;
parent[v] = make_pair(u, (int)cost);
pq.push(make_pair(dist[v], v));
}
} else {
if (d + cost < dist[v]) {
dist[v] = d + cost;
parent[v] = make_pair(u, (int)cost);
pq.push(make_pair(dist[v], v));
} else if (d + cost == dist[v]) {
int prev_cost = parent[v].second;
if (cost < prev_cost) {
parent[v] = make_pair(u, (int)cost);
}
}
}
}
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d %d", &x, &y, &z);
AdjList[x].push_back(make_pair(y, z));
AdjList[y].push_back(make_pair(x, z));
EdjList[make_pair(make_pair(x, y), z)] = i;
EdjList[make_pair(make_pair(y, x), z)] = i;
}
scanf("%d", &s);
Dijkstra();
long long res = 0;
vector<int> sol;
for (int i = 1; i <= n; i++) {
if (i == s) continue;
int prev_node = parent[i].first;
int prev_cost = parent[i].second;
res += prev_cost;
int idx = EdjList[make_pair(make_pair(i, prev_node), prev_cost)];
sol.push_back(idx);
}
printf("%I64d\n", res);
for (int i = 0; i < sol.size(); i++) {
printf("%d ", sol[i]);
}
puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
using pi = pair<long long, int>;
const int N = 300010;
const long long oo = 1LL << 60;
vector<pi> g[N];
long long d[N];
priority_queue<pi, vector<pi>, greater<pi>> pq;
long long weight[N];
set<int> vv;
long long edge[N];
int p[N];
map<pi, int> mp;
void add(int u, int v, int idx) {
if (u > v) {
swap(u, v);
}
mp[{u, v}] = idx;
}
int query(int u, int v) {
if (u > v) {
swap(u, v);
}
return mp[{u, v}];
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i) {
d[i] = oo;
edge[i] = oo;
}
for (int i = 1; i <= m; ++i) {
int x, y;
long long z;
scanf("%d %d %lld", &x, &y, &z);
g[x].push_back({y, z});
g[y].push_back({x, z});
weight[i] = z;
add(x, y, i);
}
int x;
scanf("%d", &x);
d[x] = 0;
p[x] = -1;
pq.push({0, x});
while (!pq.empty()) {
int u = pq.top().second;
if (p[u] != -1) {
vv.insert(query(u, p[u]));
}
pq.pop();
for (auto to : g[u]) {
int v = to.first, w = to.second;
if (d[v] > d[u] + w) {
d[v] = d[u] + w;
edge[v] = w;
p[v] = u;
pq.push({d[v], v});
} else if (d[v] == d[u] + w && edge[v] > w) {
edge[v] = w;
p[v] = u;
}
}
}
long long sum = 0;
for (int e : vv) {
sum += weight[e];
}
printf("%lld\n", sum);
for (int e : vv) {
printf("%d ", e);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, nxt, id;
long long w;
} a[300000 * 2 + 5];
int ecnt, pre[300000 + 5], res[300000 + 5];
int n, m, S;
long long dist[1 + 1][300000 + 5], val[300000 + 5];
void add(int u, int v, long long w, int id) {
a[++ecnt].to = v;
a[ecnt].nxt = pre[u];
a[ecnt].id = id;
a[ecnt].w = w;
pre[u] = ecnt;
}
void Dij(int s, int kdf) {
for (int i = 1; i <= n; i++)
dist[kdf][i] = 1000000000000000000, val[i] = 1000000000000000000;
dist[kdf][s] = 0;
val[s] = 0;
priority_queue<pair<long long, int> > Q;
Q.push(make_pair(0, s));
while (!Q.empty()) {
int x = Q.top().second;
long long di = -Q.top().first;
Q.pop();
if (di != dist[kdf][x]) continue;
for (int i = pre[x]; i != -1; i = a[i].nxt) {
int xnt = a[i].to;
if (dist[kdf][x] + a[i].w < dist[kdf][xnt]) {
dist[kdf][xnt] = dist[kdf][x] + a[i].w;
Q.push(make_pair(-dist[kdf][xnt], xnt));
val[xnt] = a[i].w;
res[xnt] = a[i].id;
} else if (dist[kdf][x] + a[i].w == dist[kdf][xnt] && a[i].w < val[xnt]) {
val[xnt] = a[i].w;
res[xnt] = a[i].id;
}
}
}
}
int main() {
memset(pre, -1, sizeof(pre));
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
long long w;
scanf("%d%d%lld", &u, &v, &w);
add(u, v, w, i);
add(v, u, w, i);
}
scanf("%d", &S);
Dij(S, 0);
long long ans = 0;
for (int i = 1; i <= n; i++) ans += val[i];
printf("%lld\n", ans);
for (int i = 1; i <= n; i++)
if (i != S) printf("%d ", res[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int v, w, i;
Node() {}
Node(int v, int w, int i) : v(v), w(w), i(i) {}
} node[300001];
list<Node> adj[300001];
int n, m, x, y, z, k;
priority_queue<pair<long long, int> > q1;
int dead[300001];
long long weight[300001];
int ans[300001];
void run(int k) {
weight[k] = 0;
q1.push(pair<long long, int>(-0, k));
while (!q1.empty()) {
pair<long long, int> top = q1.top();
q1.pop();
if (dead[top.second]) continue;
dead[top.second] = 1;
for (list<Node>::iterator it = adj[top.second].begin();
it != adj[top.second].end(); ++it)
if (weight[top.second] + it->w == weight[it->v]) {
if (node[ans[it->v]].w > it->w) ans[it->v] = it->i;
} else if (weight[top.second] + it->w < weight[it->v]) {
weight[it->v] = weight[top.second] + it->w;
ans[it->v] = it->i;
q1.push(pair<long long, int>(-weight[it->v], it->v));
}
}
}
int main() {
std::ios::sync_with_stdio(false);
memset(weight, 0x3f, sizeof(weight));
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d %d ", &x, &y, &z);
node[i] = Node(y, z, i);
adj[x].push_back(node[i]);
adj[y].push_back(Node(x, z, i));
}
scanf("%d", &k), run(k);
long long tot = 0;
for (int i = 1; i <= n; i++)
if (i != k) tot += node[ans[i]].w;
printf("%I64d\n", tot);
for (int i = 1; i <= n; i++)
if (i != k) printf("%d ", ans[i]);
return 0;
}
|
#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 marca[300005];
int esta[300005];
void iniciar(int n) {
memset(marca, 0, sizeof marca);
memset(esta, 0, sizeof esta);
for (int i = 0; i <= n; i++) {
grupo[i] = i;
dist[i] = 20000000000000000LL;
G[i].clear();
}
}
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);
}
scanf("%d", &a);
D(a);
ans = 0;
sort(v, v + m);
for (i = m - 1; i >= 0; i--) {
if (!marca[v[i].x] && dist[v[i].x] - v[i].p == dist[v[i].y]) {
ans += v[i].p;
marca[v[i].x] = true;
esta[v[i].id] = true;
}
if (!marca[v[i].y] && dist[v[i].y] - v[i].p == dist[v[i].x]) {
ans += v[i].p;
marca[v[i].y] = true;
esta[v[i].id] = true;
}
}
cout << ans << endl;
for (i = 1; i <= m; i++)
if (esta[i]) printf("%d ", i);
printf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
long long null = 0;
struct segment;
struct line;
struct point;
struct vec;
struct ray;
struct point {
long double x, y;
point() {}
point(long double x1, long double y1) {
x = x1;
y = y1;
}
long double dist_to_point(point p) {
return sqrt((p.x - x) * (p.x - x) + (p.y - y) * (p.y - y));
}
bool operator<(point p) { return (x < p.x) || ((x == p.x) && (y < p.y)); }
};
struct vec {
long double x, y;
vec(long double x1, long double y1) {
x = x1;
y = y1;
}
vec(point a, point b) {
x = b.x - a.x;
y = b.y - a.y;
}
vec normal() {
vec ans;
ans.x = y;
ans.y = -x;
return ans;
}
vec opposite() {
vec ans;
ans.x = -x;
ans.y = -y;
return ans;
}
vec sum(vec b) {
vec ans;
ans.x = x + b.x;
ans.y = y + b.y;
return ans;
}
long double cross_product(vec v) { return x * v.y - v.x * y; }
long double dot_product(vec v) { return x * v.x + y * v.y; }
vec resize(long double size) {
vec ans;
ans.x = (x * size) / len();
ans.y = (y * size) / len();
return ans;
}
vec() {}
long double len() { return sqrt(x * x + y * y); }
};
struct line {
long double a, b, c;
line(point a1, point b1) {
a = a1.y - b1.y;
b = b1.x - a1.x;
c = -a1.x * a - a1.y * b;
}
line(long double a1, long double b1, long double c1) {
a = a1;
b = b1;
c = c1;
}
line() {}
vec normal_vec() {
vec ans;
ans.x = a;
ans.y = b;
return ans;
}
line normal_line(point p) {
line ans;
ans.a = -b;
ans.b = a;
ans.c = -ans.a * p.x - ans.b * p.y;
return ans;
}
long double get_x(long double y1) {
if (a == 0) return 0;
return (-c - b * y1) / a;
}
long double get_y(long double x1) {
if (b == 0) return 0;
return (-c - a * x1) / b;
}
point intersection(line l) {
point ans;
ans.x = (-c * l.b + l.c * b) / (a * l.b - l.a * b);
ans.y = (-a * l.c + l.a * c) / (a * l.b - l.a * b);
return ans;
}
long double dist_to_point(point p) {
return abs((a * p.x + b * p.y + c) / (sqrt(a * a + b * b)));
}
long long is_inside(point p) {
long double k = a * p.x + b * p.y + c;
if (k < 0)
return -1;
else if (k == 0)
return 0;
return 1;
}
};
struct segment {
point a, b;
segment() {}
segment(point a1, point b1) {
a = a1;
b = b1;
}
long double len() {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
bool is_inside(point p) {
line l(a, b);
if (l.is_inside(p) != 0) return false;
vec v(p, a), v1(p, b);
if (v.dot_product(v1) > 0) return false;
return true;
}
long double dist_to_point(point p) {
vec v(a, p), v1(a, b), v2(b, p), v3(b, a);
if (v.dot_product(v1) < 0) return p.dist_to_point(a);
if (v2.dot_product(v3) < 0) return p.dist_to_point(b);
line l(a, b);
return l.dist_to_point(p);
}
point get_center() {
point ans;
ans.x = (a.x + b.x) / 2;
ans.y = (a.y + b.y) / 2;
return ans;
}
};
struct ray {
point a, b;
ray(point p, point p1) {
a = p;
b = p1;
}
ray() {}
long double dist_to_point(point p) {
vec v(a, p), v1(a, b);
if (v.dot_product(v1) < 0) return a.dist_to_point(p);
line l(a, b);
return l.dist_to_point(p);
}
bool is_inside(point p) {
line l(a, b);
if (l.is_inside(p) != 0) return false;
vec v(a, p), v1(a, b);
if (v.dot_product(v1) < 0) return false;
return true;
}
};
struct angle {
point a, b, c;
angle(){};
angle(point a1, point b1, point c1) {
a = a1;
b = b1;
c = c1;
}
long double get_angle() {
vec v(b, a), v1(b, c);
cout << v.dot_product(v1) << " " << v.len() << " " << v1.len() << endl;
return acos(v.dot_product(v1) / (v.len() * v1.len()));
}
};
struct polygon {
long long n;
vector<point> points;
long double get_area() {
point a(0, 0);
vec v(a, points[0]);
long double ans = 0;
for (long long i = 1; i < n; ++i) {
vec v1(a, points[i]);
ans = ans + v.cross_product(v1);
v = v1;
}
vec v2(a, points[0]);
vec v1(a, points[n - 1]);
return abs(ans + v1.cross_product(v2)) / 2;
}
};
struct triangle {
point a, b, c;
triangle() {}
triangle(point a1, point b1, point c1) {
a = a1;
b = b1;
c = c1;
}
long double get_area() {
point d(0, 0);
vec v(a, d), v1(b, d), v2(c, d);
return (v.cross_product(v1) + v1.cross_product(v2) + v2.cross_product(v)) /
2;
}
point get_center() {
segment s(a, b), s1(a, c);
point p = s.get_center(), p1 = s1.get_center();
line l(a, b), l1(a, c), l2(b, c);
l = l.normal_line(p);
l1 = l1.normal_line(p1);
return l.intersection(l1);
}
long double get_R() {
triangle t(a, b, c);
point p = t.get_center();
return p.dist_to_point(a);
}
};
long long power(long long a, long long b) {
if (b == 0)
return 1;
else if (b == 1)
return a;
else {
long long k = power(a, b / 2);
return k * k * power(a, b % 2);
}
}
long long power_mod(long long a, long long b, long long MOD) {
if (b == 0)
return 1;
else if (b == 1)
return a % MOD;
else {
long long k = power_mod(a, b / 2, MOD);
return ((k * k) % MOD * power_mod(a, b % 2, MOD)) % MOD;
}
}
long long sum_mod(long long a, long long b, long long MOD) {
return (a + b) % MOD;
}
long long mul_mod(long long a, long long b, long long MOD) {
return (a * b) % MOD;
}
long long ord(char a) { return a; }
char chr(long long a) { return a; }
long long strtoint(string s) {
long long ans = 0;
for (long long i = 0; i < s.size(); ++i) {
ans *= 10;
ans += ord(s[i]) - 48;
}
return ans;
}
string rev_string(string s) {
string ans = "";
for (long long i = s.size(); i >= 0; --i) {
ans += s[i];
}
return ans;
}
string inttostr(long long a) {
string ans = "", ans1 = "";
while (a > 0) {
ans += chr(a + 48);
a /= 10;
}
for (long long i = ans.size() - 1; i >= 0; --i) {
ans1 += ans[i];
}
return ans1;
}
vector<vector<pair<long long, pair<long long, long long> > > > ar;
long long arr[600000], ans[600000];
set<pair<long long, long long> > mas;
vector<pair<pair<long long, long long>, long long> > arr1;
void dijstra(long long v) {
mas.erase(make_pair(arr[v], v));
for (long long i = 0; i < ar[v].size(); ++i) {
long long to = ar[v][i].first;
long long weight = ar[v][i].second.first;
long long k = ar[v][i].second.second;
if (arr[v] + weight <= arr[to]) {
mas.erase(make_pair(arr[to], to));
arr[to] = arr[v] + weight;
ans[to] = k;
mas.insert(make_pair(arr[to], to));
}
}
if (mas.size() == 0) return;
pair<long long, long long> a = *mas.begin();
dijstra(a.second);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand(time(0));
long long n, m;
cin >> n >> m;
ar.resize(n + 1);
for (long long i = 0; i < m; ++i) {
long long u, v, w;
cin >> u >> v >> w;
arr1.push_back(make_pair(make_pair(u, v), w));
ar[u].push_back(make_pair(v, make_pair(w, i)));
ar[v].push_back(make_pair(u, make_pair(w, i)));
}
long long u;
cin >> u;
for (long long i = 1; i <= n; ++i) {
arr[i] = 1e18;
mas.insert(make_pair(arr[i], i));
}
mas.erase(make_pair(arr[u], u));
arr[u] = 0;
ans[u] = -1;
mas.insert(make_pair(arr[u], u));
dijstra(u);
long long answer = 0;
for (long long i = 1; i <= n; ++i) {
if (i != u) {
answer += arr1[ans[i]].second;
}
}
cout << answer << endl;
for (long long i = 1; i <= n; ++i) {
if (i != u) cout << ans[i] + 1 << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long INF = 2000000000000000000;
long long s;
int vika[300010];
map<pair<long long, long long>, pair<long long, long long> > mmm;
int main() {
srand(time(NULL));
cin >> n >> m;
vector<long long> d(n + 1, INF), p(n + 1);
vector<vector<pair<long long, long long> > > g(n + 1);
for (long long i = 1; i <= m; ++i) {
long long a, b, c;
cin >> a >> b >> c;
g[a].push_back(make_pair(b, c));
g[b].push_back(make_pair(a, c));
mmm[make_pair(a, b)] = make_pair(i, c);
mmm[make_pair(b, a)] = make_pair(i, c);
}
cin >> s;
d[s] = 0;
set<pair<long long, long long> > q;
q.insert(make_pair(d[s], s));
while (!q.empty()) {
long long v = q.begin()->second;
q.erase(q.begin());
for (size_t j = 0; j < g[v].size(); ++j) {
long long to = g[v][j].first;
long long llen = g[v][j].second;
if (d[v] + llen < d[to] || d[v] + llen == d[to] && llen < vika[to]) {
q.erase(make_pair(d[to], to));
d[to] = d[v] + llen;
p[to] = v;
vika[to] = llen;
q.insert(make_pair(d[to], to));
}
}
}
long long ss = 0;
vector<int> ans;
for (long long i = 1; i <= n; ++i) {
if (i == s) continue;
long long pr = p[i];
pair<long long, long long> par = mmm[make_pair(i, pr)];
ans.push_back(par.first);
ss += par.second;
}
cout << ss << endl;
for (int i = 0; i < ans.size(); ++i) {
cout << ans[i] << ' ';
}
}
|
#include <bits/stdc++.h>
long long MOD = int(1e9) + 7;
int debug = 1;
using namespace std;
int mk[300100];
int n, m;
vector<vector<pair<int, int> > > g;
map<pair<int, int>, int> d, cn;
int main() {
cin >> n >> m;
g.resize(n + 1);
int a, b, c;
int op = 0;
while (m--) {
op++;
cin >> a >> b >> c;
g[a].push_back(make_pair(b, c));
g[b].push_back(make_pair(a, c));
d[{a, b}] = op;
d[{b, a}] = op;
if (a > b) swap(a, b);
cn[{a, b}] = c;
}
long long dist[n + 3];
int src;
cin >> src;
for (int i = 0; i < n + 2; i++) {
dist[i] = 100000000000000000LL;
}
priority_queue<pair<pair<long long, int>, pair<int, int> >,
vector<pair<pair<long long, int>, pair<int, int> > >,
greater<pair<pair<long long, int>, pair<int, int> > > >
q;
dist[src] = 0;
q.push(make_pair(make_pair(0LL, -1), make_pair(-1, src)));
vector<int> v;
long long ans = 0;
int oi, ol;
while (!q.empty()) {
pair<pair<long long, int>, pair<int, int> > p = q.top();
q.pop();
long long dis = p.first.first;
int last_edge = p.first.second;
int last_vertex = p.second.first;
int vertex = p.second.second;
if (dis > dist[vertex] || mk[vertex] == 1) continue;
mk[vertex] = 1;
oi = min(vertex, last_vertex), ol = max(vertex, last_vertex);
ans += cn[{oi, ol}];
v.push_back(d[make_pair(vertex, last_vertex)]);
for (int i = 0; i < g[vertex].size(); i++) {
pair<int, int> pr = g[vertex][i];
int wt = pr.second;
int v = pr.first;
long long next_dist = dis + wt;
if (next_dist <= dist[v]) {
dist[v] = next_dist;
q.push(make_pair(make_pair(next_dist, wt), make_pair(vertex, v)));
}
}
}
cout << ans << endl;
for (int i = 1; i < v.size(); i++) {
cout << v[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3 * 1e5 + 5;
const long long INF = numeric_limits<long long>::max();
struct dijkstra {
long long dis[N], prev[N], prev_w[N];
vector<int> res;
void init() {
for (int i = 0; i < N; ++i) {
dis[i] = INF / 2;
}
}
long long calc(vector<vector<tuple<int, int, int>>>& g, int s) {
long long re = 0;
dis[s] = 0;
prev[s] = -1;
int size = g.size();
set<pair<long long, int>> se;
for (int i = 0; i < size; ++i) {
se.insert({dis[i], i});
}
while (!se.empty()) {
set<pair<long long, int>>::iterator it = se.begin();
int v = it->second;
se.erase(it);
if (prev[v] > 0) {
res.push_back(prev[v]);
re += prev_w[v];
if (res.size() == g.size() - 1) break;
}
for (int i = 0; i < (int)g[v].size(); ++i) {
int u, di, id;
tie(u, di, id) = g[v][i];
if (dis[v] + (long long)di == dis[u] && di < prev_w[u]) {
prev[u] = id;
prev_w[u] = di;
}
if (dis[v] + di < dis[u]) {
se.erase({dis[u], u});
se.insert({dis[v] + di, u});
dis[u] = dis[v] + di;
prev[u] = id;
prev_w[u] = di;
}
}
}
return re;
}
} dij;
int main() {
std::ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<vector<tuple<int, int, int>>> g(n);
for (int i = 0; i < m; ++i) {
int u, v, w;
cin >> u >> v >> w;
--u;
--v;
g[u].push_back(make_tuple(v, w, i + 1));
g[v].push_back(make_tuple(u, w, i + 1));
}
int u;
cin >> u;
--u;
dij.init();
cout << dij.calc(g, u) << endl;
assert(dij.res.size() == n - 1);
for (int i = 0; i < n - 1; ++i) {
cout << dij.res[i] << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int inf = 1e18;
long long int p = 1e9 + 7;
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int pwr(long long int x, long long int y) {
long long int res = 1;
x = x;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long int modInverse(long long int n, long long int p) {
return power(n, p - 2, p);
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int i, j, y, x, z, w, g, key, k, n, m, a, b, t;
long long int t2, t3, t4, t1, t5, t6;
map<pair<long long int, long long int>, long long int> ma;
cin >> n >> m;
vector<vector<pair<long long int, long long int>>> adj(n + 1);
for (i = 1; i <= m; i++) {
cin >> x >> y >> z;
adj[x].push_back(make_pair(y, z));
adj[y].push_back(make_pair(x, z));
ma[make_pair(x, y)] = i;
ma[make_pair(y, x)] = i;
}
long long int val;
cin >> val;
vector<long long int> d(n + 1, inf), p(n + 1, -1), last(n + 1, inf), ans;
set<pair<long long int, long long int>> q;
q.insert(make_pair(0, val));
d[val] = 0;
long long int cnt = 0;
while (!q.empty()) {
auto u = q.begin();
q.erase(q.begin());
long long int s = u->second;
if (p[s] != -1) {
cnt += last[s];
t1 = ma[make_pair(s, p[s])];
ans.push_back(t1);
}
for (auto v : adj[s]) {
long long int to = v.first;
long long int dto = v.second;
if (d[s] + dto < d[to]) {
q.erase(make_pair(d[to], to));
d[to] = d[s] + dto;
p[to] = s;
last[to] = dto;
q.insert(make_pair(d[to], to));
} else if (d[s] + dto == d[to]) {
if (dto < last[to]) {
last[to] = dto;
p[to] = s;
}
}
}
}
cout << cnt << "\n";
for (auto u : ans) cout << u << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300101;
const long long INF = 1e16;
const int INFi = 0x3f3f3f3f;
pair<long long, long long> dist[N];
vector<int> adj[N], w[N], ed[N];
vector<int> edl;
int n, m;
void dij(int u) {
priority_queue<pair<long long, int> > pq;
pq.push(make_pair(0, u));
for (int(i) = (0); (i) < (n); ++(i)) dist[i] = make_pair(INF, INF);
dist[u] = make_pair(0, 0);
vector<int> edu(n, -1);
while (!pq.empty()) {
u = pq.top().second;
long long du = -pq.top().first;
pq.pop();
if (dist[u].first < du) continue;
for (int(i) = (0); (i) < (adj[u].size()); ++(i)) {
int v = adj[u][i];
long long dv = w[u][i];
if (dist[v].first > dist[u].first + dv) {
dist[v] = make_pair(dist[u].first + dv, dv);
edu[v] = ed[u][i];
pq.push(make_pair(-dist[v].first, v));
} else if (dist[v].first == dist[u].first + dv && dist[v].second > dv) {
edu[v] = ed[u][i];
dist[v] = make_pair(dist[u].first + dv, dv);
}
}
}
vector<int> ans;
long long tt = 0;
for (int(i) = (0); (i) < (n); ++(i))
if (edu[i] != -1) {
tt += edl[edu[i]];
ans.push_back(edu[i]);
}
cout << tt << "\n";
sort(ans.begin(), ans.end());
for (int(i) = (0); (i) < (ans.size()); ++(i)) cout << ans[i] + 1 << " ";
cout << "\n";
}
int main() {
cin >> n >> m;
for (int(i) = (0); (i) < (m); ++(i)) {
int u, v, we;
cin >> u >> v >> we;
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
w[u].push_back(we);
w[v].push_back(we);
ed[u].push_back(i);
ed[v].push_back(i);
edl.push_back(we);
}
int sr;
cin >> sr;
sr--;
dij(sr);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > adj[300001];
long long weight[300001], indice[300001], dist[300001];
struct comp {
bool operator()(pair<long long, long long> n1,
pair<long long, long long> n2) {
return n1.first > n2.first;
}
};
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
comp>
qu;
void dijkstra(int src) {
long long i, h, node;
dist[src] = 0;
qu.push(make_pair(0, src));
while (!qu.empty()) {
node = qu.top().second;
qu.pop();
h = adj[node].size();
for (i = 0; i < h; i++) {
long long next, weig, id;
next = adj[node][i].first;
id = adj[node][i].second;
weig = weight[id];
if (dist[next] > (dist[node] + weig)) {
dist[next] = (dist[node] + weig);
qu.push(make_pair(dist[next], next));
indice[next] = id;
} else if (dist[next] == (dist[node] + weig)) {
if (weig < weight[indice[next]]) {
indice[next] = id;
}
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long N, M, X, Y, W, j, i, uup;
long long sum = 0;
cin >> N >> M;
for (i = 1; i <= M; i++) {
cin >> X >> Y >> W;
adj[X].push_back(make_pair(Y, i));
adj[Y].push_back(make_pair(X, i));
weight[i] = W;
}
for (i = 1; i <= N; i++) {
dist[i] = 9223372036854775807;
}
cin >> uup;
dijkstra(uup);
for (i = 1; i <= N; i++) {
sum += weight[indice[i]];
}
cout << sum << "\n";
for (i = 1; i <= N; i++) {
if (i != uup) {
cout << indice[i] << " ";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int LINF = 9000000000000000000ll;
int u;
struct Graph {
struct Ed {
int to;
long long weight;
int id;
Ed(int t, long long w, int i) : to(t), weight(w), id(i){};
};
struct Ve {
long long int distance;
int from;
long long w;
bool taken;
vector<Ed> ed;
Ve() : distance(LINF), from(-1), w(LINF), taken(0){};
};
vector<Ve> v;
Graph(int n) { v.assign(n, Ve()); }
void add(int from, int to, long long w, int i) {
v[from].ed.push_back(Ed(to, w, i));
v[to].ed.push_back(Ed(from, w, i));
}
void start(int u) {
vector<int> res;
priority_queue<pair<long long int, Ve*>> s;
v[u].distance = v[u].w = 0;
s.push(make_pair(0, &v[u]));
long long int sum = 0;
Ve* x;
int l = v.size();
while (!s.empty() && l > 0) {
x = s.top().second;
s.pop();
if (!x->taken) {
l--;
x->taken = true;
if (x->from != -1) {
res.push_back(x->from);
sum += x->w;
}
for (auto& e : x->ed) {
if (v[e.to].distance >= e.weight + x->distance) {
v[e.to].from = e.id;
v[e.to].w = e.weight;
v[e.to].distance = e.weight + x->distance;
s.push(make_pair(-v[e.to].distance, &v[e.to]));
}
}
}
}
cout << sum << "\n";
sort(res.begin(), res.end());
for (auto r : res) cout << r << " ";
cout << "\n";
}
};
int main() {
int n, m;
cin >> n >> m;
Graph g(n);
for (int i = 0; i < m; i++) {
int a, b;
long long int c;
cin >> a >> b >> c;
g.add(a - 1, b - 1, c, i + 1);
}
cin >> u;
g.start(u - 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = (int)1e6 + 10;
const long long inf = (long long)1e18;
struct Edge {
int u, v, idx;
long long w;
Edge(int u, int v, long long w, int idx) {
this->u = u;
this->v = v;
this->w = w;
this->idx = idx;
}
};
vector<Edge> edges;
struct HeapNode {
long long d;
int u;
HeapNode(long long d, int u) {
this->d = d;
this->u = u;
}
bool operator<(const HeapNode& rhs) const { return d > rhs.d; }
};
long long dist[MAX_N];
bool done[MAX_N];
vector<int> G[MAX_N];
int N, M;
void solve(int s) {
priority_queue<HeapNode> pq;
fill(dist, dist + N, inf);
memset(done, 0, sizeof(done));
dist[s] = 0;
pq.push(HeapNode(0, s));
while (!pq.empty()) {
HeapNode x = pq.top();
pq.pop();
int u = x.u;
if (done[u]) continue;
done[u] = true;
for (int i = 0; i < G[u].size(); ++i) {
Edge& e = edges[G[u][i]];
if (dist[e.v] > dist[u] + e.w) {
dist[e.v] = dist[u] + e.w;
pq.push(HeapNode(dist[e.v], e.v));
}
}
}
}
bool vis[MAX_N];
int main() {
int s, m;
scanf("%d%d", &N, &M);
for (int i = 0; i < M; i++) {
int u, v;
long long w;
scanf("%d%d%I64d", &u, &v, &w);
--u, --v;
edges.push_back(Edge(u, v, w, i + 1));
edges.push_back(Edge(v, u, w, i + 1));
m = edges.size();
G[u].push_back(m - 2);
G[v].push_back(m - 1);
}
scanf("%d", &s);
--s;
solve(s);
vector<pair<long long, int> > p;
for (int i = 0; i < N; ++i) {
p.push_back(make_pair(dist[i], i));
}
sort(p.begin(), p.end());
long long res = 0;
vector<int> ans;
memset(vis, 0, sizeof(vis));
vis[s] = 1;
for (int i = 1; i < N; i++) {
int u = p[i].second;
long long cur = inf;
int pos = -1;
for (int j = 0; j < G[u].size(); ++j) {
int v = edges[G[u][j]].v;
if (dist[v] > dist[u]) {
continue;
}
if (!vis[v]) {
continue;
}
if (cur > dist[u] - dist[v] && dist[v] + edges[G[u][j]].w == dist[u]) {
cur = dist[u] - dist[v];
pos = edges[G[u][j]].idx;
}
}
vis[u] = 1;
res += cur;
ans.push_back(pos);
}
printf("%I64d\n", res);
int sz = ans.size();
for (int i = 0; i < sz; ++i) {
printf("%d%c", ans[i], i == sz - 1 ? '\n' : ' ');
}
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});
}
}
}
}
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 gcd(long long x, long long y) {
if (!y) return x;
return gcd(y, x % y);
}
const long long MOD = 119 << 23 | 1;
const long long inf = 1e18;
long long power(long long x, long long y) {
long long res = 1ll;
x %= MOD;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % MOD;
y = y >> 1ll;
x = (x * x) % MOD;
}
return res;
}
long long inv(long long x) {
long long r = 1ll, t = x, k = MOD - 2ll;
while (k) {
if (k & 1ll) r = (long long)r * t % MOD;
t = (long long)t * t % MOD;
k >>= 1;
}
return r;
}
bool isPrime(long long x) {
if (x == 1) return false;
for (long long i = 2; i * i <= x; i++) {
if (x % i == 0) return false;
}
return true;
}
const int nax = 5e5 + 13;
void prep() {}
void solve() {}
void read() {
int n, m, start, x, y, w;
cin >> n >> m;
vector<long long> d(n);
vector<pair<pair<int, int>, int>> V[n];
vector<pair<int, int>> last(n);
for (int i = 0; i < m; i++) {
cin >> x >> y >> w;
V[x - 1].push_back({{y - 1, w}, i});
V[y - 1].push_back({{x - 1, w}, i});
}
cin >> start;
start--;
bool res[m];
for (int i = 0; i < m; i++) res[i] = false;
set<pair<int, int>> q;
for (int i = 0; i < n; i++) {
d[i] = inf;
last[i] = {inf, -1};
}
d[start] = 0;
long long sum = 0;
q.insert({d[start], start});
while (!q.empty()) {
int akt = (*q.begin()).second;
q.erase(q.begin());
for (auto u : V[akt]) {
int v = u.first.first;
w = u.first.second;
int index = u.second;
if (d[v] > d[akt] + w) {
d[v] = d[akt] + w;
if (last[v].second != -1) {
res[last[v].second] = false;
sum -= last[v].first;
}
sum += w;
res[index] = true;
last[v] = {w, index};
q.insert({d[v], v});
} else if (d[v] == d[akt] + w) {
if (w < last[v].first) {
sum -= last[v].first;
last[v].first = w;
res[last[v].second] = false;
res[index] = true;
sum += w;
last[v] = {w, index};
}
}
}
}
cout << sum << endl;
for (int i = 0; i < m; i++)
if (res[i]) cout << i + 1 << ' ';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
cout.tie();
int T = 1;
prep();
for (int i = 1; i <= T; i++) {
read();
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:225450978")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long long Mod = 1000000007LL, INF = 1e9, LINF = 1e18;
const long double Pi = 3.141592653589793116, EPS = 1e-9,
Gold = ((1 + sqrt(5)) / 2);
long long keymod[] = {1000000007LL, 1000000009LL, 1000000021LL, 1000000033LL};
long long keyCount = sizeof(keymod) / sizeof(long long);
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcountll(s);
}
auto TimeStart = chrono::steady_clock::now();
auto TimeEnd = chrono::steady_clock::now();
void ControlIO(int argc, char* argv[]);
void TimerStart();
void TimerStop();
void Exit();
long long n, m, u, v, w, st;
vector<vector<pair<long long, long long>>> adj;
map<pair<long long, long long>, long long> Map;
void Input() {
cin >> n >> m;
adj.resize(n);
for (long long i = 1; i <= m; i++) {
cin >> u >> v >> w;
u--;
v--;
adj[u].push_back(make_pair(v, w));
adj[v].push_back(make_pair(u, w));
Map[make_pair(u, v)] = i;
Map[make_pair(v, u)] = i;
}
cin >> st;
st--;
}
void Solve() {
vector<pair<long long, long long>> Dist(n, make_pair(LINF, LINF));
vector<long long> Last(n, -1LL);
vector<bool> vis(n, false);
Dist[st] = make_pair(0LL, 0LL);
priority_queue<pair<long long, long long>> Q;
Q.push(make_pair(-Dist[st].first, st));
while (!Q.empty()) {
pair<long long, long long> Z = Q.top();
Q.pop();
long long z = Z.second, d = -Z.first;
if (vis[z]) continue;
vis[z] = true;
for (auto T : adj[z]) {
long long t = T.first, p = T.second;
pair<long long, long long> tmp = make_pair(d + p, p);
if (tmp < Dist[t]) {
Dist[t] = tmp;
Last[t] = z;
Q.push(make_pair(-Dist[t].first, t));
}
}
}
long long Total = 0;
vector<long long> A;
for (long long i = 0; i < n; i++) Total += Dist[i].second;
for (long long i = 0; i < n; i++)
if (Last[i] != -1LL) A.push_back(Map[make_pair(i, Last[i])]);
cout << Total << '\n';
for (auto x : A) cout << x << " ";
}
int main(int argc, char* argv[]) {
ControlIO(argc, argv);
Input();
TimerStart();
Solve();
TimerStop();
return 0;
}
void ControlIO(int argc, char* argv[]) {}
void TimerStart() {}
void TimerStop() {}
void Exit() {
TimerStop();
exit(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());
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;
vector<pair<long long, long long> > ed[300005];
int n, m;
int pa[300005];
long long int vis[300005];
void solve() {
cin >> n >> m;
long long int u;
long long ww[m], pre[n + 1];
pair<long long, long long> edg[m];
for (int i = 0; i < m; i++) {
long long int u, v, w;
cin >> u >> v >> w;
ed[u].push_back(pair<long long, long long>(v, w));
ed[v].push_back(pair<long long, long long>(u, w));
edg[i] = pair<long long, long long>(u, v);
ww[i] = w;
}
cin >> u;
priority_queue<pair<long long, long long> > pq;
long long d[n + 1];
for (int i = 0; i < n; i++) pre[i + 1] = d[i + 1] = 1e18 + 1;
d[u] = 0;
pre[u] = 0;
pq.push(pair<long long, long long>(0, u));
while (!pq.empty()) {
pair<long long, long long> p = pq.top();
pq.pop();
if (vis[p.second]) continue;
vis[p.second] = 1;
for (pair<long long, long long> j : ed[p.second]) {
if (d[j.first] > j.second - p.first) {
d[j.first] = j.second - p.first;
pa[j.first] = p.second;
pre[j.first] = j.second;
pq.push(pair<long long, long long>(-d[j.first], j.first));
} else if (d[j.first] == j.second - p.first && j.second < pre[j.first]) {
pa[j.first] = p.second;
pre[j.first] = j.second;
}
}
}
vector<int> res;
long long wt = 0;
for (int i = 0; i < m; i++) {
long long u, v;
u = edg[i].first;
v = edg[i].second;
if (u == pa[v] || pa[u] == v) {
wt += ww[i];
res.push_back(i + 1);
}
}
cout << wt << "\n";
for (int i : res) cout << i << " ";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int n, m;
vector<pair<int, int>> edge[400000];
vector<int> edgenum[400000];
long long dis[400000];
int check[400000];
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
pq;
int p[400000];
int p2[400000];
int main() {
int i, j, k;
cin >> n >> m;
for (i = 0; i < m; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z), x--, y--;
edge[x].push_back(pair<int, int>(y, z));
edgenum[x].push_back(i + 1);
edge[y].push_back(pair<int, int>(x, z));
edgenum[y].push_back(i + 1);
}
int s;
scanf("%d", &s), s--;
fill(dis, dis + n, ((1ll << 62) - 1));
dis[s] = 0;
p[s] = -1;
pq.push(pair<long long, long long>(0, s));
while (pq.size()) {
pair<long long, long long> x = pq.top();
pq.pop();
if (check[x.second]) continue;
check[x.second] = 1;
for (int i = 0; i < edge[x.second].size(); i++) {
pair<long long, long long> e = edge[x.second][i];
if (dis[e.first] > x.first + e.second ||
(dis[e.first] == x.first + e.second && dis[p[e.first]] < x.first)) {
dis[e.first] = x.first + e.second;
p[e.first] = x.second;
p2[e.first] = edgenum[x.second][i];
pq.push(pair<long long, long long>(dis[e.first], e.first));
}
}
}
vector<int> path;
long long dab = 0;
for (i = 0; i < n; i++) {
if (i == s) continue;
dab += dis[i] - dis[p[i]];
path.push_back(p2[i]);
}
printf("%I64d\n", dab);
for (auto e : path) printf("%d ", e);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = ~0ULL >> 1;
const int maxV = 3e5 + 10;
const int maxE = 6e5 + 10;
struct EDGE {
int v, nxt;
long long w;
EDGE() {}
EDGE(int vv, int xx, long long ww) { v = vv, nxt = xx, w = ww; }
};
EDGE edg[maxE];
int EH[maxV], etot;
void initG() {
memset(EH, -1, sizeof(EH));
etot = 0;
}
void addEdge(int u, int v, long long w) {
edg[etot] = EDGE(v, EH[u], w);
EH[u] = etot++;
}
int n, m;
short an[maxE];
long long dist[maxV];
short vs[maxV];
struct Node {
int src, id;
long long dst;
Node() {}
Node(int ss, long long dd, int ii) { src = ss, dst = dd, id = ii; }
bool operator<(const Node &rhs) const {
return (rhs.dst < dst) || (dst == rhs.dst && edg[rhs.id].w < edg[id].w);
}
};
void spfa(int s) {
for (int i = 1; i <= n; i++) dist[i] = inf;
memset(vs, 0, sizeof(vs));
memset(an, 0, sizeof(an));
priority_queue<Node> que;
dist[s] = 0;
que.push(Node(s, dist[s], -1));
long long rs = 0;
while (!que.empty()) {
Node now = que.top();
que.pop();
int u = now.src;
int id = now.id;
if (vs[u]) continue;
vs[u] = 1;
if (id != -1) {
rs += edg[id].w;
an[id] = 1;
}
for (int p = EH[u]; ~p; p = edg[p].nxt) {
int v = edg[p].v;
long long w = edg[p].w;
if (dist[v] >= dist[u] + w) {
dist[v] = dist[u] + w;
que.push(Node(v, dist[v], p));
}
}
}
cout << rs << endl;
m <<= 1;
for (int i = 0; i < m; i++)
if (an[i]) cout << (i / 2 + 1) << ' ';
cout << endl;
}
int main() {
int u, v, p;
long long w;
while (~scanf("%d%d", &n, &m)) {
initG();
for (int i = 1; i <= m; i++) {
scanf("%d%d%I64d", &u, &v, &w);
addEdge(u, v, w);
addEdge(v, u, w);
}
scanf("%d", &p);
spfa(p);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
const int INF = 0x3f3f3f3f;
struct edge {
int u, v, w, id, b;
} e[N];
vector<edge> adj[N];
long long dist[N];
int last[N];
int main() {
int n, m, u, v, w, s;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &u, &v, &w);
adj[u].push_back((edge){u, v, w, i, 0});
adj[v].push_back((edge){v, u, w, i, 0});
e[i] = (edge){u, v, w, i, 0};
}
scanf("%d", &s);
memset((dist), (INF), sizeof(dist));
memset((last), (-1), sizeof(last));
dist[s] = 0;
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
q.push(make_pair(0, s));
while (!q.empty()) {
pair<long long, int> p = q.top();
q.pop();
int u = p.second;
if (dist[u] < p.first) continue;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i].v, w = adj[u][i].w;
if (dist[v] > dist[u] + w) {
dist[v] = dist[u] + w;
if (last[v] != -1) e[last[v]].b = 0;
last[v] = adj[u][i].id;
e[last[v]].b = 1;
q.push(make_pair(dist[v], v));
} else if (dist[v] == dist[u] + w && e[last[v]].w > w) {
if (last[v] != -1) e[last[v]].b = 0;
last[v] = adj[u][i].id;
e[last[v]].b = 1;
}
}
}
long long ans = 0;
for (int i = 1; i <= m; i++)
if (e[i].b) ans += e[i].w;
printf("%lld\n", ans);
for (int i = 1; i <= m; i++)
if (e[i].b) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int INF = LLONG_MAX;
vector<vector<pair<long long, long long> > > Adj;
vector<long long int> Dist;
vector<long long int> Last;
vector<int> parent;
void Dijkstra(int start) {
Dist[start] = 0;
Last[start] = 0;
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
PQ;
PQ.push(make_pair(0, start));
while (!PQ.empty()) {
int v = PQ.top().second;
long long int d_v = PQ.top().first;
PQ.pop();
if (Dist[v] != d_v) continue;
for (auto PR : Adj[v]) {
if (Dist[PR.first] == Dist[v] + PR.second && PR.second < Last[PR.first]) {
Last[PR.first] = PR.second;
parent[PR.first] = v;
}
if (Dist[PR.first] > Dist[v] + PR.second) {
cerr << PR.first << " ";
Dist[PR.first] = Dist[v] + PR.second;
Last[PR.first] = PR.second;
parent[PR.first] = v;
PQ.push(make_pair(Dist[PR.first], PR.first));
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
Adj.resize(n + 1);
Dist.resize(n + 1, INF);
Last.resize(n + 1, INF);
parent.resize(n + 1, -1);
map<pair<long long, long long>, int> cnt;
for (int i = 0; i < m; i++) {
int a, b;
long long int w;
cin >> a >> b >> w;
Adj[a].push_back(make_pair(b, w));
Adj[b].push_back(make_pair(a, w));
cnt[make_pair(a, b)] = i + 1;
cnt[make_pair(b, a)] = i + 1;
}
int u;
cin >> u;
Dijkstra(u);
long long int sum = 0;
vector<pair<long long, long long> > Edges;
for (int i = 1; i <= n; i++) {
if (parent[i] != -1) {
Edges.push_back(make_pair(i, parent[i]));
sum += Last[i];
}
}
cout << sum << endl;
vector<int> Sol;
for (auto PR : Edges) {
Sol.push_back(cnt[PR]);
}
sort(Sol.begin(), Sol.end());
for (int x : Sol) {
cout << x << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, u;
long long res;
vector<pair<pair<int, int>, int> > adj[300001];
vector<long long> d(300001, 1000000000000000000),
maxPar(300001, 1000000000000000000);
int parent[300001];
stack<int> result;
void dijkstra() {
d[u] = 0;
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
pq;
pq.push(make_pair(0, u));
while (!pq.empty()) {
pair<long long, int> temp = pq.top();
pq.pop();
long long dist = temp.first;
int node = temp.second;
if (dist > d[node]) continue;
for (int i = 0; i < adj[node].size(); i++) {
pair<int, int> v = adj[node][i].first;
if (d[node] + v.second < d[v.first]) {
d[v.first] = d[node] + v.second;
pq.push(make_pair(d[v.first], v.first));
parent[v.first] = node;
maxPar[v.first] = v.second;
} else if (d[node] + v.second == d[v.first] && v.second < maxPar[v.first])
parent[v.first] = node, maxPar[v.first] = v.second;
}
}
}
void solve() {
for (int i = 1; i <= n; i++) {
if (i == u) continue;
bool stop = 0;
for (int j = 0; j < adj[i].size() && !stop; j++) {
if (parent[i] == adj[i][j].first.first)
res += (long long)adj[i][j].first.second, result.push(adj[i][j].second);
}
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
adj[a].push_back(make_pair(pair<int, int>(b, c), i + 1));
adj[b].push_back(make_pair(pair<int, int>(a, c), i + 1));
}
scanf("%d", &u);
dijkstra();
solve();
printf("%I64d\n", res);
while (!result.empty()) {
printf("%d ", result.top());
result.pop();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr long long inf = 2000000000000000000LL;
int main() {
long long n, m;
scanf("%lld%lld", &n, &m);
vector<vector<pair<long long, pair<long long, long long>>>> siblings(n);
for (long long i = 1; i <= m; i++) {
long long u, v, e;
scanf("%lld%lld%lld", &u, &v, &e);
u--, v--;
siblings.at(u).emplace_back(v, make_pair(e, i));
siblings.at(v).emplace_back(u, make_pair(e, i));
}
long long sv;
scanf("%lld", &sv);
sv--;
vector<long long> dists(n, inf), parentDists(n, inf), parentSegs(n, 0);
priority_queue<pair<long long, long long>> nexts;
dists.at(sv) = parentDists.at(sv) = 0;
nexts.emplace(0, sv);
while (!nexts.empty()) {
auto p = nexts.top();
nexts.pop();
if (-p.first > dists.at(p.second)) continue;
for (const auto& q : siblings.at(p.second)) {
if (dists.at(q.first) > dists.at(p.second) + q.second.first ||
(dists.at(q.first) == dists.at(p.second) + q.second.first &&
parentDists.at(q.first) > q.second.first)) {
dists.at(q.first) = dists.at(p.second) + q.second.first;
parentDists.at(q.first) = q.second.first;
parentSegs.at(q.first) = q.second.second;
nexts.emplace(-dists.at(q.first), q.first);
}
}
}
long long sum = 0;
for (long long v : parentDists) sum += v;
printf("%lld\n", sum);
bool nf = false;
for (long long i = 0; i < n; i++) {
if (parentSegs.at(i) == 0) continue;
if (nf) putchar(' ');
printf("%lld", parentSegs.at(i));
nf = true;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
const int INF = 0x3f3f3f3f;
struct edge {
int u, v, w, id, b;
} e[N];
vector<edge> adj[N];
long long dist[N];
int last[N];
int main() {
int n, m, u, v, w, s;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &u, &v, &w);
adj[u].push_back((edge){-1, v, w, i, -1});
adj[v].push_back((edge){-1, u, w, i, -1});
e[i] = (edge){-1, -1, w, -1, 0};
}
scanf("%d", &s);
memset((dist), (INF), sizeof(dist));
memset((last), (-1), sizeof(last));
dist[s] = 0;
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
q.push(make_pair(0, s));
while (!q.empty()) {
pair<long long, int> p = q.top();
q.pop();
int u = p.second;
if (dist[u] < p.first) continue;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i].v, w = adj[u][i].w, id = adj[u][i].id;
if (dist[v] > dist[u] + w) {
dist[v] = dist[u] + w;
if (last[v] != -1) e[last[v]].b = 0;
last[v] = id;
e[last[v]].b = 1;
q.push(make_pair(dist[v], v));
} else if (dist[v] == dist[u] + w && e[last[v]].w > w) {
e[last[v]].b = 0;
last[v] = id;
e[last[v]].b = 1;
}
}
}
long long ans = 0;
for (int i = 1; i <= m; i++)
if (e[i].b) ans += e[i].w;
printf("%lld\n", ans);
for (int i = 1; i <= m; i++)
if (e[i].b) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 7;
const long long INF = 1e17;
set<pair<long long, int> > st;
vector<pair<int, long long> > adj[N];
long long dis[N], edge[N];
long long weight[N];
bool mark[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v, w;
cin >> u >> v >> w;
weight[i] = w;
u--, v--;
adj[v].push_back(make_pair(u, i));
adj[u].push_back(make_pair(v, i));
}
int v;
cin >> v;
v--;
for (int i = 0; i < n; i++) dis[i] = INF;
dis[v] = 0;
edge[v] = 0;
st.insert(make_pair(0, v));
while (!st.empty()) {
int u = st.begin()->second;
st.erase(st.begin());
int e = edge[u];
mark[e] = 1;
for (int i = 0; i < adj[u].size(); i++) {
int w = adj[u][i].first;
int p = adj[u][i].second;
if (dis[u] + weight[p] < dis[w] ||
(dis[u] + weight[p] == dis[w] && weight[p] < weight[edge[w]])) {
st.erase(make_pair(dis[w], w));
edge[w] = p;
dis[w] = dis[u] + weight[p];
st.insert(make_pair(dis[w], w));
}
}
}
long long cnt = 0;
for (int i = 1; i <= m; i++)
if (mark[i]) cnt += weight[i];
cout << cnt << "\n";
for (int i = 1; i <= m; i++)
if (mark[i]) cout << i << " ";
cout << "\n";
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>
struct Edge {
Edge(int a, int b, int64_t w) : a(a), b(b), weight(w), visited(false) {}
int other(int n) { return a == n ? b : a; }
int a, b;
int64_t weight;
bool visited;
};
struct DistanceWeight {
DistanceWeight(int n, int e, int64_t d, int64_t w) : n(n), e(e), d(d), w(w) {}
bool operator<(const DistanceWeight &dw) const {
if (d == dw.d) return w > dw.w;
return d > dw.d;
}
int n, e;
int64_t d, w;
};
std::vector<int64_t> nodeDistances;
std::vector<std::vector<int> > nodes;
std::vector<Edge> edges;
int main() {
int N, M;
std::cin >> N >> M;
nodes.resize(N);
for (int i = 0; i < M; ++i) {
int u, v;
int64_t w;
std::cin >> u >> v >> w;
int ei = edges.size();
edges.push_back(Edge(u - 1, v - 1, w));
nodes[u - 1].push_back(ei);
nodes[v - 1].push_back(ei);
}
int U0;
std::cin >> U0;
--U0;
nodeDistances.resize(N, -1);
nodeDistances[U0] = 0;
std::priority_queue<DistanceWeight> queue;
std::vector<int> &u0Node = nodes[U0];
for (size_t i = 0; i < u0Node.size(); ++i) {
int ei = u0Node[i];
Edge &e = edges[ei];
queue.push(DistanceWeight(e.other(U0), ei, e.weight, e.weight));
}
while (!queue.empty()) {
DistanceWeight dw = queue.top();
queue.pop();
int nodeIndex = dw.n;
if (nodeDistances[nodeIndex] >= 0) continue;
int64_t distance = dw.d;
nodeDistances[nodeIndex] = distance;
Edge &incoming = edges[dw.e];
incoming.visited = true;
std::vector<int> &node = nodes[nodeIndex];
for (size_t i = 0; i < node.size(); ++i) {
int edgeIndex = node[i];
Edge &edge = edges[edgeIndex];
if (edge.visited) continue;
int nextIndex = edge.other(nodeIndex);
if (nodeDistances[nextIndex] >= 0) continue;
queue.push(DistanceWeight(nextIndex, edgeIndex, distance + edge.weight,
edge.weight));
}
}
int64_t totalWeight = 0;
for (size_t i = 0; i < edges.size(); ++i) {
Edge &edge = edges[i];
if (edge.visited) totalWeight += edge.weight;
}
std::cout << totalWeight << std::endl;
int edgeCount = 0;
for (size_t i = 0; i < edges.size(); ++i) {
Edge &edge = edges[i];
if (edge.visited) {
if (edgeCount) std::cout << ' ';
std::cout << (i + 1);
++edgeCount;
}
}
std::cout << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
inline long long int max(long long int a, long long int b, long long int c) {
return max(max(a, b), c);
}
inline long long int min(long long int a, long long int b, long long int c) {
return min(min(a, b), c);
}
inline long long int max(long long int a, long long int b) {
return (a > b) ? a : b;
}
inline long long int min(long long int a, long long int b) {
return (a < b) ? a : b;
}
inline long long int mul(long long int x, long long int y, long long int mod_) {
return ((x % mod_) * 1LL * (y % mod_)) % mod_;
}
long long int power(long long int a, long long int n) {
long long int p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
}
n >>= 1;
a *= a;
}
return p;
}
long long int powm(long long int a, long long int n, long long int mod_) {
long long int p = 1;
while (n) {
if (n % 2) {
p = mul(p, a, mod_);
}
n >>= 1;
a = mul(a, a, mod_);
}
return p % mod_;
}
long long int powi(long long int a, long long int mod_) {
return powm(a, mod_ - 2, mod_);
}
vector<vector<pair<long long int, long long int>>> g;
vector<long long int> d, p, dep;
set<pair<long long int, long long int>> edges;
map<pair<long long int, long long int>, pair<long long int, long long int>> pos;
void dij(long long int x) {
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>>>
q;
q.push({0, x});
d[x] = 0;
while (!q.empty()) {
pair<long long int, long long int> pp = q.top();
q.pop();
for (auto pp1 : g[pp.second]) {
if ((pp.first + pp1.second < d[pp1.first]) or
((pp.first + pp1.second == d[pp1.first]) and
(pos[{pp1.first, p[pp1.first]}].second >
pos[{pp.second, pp1.first}].second))) {
d[pp1.first] = pp.first + pp1.second;
if (edges.count({pp1.first, p[pp1.first]})) {
edges.erase({pp1.first, p[pp1.first]});
edges.erase({p[pp1.first], pp1.first});
}
p[pp1.first] = pp.second;
q.push({d[pp1.first], pp1.first});
edges.insert({pp1.first, p[pp1.first]});
edges.insert({p[pp1.first], pp1.first});
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
long long int mn, mx;
long long int n, m, t, k, i, j, sum = 0, flag = 0, cnt = 0;
long long int x = 0, y = 0, z, l, r, q;
int TC = 1;
while (TC--) {
cin >> n >> m;
g.resize(n);
d.assign(n, 2000000000000000000);
p.assign(n, -1);
dep.assign(n, 0);
for (i = 0; i < m; ++i) {
cin >> x >> y >> z;
--x;
--y;
g[x].push_back({y, z});
g[y].push_back({x, z});
pos[{x, y}] = {i + 1, z};
pos[{y, x}] = {i + 1, z};
}
long long int u;
cin >> u;
--u;
dij(u);
for (auto pp : edges) {
sum += pos[pp].second;
}
sum /= 2;
cout << sum << '\n';
set<pair<long long int, long long int>> done;
for (auto pp1 : edges) {
if (done.count(pp1)) continue;
cout << pos[pp1].first << ' ';
done.insert({pp1.first, pp1.second});
done.insert({pp1.second, pp1.first});
}
};
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int SIZE = 5e6 + 5;
const long long INF = 1LL << 60;
const long double eps = 5e-11;
long long dist[300009];
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq;
vector<pair<long long, long long> > adj[300009];
vector<pair<long long, long long> > bt[300009];
long long par[300009];
vector<pair<pair<long long, long long>, long long> > el1;
long long fp(long long x) {
if (par[x] == x) return x;
return par[x] = fp(par[x]);
}
void mg(long long x, long long y) {
long long p1 = fp(x), p2 = fp(y);
if (p1 == p2) return;
par[p1] = p2;
}
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--;
adj[a].push_back(make_pair(b, c));
adj[b].push_back(make_pair(a, c));
el1.push_back(make_pair(make_pair(min(a, b), max(a, b)), i + 1));
}
sort((el1).begin(), (el1).end());
int(u);
scanf("%d", &u);
u--;
memset((dist), -1, sizeof((dist)));
dist[u] = 0;
pq.push(make_pair(0, u));
while (pq.size()) {
pair<long long, long long> cur = pq.top();
pq.pop();
long long x = cur.second;
long long d = cur.first;
if (d > dist[x]) continue;
for (auto i : adj[x]) {
long long nx = i.first;
long long nd = d + i.second;
if (dist[nx] != -1 && dist[nx] < nd) continue;
if (dist[nx] != -1 && dist[nx] == nd) {
bt[nx].push_back(make_pair(x, i.second));
} else {
bt[nx].clear();
bt[nx].push_back(make_pair(x, i.second));
dist[nx] = nd;
pq.push(make_pair(nd, nx));
}
}
}
long long tw = 0;
vector<pair<long long, long long> > ans;
for (int i = 0; i < (n); ++i) {
if (i == u) continue;
long long cmin = INF;
pair<long long, long long> cv;
for (auto j : bt[i]) {
if (cmin > j.second) {
cmin = j.second;
cv = make_pair(j.first, i);
}
}
tw += cmin;
ans.push_back(cv);
}
printf("%I64d\n", tw);
for (auto i : ans) {
auto it1 = lower_bound(
(el1).begin(), (el1).end(),
make_pair(make_pair(min(i.first, i.second), max(i.first, i.second)),
0LL));
printf("%I64d \n", it1->second);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 3e5 + 5;
long long droga[max_n], hejo[max_n];
int dojscie[max_n];
bool krotki[max_n];
vector<pair<int, pair<int, int> > > graf[max_n];
void djikstra(int x) {
for (int i = 1; i < max_n; i++) droga[i] = 1e16;
priority_queue<pair<long long, pair<int, int> > > kolejka;
droga[x] = 0;
kolejka.push(make_pair(0, make_pair(x, 0)));
while (kolejka.size()) {
pair<long long, pair<int, int> > u = kolejka.top();
kolejka.pop();
if (droga[u.second.first] < -u.first) continue;
for (auto i : graf[u.second.first]) {
if (droga[i.second.first] > i.first + droga[u.second.first]) {
droga[i.second.first] = i.first + droga[u.second.first];
kolejka.push(make_pair(-droga[i.second.first],
make_pair(i.second.first, i.second.second)));
dojscie[i.second.first] = i.second.second;
}
if (droga[i.second.first] == i.first + droga[u.second.first] &&
i.first < hejo[dojscie[i.second.first]])
dojscie[i.second.first] = i.second.second;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, a, b, c, poczatek;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> a >> b >> c;
hejo[i] = c;
graf[a].push_back(make_pair(c, make_pair(b, i)));
graf[b].push_back(make_pair(c, make_pair(a, i)));
}
cin >> poczatek;
djikstra(poczatek);
long long wynik = 0;
for (int i = 1; i <= n; i++) wynik += hejo[dojscie[i]];
cout << wynik << "\n";
for (int i = 1; i <= n; i++)
if (i != poczatek) cout << dojscie[i] << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long NN = 1e7 + 99;
const long long N = 2e6 + 99;
long long mod = 1e9 + 7;
const long long maxn = 1e7;
struct edge {
long long v, w, id;
long long u;
} e[N];
bool cmp(edge a, edge b) { return a.w < b.w; }
long long d[N];
struct Node {
long long pos, dis;
bool operator<(Node rhs) const { return rhs.dis < dis; }
};
priority_queue<Node> pq;
vector<edge> G[N];
bool vis[N];
bool ans[N];
long long W[N], U[N], V[N];
int f[N];
long long pre[N];
int Find(int x) { return f[x] == x ? x : f[x] = Find(f[x]); }
void dij(long long s) {
memset(d, 0x3f, sizeof d);
d[s] = 0;
pq.push({s, d[s]});
memset(vis, 0, sizeof vis);
while (!pq.empty()) {
auto now = pq.top();
pq.pop();
int u = now.pos;
if (vis[u]) continue;
vis[u] = 1;
for (auto e : G[u]) {
if (d[e.v] > d[u] + e.w) {
d[e.v] = d[u] + e.w;
ans[pre[e.v]] = 0;
pre[e.v] = e.id;
pq.push({e.v, d[e.v]});
ans[e.id] = 1;
} else if (d[e.v] == d[u] + e.w) {
if (W[pre[e.v]] > e.w) {
ans[pre[e.v]] = 0;
pre[e.v] = e.id;
ans[pre[e.v]] = 1;
}
}
}
}
}
long long sum = 0;
void solve() {
long long n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
long long u, v, w;
cin >> u >> v >> w;
U[i] = u, V[i] = v;
G[u].push_back({v, w, i});
G[v].push_back({u, w, i});
W[i] = w;
}
long long s;
cin >> s;
dij(s);
long long sum = 0;
for (int i = 1; i <= m; i++) {
if (ans[i]) sum += W[i];
}
cout << sum << endl;
for (int i = 1; i <= m; i++) {
if (ans[i]) cout << i << " ";
}
}
signed main() {
long long t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline char nchar() {
static const int bufl = 1 << 20;
static char buf[bufl], *a = NULL, *b = NULL;
return a == b && (b = (a = buf) + fread(buf, 1, bufl, stdin), a == b) ? EOF
: *a++;
}
inline int read() {
int x = 0, f = 1;
char c = nchar();
for (; !isdigit(c); c = nchar())
if (c == '-') f = -1;
for (; isdigit(c); c = nchar()) x = x * 10 + c - '0';
return x * f;
}
const int maxn = 3e5 + 1;
const int maxm = 3e5 + 1;
int n, m, ans[maxm], ant = 0;
namespace graph {
struct edge {
int v;
long long w;
int id, nxt;
} e[maxm << 1];
int h[maxn], tot = 0;
int pre[maxn];
long long d[maxn];
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
inline void add(int x, int y, long long w, int id) {
e[++tot] = (edge){y, w, id, h[x]};
h[x] = tot;
}
long long work(int s) {
fill(d, d + n + 1, LLONG_MAX >> 1);
q.push(pair<long long, int>(d[s] = 0, s));
while (!q.empty()) {
pair<long long, int> pr = q.top();
q.pop();
if (pr.first != d[pr.second]) continue;
int x = pr.second;
for (int i = h[x], v = e[i].v; i; i = e[i].nxt, v = e[i].v)
if (d[v] > d[x] + e[i].w) {
pre[v] = i;
q.push(pair<long long, int>(d[v] = d[x] + e[i].w, v));
} else if (d[v] == d[x] + e[i].w && e[i].w < e[pre[v]].w)
pre[v] = i;
}
long long ret = 0;
for (int i = 1; i <= n; ++i)
if (i != s) {
int p = pre[i];
ret += e[p].w;
ans[++ant] = e[p].id;
}
return ret;
}
} // namespace graph
int main() {
n = read(), m = read();
for (int i = 1; i <= m; ++i) {
int x = read(), y = read(), w = read();
graph::add(x, y, w, i);
graph::add(y, x, w, i);
}
printf("%lld\n", graph::work(read()));
for (int i = 1; i <= ant; ++i) printf("%d%c", ans[i], " \n"[i == ant]);
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 300010;
const long long INF = 1e16;
using namespace std;
set<long long> si;
long long d[MAXN];
int p[MAXN];
bool vis[MAXN];
int n, m;
struct HeapNode {
long long d;
int u;
bool operator<(const HeapNode& rhs) const { return d > rhs.d; }
};
struct Edge {
int to, next;
long long w;
int id;
} edge[MAXN << 1];
int head[MAXN], tot;
void init() {
tot = 0;
memset(head, 0xff, sizeof(head));
}
void addedge(int u, int v, long long w, int id) {
edge[tot].to = v;
edge[tot].w = w;
edge[tot].id = id;
edge[tot].next = head[u];
head[u] = tot++;
}
void dijkstra(int s) {
priority_queue<HeapNode> q;
for (int i = 1; i <= n; ++i) d[i] = INF;
d[s] = 0;
memset(vis, false, sizeof(vis));
memset(p, 0xff, sizeof(p));
q.push((HeapNode){0, s});
while (!q.empty()) {
HeapNode x = q.top();
q.pop();
int u = x.u;
if (vis[u]) continue;
vis[u] = 1;
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].to;
long long w = edge[i].w;
if (d[v] > d[u] + w) {
d[v] = d[u] + w;
p[v] = i;
q.push((HeapNode){d[v], v});
} else if (d[v] == d[u] + w && edge[p[v]].w > w) {
p[v] = i;
}
}
}
}
void print(int s) {
long long ans = 0;
for (int i = 1; i <= n; ++i) {
if (p[i] >= 0) ans += edge[p[i]].w;
}
cout << ans << endl;
for (int i = 1; i <= n; ++i) {
if (p[i] >= 0) si.insert(edge[p[i]].id);
}
for (__typeof((si).begin()) i = (si).begin(); i != (si).end(); ++i) {
printf("%d ", *i);
}
puts("");
}
int main() {
int u, v, s;
long long w;
scanf("%d%d", &n, &m);
init();
for (int i = 1; i <= m; ++i) {
scanf("%d%d%I64d", &u, &v, &w);
addedge(u, v, w, i);
addedge(v, u, w, i);
}
scanf("%d", &s);
dijkstra(s);
print(s);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1000000000000000000;
const int maxn = 300005;
struct Edge {
int v, w, j;
Edge(int a = 0, int b = 0, int c = 0) : v(a), w(b), j(c) {}
};
vector<Edge> G[maxn];
int p[maxn];
int q[maxn];
long long d[maxn];
struct cmp {
bool operator()(int a, int b) { return (d[a] == d[b] ? a < b : d[a] < d[b]); }
};
long long Dijkstra(int u) {
set<int, cmp> S;
long long res = 0;
S.insert(u);
while (S.size()) {
u = *S.begin();
res += q[u];
S.erase(S.begin());
for (int i = 0; i < G[u].size(); ++i) {
Edge e = G[u][i];
if (d[u] + e.w < d[e.v]) {
p[e.v] = e.j;
q[e.v] = e.w;
S.erase(e.v);
d[e.v] = d[u] + e.w;
S.insert(e.v);
} else if (d[e.v] == d[u] + e.w && q[e.v] > e.w) {
p[e.v] = e.j;
q[e.v] = e.w;
}
}
}
return res;
}
int main() {
int n, m, u, a, b, c;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d", &a, &b, &c);
G[a].push_back(Edge(b, c, i));
G[b].push_back(Edge(a, c, i));
}
scanf("%d", &u);
for (int i = 1; i <= n; ++i)
if (i != u) d[i] = inf;
cout << Dijkstra(u) << endl;
for (int i = 1; i <= n; ++i)
if (i != u) cout << p[i] << ' ';
}
|
#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<int> > ve;
vector<Edge> 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(i);
ve[v].push_back(i);
edges.push_back(Edge(u, v, w));
}
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) {
Edge &e = edges[ve[u][i]];
int v = (u == e.v ? e.u : e.v);
if ((d[u] + e.w < d[v]) || (d[u] + e.w == d[v] && e.w < w[v])) {
d[v] = d[u] + e.w;
h[v] = ve[u][i] + 1;
w[v] = e.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 << h[i] << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class Compare {
public:
bool operator()(pair<long long, int> x, pair<long long, int> y) {
return x.first > y.first;
}
};
vector<int> mat[300010], num[300010];
vector<long long> cost[300010];
priority_queue<pair<long long, int>, vector<pair<long long, int> >, Compare>
que;
int n, m;
long long dis[300010], CC[300010], Fuck[300010];
void dijkstra(int p) {
dis[p] = 0;
que.push(make_pair(dis[p], p));
while (!que.empty()) {
pair<long long, int> use = que.top();
p = use.second;
que.pop();
if (use.first != dis[p]) continue;
for (int i = 0; i <= (int)mat[p].size() - 1; i++) {
int x = mat[p][i];
if (dis[x] > dis[p] + cost[p][i]) {
dis[x] = dis[p] + cost[p][i];
CC[x] = cost[p][i];
Fuck[x] = num[p][i];
que.push(make_pair(dis[x], x));
} else if (dis[x] == dis[p] + cost[p][i] && CC[x] > cost[p][i])
CC[x] = cost[p][i], Fuck[x] = num[p][i];
}
}
return;
}
void prin() {
long long c = 0;
for (int i = 1; i <= n; i++) c += CC[i];
cout << c << endl;
for (int i = 1; i <= n; i++)
if (Fuck[i] != 0) cout << Fuck[i] << ' ';
}
void dijkstra_input() {
long long x, y, z, u;
for (int i = 1; i <= m; i++) {
cin >> x >> y >> z;
mat[x].push_back(y);
cost[x].push_back(z);
num[x].push_back(i);
mat[y].push_back(x);
cost[y].push_back(z);
num[y].push_back(i);
}
long long v = 1000000000000000000;
for (int i = 1; i <= n; i++) dis[i] = v;
cin >> u;
dijkstra(u);
prin();
return;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
dijkstra_input();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long n1, long long n2) {
if (n2 == 0) return n1;
if (n1 % n2 == 0) return n2;
return gcd(n2, n1 % n2);
}
long long powmod(long long base, long long exponent) {
if (exponent < 0) exponent += 1000000007LL - 1;
long long ans = 1;
while (exponent) {
if (exponent & 1) ans = (ans * base) % 1000000007LL;
base = (base * base) % 1000000007LL;
exponent /= 2;
}
return ans;
}
vector<pair<long long, long long> > v[1000005];
long long dist[1000005];
set<pair<long long, long long> > se;
map<pair<long long, long long>, pair<long long, long long> > me;
int pre[1000005], visit[1000005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
long long a, b, c;
cin >> a >> b >> c;
v[a].push_back(make_pair(b, c));
v[b].push_back(make_pair(a, c));
me[make_pair(a, b)] = make_pair(i + 1, c);
me[make_pair(b, a)] = make_pair(i + 1, c);
}
for (int i = 0; i <= n; i++) dist[i] = 1000000000000000000LL;
long long u;
cin >> u;
dist[u] = 0;
se.insert(make_pair(dist[u], u));
while (!se.empty()) {
int w = se.begin()->first;
int node = se.begin()->second;
se.erase(se.begin());
for (int i = 0; i < v[node].size(); i++) {
if (dist[v[node][i].first] >= dist[node] + v[node][i].second) {
se.erase(make_pair(dist[v[node][i].first], v[node][i].first));
dist[v[node][i].first] = dist[node] + v[node][i].second;
pre[v[node][i].first] = node;
se.insert(make_pair(dist[v[node][i].first], v[node][i].first));
}
}
}
long long sum = 0;
for (int i = 1; i <= n; i++) {
if (i == u) continue;
sum += me[make_pair(pre[i], i)].second;
}
cout << sum << '\n';
for (int i = 1; i <= n; i++) {
if (i == u) continue;
cout << me[make_pair(pre[i], i)].first << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
const long long inf = 1e18;
int n, m, s;
struct edge {
int v;
int w;
int id;
edge(int v = 0, int w = 0, int id = 0) : v(v), w(w), id(id) {}
};
vector<edge> G[N];
long long d[N];
vector<pair<int, int> > T[N];
long long ans;
vector<int> vec;
void dijkstra() {
for (int i = 1; i <= n; ++i) d[i] = inf;
d[s] = 0;
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
pq;
pq.push(make_pair(0, s));
while (!pq.empty()) {
pair<long long, int> t = pq.top();
pq.pop();
long long du = t.first;
int u = t.second;
if (du != d[u]) continue;
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i].v, w = G[u][i].w;
if (d[v] > du + w) d[v] = du + w, pq.push(pair<long long, int>(d[v], v));
}
}
}
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;
G[u].push_back(edge(v, w, i));
G[v].push_back(edge(u, w, i));
}
cin >> s;
dijkstra();
for (int u = 1; u <= n; ++u) {
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i].v, w = G[u][i].w, id = G[u][i].id;
if (d[v] == d[u] + w) T[v].push_back(make_pair(w, id));
}
}
for (int i = 1; i <= n; ++i)
if (T[i].size()) {
sort(T[i].begin(), T[i].end());
ans += T[i][0].first;
vec.push_back(T[i][0].second);
}
printf("%lld\n", ans);
for (int id : vec) printf("%d ", id);
printf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int y, w, idx;
Edge(int _y = 0, int _w = 0, int _idx = 0) {
y = _y;
w = _w;
idx = _idx;
}
};
int n, m, edgeIdx[300010], edgeWei[300010];
long long dis[300010], totalWei;
vector<int> ans;
vector<Edge> adj[300010];
void dijkstra(int s) {
set<pair<long long, int> > st;
for (int i = 0; i <= n; i++)
dis[i] = 1000ll * 1000 * 1000 * 1000 * 1000 * 1000;
dis[s] = 0;
st.insert(make_pair(0, s));
while ((int)st.size() > 0) {
pair<long long, int> v = *(st.begin());
st.erase(v);
int x = v.second;
if (x != s) {
ans.push_back(edgeIdx[x]);
totalWei += edgeWei[x];
}
for (int i = 0; i < (int)adj[x].size(); i++) {
int w = adj[x][i].w;
int y = adj[x][i].y;
if ((dis[x] + w < dis[y]) ||
(dis[x] + w == dis[y] && adj[x][i].w < edgeWei[y])) {
st.erase(make_pair(dis[y], y));
dis[y] = dis[x] + w;
st.insert(make_pair(dis[y], y));
edgeIdx[y] = adj[x][i].idx;
edgeWei[y] = adj[x][i].w;
}
}
}
}
int main() {
int s;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y, w;
cin >> x >> y >> w;
Edge e1 = Edge(y, w, i + 1);
Edge e2 = Edge(x, w, i + 1);
adj[x].push_back(e1);
adj[y].push_back(e2);
}
cin >> s;
dijkstra(s);
cout << totalWei << endl;
for (int i = 0; i < (int)ans.size(); i++) cout << ans[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int V, E;
vector<pair<int, int> > G[300000 + 10];
long long d[300000 + 10];
int f[300000 + 10], t[300000 + 10], co[300000 + 10];
int val[300000 + 10], pos[300000 + 10];
void dijkstra(int s) {
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
Q;
d[s] = 0;
Q.push(make_pair(d[s], s));
while (!Q.empty()) {
pair<int, int> p = Q.top();
Q.pop();
int v = p.second;
if (d[v] < p.first) continue;
for (int i = 0; i < G[v].size(); i++) {
pair<int, int> e = G[v][i];
if (d[e.first] > d[v] + (long long)e.second) {
d[e.first] = d[v] + (long long)e.second;
Q.push(make_pair(d[e.first], e.first));
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> V >> E;
for (int i = 0; i < V; i++) d[i] = 1000000000000000LL;
for (int i = 0; i < E; i++) {
int x, y, c;
cin >> x >> y >> c;
x--;
y--;
f[i] = x;
t[i] = y;
co[i] = c;
G[x].push_back(make_pair(y, c));
G[y].push_back(make_pair(x, c));
}
int s;
cin >> s;
s--;
dijkstra(s);
memset(val, 0x3f, sizeof(val));
for (int i = 0; i < E; i++) {
long long p = d[f[i]], q = d[t[i]];
int ss = f[i], tt = t[i], cc = co[i];
if (p > q) {
swap(p, q);
swap(ss, tt);
}
if (cc == (q - p) && cc < val[tt]) {
val[tt] = cc;
pos[tt] = i + 1;
}
}
long long sum = 0;
for (int i = 0; i < V; i++)
if (i != s) sum = sum + val[i];
cout << sum << endl;
for (int i = 0; i < V; i++)
if (i != s) cout << pos[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct e {
int vertex;
int w;
int id;
e(int _vertex, int _w, int _id) {
vertex = _vertex;
w = _w;
id = _id;
}
};
struct pq_e {
int vertex;
long long total_w;
int w;
int id;
int prev;
pq_e(int _vertex, long long _total_w, int _w, int _id, int _prev) {
vertex = _vertex;
total_w = _total_w;
w = _w;
id = _id;
prev = _prev;
}
};
class comp {
public:
bool operator()(const pq_e &a, const pq_e &b) {
if (a.total_w != b.total_w) {
return a.total_w > b.total_w;
}
return a.w > b.w;
}
};
int n = 0;
int m = 0;
int start = 0;
long long total = 0;
vector<int> ans;
const long long inf = 1000000000000000;
long long dis[300005];
bool vis[300005];
vector<e> graph[300005];
priority_queue<pq_e, vector<pq_e>, comp> pq;
void dijkstra() {
for (int i = 1; i <= n; i++) {
vis[i] = 0;
dis[i] = inf;
}
dis[0] = 0;
pq_e pqe(start, 0, 0, 0, 0);
pq.push(pqe);
while (!pq.empty()) {
while (!pq.empty() && vis[pq.top().vertex]) pq.pop();
if (pq.empty()) break;
pq_e cur = pq.top();
pq.pop();
vis[cur.vertex] = 1;
dis[cur.vertex] = cur.total_w;
ans.push_back(cur.id);
total += cur.w;
for (int i = 0; i < graph[cur.vertex].size(); i++) {
if (!vis[graph[cur.vertex][i].vertex]) {
pq_e nw(graph[cur.vertex][i].vertex,
graph[cur.vertex][i].w * 1ll + cur.total_w,
graph[cur.vertex][i].w, graph[cur.vertex][i].id, cur.vertex);
pq.push(nw);
}
}
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int a, b, w;
cin >> a >> b >> w;
e edge1(b, w, i);
e edge2(a, w, i);
graph[a].push_back(edge1);
graph[b].push_back(edge2);
}
cin >> start;
dijkstra();
cout << total << endl;
for (int i = 1; i < ans.size(); i++) {
cout << ans[i] << " ";
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, ss, u;
long long int d, v, w = 0;
vector<vector<pair<long long int, int> > > adj((int)(3e5 + 10));
vector<long long int> p((int)(3e5 + 10), (long long int)(1e15 + 10));
vector<int> a((int)(3e5 + 10)), ans;
vector<bool> c((int)(3e5 + 10), 0);
map<pair<int, int>, pair<long long int, int> > e;
multiset<pair<long long int, int>, less<pair<long long int, int> > > q;
void sol() {
q.insert(make_pair(0, ss));
a[ss] = ss;
p[ss] = 0;
for (int i = 1; i <= n; i++)
if (i != ss) q.insert(make_pair((long long int)(1e15 + 10), i));
while (!q.empty()) {
u = q.begin()->second, v = q.begin()->first, q.erase(q.begin());
c[u] = 1;
x = min(u, a[u]), y = max(u, a[u]);
if (e[make_pair(x, y)].first != 0) {
w += e[make_pair(x, y)].first;
ans.push_back(e[make_pair(x, y)].second);
e[make_pair(x, y)].first = 0;
}
for (int i = 0, node; i < adj[u].size(); i++) {
node = adj[u][i].second, d = adj[u][i].first;
if (c[node]) continue;
if (v + d <= p[node]) {
q.erase(q.find(make_pair(p[node], node)));
p[node] = v + d, a[node] = u;
q.insert(make_pair(p[node], node));
}
}
}
}
int main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0, tx, ty; i < m; i++) {
cin >> tx >> ty >> d;
x = min(tx, ty);
y = max(tx, ty);
e[make_pair(x, y)] = make_pair(d, i + 1);
adj[x].push_back(make_pair(d, y));
adj[y].push_back(make_pair(d, x));
}
cin >> ss;
sol();
sort(ans.begin(), ans.end());
cout << w << "\n";
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a < b)
return a;
else
return b;
}
struct ff {
long long v, w, idx;
ff(long long a, long long b, long long c) {
v = a;
w = b;
idx = c;
}
};
struct node {
long long cur, cost, idx, weight;
node(long long a, long long b, long long c, long long d) {
cur = a;
cost = b;
weight = c;
idx = d;
}
};
bool operator<(node a, node b) { return a.cost > b.cost; }
vector<ff> g[300005];
pair<long long, long long> dist[300005];
vector<long long> edge;
long long dijkstra(long long s, long long n) {
for (int i = 1; i <= n; i++) {
dist[i].first = 9223372036854775806;
}
priority_queue<node> pq;
pq.push(node(s, 0, 0, 0));
dist[s].first = 0;
long long ans = 0;
while (!pq.empty()) {
long long u = pq.top().cur;
long long c = pq.top().cost;
long long i = pq.top().idx;
long long last = pq.top().weight;
pq.pop();
if (dist[u].first != c || dist[u].second != last) continue;
ans += last;
edge.push_back(i);
for (ff x : g[u]) {
long long v = x.v;
long long w = x.w;
long long j = x.idx;
if (dist[u].first + w == dist[v].first) {
if (w < dist[v].second) {
dist[v].second = w;
pq.push(node(v, dist[v].first, w, j));
}
} else if (dist[u].first + w < dist[v].first) {
dist[v].first = dist[u].first + w;
dist[v].second = w;
pq.push(node(v, dist[v].first, w, j));
}
}
}
return ans;
}
int main() {
long long n, m, u, v, w;
scanf("%lld %lld", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%lld %lld %lld", &u, &v, &w);
g[u].push_back(ff(v, w, i));
g[v].push_back(ff(u, w, i));
}
scanf("%lld", &u);
long long ans = dijkstra(u, n);
printf("%lld\n", ans);
for (int i = 1; i < edge.size(); i++) {
printf("%lld ", edge[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 10, MOD = 1e9 + 7, INF = 1e15, SQ = 370, LOG = 30;
long long n, m, x, y, z, t, now, d, cur, ans, k, dp[N], sum, ptr, val[N],
par[N], pare[N], last[N];
bool mark[N];
vector<pair<pair<long long, long long>, long long> > v[N];
vector<long long> e;
set<pair<long long, long long> > s;
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> x >> y >> z;
val[i] = z;
v[x].push_back(make_pair(make_pair(y, z), i));
v[y].push_back(make_pair(make_pair(x, z), i));
}
for (int i = 1; i <= n; i++) last[i] = dp[i] = INF;
cin >> now;
dp[now] = 0;
par[now] = -1;
s.insert(make_pair(0, now));
while (s.size()) {
sum = (*s.begin()).first;
now = (*s.begin()).second;
s.erase(s.begin());
for (int i = 0; i < v[now].size(); i++) {
x = v[now][i].first.first, y = v[now][i].first.second,
z = v[now][i].second;
if (sum + y < dp[x]) {
last[x] = val[z];
dp[x] = sum + y;
par[x] = now;
pare[x] = z;
s.insert(make_pair(dp[x], x));
}
if (sum + y == dp[x] && val[z] < last[x]) {
last[x] = val[z];
dp[x] = sum + y;
par[x] = now;
pare[x] = z;
s.insert(make_pair(dp[x], x));
}
}
}
for (int i = 1; i <= n; i++) {
x = i;
while (par[x] != -1 && !mark[x]) {
e.push_back(pare[x]);
mark[x] = true;
x = par[x];
}
}
for (int i = 0; i < e.size(); i++) {
ans += val[e[i]];
}
cout << ans << '\n';
sort(e.begin(), e.end());
for (int i = 0; i < e.size(); i++) {
cout << e[i] << ' ';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 6e5 + 5;
struct Edge {
int to, ne, ii;
long long w;
} e[MAX];
int head[MAX], tot, n, m;
bool vis[MAX];
int ans[MAX], cnt;
long long dis[MAX];
void add(int u, int v, long long w, int i) {
e[++tot].to = v;
e[tot].ne = head[u];
e[tot].w = w;
e[tot].ii = i;
head[u] = tot;
}
struct Point {
int id;
long long c;
Point() {}
Point(int id, long long c) : id(id), c(c) {}
bool operator<(const Point& b) const { return c > b.c; }
};
void Dijkstra(int st) {
for (int i = 1; i <= n; i++) dis[i] = LLONG_MAX;
dis[st] = 0;
priority_queue<Point> pq;
pq.push(Point(st, 0));
while (!pq.empty()) {
Point cur = pq.top();
pq.pop();
if (vis[cur.id]) continue;
vis[cur.id] = 1;
for (int i = head[cur.id]; i != -1; i = e[i].ne) {
int v = e[i].to;
if (dis[v] > dis[cur.id] + e[i].w) {
dis[v] = dis[cur.id] + e[i].w;
pq.push(Point(v, dis[v]));
}
}
}
}
int main() {
int u, v;
memset(head, -1, sizeof head);
long long w;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
scanf("%d%d%lld", &u, &v, &w);
add(u, v, w, i);
add(v, u, w, i);
}
cin >> u;
Dijkstra(u);
int minid;
long long ANS = 0;
for (int i = 1; i <= n; i++) {
if (i == u) continue;
long long minn = LLONG_MAX;
for (int j = head[i]; j != -1; j = e[j].ne) {
if (dis[i] == dis[e[j].to] + e[j].w && minn > e[j].w) {
minn = e[j].w;
minid = e[j].ii;
}
}
ANS += minn;
ans[++cnt] = minid;
}
printf("%lld\n", ANS);
for (int i = 1; i <= cnt; i++) {
printf("%d ", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > p[300001];
map<pair<int, int>, int> mp;
vector<pair<int, int> > ans;
priority_queue<pair<int64_t, int> > q;
priority_queue<pair<int64_t, int> > distanc;
bool used[300001];
int64_t d[300001];
int64_t d1[300001];
int path[300001];
int len[300001], m, n;
int get_max() {
if (distanc.size()) {
while (distanc.size() and used[distanc.top().second] == 0) {
distanc.pop();
}
if (distanc.size()) return distanc.top().second;
}
return -1;
}
int main() {
int v1, v2, w;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
scanf("%d %d %d", &v1, &v2, &w);
p[v1].push_back(make_pair(v2, w));
p[v2].push_back(make_pair(v1, w));
mp[make_pair(v1, v2)] = i;
mp[make_pair(v2, v1)] = i;
}
for (int i = 1; i <= 3e5; i++) {
d[i] = 1e15;
}
pair<int64_t, int> v, to;
int u;
cin >> u;
q.push(make_pair(0, u));
d[u] = 0;
while (q.size()) {
v = q.top();
q.pop();
if (used[v.second] == 1) continue;
v.first = -v.first;
used[v.second] = 1;
for (int i = 0; i < p[v.second].size(); i++) {
to = p[v.second][i];
if (d[v.second] + to.second < d[to.first]) {
d[to.first] = d[v.second] + to.second;
q.push(make_pair(-d[to.first], to.first));
}
}
}
for (int i = 1; i <= 3e5; i++) {
d1[i] = d[i];
distanc.push(make_pair(-d1[i], i));
d[i] = 1e15;
used[i] = 0;
}
q.push(make_pair(0, u));
d[u] = 0;
path[u] = -1;
while (q.size()) {
v = q.top();
q.pop();
v.first = -v.first;
if (used[v.second] == 1) continue;
used[v.second] = 1;
for (int i = 0; i < p[v.second].size(); i++) {
to = p[v.second][i];
if (to.second < d[to.first] and
d1[v.second] + to.second <= d1[to.first]) {
d[to.first] = to.second;
path[to.first] = v.second;
q.push(make_pair(-d[to.first], to.first));
}
}
}
int64_t weight = 0;
while (1) {
int last = get_max();
if (last == -1) break;
weight += d1[last];
while (1) {
used[last] = 0;
if (path[last] != -1) {
ans.push_back(make_pair(last, path[last]));
}
last = path[last];
if (last == -1 or used[last] == 0) break;
}
if (last != -1) weight -= d1[last];
}
cout << weight << endl;
for (int i = 0; i < ans.size(); i++) {
printf("%d ", mp[make_pair(ans[i].first, ans[i].second)]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 7, M = 2e6;
const long long mod = 1e9 + 7;
inline int read() {
int ret = 0;
char ch = getchar();
bool f = 1;
for (; !isdigit(ch); ch = getchar()) f ^= !(ch ^ '-');
for (; isdigit(ch); ch = getchar()) ret = (ret << 1) + (ret << 3) + ch - 48;
return f ? ret : -ret;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long ksm(long long a, long long b, long long mod) {
int ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ans;
}
long long inv2(long long a, long long mod) { return ksm(a, mod - 2, mod); }
long long wei[M], dis[N], d[N];
bool vis[N];
int fa[N];
int head[N], NEXT[M], ver[M], tot;
void link(int u, int v, long long w) {
ver[++tot] = v;
NEXT[tot] = head[u];
head[u] = tot;
wei[tot] = w;
}
long long ans;
int cha(int x) {
if (x == fa[x]) return x;
return fa[x] = cha(fa[x]);
}
struct node {
int u, v;
long long w;
int id;
} pre[N];
int n;
vector<int> qq;
void dij(int x) {
for (int i = 1; i <= n; i++) {
dis[i] = 1152921504606846976;
}
dis[x] = 0;
pre[x].id = 0;
priority_queue<pair<long long, int> > q;
q.push(make_pair(0, x));
while (!q.empty()) {
x = q.top().second;
q.pop();
if (vis[x]) continue;
vis[x] = true;
if (pre[x].id != 0) {
int xx = cha(pre[x].u);
int yy = cha(pre[x].v);
if (xx != yy) {
qq.push_back(pre[x].id);
ans += wei[pre[x].id * 2];
fa[xx] = yy;
}
}
for (int i = head[x]; i; i = NEXT[i]) {
int y = ver[i];
if (dis[y] > dis[x] + wei[i]) {
dis[y] = dis[x] + wei[i];
q.push(make_pair(-dis[y], y));
pre[y].id = i / 2;
pre[y].u = x;
pre[y].v = y;
} else if (dis[y] == dis[x] + wei[i]) {
if (wei[pre[y].id * 2] > wei[i]) {
pre[y].id = i / 2;
pre[y].u = x;
pre[y].v = y;
}
}
}
}
}
int main() {
int m;
int u, v;
long long w;
scanf("%d%d", &n, &m);
tot = 1;
ans = 0;
for (int i = 1; i <= n; i++) fa[i] = i, d[i] = 1152921504606846976;
for (int i = 1; i <= m; i++) {
scanf("%d%d%lld", &u, &v, &w);
link(u, v, w);
link(v, u, w);
}
int inp;
scanf("%d", &inp);
dij(inp);
printf("%lld\n", ans);
for (int i = 0; i < qq.size(); i++) printf("%d ", qq[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 0x3f3f3f3f3f3f3f3fll;
int N, M, S;
struct T_Edge {
int u, v, l;
T_Edge() {}
T_Edge(int u, int v, int l) : u(u), v(v), l(l) {}
inline int other(int x) { return x == u ? v : u; }
} es[300009];
vector<int> tab[300009];
long long dis[300009];
int ans[300009];
int main() {
scanf("%d%d", &N, &M);
for (int i = 0; i < M; i++) {
scanf("%d%d%d", &es[i].u, &es[i].v, &es[i].l);
tab[es[i].u].push_back(i);
tab[es[i].v].push_back(i);
}
scanf("%d", &S);
memset(dis, 0x3f, sizeof(dis));
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
q.push(make_pair(0ll, S));
static bool used[300009];
memset(used, 0, sizeof(used));
memset(ans, -1, sizeof(ans));
while (!q.empty()) {
pair<long long, int> h = q.top();
q.pop();
int &u = h.second;
long long &d = h.first;
if (used[u]) continue;
dis[u] = d;
used[u] = true;
for (size_t i = 0; i < tab[u].size(); i++) {
T_Edge &e = es[tab[u][i]];
int v = e.other(u);
if (d + e.l <= dis[v] && (ans[v] == -1 || e.l < es[ans[v]].l))
ans[v] = tab[u][i];
if (!used[v] && d + e.l < dis[v]) {
dis[v] = d + e.l;
q.push(make_pair(d + e.l, v));
}
}
}
long long weight = 0;
for (int i = 1; i <= N; i++)
if (i != S) weight += es[ans[i]].l;
printf("%I64d\n", weight);
for (int i = 1; i <= N; i++)
if (i != S) printf("%d ", ans[i] + 1);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream& operator<<(ostream& stream, const vector<T> v) {
stream << "[ ";
for (int i = 0; i < (int)v.size(); i++) stream << v[i] << " ";
stream << "]";
return stream;
}
long long fpow(long long x, long long p, long long m) {
long long r = 1;
for (; p; p >>= 1) {
if (p & 1) r = r * x % m;
x = x * x % m;
}
return r;
}
long long inv(long long a, long long b) {
return a < 2 ? a : ((a - inv(b % a, a)) * b + 1) / a % b;
}
int gcd(int a, int b) {
if (!b) return a;
return gcd(b, a % b);
}
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
struct edge {
int id, to;
edge(int id, int to) : id(id), to(to) {}
};
int N, M, c[300010], deg[300010];
vector<edge> g[300010], gd[300010];
long long dist[300010];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> N >> M;
int i, x, y;
for (i = 1; i <= M; i++) {
cin >> x >> y >> c[i];
g[x].push_back(edge(i, y));
g[y].push_back(edge(i, x));
}
int u;
cin >> u;
for (i = 1; i <= N; i++) dist[i] = -1;
dist[u] = 0;
set<pair<int, int> > st;
st.insert({0, u});
while (!st.empty()) {
pair<int, int> cr = *st.begin();
st.erase(st.begin());
int nod = cr.second;
for (edge e : g[nod]) {
long long d = c[e.id] + dist[nod];
if (dist[e.to] == -1 || d < dist[e.to]) {
if (dist[e.to] != -1) st.erase({dist[e.to], e.to});
dist[e.to] = d;
st.insert({d, e.to});
}
}
}
for (i = 1; i <= N; i++)
for (edge e : g[i])
if (dist[i] + c[e.id] == dist[e.to])
gd[e.to].push_back({e.id, i}), deg[i]++;
vector<int> q;
for (i = 1; i <= N; i++)
if (deg[i] == 0) q.push_back(i);
vector<int> ans;
long long res = 0;
for (i = 0; i < q.size(); i++) {
int nod = q[i];
if (nod == u) break;
long long minc = (1ll << 40), id = 0;
for (edge e : gd[nod]) {
deg[e.to]--;
if (c[e.id] < minc) {
minc = c[e.id];
id = e.id;
}
if (deg[e.to] == 0) q.push_back(e.to);
}
ans.push_back(id);
res += minc;
}
cout << res << "\n";
for (i = 0; i < N - 1; i++) cout << ans[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char buf[100000], *p1 = buf, *p2 = buf;
inline int gi() {
int x = 0, f = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48), ch = getchar();
}
return (f == 1) ? x : -x;
}
const int maxn = 3e5 + 5;
int pre[maxn], s, n, m, lst[maxn];
long long dis[maxn];
vector<pair<int, pair<int, int>>> e[maxn];
struct node {
int u;
long long dis;
inline bool operator<(const node &b) const { return dis > b.dis; }
};
priority_queue<node> pq;
long long ans;
inline void input() {
n = gi(), m = gi();
for (int i = 1; i <= m; ++i) {
int u = gi(), v = gi(), w = gi();
e[u].push_back({i, {v, w}});
e[v].push_back({i, {u, w}});
}
s = gi();
}
bool vis[maxn];
inline void dijkstra(int u) {
pq.push({u, 0});
memset(dis, 0x3f, sizeof(dis));
dis[u] = 0;
while (!pq.empty()) {
int u = pq.top().u;
pq.pop();
if (vis[u]) continue;
vis[u] = 1;
for (auto x : e[u]) {
int id = x.first, v = x.second.first, w = x.second.second;
if (dis[v] > dis[u] + w) {
ans -= lst[v], ans += w;
dis[v] = dis[u] + w;
pre[v] = id;
lst[v] = w;
pq.push({v, dis[v]});
} else if (dis[v] == dis[u] + w && w < lst[v]) {
pre[v] = id;
ans -= lst[v];
ans += w;
lst[v] = w;
}
}
}
}
inline void solve() {
dijkstra(s);
printf("%lld\n", ans);
vector<int> answers;
for (int i = 1; i <= n; ++i)
if (i != s) answers.push_back(pre[i]);
sort(answers.begin(), answers.end());
for (int x : answers) printf("%d ", x);
}
int main() {
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
template <class T>
T _diff(T a, T b) {
return (a < b ? b - a : a - b);
}
template <class T>
T _abs(T a) {
return (a < 0 ? -a : 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>
T max3(T a, T b, T c) {
return (_max(a, b) > c ? _max(a, b) : c);
}
template <class T>
T min3(T a, T b, T c) {
return (_min(a, b) < c ? _min(a, b) : c);
}
template <class T>
T GCD(T a, T b) {
a = _abs(a);
b = _abs(b);
T tmp;
while (a % b) {
tmp = a % b;
a = b;
b = tmp;
}
return b;
}
template <class T>
T LCM(T a, T b) {
a = _abs(a);
b = _abs(b);
return (a / GCD(a, b)) * b;
}
template <class T>
T toRad(T deg) {
return (deg * 2.0 * acos(0.0)) / (180.0);
}
template <class T>
T toDeg(T rad) {
return (rad * 180.0) / (2.0 * acos(0.0));
}
using namespace std;
class Edge {
public:
int u, id;
long long w, tot;
bool operator<(const Edge &b) const {
if (tot == b.tot)
return w > b.w;
else
return tot > b.tot;
}
};
vector<Edge> mat[300005];
vector<int> res_Edge;
long long total;
bool vis[300005];
priority_queue<Edge> Q;
int n, m;
int main() {
int u, v;
long long w;
Edge tmp;
scanf("%d", &n);
scanf("%d", &m);
memset(vis, 0, sizeof(vis));
for (int i = 0; i <= n; i++) mat[i].clear();
while (!Q.empty()) Q.pop();
for (int i = 1; i <= m; i++) {
scanf("%d", &u);
scanf("%d", &v);
cin >> w;
tmp.id = i;
tmp.tot = w;
tmp.w = w;
tmp.u = u;
mat[v].push_back(tmp);
tmp.u = v;
mat[u].push_back(tmp);
}
cin >> u;
total = 0;
Edge tmp1;
res_Edge.clear();
vis[u] = 1;
for (int i = 0; i < mat[u].size(); i++) {
Q.push(mat[u][i]);
}
while (!Q.empty()) {
tmp = Q.top();
Q.pop();
if (vis[tmp.u]) continue;
res_Edge.push_back(tmp.id);
total += tmp.w;
vis[tmp.u] = 1;
for (int i = 0; i < mat[tmp.u].size(); i++) {
if (vis[mat[tmp.u][i].u]) continue;
tmp1 = mat[tmp.u][i];
tmp1.tot = tmp1.w + tmp.tot;
Q.push(tmp1);
}
}
cout << total << endl;
for (int i = 0; i < res_Edge.size(); i++) cout << res_Edge[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
vector<pair<int, pair<long long int, long long int>>> adj[n + 5];
long long int x, y, w, idx, wei;
vector<long long int> weights(m);
for (int i = 0; i < m; i++) {
cin >> x >> y >> w;
adj[x].emplace_back(i, make_pair(w, y));
adj[y].emplace_back(i, make_pair(w, x));
weights[i] = w;
}
int st;
cin >> st;
vector<bool> vis(n + 5, false);
vector<long long int> rel(m + 5, false), cur(m + 5, -1),
dist(n + 5, LLONG_MAX / 2);
priority_queue<pair<long long int, long long int>> Q;
Q.emplace(0, st);
dist[st] = 0;
while (!Q.empty()) {
auto X = Q.top();
tie(w, x) = X;
Q.pop();
w = -w;
for (auto to : adj[x]) {
idx = to.first;
y = to.second.second;
wei = to.second.first;
if (dist[x] + wei == dist[y] and weights[idx] < weights[cur[y]]) {
dist[y] = dist[x] + wei;
Q.emplace(-dist[y], y);
rel[idx] = true;
if (cur[y] != -1) {
rel[cur[y]] = false;
}
cur[y] = idx;
}
if (dist[x] + wei < dist[y]) {
dist[y] = dist[x] + wei;
Q.emplace(-dist[y], y);
rel[idx] = true;
if (cur[y] != -1) {
rel[cur[y]] = false;
}
cur[y] = idx;
}
}
}
long long int ans = 0;
for (int i = 0; i < rel.size(); i++)
if (rel[i]) ans += weights[i];
cout << ans << '\n';
for (int i = 0; i < m + 5; i++)
if (rel[i]) cout << i + 1 << ' ';
cout << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
if (e == 0) return 1;
if (e % 2 == 0) {
T t = bigmod(p, e / 2, M);
return (t * t) % M;
}
return (bigmod(p, e - 1, M) * p) % M;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
struct Z {
int node, edge;
long long w, c;
Z() {}
Z(int _, long long __, int ___, long long ____) {
node = _;
w = __;
edge = ___;
c = ____;
}
bool operator<(const Z& A) const {
if (w == A.w) return c > A.c;
return w > A.w;
}
};
bool vis[300009];
long long cost[300009];
long long edgecost[300009];
vector<Z> V[300009];
void DIJKSTRA(int st) {
priority_queue<Z> PQ;
PQ.push(Z(st, 0, 0, 0));
memset(vis, false, sizeof vis);
while (!PQ.empty()) {
Z top = PQ.top();
PQ.pop();
int cn = top.node;
long long cc = top.w;
int edge = top.edge;
long long c = top.c;
if (vis[cn]) continue;
vis[cn] = 1;
cost[cn] = cc;
edgecost[edge] = c;
int sz = V[cn].size();
for (int i = 0; i < sz; i++) {
int adn = V[cn][i].node;
long long adc = V[cn][i].w + cc;
int ed = V[cn][i].edge;
if (!vis[adn]) {
PQ.push(Z(adn, adc, ed, V[cn][i].w));
}
}
}
}
int main() {
int i, j, k;
string str, inp;
int m, t, n;
int u, v;
long long w;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> u >> v >> w;
V[u].push_back(Z(v, w, i, -1));
V[v].push_back(Z(u, w, i, -1));
}
int st;
cin >> st;
DIJKSTRA(st);
long long res = 0ll;
for (i = 0; i < m; i++) res += edgecost[i];
cout << res << endl;
for (i = 0; i < m; i++) {
if (edgecost[i]) cout << i + 1 << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
long long power(long long a, long long b, long long modi) {
a %= modi;
long long res = 1;
while (b) {
if (b % 2) {
res = (res * a) % modi;
}
b /= 2;
a = (a * a) % modi;
}
return res;
}
vector<pair<int, int> > adj[300001];
long long dis[300001][2];
set<int> se;
map<pair<int, int>, pair<int, int> > ma;
long long ans = 0;
void dijkstra(int v) {
set<pair<pair<long long, int>, pair<int, int> > > s;
s.insert({{0, 0}, {v, -1}});
dis[v][0] = dis[v][1] = 0;
while (!s.empty()) {
pair<pair<long long, int>, pair<int, int> > p = *s.begin();
s.erase(s.begin());
long long d = p.first.first;
int c = p.second.first;
int pre = p.second.second;
long long lw = p.first.second;
if (d > dis[c][0] || (d == dis[c][0] && lw > dis[c][1])) continue;
if (pre != -1) {
se.insert(ma[{pre, c}].first);
ans += ma[{pre, c}].second;
}
for (int i = 0; i < (int)adj[c].size(); i++) {
int u = adj[c][i].first;
int w = adj[c][i].second;
if (d + w < dis[u][0] || (d + w == dis[u][0] && dis[u][1] > w)) {
s.insert({{d + w, w}, {u, c}});
dis[u][0] = d + w;
dis[u][1] = w;
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v, w;
cin >> u >> v >> w;
adj[u].push_back({v, w});
adj[v].push_back({u, w});
ma[{u, v}] = {i, w};
ma[{v, u}] = {i, w};
}
for (int i = 1; i <= n; i++) dis[i][0] = dis[i][1] = 1e18;
int s;
cin >> s;
dijkstra(s);
cout << ans << '\n';
for (auto x : se) cout << x << " ";
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.