text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
unsigned long long int a[200] = {0}, b[100005];
string s;
int main() {
map<pair<char, unsigned long long int>, unsigned long long int> m;
unsigned long long int ans = 0;
for (int i = 0; i < 26; i++) cin >> a[i + 'a'];
cin >> s;
for (int i = 0; i < s.size(); i++) {
b[i] = a[s[i]];
}
for (int i = 1; i < s.size(); i++) b[i] += b[i - 1];
for (int i = s.size() - 2; i > -1; i--) {
m[{s[i + 1], b[i]}] += 1;
ans += m[{s[i], b[i]}];
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long int, long long int> v[125];
long int a[26];
int main() {
ios_base::sync_with_stdio(0);
string s;
long long int i, j, l, ct = 0, sum = 0;
for (i = 0; i < 26; i++) cin >> a[i];
cin >> s;
l = s.length();
for (i = 0; i < l; i++) {
ct += v[s[i] - 'a'][sum];
v[s[i] - 'a'][sum += a[s[i] - 'a']]++;
}
cout << ct << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, int> m[26];
map<long long, int>::iterator it;
string s;
long long x[26], sum[100010];
void scan() {
for (int i = 0; i < 26; i++) scanf("%lld", &x[i]);
cin >> s;
}
void out() {
long long ans = 0;
sum[0] = x[s[0] - 'a'];
m[s[0] - 'a'][sum[0]] = 1;
for (int i = 1; i < s.size(); i++) {
sum[i] = x[s[i] - 'a'] + sum[i - 1];
ans += m[s[i] - 'a'][sum[i - 1]];
++m[s[i] - 'a'][sum[i]];
}
cout << ans << '\n';
}
int main() {
scan();
out();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int xx[4] = {0, 0, 1, -1};
int yy[4] = {1, -1, 0, 0};
int n;
map<pair<long long, int>, int> mymap;
int d[int(1e5 + 100)];
long long f[int(1e5 + 100)];
char s[int(1e5 + 100)];
pair<long long, int> x, y;
int main() {
for (int i = ('a'), _b = ('z'); i <= _b; i++) scanf("%d", &d[i]);
scanf("%s", s + 1);
int l = strlen(s + 1);
long long res = 0;
for (int i = (1), _b = (l); i <= _b; i++) {
f[i] = f[i - 1] + d[s[i]];
x = pair<long long, int>(f[i - 1], s[i]);
res += mymap[x];
y = pair<long long, int>(f[i], s[i]);
mymap[y]++;
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
int val[27];
char a[N];
int n;
map<long long, int> h[26];
int main() {
int i;
for (i = 0; i < 26; ++i) {
cin >> val[i];
}
cin >> (a + 1);
n = strlen(a + 1);
long long sc = 0, rez = 0;
for (i = 1; i <= n; ++i) {
a[i] -= 'a';
sc += val[a[i]];
rez += h[a[i]][sc - val[a[i]]];
h[a[i]][sc]++;
}
cout << rez;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
map<long long, int> h[30];
char s[N];
int val[30];
long long ans, sum[N];
int main() {
for (int i = 0; i < 26; ++i) scanf("%d", val + i);
scanf("%s", s + 1);
int vfk = strlen(s + 1);
for (int i = 1; i <= vfk; ++i) {
ans += h[s[i] - 'a'][sum[i - 1]];
sum[i] = sum[i - 1] + val[s[i] - 'a'];
++h[s[i] - 'a'][sum[i]];
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 3e5 + 10, Maxn = 1e5 + 10, SQ = 360, lg = 22;
const long long mod = 1e9 + 7;
const long long inf = 1e18 + 10;
vector<pair<long long, long long>> adj[maxn];
long long d[maxn], p[maxn], n, m;
map<pair<long long, long long>, pair<long long, long long>> mp;
void dij(long long s) {
for (long long i = 0; i < n; i++) d[i] = inf, p[i] = -1;
set<pair<long long, long long>> q;
q.insert({0, s});
d[s] = 0;
while (!q.empty()) {
long long v = q.begin()->second;
q.erase(q.begin());
for (auto e : adj[v]) {
long long u = e.first;
long long len = e.second;
if (d[v] + len <= d[u]) {
q.erase({d[u], u});
p[u] = v;
d[u] = d[v] + len;
q.insert({d[u], u});
}
}
}
}
int32_t main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long u, v, w;
cin >> u >> v >> w;
u--, v--;
mp[make_pair(u, v)] = mp[make_pair(v, u)] = {i, w};
adj[u].push_back({v, w});
adj[v].push_back({u, w});
}
long long x;
cin >> x;
x--;
dij(x);
vector<long long> v;
long long ans = 0;
for (long long i = 0; i < n; i++) {
if (i == x) continue;
ans += mp[make_pair(p[i], i)].second;
v.push_back(mp[make_pair(p[i], i)].first);
}
cout << ans << "\n";
for (auto i : v) cout << i + 1 << ' ';
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 4 * 1e5;
const long long Q = 1e18 + 7;
vector<pair<pair<int, int>, int> > g[M];
int u[M], w[M], v[M];
long long d[M];
int ww[M];
bool used[M];
priority_queue<pair<pair<long long, pair<int, int> >, int> > q;
int main() {
srand(time(NULL));
int n;
int m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &u[i], &v[i], &w[i]);
g[u[i]].push_back(make_pair(make_pair(v[i], w[i]), i));
g[v[i]].push_back(make_pair(make_pair(u[i], w[i]), i));
}
int u1;
scanf("%d", &u1);
for (int i = 1; i <= n; i++) d[i] = Q;
d[u1] = 0;
q.push(make_pair(make_pair(0, make_pair(0, 0)), u1));
while (!q.empty()) {
pair<pair<long long, pair<int, int> >, int> cur = q.top();
q.pop();
if (used[cur.second]) continue;
ww[cur.second] = cur.first.second.second;
used[cur.second] = true;
for (int j = 0; j < (int)g[cur.second].size(); j++) {
int vv = g[cur.second][j].first.first;
int we = g[cur.second][j].first.second;
if (d[vv] >= -cur.first.first + we) {
d[vv] = -cur.first.first + we;
q.push(make_pair(
make_pair(-d[vv], make_pair(-we, g[cur.second][j].second)), vv));
}
}
}
long long sum = 0;
for (int i = 1; i <= n; i++) sum += w[ww[i]];
cout << sum << endl;
for (int i = 1; i <= n; i++)
if (ww[i]) printf("%d ", ww[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long oo = 0x3f3f3f3f;
const double EPS = 1e-9;
const int MAXN = (int)3e5 + 10;
vector<pair<int, int>> ady[MAXN];
long long W[MAXN];
long long dist[MAXN];
bool mk[MAXN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
int u, v;
cin >> u >> v >> W[i];
ady[u].push_back(make_pair(v, i));
ady[v].push_back(make_pair(u, i));
}
int s;
cin >> s;
vector<int> edges;
memset(dist, oo, sizeof dist);
priority_queue<pair<pair<long long, long long>, pair<int, int>>> PQ;
PQ.push(make_pair(make_pair(0, 0), make_pair(s, -1)));
dist[s] = 0;
long long sum = 0;
while (!PQ.empty()) {
auto cur = PQ.top();
PQ.pop();
long long d = -cur.first.first;
int nd = cur.second.first;
int ed = cur.second.second;
if (dist[nd] < d || mk[nd]) continue;
mk[nd] = true;
if (ed != -1) {
edges.push_back(ed);
sum += W[ed];
}
for (auto nx : ady[nd]) {
if (dist[nx.first] >= d + W[nx.second]) {
dist[nx.first] = d + W[nx.second];
PQ.push(make_pair(make_pair(-dist[nx.first], -W[nx.second]), nx));
}
}
}
cout << sum << '\n';
for (auto ed : edges) cout << ed << " ";
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int last[300005], vis[300006], par[300006];
map<pair<int, int>, int> ma;
vector<pair<int, int> > v[300006];
long long dis[300005];
int main() {
long long ans = 0;
vector<int> edges;
int n, m, i, j, u, a, b, c;
scanf("%d %d", &n, &m);
;
for (i = 0; i < m; i++) {
scanf("%d %d %d", &a, &b, &c);
;
ma[make_pair(a, b)] = i + 1;
ma[make_pair(b, a)] = i + 1;
v[a].push_back(make_pair(b, c));
v[b].push_back(make_pair(a, c));
}
scanf("%d", &u);
;
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;
pq.push(make_pair(make_pair(0, -1), make_pair(u, 0)));
dis[u] = 0;
last[u] = 0;
while (!pq.empty()) {
pair<pair<long long, int>, pair<int, int> > p = pq.top();
pq.pop();
if (!vis[p.second.first]) {
vis[p.second.first] = 1;
dis[p.second.first] = p.first.first;
last[p.second.first] = p.second.second;
par[p.second.first] = p.first.second;
for (auto it : v[p.second.first]) {
pq.push(make_pair(make_pair(it.second + p.first.first, p.second.first),
make_pair(it.first, it.second)));
}
} else if (dis[p.second.first] == p.first.first) {
if (last[p.second.first] > p.second.second) {
last[p.second.first] = min(last[p.second.first], p.second.second);
par[p.second.first] = p.first.second;
}
}
}
for (i = 1; i <= n; i++) {
if (i != u) {
ans += (last[i]);
edges.push_back(ma[make_pair(i, par[i])]);
}
}
printf("%lld", ans);
;
printf("\n");
for (i = 0; i < edges.size(); i++) {
printf("%d ", edges[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd1(int a, int b) {
if (a == 0) return b;
return gcd1(b % a, a);
}
long long modx(long long base, long long ex) {
long long ans = 1LL, val = base;
while (ex > 0LL) {
if (ex & 1LL) ans = (ans * val) % 1000000009LL;
val = (val * val) % 1000000009LL;
ex = ex >> 1LL;
}
return ans;
}
struct node {
int x, i;
long long w;
};
int n, m;
vector<node> adj[300005];
set<pair<pair<long long, long long>, pair<int, int> > > s;
bool visit[300005];
long long dist[300005];
vector<int> ans;
long long tot;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
node nd;
int u, v;
long long w;
for (int i = 1; i <= m; i++) {
cin >> u >> v >> w;
nd.x = u;
nd.i = i;
nd.w = w;
adj[v].push_back(nd);
nd.x = v;
adj[u].push_back(nd);
}
for (int i = 1; i <= n; i++) dist[i] = 2000000000000000000LL;
cin >> u;
dist[u] = 0;
s.insert(make_pair(make_pair(0, 0), make_pair(u, 0)));
while (!s.empty()) {
pair<pair<long long, long long>, pair<int, int> > p = *s.begin();
s.erase(s.begin());
long long d = p.first.first;
long long wt = p.first.second;
int f = p.second.first;
int ind = p.second.second;
if (visit[f]) continue;
visit[f] = true;
tot += wt;
if (ind) ans.push_back(ind);
for (int i = 0; i < adj[f].size(); i++) {
int pt = adj[f][i].x, pos = adj[f][i].i;
w = adj[f][i].w;
if (visit[pt] || dist[pt] < w + d) continue;
dist[pt] = w + d;
s.insert(make_pair(make_pair(dist[pt], w), make_pair(pt, pos)));
}
}
cout << tot << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 300010;
const long long INF = 0x3f3f3f3f3f3f3f;
int assoc_weight[MAX];
int assoc_edge[MAX];
map<pair<long long, long long>, long long> edge_map;
bool choose[MAX];
vector<long long> dijkstra(int source,
vector<vector<pair<long long, long long> > > g) {
int n = (int)g.size();
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
heap;
vector<long long> dis = vector<long long>(n);
fill(dis.begin(), dis.end(), INF);
heap.push(make_pair(0, source));
dis[source] = 0;
while (!heap.empty()) {
pair<long long, long long> p = heap.top();
heap.pop();
long long d = p.first;
int x = p.second;
if (d != dis[x]) {
continue;
}
int m = (int)g[x].size();
for (int i = 0; i < m; ++i) {
long long y = g[x][i].first;
long long val = (long long)g[x][i].second;
if (dis[x] + val < dis[y]) {
dis[y] = dis[x] + val;
heap.push(make_pair(dis[y], y));
assoc_weight[y] = val;
int edge_num = edge_map[make_pair(x, i)];
choose[assoc_edge[y]] = false;
choose[edge_num] = true;
assoc_edge[y] = edge_num;
}
if (dis[x] + val == dis[y]) {
if (val < assoc_weight[y]) {
assoc_weight[y] = val;
int edge_num = edge_map[make_pair(x, i)];
choose[assoc_edge[y]] = false;
choose[edge_num] = true;
assoc_edge[y] = edge_num;
}
}
}
}
return dis;
}
vector<vector<pair<long long, long long> > > graph(MAX);
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);
graph[a].push_back(make_pair(b, c));
graph[b].push_back(make_pair(a, c));
edge_map[make_pair(a, graph[a].size() - 1)] = i + 1;
edge_map[make_pair(b, graph[b].size() - 1)] = i + 1;
}
int source;
scanf("%d", &source);
dijkstra(source, graph);
long long ans = 0;
for (int i = 1; i <= n; ++i) {
ans += assoc_weight[i];
}
cout << ans << endl;
for (int i = 0; i < MAX; ++i) {
if (choose[i]) {
cout << i << " ";
}
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int N = 300010;
const long long INF = 1ll << 60;
const int inf = 0x3f3f3f3f;
const long long mod = 1e9 + 7;
std::vector<int> ans;
std::map<std::pair<int, int>, int> ma;
int a[N];
int b[N];
int c[N];
long long ans_val;
class Graph {
public:
void Init(int n) {
e_.clear();
e_.push_back(Edge(0, 0, 1, 0));
m_ = 0;
n_ = n;
hd_.assign(n + 1, 0);
vis_.assign(n + 1, false);
connected_num_ = 0;
for (int i = 1; i <= n; ++i) {
deg_in_[i] = 0;
}
}
void Init(int n, long long w[]) {
e_.clear();
e_.push_back(Edge(0, 0, 1, 0));
m_ = 0;
n_ = n;
hd_.assign(n + 1, 0);
vis_.assign(n + 1, false);
connected_num_ = 0;
for (int i = 1; i <= n; ++i) {
deg_in_[i] = 0;
weight[i] = w[i];
}
}
void Add(int u, int v, long long w = 1ll, int type = 0) {
Edge edge(v, hd_[u], w, type);
e_.push_back(edge);
hd_[u] = ++m_;
++deg_in_[v];
}
int Head(int id_v) { return hd_[id_v]; }
int Next(int id_e) { return e_[id_e].nxt; }
int To(int id_e) { return e_[id_e].v; }
long long& W(int id_e) { return e_[id_e].w; }
int& Type(int id_e) { return e_[id_e].type; }
int NumNode() { return n_; }
long long WNode(int u) { return weight[u]; }
private:
struct Edge {
int v, nxt;
long long w;
int type;
Edge(int _v, int _nxt, long long _w, int _type)
: v(_v), nxt(_nxt), w(_w), type(_type) {}
};
int n_;
std::vector<int> hd_;
long long weight[N];
int m_;
std::vector<Edge> e_;
std::vector<bool> vis_;
int deg_in_[N];
int connected_num_;
} graph;
class Dijkstra {
public:
Dijkstra() {}
void Init(int n) {
for (int i = 1; i <= n; ++i) {
dis_[i] = -1;
vis_[i] = false;
num_[i] = 0;
}
while (!q_.empty()) {
q_.pop();
}
}
void InitState(int sta, long long dis) {
q_.push((HeapNode){sta, dis});
dis_[sta] = dis;
num_[sta] = 1ll;
}
void Solve(Graph& graph) {
while (!q_.empty()) {
HeapNode x = q_.top();
q_.pop();
int& sta = x.sta;
long long& dis = x.dis;
if (vis_[sta]) {
continue;
}
assert(dis == dis_[sta]);
vis_[sta] = true;
for (int i = graph.Head(sta); i; i = graph.Next(i)) {
int sta_nxt = graph.To(i);
long long w = graph.W(i);
if (dis_[sta_nxt] == -1ll || dis_[sta_nxt] > dis_[sta] + w) {
dis_[sta_nxt] = dis_[sta] + w;
num_[sta_nxt] = num_[sta];
q_.push((HeapNode){sta_nxt, dis_[sta_nxt]});
pre_[sta_nxt] = sta;
pre_min_[sta_nxt] = w;
} else if (dis_[sta_nxt] == dis_[sta] + w) {
num_[sta_nxt] = (num_[sta_nxt] + num_[sta]) % mod;
if (pre_min_[sta_nxt] > w) {
pre_[sta_nxt] = sta;
pre_min_[sta_nxt] = w;
}
}
}
}
ans.clear();
ans_val = 0ll;
for (int u = 1; u <= graph.NumNode(); ++u) {
if (pre_[u]) {
ans.push_back(ma[{u, pre_[u]}]);
ans_val += c[ans.back()];
}
}
}
long long ShortestDis(int sta) { return dis_[sta]; }
long long ShortestNum(int sta) { return num_[sta]; }
private:
struct HeapNode {
int sta;
long long dis;
bool operator<(const HeapNode& rhs) const { return dis > rhs.dis; }
};
std::priority_queue<HeapNode> q_;
long long dis_[N];
bool vis_[N];
long long num_[N];
long long pre_min_[N];
int pre_[N];
} dij;
int t;
int n, m;
int x;
int main() {
scanf("%d%d", &n, &m);
graph.Init(n);
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d", &a[i], &b[i], &c[i]);
graph.Add(b[i], a[i], c[i]);
graph.Add(a[i], b[i], c[i]);
ma[{a[i], b[i]}] = i;
ma[{b[i], a[i]}] = i;
}
scanf("%d", &x);
dij.Init(n);
dij.InitState(x, 0);
dij.Solve(graph);
printf("%lld\n", ans_val);
for (size_t i = 0; i < ans.size(); ++i) {
printf("%d%s", ans[i], i == ans.size() - 1 ? "\n" : " ");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class node {
public:
int target;
int price;
int redenB;
node* next;
};
class graf {
public:
node** lista;
int n;
vector<long long> taken;
priority_queue<pair<long long, int> > pqPrim;
graf(int n) {
n++;
this->n = n;
lista = new node*[n];
for (int ctr1 = 0; ctr1 < n; ctr1++) {
lista[ctr1] = NULL;
}
}
void add(int x, int y, int price, int rb) {
node* cur = new node;
cur->target = y;
cur->price = price;
cur->next = NULL;
cur->redenB = rb;
if (lista[x] == NULL) {
lista[x] = cur;
} else {
cur->next = lista[x];
lista[x] = cur;
}
}
void print() {
for (int ctr1 = 0; ctr1 < n; ctr1++) {
cout << ctr1 << ": ";
node* temp = lista[ctr1];
while (temp != NULL) {
cout << temp->target << " ";
temp = temp->next;
}
cout << endl;
}
}
vector<long long> Djikstra(int s) {
vector<long long> dist(n, 1000000000000000000);
vector<long long> lastdist(n, -1);
vector<long long> from(n, -1);
dist[s] = 0;
lastdist[s] = 0;
from[s] = 0;
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
pq;
pq.push(pair<long long, int>(0, s));
while (!pq.empty()) {
pair<long long, int> front = pq.top();
pq.pop();
int d = front.first, u = front.second;
if (d > dist[u]) continue;
for (node* ctr = lista[u]; ctr != NULL; ctr = ctr->next) {
pair<long long, int> v(ctr->target, ctr->price);
if (dist[u] + v.second < dist[v.first]) {
dist[v.first] = dist[u] + v.second;
lastdist[v.first] = v.second;
from[v.first] = ctr->redenB;
pq.push(pair<long long, int>(dist[v.first], v.first));
}
if (dist[u] + v.second == dist[v.first]) {
if (lastdist[v.first] > v.second) {
lastdist[v.first] = v.second;
from[v.first] = from[v.first] = ctr->redenB;
;
}
}
}
}
long long rez = 0;
for (int ctr1 = 1; ctr1 < from.size(); ctr1++) {
if (ctr1 != s) rez += lastdist[ctr1];
}
cout << rez << endl;
for (int ctr1 = 1; ctr1 < from.size(); ctr1++) {
if (ctr1 != s) cout << from[ctr1] << " ";
}
vector<long long> a;
return a;
}
};
int main() {
int n, m;
cin >> n >> m;
graf g(n);
int u, v, w;
for (int ctr1 = 1; ctr1 <= m; ctr1++) {
cin >> u >> v >> w;
g.add(u, v, w, ctr1);
g.add(v, u, w, ctr1);
}
int source;
cin >> source;
g.Djikstra(source);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int a, b, w;
Edge() {}
Edge(int _a, int _b, int _w) {
a = _a;
b = _b;
w = _w;
}
};
int n, m, a, b, c, start;
long long best[300010], bestew[300010], taken[300010];
vector<int> e[300010];
Edge edges[300010];
char been[300010];
char used[300010];
set<pair<long long, long long> > S;
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d %d %d", &a, &b, &c);
a--;
b--;
e[a].push_back(i);
e[b].push_back(i);
edges[i] = Edge(a, b, c);
}
scanf("%d", &start);
start--;
S.insert(make_pair(0, start));
for (int i = 0; i < n; i++) {
best[i] = 4e16;
bestew[i] = -1;
}
best[start] = 0;
while (!S.empty()) {
long long d = S.begin()->first;
long long p = S.begin()->second;
S.erase(S.begin());
for (int i = 0; i < e[p].size(); i++) {
int next = (edges[e[p][i]].a == p) ? edges[e[p][i]].b : edges[e[p][i]].a;
long long cost = edges[e[p][i]].w;
if (best[next] > d + cost) {
best[next] = d + cost;
bestew[next] = e[p][i];
S.insert(make_pair(best[next], next));
} else if (best[next] == d + cost && edges[bestew[next]].w > cost) {
S.erase(make_pair(best[next], next));
bestew[next] = e[p][i];
S.insert(make_pair(best[next], next));
}
}
}
long long cost = 0LL;
for (int i = 0; i < n; i++)
if (i != start && bestew[i] != -1) {
cost += edges[bestew[i]].w;
used[bestew[i]] = 1;
}
printf("%I64d\n", cost);
for (int i = 0; i < m; i++)
if (used[i]) printf("%d ", i + 1);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
long long par[maxn], dp[maxn];
vector<pair<long long, long long>> g[maxn];
map<pair<long long, long long>, pair<long long, long long>> mp;
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;
g[u].push_back({v, w});
g[v].push_back({u, w});
mp[{u, v}] = {i, w};
mp[{v, u}] = {i, w};
}
int c;
cin >> c;
set<pair<long long, long long>> s;
for (int i = 1; i <= n; i++) {
dp[i] = 1e18;
}
dp[c] = 0;
s.insert({0, c});
while (!s.empty()) {
int v = (*s.begin()).second;
s.erase(s.begin());
for (auto i : g[v]) {
if (dp[i.first] >= dp[v] + i.second) {
s.erase({dp[i.first], i.first});
dp[i.first] = dp[v] + i.second;
par[i.first] = v;
s.insert({dp[i.first], i.first});
}
}
}
long long sum = 0;
for (int i = 1; i <= n; i++) {
if (i != c) {
auto it = mp.find({i, par[i]});
sum += it->second.second;
}
}
cout << sum << '\n';
for (int i = 1; i <= n; i++) {
if (i != c) {
auto it = mp.find({i, par[i]});
cout << it->second.first << ' ';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
void __print(int first) { cerr << first; }
void __print(long first) { cerr << first; }
void __print(long long first) { cerr << first; }
void __print(unsigned first) { cerr << first; }
void __print(unsigned long first) { cerr << first; }
void __print(unsigned long long first) { cerr << first; }
void __print(float first) { cerr << first; }
void __print(double first) { cerr << first; }
void __print(long double first) { cerr << first; }
void __print(char first) { cerr << '\'' << first << '\''; }
void __print(const char *first) { cerr << '\"' << first << '\"'; }
void __print(const string &first) { cerr << '\"' << first << '\"'; }
void __print(bool first) { cerr << (first ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &first) {
cerr << '{';
__print(first.first);
cerr << ',';
__print(first.second);
cerr << '}';
}
template <typename T>
void __print(const T &first) {
int f = 0;
cerr << '{';
for (auto &i : first) 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...);
}
struct edge {
long long node;
long long w;
long long total_w;
long long no;
};
map<pair<long long, long long>, long long> edge_no;
struct comp {
bool operator()(edge a, edge b) const {
if (a.total_w != b.total_w)
return a.total_w < b.total_w;
else if (a.w != b.w)
return a.w < b.w;
else
return a.node < b.node;
}
};
vector<vector<pair<long long, long long> > > vect;
vector<long long> ans;
long long visited[500000];
long long sum;
void solve(long long root) {
set<edge, comp> s;
s.insert({root, 0});
while (!s.empty()) {
edge temp = *(s.begin());
s.erase(s.begin());
if (visited[temp.node]) continue;
visited[temp.node] = 1;
sum += temp.w;
if (temp.node != root) ans.push_back(temp.no);
for (auto &child : vect[temp.node]) {
s.insert({child.first, child.second, child.second + temp.total_w,
edge_no[{min(child.first, temp.node),
max(child.first, temp.node)}]});
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, m;
cin >> n >> m;
vect.resize(n + 1);
long long u, v, w;
for (long long i = 0; i < m; i++) {
cin >> u >> v >> w;
vect[u].push_back({v, w});
vect[v].push_back({u, w});
edge_no[{min(u, v), max(u, v)}] = i + 1;
}
long long root;
cin >> root;
solve(root);
sort(ans.begin(), ans.end());
cout << sum << "\n";
for (auto &node : ans) cout << node << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<tuple<int, int, int>>> g;
void dijkestra(long long s) {
vector<long long> dist(g.size(), numeric_limits<long long>::max());
vector<bool> vis(g.size(), false);
dist[s] = 0;
long long ans = 0;
priority_queue<tuple<long long, int, int, int>,
vector<tuple<long long, int, int, int>>,
greater<tuple<long long, int, int, int>>>
Q;
Q.push(make_tuple(0ll, 0, s, 0));
int nbr = 0;
vector<int> reponse;
while (nbr < g.size()) {
tuple<long long, int, int, int> p = Q.top();
Q.pop();
long long w = get<0>(p);
int u = get<2>(p);
if (vis[u]) continue;
vis[u] = true;
reponse.push_back(get<3>(p));
ans += get<1>(p);
nbr++;
int l = g[u].size();
for (int i = 0; i < l; i++) {
int v = get<1>(g[u][i]);
if (!vis[v] && w + get<0>(g[u][i]) <= dist[v]) {
dist[v] = w + get<0>(g[u][i]);
Q.push(make_tuple(dist[v], get<0>(g[u][i]), v, get<2>(g[u][i])));
}
}
}
cout << ans << endl;
int l = reponse.size();
for (int i = 1; i < l; i++) {
cout << reponse[i] << " ";
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
g.resize(n);
int cpt = 0;
while (m--) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
a--;
b--;
g[a].push_back(make_tuple(c, b, ++cpt));
g[b].push_back(make_tuple(c, a, cpt));
}
int s;
scanf("%d", &s);
dijkestra(--s);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > g[300005];
long long dist[300005];
long long marker[300005];
map<pair<long long, long long>, long long> Index, Cost;
bool done[300005];
vector<pair<long long, long long> > nodes;
long long sum;
vector<long long> ans;
long long inf = 1e18;
long long n, m;
void dijk(long long src) {
for (long long i = 0; i < n; i++) dist[i] = inf;
dist[src] = 0;
priority_queue<pair<long long, int> > pq;
pq.push(make_pair(0, src));
while (!pq.empty()) {
long long node = pq.top().second;
long long cost = -pq.top().first;
pq.pop();
if (cost > dist[node]) continue;
for (int i = 0; i < int(g[node].size()); i++) {
long long child = g[node][i].first;
long long price = g[node][i].second;
if (dist[child] <= price + cost) continue;
dist[child] = price + cost;
pq.push(make_pair(-dist[child], child));
}
}
return;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long u, v, w;
cin >> u >> v >> w;
--u;
--v;
g[u].push_back(make_pair(v, w));
g[v].push_back(make_pair(u, w));
Index[make_pair(u, v)] = i;
Index[make_pair(v, u)] = i;
Cost[make_pair(u, v)] = w;
Cost[make_pair(v, u)] = w;
}
long long src;
cin >> src;
--src;
dijk(src);
for (long long i = 0; i < n; i++) {
nodes.push_back(make_pair(dist[i], i));
marker[i] = -1;
}
marker[src] = src;
sort(nodes.begin(), nodes.end());
for (long long i = 0; i < int(nodes.size()); i++) {
long long node = nodes[i].second;
done[node] = true;
long long parent = marker[node];
if (node != parent) {
ans.push_back(Index[make_pair(node, parent)]);
sum += Cost[make_pair(node, parent)];
}
for (long long i = 0; i < int(g[node].size()); i++) {
long long child = g[node][i].first;
long long cost = g[node][i].second;
if (done[child] || dist[node] + cost != dist[child]) continue;
long long pastMarker = marker[child];
long long curMarker = node;
if (pastMarker == -1 || dist[curMarker] >= dist[pastMarker])
marker[child] = curMarker;
}
}
cout << sum << endl;
for (long long i = 0; i < int(ans.size()); i++) cout << ans[i] + 1 << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 100, M = 1e4, LG = 30, base = 2;
const int MOD = 1e9 + 7, mod = 1e9 + 9;
const long long INF = 1e9, inf = 1e18;
long long n, m, a, b, w, src, v, d[N];
long long k, par[N], e[N];
vector<long long> ans;
vector<pair<long long, long long> > g[N];
set<pair<pair<long long, long long>, long long> > s;
map<pair<long long, long long>, long long> mp;
void dij(long long src) {
for (int i = 1; i <= n; i++) {
if (i == src) d[i] = 0;
if (i != src) d[i] = inf;
s.insert({{d[i], 0}, i});
}
while (s.size()) {
v = (*s.begin()).second;
s.erase(s.begin());
for (auto u : g[v]) {
if (d[v] + u.second < d[u.first] ||
(d[v] + u.second == d[u.first] && u.second < e[u.first])) {
s.erase({{d[u.first], e[u.first]}, u.first});
d[u.first] = d[v] + u.second;
e[u.first] = u.second;
par[u.first] = v;
s.insert({{d[u.first], e[u.first]}, u.first});
}
}
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a >> b >> w;
g[a].push_back({b, w}), g[b].push_back({a, w});
mp[{a, b}] = i + 1, mp[{b, a}] = i + 1;
}
cin >> src;
dij(src);
for (int i = 1; i <= n; i++)
if (i != src) k += e[i];
cout << k << "\n";
for (int i = 1; i <= n; i++)
if (i != src) cout << mp[{i, par[i]}] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long int, long long int>> adj[300000];
long long int V;
long long int dist[300000];
void dijkstra(long long int s, long long int d[], long long int p[]) {
long long int n = V;
fill(d, d + n, 1000000000000000001);
fill(p, p + n, -1);
d[s] = 0;
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
q;
q.push({0, s});
while (!q.empty()) {
long long int v = q.top().second;
long long int d_v = q.top().first;
q.pop();
if (d_v != d[v]) continue;
long long int dist = d[v];
for (auto edge : adj[v]) {
long long int to = edge.first;
long long int len = edge.second;
if (dist + len < d[to]) {
d[to] = dist + len;
p[to] = v;
q.push({d[to], to});
}
}
}
}
void modifiedPrim(long long int s, long long int d[], long long int p[]) {
long long int n = V;
fill(d, d + n, 1000000000000000001);
fill(p, p + n, -1);
d[s] = 0;
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
q;
q.push({0, s});
while (!q.empty()) {
long long int v = q.top().second;
long long int d_v = q.top().first;
q.pop();
if (d_v != d[v]) continue;
for (auto edge : adj[v]) {
long long int to = edge.first;
long long int len = edge.second;
if (len < d[to] && dist[v] + len == dist[to]) {
d[to] = len;
p[to] = v;
q.push({d[to], to});
}
}
}
}
int main() {
std::ios::sync_with_stdio(false);
long long int m;
cin >> V >> m;
map<pair<long long int, long long int>, long long int> edge_map;
for (long long int i = 0; i < m; i++) {
long long int a, b, w;
cin >> a >> b >> w;
a--;
b--;
adj[a].push_back(make_pair(b, w));
adj[b].push_back(make_pair(a, w));
edge_map[make_pair(a, b)] = i + 1;
edge_map[make_pair(b, a)] = i + 1;
}
long long int u;
cin >> u;
u--;
long long int parent[V], d[V];
dijkstra(u, dist, parent);
modifiedPrim(u, d, parent);
long long int total = 0;
for (long long int i = 0; i < V; i++) total += d[i];
cout << total << "\n";
for (long long int i = 0; i < V; i++) {
if (i != u) {
pair<long long int, long long int> temp = make_pair(i, parent[i]);
cout << edge_map[temp] << " ";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, pair<long long, int> > > v[300010];
vector<pair<int, pair<int, long long> > > vv;
vector<int> ans;
set<pair<long long, pair<int, int> > > s;
int parents[300010];
long long value[300010];
int edges[300010];
int main() {
int n, m, i, x, y;
long long a, z = 0;
;
set<pair<long long, pair<int, int> > >::iterator it;
cin >> n >> m;
for (i = 0; i < m; i++) {
scanf("%d%d%lld", &x, &y, &a);
v[x].push_back(make_pair(y, make_pair(a, i)));
v[y].push_back(make_pair(x, make_pair(a, i)));
vv.push_back(make_pair(x, make_pair(y, a)));
}
cin >> z;
parents[z] = -1;
s.insert(make_pair(0, make_pair(z, -1)));
z = 0;
while (!s.empty()) {
it = s.begin();
a = (*it).first;
x = (*it).second.first;
y = (*it).second.second;
if (y != -1) ans.push_back(y);
s.erase(s.begin());
for (i = 0; i < v[x].size(); i++) {
if (parents[v[x][i].first] == 0) {
parents[v[x][i].first] = x;
value[v[x][i].first] = a + v[x][i].second.first;
edges[v[x][i].first] = v[x][i].second.second;
s.insert(make_pair(a + v[x][i].second.first,
make_pair(v[x][i].first, v[x][i].second.second)));
} else if (value[v[x][i].first] > (a + v[x][i].second.first)) {
it = s.find(make_pair(value[v[x][i].first],
make_pair(v[x][i].first, edges[v[x][i].first])));
s.erase(it);
parents[v[x][i].first] = x;
value[v[x][i].first] = a + v[x][i].second.first;
edges[v[x][i].first] = v[x][i].second.second;
s.insert(make_pair(a + v[x][i].second.first,
make_pair(v[x][i].first, v[x][i].second.second)));
} else if (value[v[x][i].first] == (a + v[x][i].second.first)) {
y = edges[v[x][i].first];
if (vv[y].second.second > vv[v[x][i].second.second].second.second) {
it =
s.find(make_pair(value[v[x][i].first],
make_pair(v[x][i].first, edges[v[x][i].first])));
s.erase(it);
parents[v[x][i].first] = x;
value[v[x][i].first] = a + v[x][i].second.first;
edges[v[x][i].first] = v[x][i].second.second;
s.insert(make_pair(a + v[x][i].second.first,
make_pair(v[x][i].first, v[x][i].second.second)));
}
}
}
}
for (i = 0; i < ans.size(); i++) z += vv[ans[i]].second.second;
cout << z << "\n";
for (i = 0; i < ans.size(); i++) printf("%d ", ans[i] + 1);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, u, r[300010];
long long d[300010], use[300010];
vector<pair<int, int> > g[300010];
vector<int> a[300010];
bool ds[300010];
void IJK(int u) {
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
memset(d, 60, sizeof(d));
pair<long long, int> p = make_pair(d[u] = 0, u);
q.push(p);
while (!q.empty()) {
pair<long long, int> p = q.top();
q.pop();
u = p.second;
for (int i = 0; i < g[u].size(); ++i) {
int v = p.second = g[u][i].first;
long long l = p.first = g[u][i].second;
if (d[v] < d[u] + l || (d[v] == d[u] + l && l >= use[v])) continue;
use[v] = l;
d[v] = d[u] + g[u][i].second;
r[v] = a[u][i];
q.push(p);
}
}
}
void take() {
long long total = 0;
for (int i = 1; i <= n; ++i) total += use[i];
cout << total << endl;
for (int i = 1; i <= n; ++i)
if (i != u) ds[r[i]] = 1;
for (int i = 1; i <= m; ++i)
if (ds[i]) cout << i << " ";
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1, x, y, l; i <= m; ++i) {
cin >> x >> y >> l;
g[x].push_back(make_pair(y, l));
g[y].push_back(make_pair(x, l));
a[x].push_back(i);
a[y].push_back(i);
}
cin >> u;
IJK(u);
take();
}
|
#include <bits/stdc++.h>
using namespace std;
long long Answer = 0, idx[300100], edges[300100], dis[300100];
int n, m, x, y, w, u;
vector<pair<pair<int, int>, int> > v[300100];
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
Q;
void dik() {
for (int i = 1; i <= n; i++) dis[i] = 1e18;
Q.push({0, u});
dis[u] = 0;
while (!Q.empty()) {
pair<int, int> x = Q.top();
Q.pop();
for (int i = 0; i < v[x.second].size(); i++) {
int V = v[x.second][i].first.first;
int cost = v[x.second][i].first.second;
int id = v[x.second][i].second;
if (dis[V] > dis[x.second] + cost ||
(dis[V] == dis[x.second] + cost && edges[idx[V]] > edges[id])) {
dis[V] = dis[x.second] + cost;
idx[V] = id;
Q.push({dis[V], V});
}
}
}
}
int main() {
memset(idx, -1, sizeof(idx));
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> x >> y >> w;
v[x].push_back({{y, w}, i + 1});
v[y].push_back({{x, w}, i + 1});
edges[i + 1] = w;
}
cin >> u;
dik();
for (int i = 1; i <= n; i++) {
if (idx[i] != -1) {
Answer += edges[idx[i]];
}
}
cout << Answer << endl;
for (int i = 1; i <= n; i++) {
if (idx[i] != -1) cout << idx[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int maxn = 300010;
const long long inf = 1e16;
int cnt, head[maxn];
int pre[maxn], vis[maxn], val[maxn];
long long dis[maxn];
struct edge {
int to, w, nxt, id;
} e[maxn << 1];
void init() {
cnt = 0;
memset(head, -1, sizeof(head));
}
void add(int u, int v, int w, int id) {
e[cnt].to = v;
e[cnt].w = w;
e[cnt].id = id;
e[cnt].nxt = head[u];
head[u] = cnt++;
}
void spfa(int s) {
memset(pre, 0, sizeof(pre));
memset(vis, 0, sizeof(vis));
for (int i = 0; i < maxn; i++) dis[i] = inf;
queue<int> que;
que.push(s);
dis[s] = 0, vis[s] = 1;
while (!que.empty()) {
int u = que.front();
que.pop();
vis[u] = 0;
for (int i = head[u]; ~i; i = e[i].nxt) {
int v = e[i].to;
if (dis[v] > dis[u] + e[i].w) {
dis[v] = dis[u] + e[i].w;
pre[v] = e[i].id;
if (!vis[v]) {
vis[v] = 1;
que.push(v);
}
} else if (dis[v] == dis[u] + e[i].w) {
if (e[i].w < val[pre[v]]) {
pre[v] = e[i].id;
if (!vis[v]) {
vis[v] = 1;
que.push(v);
}
}
}
}
}
}
int main() {
int n, m;
while (~scanf("%d%d", &n, &m)) {
init();
for (int i = 1; i <= m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
add(u, v, w, i);
add(v, u, w, i);
val[i] = w;
}
int s;
scanf("%d", &s);
spfa(s);
long long sum = 0;
for (int i = 1; i <= n; i++)
if (pre[i]) sum += val[pre[i]];
cout << sum << endl;
for (int i = 1; i <= n; i++)
if (pre[i]) printf("%d ", pre[i]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
const long long INF = 0x3f3f3f3f3f3f3f3f;
struct node {
int v, id;
long long w;
node(int v = 0, long long w = 0, int id = 0) : v(v), w(w), id(id) {}
bool operator<(const node& a) const {
if (w == a.w)
return v < a.v;
else
return w > a.w;
}
};
vector<node> G[maxn];
long long dis[maxn];
node pre[maxn];
int n, m, vis[maxn];
void dijkstra(int s) {
for (int i = 1; i <= n; i++) dis[i] = INF;
dis[s] = 0;
pre[s] = node(0, 0, 0);
vis[s] = 1;
priority_queue<node> q;
q.push(node(s, dis[s]));
while (!q.empty()) {
node p1 = q.top();
int u = p1.v;
vis[u] = 1;
q.pop();
for (int i = 0; i < G[u].size(); i++) {
node p2 = G[u][i];
int v = p2.v;
if (!vis[v] && dis[v] > dis[u] + p2.w) {
dis[v] = dis[u] + p2.w;
pre[v] = p2;
q.push(node(v, dis[v], p2.id));
} else if (dis[v] == dis[u] + p2.w) {
if (pre[v].w > p2.w) {
pre[v] = p2;
}
}
}
}
}
int main() {
int u, v, w;
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d %d", &u, &v, &w);
G[u].push_back(node(v, w, i));
G[v].push_back(node(u, w, i));
}
scanf("%d", &u);
dijkstra(u);
long long sum = 0;
for (int i = 1; i <= n; i++) {
node p = pre[i];
if (p.v != 0) {
sum += p.w;
}
}
printf("%I64d\n", sum);
for (int i = 1; i <= n; i++) {
node p = pre[i];
if (p.v != 0) {
printf("%d ", p.id);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxn = 3e5 + 5;
const long long mod = 998244353;
long long dis[mxn];
bool vis[mxn];
struct data {
int u;
long long w;
int idx;
};
vector<data> adj[mxn];
data par[mxn];
int main() {
int n, m;
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);
adj[u].push_back({v, w, i});
adj[v].push_back({u, w, i});
}
int src;
scanf("%d", &src);
memset(dis, 63, sizeof dis);
priority_queue<pair<long long, long long> > pq;
pq.push({0, src});
dis[src] = 0;
while (!pq.empty()) {
pair<long long, long long> top = pq.top();
pq.pop();
int u = top.second;
if (vis[u]) continue;
vis[u] = 1;
for (auto it : adj[u]) {
int v = it.u;
long long w = it.w;
if (dis[u] + w < dis[v]) {
dis[v] = dis[u] + w;
par[v] = {u, w, it.idx};
pq.push({-dis[v], v});
} else if (dis[u] + w == dis[v] && w < par[v].w) {
par[v] = {v, w, it.idx};
}
}
}
vector<int> ans;
long long sum = 0;
for (int i = 1; i <= n; i++) {
if (i == src) continue;
ans.push_back(par[i].idx);
sum += par[i].w;
}
sort(ans.begin(), ans.end());
cout << sum << '\n';
for (auto i : ans) {
cout << i << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 3 * 100000 + 10;
int n, m, u;
int e[Maxn];
vector<pair<pair<int, int>, int> > nei[Maxn];
set<pair<pair<long long int, int>, int> > s;
vector<int> ans;
vector<int> edge;
long long int dis[Maxn];
long long int inf = 100000;
int main() {
inf *= 100000;
inf *= 100000;
cin >> n >> m;
edge.push_back(0);
for (int i = 0; i < m; i++) {
int a, b, w;
cin >> a >> b >> w;
nei[a].push_back(make_pair(make_pair(w, b), i + 1));
nei[b].push_back(make_pair(make_pair(w, a), i + 1));
edge.push_back(w);
}
cin >> u;
for (int i = 1; i <= n; i++) dis[i] = inf;
dis[u] = 0;
for (int i = 1; i <= n; i++) s.insert(make_pair(make_pair(dis[i], 0), i));
while (s.size() > 0) {
pair<pair<long long int, int>, int> f;
f = *s.begin();
s.erase(f);
int v = f.second;
if (e[v] != 0) ans.push_back(e[v]);
for (int i = 0; i < nei[v].size(); i++) {
if (s.find(make_pair(make_pair(dis[nei[v][i].first.second],
edge[e[nei[v][i].first.second]]),
nei[v][i].first.second)) == s.end())
continue;
if (make_pair(dis[nei[v][i].first.second],
edge[e[nei[v][i].first.second]]) >
make_pair(dis[v] + nei[v][i].first.first, edge[nei[v][i].second])) {
s.erase(s.find(make_pair(make_pair(dis[nei[v][i].first.second],
edge[e[nei[v][i].first.second]]),
nei[v][i].first.second)));
dis[nei[v][i].first.second] = dis[v] + nei[v][i].first.first;
e[nei[v][i].first.second] = nei[v][i].second;
s.insert(make_pair(make_pair(dis[nei[v][i].first.second],
edge[e[nei[v][i].first.second]]),
nei[v][i].first.second));
}
}
}
long long int W = 0;
for (int i = 0; i < ans.size(); i++) W += edge[ans[i]];
cout << W << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = 2.0 * acos(0.0);
const double E = exp(1);
template <class T1>
void deb(T1 e) {
cout << e << endl;
}
template <class T1, class T2>
void deb(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void deb(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void deb(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << endl;
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5, T6 e6) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << " " << e6
<< endl;
}
template <typename T>
inline T sqr(T n) {
return n * n;
}
inline double hypot(double x, double y) { return sqrt(sqr(x) + sqr(y)); }
template <typename T>
inline T pmod(T n, T m) {
return ((n % m) + m) % m;
}
template <typename T>
T power(T n, int p) {
return (p == 0) ? (T)(1) : (sqr(power(n, p >> 1)) * ((p & 1) * (n - 1) + 1));
}
template <typename T>
T bigmod(T n, int p, T m) {
return (p == 0)
? (T)(1)
: ((sqr(bigmod(n, p >> 1, m)) % m) * ((p & 1) * (n - 1) % m + 1)) %
m;
}
struct node {
int u;
long long w;
long long sum = 0;
node() {}
node(int _u, long long _w, long long _s) : u(_u), w(_w), sum(_s) {}
bool operator<(const node& p) const { return w > p.w; }
};
int n, m, p;
int par[3 * 100005];
pair<long long, long long> dist[300006];
vector<pair<int, int> > adj[3 * 100005];
bool vis[300005];
map<pair<int, int>, pair<int, int> > mk;
long long sum_edge;
map<pair<int, int>, int> res;
void dijkstra(int s) {
for (int i = 0; i <= 300000; i++)
dist[i].first = dist[i].second = (1ll << 50);
dist[s].first = dist[s].second = 0;
priority_queue<node> q;
node tmp;
int u, v;
long long w;
q.push(node(s, 0, 0));
while (q.empty() == false) {
u = q.top().u;
w = q.top().w;
q.pop();
for (int i = 0; i < (int)adj[u].size(); i++) {
v = adj[u][i].first;
long long cst = (long long)adj[u][i].second;
if (dist[v].first > dist[u].first + cst) {
dist[v].first = dist[u].first + cst;
dist[v].second = (long long)cst;
q.push(node(v, dist[v].first, dist[v].second));
if (par[v] == 0) {
par[v] = u;
sum_edge += cst;
res[make_pair(u, v)] = mk[make_pair(u, v)].first;
res[make_pair(v, u)] = mk[make_pair(u, v)].first;
} else {
int tu = par[v];
int tv = v;
res[make_pair(tv, tu)] = 0;
res[make_pair(tu, tv)] = 0;
sum_edge -= mk[make_pair(tu, tv)].second;
sum_edge += cst;
par[v] = u;
res[make_pair(u, v)] = mk[make_pair(u, v)].first;
res[make_pair(v, u)] = mk[make_pair(u, v)].first;
}
} else if (dist[v].first == dist[u].first + cst && dist[v].second > cst) {
dist[v].first = dist[u].first + cst;
dist[v].second = (long long)cst;
q.push(node(v, dist[v].first, dist[v].second));
if (par[v] == 0) {
par[v] = u;
sum_edge += cst;
res[make_pair(u, v)] = mk[make_pair(u, v)].first;
res[make_pair(v, u)] = mk[make_pair(u, v)].first;
} else {
int tu = par[v];
int tv = v;
res[make_pair(tv, tu)] = 0;
res[make_pair(tu, tv)] = 0;
sum_edge -= mk[make_pair(tu, tv)].second;
sum_edge += cst;
par[v] = u;
res[make_pair(u, v)] = mk[make_pair(u, v)].first;
res[make_pair(v, u)] = mk[make_pair(u, v)].first;
}
}
}
}
}
int main() {
scanf("%d %d", &n, &m);
int u, v, w;
for (int i = 0; i < m; ++i) {
scanf("%d %d %d", &u, &v, &w);
adj[u].push_back(make_pair(v, w));
adj[v].push_back(make_pair(u, w));
mk[make_pair(u, v)] = make_pair(i + 1, w);
mk[make_pair(v, u)] = make_pair(i + 1, w);
}
int s;
scanf("%d", &s);
dijkstra(s);
deb(sum_edge);
for (auto it = res.begin(); it != res.end(); it++) {
if (it->second > 0) vis[it->second] = 1;
}
for (int i = 1; i <= m; ++i)
if (vis[i]) printf("%d ", i);
printf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<long long, int>>> adj;
int N, M, U;
long long dist[300000];
pair<long long, int> tgt[300000];
void dijkstra() {
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
pq;
pq.emplace(0, U);
fill_n(dist, N, LLONG_MAX);
dist[U] = 0;
while (!pq.empty()) {
pair<long long, int> pt = pq.top();
pq.pop();
int n = pt.second;
long long d = pt.first;
if (dist[n] != d) continue;
for (pair<long long, int> pm : adj[n]) {
long long& dm = dist[pm.first];
long long nd = d + pm.second;
if (nd < dm) {
dm = nd;
pq.emplace(nd, pm.first);
tgt[pm.first] = pair<long long, int>(pm.second, n);
} else if (nd == dm && pm.second < tgt[pm.first].first) {
tgt[pm.first] = pair<long long, int>(pm.second, n);
}
}
}
}
int main() {
map<pair<long long, int>, int> lkp;
scanf("%d%d", &N, &M);
adj.resize(N);
for (int m = 0; m < int(M); m++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
u--;
v--;
adj[u].emplace_back(v, w);
adj[v].emplace_back(u, w);
lkp[pair<long long, int>(min(u, v), max(u, v))] = m + 1;
}
scanf("%d", &U);
U--;
dijkstra();
long long tw = 0;
vector<int> usg;
for (int n = 0; n < int(N); n++)
if (n != U) {
tw += tgt[n].first;
usg.push_back(lkp[pair<long long, int>(min(n, tgt[n].second),
max(n, tgt[n].second))]);
}
printf("%lld\n", tw);
sort(begin(usg), end(usg));
for (int e : usg) {
printf("%d ", e);
}
printf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
int pre[300005], wt[300005];
long long SP[300005];
vector<vector<pair<int, pair<long long, int> > > > X(300005);
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
Q;
void relax(int u, int v, long long w, int indx) {
if (SP[v] > SP[u] + w) {
SP[v] = SP[u] + w;
pre[v] = indx;
wt[v] = w;
Q.push(pair<long long, int>(SP[v], v));
} else if (SP[v] == SP[u] + w) {
if (w < wt[v]) {
pre[v] = indx;
wt[v] = w;
Q.push(pair<long long, int>(SP[v], v));
}
}
}
int main() {
int N, M;
scanf("%d %d", &N, &M);
int a, b;
long long c;
for (int i = 1; i <= M; i++) {
scanf("%d %d %lld", &a, &b, &c);
X[a].push_back(make_pair(b, make_pair(c, i)));
X[b].push_back(make_pair(a, make_pair(c, i)));
}
int u;
scanf("%d", &u);
for (int i = 1; i <= N; i++) {
SP[i] = 1000000000000000000LL;
pre[i] = -1;
}
SP[u] = 0;
Q.push(pair<long long, int>(SP[u], u));
while (!Q.empty()) {
pair<long long, int> x = Q.top();
int indx = x.second;
long long dist = x.first;
Q.pop();
if (dist <= SP[indx]) {
for (vector<pair<int, pair<long long, int> > >::iterator it =
X[indx].begin();
it != X[indx].end(); it++)
relax(indx, it->first, (it->second).first, (it->second).second);
}
}
long long ans = 0;
for (int i = 1; i <= N; i++) ans += wt[i];
printf("%lld\n", ans);
for (int i = 1; i <= N; i++)
if (pre[i] != -1) printf("%d ", pre[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
const long long int INF = 1e16 + 3;
int n, m;
vector<pair<int, pair<int, int> > > v[N];
int forv[N];
int forw[N];
set<pair<long long int, int> > check;
long long int d[N];
void dijkstra(int s) {
d[s] = 0;
check.insert(make_pair(0, s));
int now;
pair<int, pair<int, int> > kid;
while (check.size()) {
now = check.begin()->second;
check.erase(check.begin());
for (int i = 0; i < v[now].size(); ++i) {
kid = v[now][i];
if ((d[kid.first] > d[now] + (long long int)kid.second.first) ||
((d[kid.first] == d[now] + (long long int)kid.second.first) and
(kid.second.first < forw[forv[kid.first]]))) {
if (d[kid.first] != INF) {
forw[forv[kid.first]] = 0;
}
check.erase(make_pair(d[kid.first], kid.first));
forv[kid.first] = kid.second.second;
d[kid.first] = d[now] + (long long int)kid.second.first;
forw[kid.second.second] = kid.second.first;
check.insert(make_pair(d[kid.first], kid.first));
}
}
}
}
int main() {
for (int i = 0; i < N; ++i) d[i] = INF;
cin >> n >> m;
int vi, xi, wi;
for (int i = 0; i < m; ++i) {
scanf("%d%d%d", &vi, &xi, &wi);
if (vi == xi) continue;
v[vi].push_back(make_pair(xi, make_pair(wi, i)));
v[xi].push_back(make_pair(vi, make_pair(wi, i)));
}
int help;
cin >> help;
dijkstra(help);
long long int ans = 0;
for (int i = 0; i < N; ++i) ans += forw[i];
cout << ans << endl;
for (int i = 0; i < N; ++i)
if (forw[i]) cout << i + 1 << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300000 + 333;
struct edge {
int to, w, id;
edge(int to, int w, int id) : to(to), w(w), id(id) {}
edge() {}
};
long long dist[MAXN];
vector<edge> g[MAXN];
set<pair<int, int> > s;
int n, m, start, par_e[MAXN], par_w[MAXN];
void load() {
scanf("%d %d", &n, &m);
for (int i = 0, u, v, w; i < m; i++) {
scanf("%d %d %d", &u, &v, &w);
g[u].push_back(edge(v, w, i + 1));
g[v].push_back(edge(u, w, i + 1));
}
scanf("%d", &start);
fill(dist, dist + n + 1, LLONG_MAX);
fill(par_e, par_e + n + 1, -1);
}
void solve() {
dist[start] = 0ll;
s.insert({0, start});
while (s.size()) {
int v = (*s.begin()).second;
s.erase(s.begin());
for (edge e : g[v]) {
if (dist[e.to] > dist[v] + e.w) {
dist[e.to] = dist[v] + e.w;
par_w[e.to] = e.w;
par_e[e.to] = e.id;
s.insert({dist[e.to], e.to});
} else if (dist[e.to] == dist[v] + e.w && e.w < par_w[e.to]) {
par_e[e.to] = e.id;
par_w[e.to] = e.w;
}
}
}
long long answer = 0ll;
for (int i = 1; i <= n; i++) answer += par_w[i];
cout << answer << endl;
for (int i = 1; i <= n; i++)
if (i != start) printf("%d ", par_e[i]);
}
int main() {
load();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 gen(time(NULL));
const long double eps = 1e-9;
const int inf = 1e9;
const int mod = 1e9 + 7;
const long long infinity = 2 * 1e18;
struct edge {
int u, v, i, w;
bool operator<(const edge &other) { return w < other.w; }
};
int n;
vector<pair<int, int> > g[300005];
edge e[300005];
int m;
pair<long long, int> dp[300005];
map<pair<int, int>, int> mx;
void spfa(int u) {
fill_n(dp, 300005, make_pair(1e18, inf));
dp[u] = make_pair(0, -1);
queue<int> q;
q.push(u);
while (q.size()) {
int x = q.front();
q.pop();
for (auto v : g[x]) {
auto w = e[mx[make_pair(min(v.first, x), max(v.first, x))]];
if (dp[v.first].second == -1) continue;
if (dp[v.first].first > dp[x].first + w.w ||
(dp[v.first].first == dp[x].first + w.w &&
w.w < e[dp[v.first].second].w)) {
dp[v.first] = make_pair(dp[x].first + w.w, w.i);
q.push(v.first);
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
int u, v, w;
for (int i = 0; i < m; i++) {
cin >> u >> v >> w;
e[i] = {u, v, i, w};
g[u].push_back({v, w}), g[v].push_back({u, w});
if (u > v) swap(u, v);
mx[make_pair(u, v)] = i;
}
cin >> u;
spfa(u);
long long wmin = 0;
for (int i = 1; i <= n; i++)
if (i != u && 0 <= dp[i].second && dp[i].second < m)
wmin += e[dp[i].second].w;
cout << wmin << '\n';
for (int i = 1; i <= n; i++)
if (i != u) cout << dp[i].second + 1 << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct SegmentTree {};
long long n, m, u;
vector<vector<pair<pair<long long, long long>, long long> > > g;
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq;
long long dist[300005];
pair<long long, long long> s[300005];
void input() {
cin >> n >> m;
g.assign(n, vector<pair<pair<long long, long long>, long long> >());
for (long long i = 1; i <= m; i++) {
long long x, y, w;
cin >> x >> y >> w;
g[--x].push_back({{--y, w}, i});
g[y].push_back({{x, w}, i});
}
cin >> u;
--u;
}
void solve() {
for (long long i = 0; i < n; i++) dist[i] = 92233720368547757;
for (long long i = 0; i < n; i++)
s[i].first = (i == u ? 0 : 92233720368547757);
pq.push({0, u});
dist[u] = 0;
while (!pq.empty()) {
long long v = pq.top().second, d = pq.top().first;
pq.pop();
if (d > dist[v]) continue;
for (pair<pair<long long, long long>, long long> t : g[v]) {
if (dist[t.first.first] > dist[v] + t.first.second) {
dist[t.first.first] = dist[v] + t.first.second;
s[t.first.first] = {t.first.second, t.second};
pq.push({dist[t.first.first], t.first.first});
} else if (dist[t.first.first] == dist[v] + t.first.second) {
s[t.first.first] = min(s[t.first.first], {t.first.second, t.second});
}
}
}
long long ans = 0;
for (long long i = 0; i < n; i++) ans += s[i].first;
cout << ans << "\n";
for (long long i = 0; i < n; i++)
if (i != u) cout << s[i].second << " ";
}
signed main(signed argc, char** argv) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int u;
int v;
long long weight;
Edge(int u, int v, long long weight) {
this->u = u;
this->v = v;
this->weight = weight;
}
int getNeighbor(int curr) {
if (this->u == curr) {
return this->v;
} else {
return this->u;
}
}
};
struct DijkstraEntry {
int pred;
int curr;
long long totalCost;
long long lastCost;
DijkstraEntry() {}
DijkstraEntry(int pred, int curr, long long totalCost, long long lastCost) {
this->pred = pred;
this->curr = curr;
this->totalCost = totalCost;
this->lastCost = lastCost;
}
};
struct CompareDE {
bool operator()(DijkstraEntry &de1, DijkstraEntry &de2) {
return (de1.totalCost > de2.totalCost) or
(de1.totalCost == de2.totalCost and de1.lastCost > de2.lastCost);
}
};
int n, m;
int u, v, w;
vector<bool> explored;
vector<vector<Edge> > edges;
map<pair<int, int>, int> edgeIndices;
vector<int> pred;
int main() {
cin >> n >> m;
pred.resize(n);
for (int i = 0; i < n; i++) {
pred[i] = -2;
}
explored.resize(n);
for (int i = 0; i < n; i++) {
explored[i] = false;
}
edges.resize(n);
for (int i = 0; i < m; i++) {
cin >> u >> v >> w;
u--;
v--;
edges[u].push_back(Edge(u, v, w));
edges[v].push_back(Edge(u, v, w));
edgeIndices[pair<int, int>(u, v)] = i + 1;
edgeIndices[pair<int, int>(v, u)] = i + 1;
}
cin >> u;
u--;
priority_queue<DijkstraEntry, vector<DijkstraEntry>, CompareDE> toDo;
toDo.push(DijkstraEntry(-1, u, 0, 0));
while (!toDo.empty()) {
DijkstraEntry de = toDo.top();
toDo.pop();
if (not explored[de.curr]) {
explored[de.curr] = true;
pred[de.curr] = de.pred;
for (int i = 0; i < edges[de.curr].size(); i++) {
Edge newEdge = edges[de.curr][i];
int newVertex = newEdge.getNeighbor(de.curr);
long long totalCost = de.totalCost + newEdge.weight;
toDo.push(DijkstraEntry(de.curr, newVertex, totalCost, newEdge.weight));
}
}
}
long long totalCost = 0;
for (int i = 0; i < n; i++) {
int p = pred[i];
if (p != -1) {
for (int j = 0; j < edges[i].size(); j++) {
if (edges[i][j].getNeighbor(i) == p) {
totalCost += edges[i][j].weight;
}
}
}
}
cout << totalCost << "\n";
for (int i = 0; i < n; i++) {
int p = pred[i];
if (p != -2) {
for (int j = 0; j < edges[i].size(); j++) {
if (edges[i][j].getNeighbor(i) == p) {
cout << edgeIndices[pair<int, int>(i, p)] << " ";
}
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long dist[300010];
bool mark[300010];
int last[300010];
int par[300010];
vector<pair<pair<int, int>, int> > g[300010];
void dijkstra(int n) {
for (int i = 0; i < 300010; i++) dist[i] = 1LL << 60;
memset(mark, 0, sizeof(mark));
dist[n] = 0;
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq;
pq.push({dist[n], n});
while (!pq.empty()) {
int u = pq.top().second;
pq.pop();
if (mark[u]) continue;
mark[u] = true;
for (int i = 0; i < g[u].size(); i++) {
pair<int, int> v = g[u][i].first;
if (dist[v.first] > dist[u] + v.second) {
dist[v.first] = dist[u] + v.second;
last[v.first] = v.second;
par[v.first] = g[u][i].second;
pq.push({dist[v.first], v.first});
} else if (dist[v.first] == dist[u] + v.second &&
last[v.first] > v.second) {
last[v.first] = v.second;
par[v.first] = g[u][i].second;
}
}
}
}
int main(int argc, char const *argv[]) {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int a, b, c;
cin >> a >> b >> c;
g[a].push_back({{b, c}, i});
g[b].push_back({{a, c}, i});
}
int u;
cin >> u;
dijkstra(u);
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += last[i];
}
cout << ans << endl;
for (int i = 1; i <= n; i++) {
if (par[i]) {
cout << par[i] << " ";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, cnt = 1;
int last[300004], pre[300004];
bool mark[600004], vis[300004];
long long dis[300004];
struct edge {
int to, next, v;
} e[600004];
void insert(int u, int v, int w) {
e[++cnt] = (edge){v, last[u], w};
last[u] = cnt;
e[++cnt] = (edge){u, last[v], w};
last[v] = cnt;
}
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
void dijkstra(int x) {
for (int i = 1; i <= n; i++) dis[i] = 1LL << 60;
dis[x] = 0;
q.push(make_pair(0, x));
while (!q.empty()) {
int now = q.top().second;
q.pop();
if (vis[now]) continue;
vis[now] = 1;
for (int i = last[now]; i; i = e[i].next) {
if (!vis[e[i].to] && dis[now] + e[i].v <= dis[e[i].to]) {
if (dis[now] + e[i].v < dis[e[i].to])
pre[e[i].to] = i;
else if (e[i].v < e[pre[e[i].to]].v)
pre[e[i].to] = i;
dis[e[i].to] = dis[now] + e[i].v;
q.push(make_pair(dis[e[i].to], e[i].to));
}
}
}
}
vector<int> ans;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
insert(u, v, w);
}
int t;
scanf("%d", &t);
dijkstra(t);
for (int i = 1; i <= n; i++) mark[pre[i]] = 1;
long long tot = 0;
for (int i = 2; i <= cnt; i += 2) {
if (mark[i] || mark[i + 1]) {
ans.push_back(i >> 1);
tot += e[i].v;
}
}
printf("%I64d\n", tot);
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300010;
const int maxm = 1010;
const int maxs = 26;
const int inf = 0x3f3f3f3f;
const int P = 1000000007;
const double error = 1e-9;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') f = (ch == '-' ? -1 : 1), ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
struct edge {
int u, v;
long long w;
int next, pos;
} e[2 * maxn];
int n, m, s, cnt, head[maxn], vis[maxn], fa[maxn];
long long ans, dis[maxn];
void insert(int u, int v, long long w, int pos) {
e[cnt] = (edge){u, v, w, head[u], pos}, head[u] = cnt++;
e[cnt] = (edge){v, u, w, head[v], pos}, head[v] = cnt++;
}
void spfa() {
for (int i = 1; i <= n; i++) dis[i] = (long long)inf * inf;
queue<int> q;
q.push(s), dis[s] = 0;
while (!q.empty()) {
int u = q.front();
q.pop(), vis[u] = 0;
for (int i = head[u]; i != -1; i = e[i].next) {
int v = e[i].v;
if (dis[v] > dis[u] + e[i].w) {
dis[v] = dis[u] + e[i].w;
if (!vis[v]) vis[v] = 1, q.push(v);
}
}
}
}
bool cmp(edge a, edge b) {
long long disa = max(dis[a.u], dis[a.v]);
long long disb = max(dis[b.u], dis[b.v]);
return disa < disb || disa == disb && a.w < b.w;
}
int find(int u) { return u == fa[u] ? u : fa[u] = find(fa[u]); }
vector<int> num;
int main() {
n = read(), m = read();
memset(head, -1, sizeof head);
for (int i = 1; i <= m; i++) {
int u = read(), v = read();
long long w = read();
insert(u, v, w, i);
}
s = read(), spfa();
sort(e, e + cnt, cmp);
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 0; i < cnt; i++) {
int u = e[i].u, v = e[i].v;
if (abs(dis[u] - dis[v]) == e[i].w) {
int fu = find(u), fv = find(v);
if (fu != fv) {
ans += e[i].w, fa[fu] = fv;
num.push_back(e[i].pos);
}
}
}
printf("%I64d\n", ans);
for (int i = 0; i < num.size(); i++) printf("%d ", num[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
string ToString(T t) {
stringstream s;
s << t;
return s.str();
}
template <class T>
void ToOther(T& t, string a) {
stringstream s(a);
s >> t;
}
struct data {
long long e, w, idx;
data(long long _e, long long _w, long long _idx) {
e = _e;
w = _w;
idx = _idx;
}
};
vector<data> v[300005];
long long n, m, u;
pair<long long, long long> d[300005];
long long from[300005];
pair<pair<long long, long long>, long long> make(long long a, long long b,
long long c) {
return make_pair(pair<long long, long long>(a, b), c);
}
pair<pair<long long, long long>, long long> make(pair<long long, long long> a,
long long c) {
return make_pair(a, c);
}
pair<long long, long long> sum(pair<long long, long long> a, long long b) {
a.first += b;
a.second = b;
return a;
}
void dij(long long u) {
for (long long i = 0; i < n; i++)
d[i] = pair<long long, long long>(1ll << 50, (1 << 30));
d[u] = pair<long long, long long>(0, 0);
priority_queue<pair<pair<long long, long long>, long long>,
vector<pair<pair<long long, long long>, long long> >,
greater<pair<pair<long long, long long>, long long> > >
q;
q.push(make(d[u], u));
while (q.size()) {
pair<long long, long long> dis = q.top().first;
long long k = q.top().second;
q.pop();
if (d[k] < dis) continue;
for (long long i = 0; i < v[k].size(); i++) {
long long t = v[k][i].e;
long long w = v[k][i].w;
long long idx = v[k][i].idx;
if (sum(dis, w) < d[t]) {
d[t] = sum(dis, w);
from[t] = idx;
q.push(make(d[t], t));
}
}
}
}
long long ww[300005];
int main() {
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long s, e, w;
scanf("%lld%lld%lld", &s, &e, &w);
s--;
e--;
v[s].push_back(data(e, w, i + 1));
v[e].push_back(data(s, w, i + 1));
ww[i + 1] = w;
}
cin >> u;
u--;
dij(u);
long long r = 0;
vector<long long> v;
for (long long i = 0; i < n; i++) {
if (from[i] == 0) continue;
r += ww[from[i]];
v.push_back(from[i]);
}
sort((v).begin(), (v).end());
cout << r << endl;
for (long long i = 0; i < v.size(); i++) printf("%lld ", v[i]);
puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300005;
long long dist[300005];
struct edge {
int y;
int weight;
int id;
edge* next;
};
edge* li[300005];
edge* new_edge() {
static edge a[1000005];
static int top = 0;
return &a[top++];
}
void inserts(int x, int y, int z, int w) {
edge* t = new_edge();
t->y = y;
t->weight = z;
t->id = w;
t->next = li[x];
li[x] = t;
}
void insert_edge(int x, int y, int z, int w) {
inserts(x, y, z, w);
inserts(y, x, z, w);
}
int pre[maxn];
int pre_weight[maxn];
bool visit[maxn];
void dijkstra(int s) {
memset(visit, false, sizeof(visit));
priority_queue<pair<long long, int> > q;
dist[s] = 0;
pre[s] = -1;
q.push(make_pair(0, s));
for (; !q.empty();) {
int now = q.top().second;
q.pop();
if (visit[now]) continue;
visit[now] = true;
edge* t;
for (t = li[now]; t != 0; t = t->next) {
if (dist[t->y] > dist[now] + t->weight) {
dist[t->y] = dist[now] + t->weight;
pre[t->y] = t->id;
pre_weight[t->y] = t->weight;
q.push(make_pair(-dist[t->y], t->y));
} else if (dist[t->y] == dist[now] + t->weight) {
if (pre_weight[t->y] > t->weight) {
pre[t->y] = t->id;
pre_weight[t->y] = t->weight;
}
}
}
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
int i;
for (i = 0; i < m; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
x--;
y--;
insert_edge(x, y, z, i + 1);
}
int t;
scanf("%d", &t);
t--;
for (i = 0; i < n; i++) {
dist[i] = 99999999999999999ll;
}
dijkstra(t);
long long maxans = 0;
for (i = 0; i < n; i++) {
if (i != t) {
maxans = maxans + pre_weight[i];
}
}
printf("%I64d\n", maxans);
for (i = 0; i < n; i++) {
if (i != t) {
printf("%d ", pre[i]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + ch - '0';
ch = getchar();
}
return x * f;
}
const long long SIZE = 500005;
long long nxt[SIZE << 1], ver[SIZE << 1], head[SIZE << 1], tot, val[SIZE << 1];
inline void add(long long x, long long y, long long z) {
ver[++tot] = y, val[tot] = z, nxt[tot] = head[x], head[x] = tot;
}
struct node {
long long id, dst;
bool operator<(const node &x) const { return dst > x.dst; }
};
priority_queue<node> q;
long long n, m, d[SIZE], t, pre[SIZE], ans;
bool v[SIZE];
void dijkstra(long long s) {
memset(d, 0x7f, sizeof(d));
d[s] = 0, q.push((node){s, 0});
while (!q.empty()) {
node tmp = q.top();
q.pop();
long long x = tmp.id;
if (v[x]) continue;
v[x] = true;
for (long long i = head[x]; i; i = nxt[i]) {
long long y = ver[i];
if (d[y] > d[x] + val[i]) pre[y] = i, d[y] = d[x] + val[i];
q.push((node){y, d[y]});
if (d[y] == d[x] + val[i] && val[pre[y]] > val[i]) pre[y] = i;
}
}
}
int main() {
n = read(), m = read();
for (long long i = 1; i <= m; i++) {
long long x = read(), y = read(), z = read();
add(x, y, z), add(y, x, z);
}
t = read(), dijkstra(t);
for (long long i = 1; i <= n; i++) ans += val[pre[i]];
for (long long i = 1; i <= n; i++) d[i] = (pre[i] + 1) >> 1;
sort(d + 1, d + n + 1);
printf("%lld\n", ans);
for (long long i = 2; i <= n; i++) printf("%lld ", d[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma optimize(�Ofast�)
const int MAXN = 3e5 + 10;
const long long INF = 1e17;
vector<pair<int, int> > g[MAXN];
void solve() {
int n, m;
cin >> n >> m;
map<pair<int, int>, int> mp;
map<int, int> mr;
for (int i = 0; i < m; i++) {
int x, y, w;
cin >> x >> y >> w;
pair<int, int> p1 = {x, w};
pair<int, int> p2 = {y, w};
g[x].push_back(p2);
g[y].push_back(p1);
mp[{min(x, y), max(x, y)}] = i + 1;
mr[i + 1] = w;
}
int u;
cin >> u;
vector<long long> dst(n + 2, INF);
vector<int> p(n + 2, 0);
set<pair<long long, int> > s;
pair<long long, int> start = {0, u};
s.insert(start);
dst[u] = 0;
while (!s.empty()) {
pair<long long, int> f = *s.begin();
s.erase(f);
long long d = f.first;
int q = f.second;
for (auto i : g[q]) {
int to = i.first;
int w = i.second;
if (dst[to] >= d + w) {
s.erase({dst[to], to});
dst[to] = d + w;
s.insert({dst[to], to});
p[to] = q;
}
}
}
set<int> ans;
p[u] = -1;
for (int i = 1; i <= n; i++) {
if (i != u) {
int cur = p[i];
int lst = i;
while (cur != -1) {
int z = mp[{min(cur, lst), max(cur, lst)}];
ans.insert(z);
lst = cur;
cur = p[cur];
break;
}
}
}
long long sum = 0;
for (auto i : ans) {
sum += (long long)mr[i];
}
cout << sum << "\n";
for (auto i : ans) {
cout << i << " ";
}
}
int main() {
ios_base::sync_with_stdio(false);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
map<pair<int, int>, pair<int, int> > M;
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
Q;
vector<pair<int, int> > adjList[N];
pair<long long, int> dist[N];
int parent[N];
vector<int> ans;
int main() {
int n, m, u, v, src;
long long w, d;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> u >> v >> w;
M[{u, v}] = {i, w};
M[{v, u}] = {i, w};
adjList[u].push_back({v, w});
adjList[v].push_back({u, w});
}
cin >> src;
Q.push({0, src});
for (int i = 1; i <= n; i++)
dist[i].first = LLONG_MAX, dist[i].second = INT_MAX;
dist[src].first = dist[src].second = 0;
while (!Q.empty()) {
u = Q.top().second, d = Q.top().first;
Q.pop();
if (d > dist[u].first) continue;
for (int i = 0; i < adjList[u].size(); i++) {
v = adjList[u][i].first, w = adjList[u][i].second;
if (d + w < dist[v].first) {
dist[v].first = d + w;
dist[v].second = w;
parent[v] = u;
Q.push({dist[v].first, v});
} else if (d + w == dist[v].first && dist[v].second > w) {
dist[v].second = w;
parent[v] = u;
Q.push({dist[v].first, v});
}
}
}
d = 0;
for (int i = 1; i <= n; i++) {
if (i == src) continue;
ans.push_back(M[{parent[i], i}].first);
d += M[{parent[i], i}].second;
}
cout << d << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, e, n, m, u, v, w, cost, size;
cin >> n >> m;
vector<pair<long long int, pair<long long int, long long int> > >
graph[n + 1];
long long int done[n + 1];
long long int sp[n + 1];
vector<long long int> taken;
for (i = 1; i <= m; i++) {
cin >> u >> v >> w;
graph[u].push_back(make_pair(i, make_pair(v, w)));
graph[v].push_back(make_pair(i, make_pair(u, w)));
}
memset(done, 0, sizeof(done));
for (i = 1; i <= n; i++) sp[i] = 10e+17;
cin >> u;
priority_queue<pair<pair<long long int, long long int>,
pair<long long int, long long int> > >
q;
q.push(make_pair(make_pair(0, 0), make_pair(u, -1)));
sp[u] = 0;
cost = 0;
while (!q.empty()) {
u = (q.top()).second.first;
e = (q.top()).second.second;
w = (-(q.top()).first.second);
q.pop();
if (done[u] == 1) continue;
done[u] = 1;
cost += w;
taken.push_back(e);
size = graph[u].size();
for (i = 0; i < size; i++) {
e = graph[u][i].first;
v = graph[u][i].second.first;
w = graph[u][i].second.second;
if (done[v] == 1) continue;
if (sp[v] >= sp[u] + w) {
sp[v] = sp[u] + w;
q.push(make_pair(make_pair(-sp[v], -w), make_pair(v, e)));
}
}
}
cout << cost << endl;
size = taken.size();
for (i = 1; i < size; i++) cout << taken[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, x, y, z, st, tot[300039], now, w[300039];
long long d[300039], ans;
struct yyy {
int to, w, z, id;
} tmp;
struct ljb {
int head, h[300039];
yyy f[600039];
inline void add(int x, int y, int z, int id) {
f[++head] = (yyy){y, z, h[x], id};
h[x] = head;
}
} s;
queue<int> q;
int main() {
memset(d, 0x3f, sizeof(d));
register int i;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++)
scanf("%d%d%d", &x, &y, &w[i]), s.add(x, y, w[i], i), s.add(y, x, w[i], i);
scanf("%d", &st);
q.push(st);
d[st] = 0;
while (!q.empty()) {
now = q.front();
q.pop();
for (int cur = s.h[now]; cur; cur = tmp.z) {
tmp = s.f[cur];
if (d[tmp.to] > d[now] + tmp.w)
tot[tmp.to] = tmp.id, d[tmp.to] = d[now] + tmp.w, q.push(tmp.to);
else if (d[tmp.to] == d[now] + tmp.w)
tot[tmp.to] = w[tot[tmp.to]] > tmp.w ? tmp.id : tot[tmp.to];
}
}
for (i = 1; i <= n; i++)
if (tot[i]) ans += w[tot[i]];
printf("%lld\n", ans);
for (i = 1; i <= n; i++)
if (tot[i]) printf("%d ", tot[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
return b == 0 ? a : gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return a * (b / gcd(a, b));
}
long long int power(long long int a, long long int b) {
long long int ans = 1;
while (b > 0) {
if (b & 1) ans = ((ans % 1000000007) * (a % 1000000007)) % 1000000007;
a = ((a % 1000000007) * (a % 1000000007)) % 1000000007;
b >>= 1;
}
return ans;
}
vector<vector<pair<long long int, long long int> > > adj;
long long int parent[300010], dis[300010], n, enter[300010];
void shortest_path(long long int source) {
long long int i;
dis[source] = 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> > >
p;
p.push(make_pair(0, source));
while (!p.empty()) {
pair<long long int, long long int> T = p.top();
long long int d = T.first;
long long int curr = T.second;
p.pop();
if (d > dis[curr]) continue;
for (auto it : adj[curr]) {
if (dis[curr] + it.first <= dis[it.second]) {
if (it.first < enter[it.second]) {
enter[it.second] = it.first;
parent[it.second] = curr;
dis[it.second] = dis[curr] + it.first;
p.push(make_pair(dis[it.second], it.second));
}
}
}
}
return;
}
int main() {
long long int max_val = 1e18;
map<pair<long long int, long long int>, long long int> ma;
long long int m, i;
long long int u, v, w;
cin >> n >> m;
for (i = 1; i < n + 1; i++) {
dis[i] = max_val;
enter[i] = max_val;
}
adj.resize(n + 1);
for (i = 1; i < m + 1; i++) {
cin >> u >> v >> w;
ma[pair<long long int, long long int>(u, v)] = i;
ma[pair<long long int, long long int>(v, u)] = i;
adj[u].push_back(make_pair(w, v));
adj[v].push_back(make_pair(w, u));
}
long long int source;
cin >> source;
shortest_path(source);
long long int sum = 0;
for (i = 1; i < n + 1; i++)
if (enter[i] != max_val) sum += enter[i];
cout << sum << endl;
for (i = 1; i < n + 1; i++)
if (enter[i] != max_val)
cout << ma[pair<long long int, long long int>(i, parent[i])] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long INF = 1e18;
vector<long long> g[500000];
vector<long long> root, sz, dist, ans, interesting;
long long answ;
struct edge {
long long a, b, c, id;
};
bool comp(edge a, edge b) { return a.c < b.c; }
long long Root(long long x) {
return x == root[x] ? x : root[x] = Root(root[x]);
}
void Merge(edge x) {
long long v = Root(x.a), u = Root(x.b);
if (abs(dist[x.a] - dist[x.b]) != x.c) return;
if (v == u) return;
if (dist[x.a] > dist[x.b]) {
if (!interesting[x.a]) return;
interesting[x.a] = 0;
} else {
if (!interesting[x.b]) return;
interesting[x.b] = 0;
}
ans.push_back(x.id);
answ += x.c;
if (sz[v] >= sz[u]) {
swap(v, u);
}
root[v] = u;
sz[u] += sz[v];
}
signed main() {
long long n, m;
cin >> n >> m;
vector<edge> edges;
for (long long i = 0; i < m; i++) {
long long a, b, c;
cin >> a >> b >> c;
a--, b--;
g[a].push_back(i);
g[b].push_back(i);
edges.push_back({a, b, c, i + 1});
}
long long s;
cin >> s;
s--;
set<pair<long long, long long> > q;
q.insert({0, s});
dist.resize(n);
fill(dist.begin(), dist.end(), INF);
dist[s] = 0;
while (q.size()) {
pair<long long, long long> k = *(q.begin());
q.erase(q.begin());
for (auto i : g[k.second]) {
long long f = k.second;
long long t = edges[i].a + edges[i].b - f;
if (dist[t] > dist[f] + edges[i].c) {
q.erase({dist[t], t});
dist[t] = dist[f] + edges[i].c;
q.insert({dist[t], t});
}
}
}
root.resize(n), sz.resize(n), interesting.resize(n);
fill(sz.begin(), sz.end(), 1);
fill(interesting.begin(), interesting.end(), 1);
iota(root.begin(), root.end(), 0);
sort(edges.begin(), edges.end(), comp);
interesting[s] = 0;
for (long long i = 0; i < m; i++) {
Merge(edges[i]);
}
cout << answ << "\n";
for (long long i = 0; i < ans.size(); i++) {
cout << ans[i] << " ";
}
}
|
#include <bits/stdc++.h>
const int maxn = 1200010;
int n, m, mk[maxn], eu[maxn], t[maxn];
int next[maxn], nbs[maxn], ev[maxn], f[maxn], ew[maxn];
long long d[maxn];
int open[maxn], open2[maxn];
const long long inf = 0x7fffffffffffffLL;
void spfa(int x) {
open[1] = x;
for (int i = 1; i <= n; i++) d[i] = inf, f[i] = -1;
d[x] = 0, f[x] = 0;
memset(mk, 0, sizeof(mk));
int tail2, tail = 1;
int u, v, p = 0;
while (p++, tail) {
for (int i = 1; i <= tail; i++) open2[i] = open[i];
tail2 = tail;
tail = 0;
for (int i = 1; i <= tail2; i++) {
u = open2[i];
for (int j = nbs[u]; j != -1; j = next[j]) {
v = ev[j];
if (d[u] + ew[j] < d[v] || (d[u] + ew[j] == d[v] && ew[j] < ew[f[v]])) {
d[v] = d[u] + ew[j];
f[v] = j;
if (mk[v] != p) {
mk[v] = p;
open[++tail] = v;
}
}
}
}
}
}
int main() {
while (scanf("%d %d", &n, &m) != EOF) {
int num = 0;
memset(nbs, 0xff, sizeof(nbs));
for (int i = 1; i <= m; i++) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
next[num] = nbs[u];
nbs[u] = num;
eu[num] = u;
ev[num] = v;
ew[num] = w;
num++;
next[num] = nbs[v];
nbs[v] = num;
eu[num] = v;
ev[num] = u;
ew[num] = w;
num++;
}
int r;
scanf("%d", &r);
spfa(r);
long long ret = 0;
for (int i = 1; i <= n; i++)
if (i != r) ret += ew[f[i]];
printf("%I64d\n", ret);
for (int i = 1; i <= n; i++)
if (i != r) printf("%d ", (f[i] >> 1) + 1);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300100;
vector<pair<long long, long long> > adj[MAXN];
map<pair<long long, long long>, pair<long long, long long> > mp;
long long d[MAXN];
int par[MAXN];
bool fin[MAXN];
int n, m, src;
void solve() {
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq;
memset(fin, 0, sizeof(fin));
for (int i = 0; i < (n); ++i) d[i] = (1e17);
d[src] = 0;
pq.push(make_pair(d[src], src));
memset(par, -1, sizeof(par));
while (!pq.empty()) {
long long w = pq.top().first;
int u = pq.top().second;
pq.pop();
if (d[u] == w) {
fin[u] = true;
for (__typeof((adj[u]).begin()) it = (adj[u]).begin();
it != (adj[u]).end(); ++it) {
long long l = it->first;
int v = it->second;
if (w + it->first < d[it->second]) {
par[it->second] = u;
d[it->second] = w + it->first;
pq.push(make_pair(d[it->second], it->second));
} else if (fin[u] && w + it->first == d[it->second]) {
if (it->first < mp[make_pair(it->second, par[it->second])].second) {
par[it->second] = u;
}
}
}
}
}
long long sum = 0;
vector<long long> ans;
for (int i = 0; i < (n); ++i)
if (par[i] != -1) {
assert(mp.find(make_pair(i, par[i])) != mp.end());
ans.push_back(mp[make_pair(i, par[i])].first);
sum += mp[make_pair(i, par[i])].second;
}
cout << sum << "\n";
for (__typeof((ans).begin()) it = (ans).begin(); it != (ans).end(); ++it) {
if (it != ans.begin()) cout << " ";
cout << *it;
}
cout << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
while (cin >> n >> m) {
for (int i = 0; i < (m); ++i) {
int x, y, w;
cin >> x >> y >> w;
--x;
--y;
mp[make_pair(x, y)] = make_pair(i + 1, w);
mp[make_pair(y, x)] = make_pair(i + 1, w);
adj[x].push_back(make_pair(w, y));
adj[y].push_back(make_pair(w, x));
}
cin >> src;
--src;
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ii = pair<int, int>;
using ti = tuple<int, int, int>;
using lint = long long;
using li = pair<lint, int>;
const int N = 3 * 1e5 + 5;
const lint inf = 1e18 + 5;
int n, m, st;
vector<ti> a[N];
vector<ii> pr[N];
lint ans_val;
vector<int> ans_vec;
lint dist[N];
void make() {
priority_queue<li, vector<li>, greater<li> > pq;
fill(dist, dist + N, inf);
pq.push(li(0, st));
dist[st] = 0;
while (!pq.empty()) {
lint cd = pq.top().first;
int cp = pq.top().second;
pq.pop();
for (size_t i = 0; i < a[cp].size(); i++) {
int idx = get<0>(a[cp][i]);
int np = get<1>(a[cp][i]);
int ct = get<2>(a[cp][i]);
lint nd = cd + (lint)(ct);
if (dist[np] >= nd) {
if (dist[np] > nd) {
pr[np].clear();
dist[np] = nd;
pq.push(li(nd, np));
}
pr[np].push_back(ii(ct, idx));
}
}
}
}
void go() {
vector<li> v;
for (int i = 1; i <= n; i++) {
v.push_back(li(dist[i], i));
sort(pr[i].begin(), pr[i].end());
}
sort(v.begin(), v.end());
for (int i = 1; i < n; i++) {
int idx = v[i].second;
ans_val += (lint)(pr[idx][0].first);
ans_vec.push_back(pr[idx][0].second);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y, w;
scanf("%d%d%d", &x, &y, &w);
a[x].push_back(ti(i, y, w));
a[y].push_back(ti(i, x, w));
}
scanf("%d", &st);
make();
go();
printf("%lld\n", ans_val);
for (int e : ans_vec) {
printf("%d ", e);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300010;
const long long inf = (1LL << 60);
struct edge {
int u;
int w;
int ind;
};
vector<edge> graph[MAXN];
int main() {
int n, m;
scanf("%d%d", &n, &m);
vector<pair<edge, edge> > ar(m);
for (int i = 0; i < m; i++) {
int x, y, w;
scanf("%d%d%d", &x, &y, &w);
x--;
y--;
edge a, b;
a.u = y;
a.w = w;
a.ind = i;
b.u = x;
b.w = w;
b.ind = i;
graph[x].push_back(a);
graph[y].push_back(b);
ar[i] = make_pair(a, b);
}
int u;
scanf("%d", &u);
u--;
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
pq;
vector<long long> dist(n, inf);
vector<int> from(n, -1);
dist[u] = 0;
pq.push(make_pair(0, u));
while (!pq.empty()) {
int v = pq.top().second;
long long w = pq.top().first;
pq.pop();
if (dist[v] < w) {
continue;
}
for (int i = 0; i < graph[v].size(); i++) {
int t = graph[v][i].u;
int tw = graph[v][i].w;
int ind = graph[v][i].ind;
if (w + tw < dist[t] || (w + tw == dist[t] && tw < ar[from[t]].first.w)) {
dist[t] = w + tw;
pq.push(make_pair(dist[t], t));
from[t] = ind;
}
}
}
set<int> b6e5;
vector<int> ans;
for (int i = 0; i < n; i++) {
if (from[i] != -1) {
int ind = from[i];
b6e5.insert(ind);
}
}
long long w = 0;
for (auto x : b6e5) {
w += ar[x].first.w;
ans.push_back(x);
}
printf("%I64d\n", w);
for (int i = 0; i < ans.size(); i++) {
if (i) printf(" ");
printf("%d", ans[i] + 1);
}
puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
bool debug = 1;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
long long ln, lk, lm;
long long dis[300105];
int S;
vector<pair<pair<int, int>, int>> mp[300105];
bool used[300105];
int preid[300105], W[300105];
void dij() {
for (int(i) = 0; (i) < (int)(300105); (i)++) dis[i] = (1LL << 60);
dis[S] = 0;
priority_queue<pair<long long, int>, std::vector<pair<long long, int>>,
std::greater<pair<long long, int>>>
q;
q.push({0, S});
while (!q.empty()) {
int x = q.top().second;
q.pop();
if (used[x]) continue;
used[x] = 1;
for (auto p : mp[x]) {
int d = p.first.second, y = p.first.first, id = p.second;
if (dis[x] + d < dis[y]) {
dis[y] = dis[x] + d;
q.push({dis[y], y});
preid[y] = id;
} else if (dis[x] + d == dis[y]) {
if (W[preid[y]] > W[id]) preid[y] = id;
}
}
}
long long ans = 0;
for (int(i) = 1; (i) <= (int)(n); (i)++)
if (i != S) ans += W[preid[i]];
printf("%lld\n", ans);
for (int(i) = 1; (i) <= (int)(n); (i)++)
if (i != S) printf("%d ", preid[i]);
puts("");
}
int main() {
scanf("%d%d", &n, &m);
for (int u, v, w, i = 1; i <= m; i++) {
scanf("%d%d%d", &u, &v, &w);
W[i] = w;
mp[u].push_back({{v, w}, i});
mp[v].push_back({{u, w}, i});
}
scanf("%d", &S);
dij();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 3e5 + 9;
struct s {
long long d, w, idx;
s(long long _d, long long _w, long long _idx) {
d = _d;
w = _w;
idx = _idx;
}
};
vector<s> edges[MAX];
long long dis[MAX], counter = 0, par[MAX], cost[MAX];
bool vis[MAX];
set<int> ans;
map<pair<int, int>, int> mp;
void Dijkstra(int u) {
priority_queue<pair<long long, long long> > pq;
for (int i = 0; i < MAX; i++) dis[i] = 1e18;
pq.push({0, u});
dis[u] = 0;
while (!pq.empty()) {
long long c = -pq.top().first;
u = pq.top().second;
pq.pop();
for (auto it : edges[u]) {
int v = it.d;
c = it.w;
if (dis[v] > dis[u] + c) {
dis[v] = dis[u] + c;
pq.push({-dis[v], v});
}
}
}
}
int main(void) {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
long long in1, in2, in3;
scanf("%lld %lld %lld", &in1, &in2, &in3);
edges[in1].push_back(s(in2, in3, i + 1));
edges[in2].push_back(s(in1, in3, i + 1));
mp[{in1, in2}] = i + 1;
mp[{in2, in1}] = i + 1;
}
int st;
scanf("%d", &st);
Dijkstra(st);
for (int i = 1; i <= n; i++) {
bool found = false;
long long mi = 1e18;
long long e = 0;
for (int j = 0; j < edges[i].size(); j++) {
long long k = edges[i][j].d;
long long c = edges[i][j].w;
if (dis[i] == dis[k] + c && mi > c) {
found = true;
mi = c;
e = k;
}
}
if (found == true) ans.insert(mp[{i, e}]), counter += mi;
}
printf("%lld\n", counter);
for (auto it : ans) printf("%d ", it);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T abs(T x) {
return x > 0 ? x : -x;
}
int n, m, s;
vector<pair<pair<int, int>, int> > g[300005];
vector<pair<pair<int, int>, pair<int, int> > > newg;
pair<pair<int, int>, int> from[300005];
const long long INF = 100000000000000000;
vector<long long> d(300005, INF), p(300005);
bool used[300005];
vector<int> res;
void dijkstra() {
d[s] = 0;
priority_queue<pair<long long, int> > q;
q.push(make_pair(0, s));
while (!q.empty()) {
int v = q.top().second, cur_d = -q.top().first;
q.pop();
if (cur_d > d[v]) continue;
for (size_t j = 0; j < g[v].size(); ++j) {
int to = g[v][j].first.first, len = g[v][j].first.second;
if (d[v] + len < d[to]) {
d[to] = d[v] + len;
p[to] = v;
q.push(make_pair(-d[to], to));
}
}
}
}
int pp[300005];
int dsu_get(int v) { return (v == pp[v]) ? v : (pp[v] = dsu_get(pp[v])); }
void dsu_unite(int a, int b) {
a = dsu_get(a);
b = dsu_get(b);
if (rand() & 1) swap(a, b);
if (a != b) pp[a] = b;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
x--;
y--;
g[x].push_back(make_pair(make_pair(y, z), i));
g[y].push_back(make_pair(make_pair(x, z), i));
}
cin >> s;
s--;
dijkstra();
long long cost = 0;
for (int i = 0; i < n; i++) {
long long cur_min = 100000000000000;
int cur_num = 0;
for (int j = 0; j < g[i].size(); j++) {
int to = g[i][j].first.first;
int len = g[i][j].first.second;
int num = g[i][j].second;
if (d[i] - len == d[to] && len < cur_min) {
cur_min = len;
cur_num = num;
}
}
if (cur_min != 100000000000000) {
cost += cur_min;
res.push_back(cur_num);
}
}
cout << cost << "\n";
for (int i = 0; i < res.size(); i++) {
printf("%d ", res[i] + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e5 + 1;
const long long mod = 1e18 + 7;
template <typename T>
inline istream &operator>>(istream &is, vector<T> &A);
template <class Ch, class Tr, class Container>
inline basic_ostream<Ch, Tr> &operator<<(basic_ostream<Ch, Tr> &os,
Container const &x);
template <class X, class Y>
inline ostream &operator<<(ostream &os, pair<X, Y> const &p);
void solve() {
long long n, m;
cin >> n >> m;
vector<vector<pair<long long, long long>>> adj(n);
map<pair<long long, long long>, long long> mp;
vector<long long> wieght(m);
for (long long i = 0; i < m; i++) {
long long u, v, w;
cin >> u >> v >> w;
--u, --v;
adj[u].push_back({v, w});
adj[v].push_back({u, w});
mp[{u, v}] = i + 1;
mp[{v, u}] = i + 1;
wieght[i] = w;
}
long long src;
cin >> src;
--src;
priority_queue<array<long long, 4>, vector<array<long long, 4>>,
greater<array<long long, 4>>>
pq;
vector<long long> parent(n, -1);
long long tim = 0;
vector<long long> dist(n, mod);
vector<long long> vis(n);
pq.push({0, 0, src, -1});
dist[src] = 0;
long long cost = 0;
while (!pq.empty()) {
auto [w, t, x, p] = pq.top();
pq.pop();
if (vis[x]) continue;
vis[x] = true;
parent[x] = p;
;
for (const auto &[y, d] : adj[x]) {
if (w + d <= dist[y]) {
dist[y] = w + d;
;
pq.push({w + d, d, y, x});
}
}
};
vector<long long> ans;
for (long long i = 0; i < n; i++) {
if (parent[i] != -1) {
long long x = mp[{parent[i], i}];
cost += wieght[x - 1];
ans.push_back(x);
}
}
cout << cost << "\n";
cout << ans;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
t = 1;
for (long long I = 1; I <= t; I++) {
solve();
}
return 0;
}
template <typename T>
inline istream &operator>>(istream &is, vector<T> &A) {
for (long long i = 0; i < A.size(); i++) is >> A[i];
return is;
}
template <class Ch, class Tr, class Container>
inline basic_ostream<Ch, Tr> &operator<<(basic_ostream<Ch, Tr> &os,
Container const &x) {
for (auto &y : x) os << y << ' ';
return os;
}
template <class X, class Y>
inline ostream &operator<<(ostream &os, pair<X, Y> const &p) {
return os << p.first << " " << p.second;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mi = 999999999;
struct edge {
long long to;
long long la;
long long val;
} e[600010];
long long h[300010];
long long dis[300010];
long long pre[300010];
long long v[300010];
long long cnt = 0;
priority_queue<long long> s;
void ae(long long f, long long t, long long v) {
e[++cnt].to = t;
e[cnt].val = v;
e[cnt].la = h[f];
h[f] = cnt;
}
void spfa(long long x) {
memset(dis, 0x3f, sizeof(dis));
dis[x] = 0;
queue<long long> q;
q.push(x);
v[x] = 1;
while (q.size()) {
long long u = q.front();
q.pop();
v[u] = 0;
for (long long i = h[u]; i; i = e[i].la) {
long long t = e[i].to;
if (dis[t] > dis[u] + e[i].val) {
dis[t] = dis[u] + e[i].val;
pre[t] = i;
if (v[t] == 0) {
q.push(t);
v[t] = 1;
}
} else if (dis[t] == dis[u] + e[i].val && e[i].val < e[pre[t]].val) {
pre[t] = i;
}
}
}
}
int main() {
long long n, m;
scanf("%lld%lld", &n, &m);
for (long long i = 1; i <= m; i++) {
long long x, y, z;
scanf("%lld%lld%lld", &x, &y, &z);
ae(x, y, z);
ae(y, x, z);
}
long long st;
scanf("%lld", &st);
spfa(st);
long long ans = 0;
for (long long i = 1; i <= n; i++) {
ans += e[pre[i]].val;
if (i != st) {
s.push(-pre[i]);
}
}
printf("%lld\n", ans);
while (s.size()) {
long long u = s.top();
s.pop();
u = -u;
printf("%lld ", (u + 1) / 2);
}
puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1000000000, INFLL = INF * INF;
struct ple {
long long gdzie, waga;
long long i;
ple(long long a, long long b, long long c) {
gdzie = a;
waga = b;
i = c;
}
};
struct vertex {
vector<ple> v;
};
const int N = 300005;
vertex tab[N];
long long edges[N], popr[N], dist[N];
void jebaj() {
long long n, m;
cin >> n >> m;
for (auto i = (0); i <= ((m)-1); ++i) {
int a, b, c;
cin >> a >> b >> c;
tab[a].v.push_back(ple(b, c, i));
tab[b].v.push_back(ple(a, c, i));
edges[i] = c;
}
edges[m] = INFLL;
long long start;
cin >> start;
for (auto i = (1); i <= (n); ++i) {
if (i == start)
dist[i] = 0;
else
dist[i] = INFLL;
popr[i] = m;
}
set<pair<long long, long long> > secik;
for (auto i = (1); i <= (n); ++i) {
secik.insert(make_pair(dist[i], i));
}
while (!secik.empty()) {
auto a = *secik.begin();
secik.erase(secik.begin());
int act = a.second;
long long odl = a.first;
for (auto b : tab[act].v) {
if (odl + b.waga <= dist[b.gdzie]) {
if (odl + b.waga < dist[b.gdzie]) {
popr[b.gdzie] = b.i;
secik.erase(make_pair(dist[b.gdzie], b.gdzie));
dist[b.gdzie] = odl + b.waga;
secik.insert(make_pair(dist[b.gdzie], b.gdzie));
} else {
if (b.waga < edges[popr[b.gdzie]]) {
popr[b.gdzie] = b.i;
}
}
}
}
}
long long res = 0;
for (auto i = (1); i <= (n); ++i)
if (i != start) res += edges[popr[i]];
cout << res << "\n";
for (auto i = (1); i <= (n); ++i)
if (i != start) cout << popr[i] + 1 << " ";
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
int t = 1;
for (auto i = (0); i <= ((t)-1); ++i) {
jebaj();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long NMAX = 300000 + 5;
const long long inf = 922337203685477580LL;
vector<vector<pair<long long, long long> > > g(NMAX);
vector<vector<int> > id(NMAX);
long long dis[NMAX];
long long last[NMAX];
long long a[NMAX];
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
g[a].push_back({b, c});
g[b].push_back({a, c});
id[a].push_back(i);
id[b].push_back(i);
}
int s;
cin >> s;
for (int i = 1; i <= n; i++) dis[i] = inf;
dis[s] = 0;
for (int i = 1; i <= n; i++) last[i] = inf;
last[s] = 0;
set<pair<int, int> > q;
q.insert({0, s});
while (!q.empty()) {
int w = q.begin()->second;
q.erase(q.begin());
for (int i = 0; i < g[w].size(); i++) {
int to = g[w][i].first;
int len = g[w][i].second;
if (dis[w] + len < dis[to] ||
(dis[w] + len <= dis[to] && len < last[to])) {
q.erase(make_pair(dis[to], to));
dis[to] = dis[w] + len;
last[to] = len;
a[to] = id[w][i] + 1;
q.insert(make_pair(dis[to], to));
}
}
}
for (int i = 1; i <= n; i++) ans += last[i];
cout << ans << endl;
for (int i = 1; i <= n; i++) {
if (i != s) {
cout << a[i] << " ";
}
}
cout << endl;
return 0;
}
|
#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);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, u;
vector<pair<pair<long long, long long>, long long> > v[300005];
vector<long long> ans;
long long dis[300005];
bool vis[300005];
long long sum;
void solve() {
memset(vis, false, sizeof(vis));
for (long long i = 0; i <= n; i++) dis[i] = LLONG_MAX;
dis[u] = 0;
set<pair<pair<long long, long long>, pair<long long, long long> > > s1;
s1.insert({{0, u}, {0, 0}});
int cnt = 0;
while (!s1.empty()) {
pair<pair<long long, long long>, pair<long long, long long> > p =
*s1.begin();
s1.erase(s1.begin());
long long w = p.second.first;
long long x = p.first.second;
if (vis[x]) continue;
vis[x] = true;
sum += w;
cnt++;
long long z = p.second.second;
if (z != 0) {
ans.push_back(z);
}
if (cnt == n) break;
for (auto it : v[x]) {
long long y = it.first.first;
long long cost = it.first.second;
if (dis[x] + cost <= dis[y]) {
dis[y] = dis[x] + cost;
s1.insert({{dis[y], y}, {cost, it.second}});
}
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
long long x, y, w;
scanf("%lld%lld%lld", &x, &y, &w);
v[x].push_back({{y, w}, i + 1});
v[y].push_back({{x, w}, i + 1});
}
cin >> u;
sum += 0;
solve();
cout << sum << endl;
sort(ans.begin(), ans.end());
for (auto it : ans) cout << it << " ";
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct comp {
bool operator()(pair<int, long long> &a, pair<int, long long> &b) {
return a.second > b.second;
}
};
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, pair<int, int>>> adj[n + 1];
long long dist[n + 1];
int edg[n + 1];
int edge[m + 1];
memset(edge, 0, sizeof(edge));
memset(dist, 0x3f, sizeof(dist));
for (int i = 1; i < n + 1; i++) {
edg[i] = 0;
}
for (int i = 1; i <= m; i++) {
int x, y, z;
cin >> x >> y >> z;
adj[x].push_back(make_pair(y, make_pair(z, i)));
adj[y].push_back(make_pair(x, make_pair(z, i)));
edge[i] = z;
}
int u;
cin >> u;
dist[u] = 0;
priority_queue<pair<int, long long>, vector<pair<int, long long>>, comp> q;
q.push(make_pair(u, 0));
while (!q.empty()) {
int curr_node = q.top().first;
long long curr_dist = q.top().second;
q.pop();
for (int i = 0; i < adj[curr_node].size(); i++) {
int child = adj[curr_node][i].first;
int ed = adj[curr_node][i].second.first;
int edi = adj[curr_node][i].second.second;
if (curr_dist + ed < dist[child]) {
dist[child] = curr_dist + ed;
edg[child] = edi;
q.push(make_pair(child, dist[child]));
} else if (curr_dist + ed == dist[child]) {
int old_e = edge[edg[child]];
if (ed < old_e) {
edg[child] = edi;
}
}
}
}
long long maxx = 0;
for (int i = 1; i < n + 1; i++) {
maxx += edge[edg[i]];
}
cout << maxx << endl;
for (int i = 1; i < n + 1; i++) {
if (edg[i]) cout << edg[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 3e5 + 10;
const long long inf = 1e18 + 10;
using namespace std;
typedef tuple<long long, pair<int, int>, int> trinca;
struct Edge {
int j, w, id;
Edge(int j = 0, int w = 0, int id = 0) : j(j), w(w), id(id) {}
bool operator<(Edge other) const { return w < other.w; }
};
int n, m, s;
vector<int> ans;
bool marc[MAXN];
long long resp;
long long dist[MAXN];
vector<Edge> adj[MAXN];
void dijkstra() {
priority_queue<trinca, vector<trinca>, greater<trinca> > fila;
for (int i = 0; i < MAXN; i++) dist[i] = inf;
dist[s] = 0;
fila.push(make_tuple(0, make_pair(0, 0), s));
while (!fila.empty()) {
long long d = get<0>(fila.top());
pair<int, int> p = get<1>(fila.top());
int cur = get<2>(fila.top());
fila.pop();
if (marc[cur]) continue;
marc[cur] = true;
resp += 1LL * p.first;
if (p.second > 0) ans.push_back(p.second);
for (Edge e : adj[cur])
if (dist[e.j] >= d + 1LL * e.w) {
dist[e.j] = d + 1LL * e.w;
fila.push(make_tuple(dist[e.j], make_pair(e.w, e.id), e.j));
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, u, v, w; i <= m; i++) {
scanf("%d%d%d", &u, &v, &w);
adj[u].push_back(Edge(v, w, i));
adj[v].push_back(Edge(u, w, i));
}
scanf("%d", &s);
dijkstra();
printf("%lld\n", resp);
sort(ans.begin(), ans.end());
for (int x : ans) printf("%d ", x);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long>> ad[350000];
long long dis[350000];
long long vis[350000];
map<pair<long long, long long>, long long> mpp;
int main() {
long long i, j, k, l, m, n, u, v, co;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> u >> v >> co;
ad[u].push_back({v, co});
ad[v].push_back({u, co});
mpp[{u, v}] = mpp[{v, u}] = i + 1;
}
long long root, w;
cin >> root;
for (i = 1; i <= n; i++) dis[i] = 1e18;
dis[root] = 0;
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
pq;
pq.push({0ll, root});
while (!pq.empty()) {
w = pq.top().first;
u = pq.top().second;
pq.pop();
if (vis[u]) continue;
vis[u] = 1;
for (auto x : ad[u]) {
v = x.first;
if (dis[v] <= (x.second + w)) continue;
dis[v] = x.second + w;
pq.push({dis[v], v});
}
}
long long ans = 0;
vector<long long> fin;
for (i = 1; i <= n; i++) {
pair<long long, long long> par = {1e18, -1};
for (auto x : ad[i]) {
v = x.first;
w = x.second;
if (dis[i] == (w + dis[v])) {
par = min(par, {w, v});
}
}
if (par.second != -1) {
ans += par.first;
fin.push_back(mpp[{i, par.second}]);
}
}
cout << ans << '\n';
sort(fin.begin(), fin.end());
for (auto x : fin) cout << x << " ";
cout << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300001;
vector<pair<int, int> > v[N];
long long dist[N];
int pre[N];
int weight[N];
int n, m;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) dist[i] = 1e18;
for (int i = 1; i <= m; i++) {
int a, b, c;
cin >> a >> b >> c;
v[b].push_back(make_pair(a, i));
v[a].push_back(make_pair(b, i));
weight[i] = c;
}
int source;
cin >> source;
priority_queue<pair<long long, int> > q;
q.push(make_pair(0LL, source));
dist[source] = 0LL;
pre[source] = 0;
weight[0] = 0;
while (!q.empty()) {
int node = q.top().second;
q.pop();
int x = v[node].size();
while (x--) {
int next = v[node][x].first;
int id = v[node][x].second;
int weigh = weight[id];
if (dist[next] > dist[node] + weigh) {
dist[next] = dist[node] + weigh;
pre[next] = id;
q.push(make_pair(-dist[next], next));
} else {
if (dist[next] == dist[node] + weigh) {
if (weigh < weight[pre[next]]) {
pre[next] = id;
}
}
}
}
}
long long sum = 0;
for (int i = 1; i <= n; i++) sum += weight[pre[i]];
cout << sum << "\n";
for (int i = 1; i <= n; i++) {
if (i != source) {
cout << pre[i] << " ";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
const int maxn = 300010;
const long long inf = 1e16;
int cnt, head[maxn];
int pre[maxn], vis[maxn], val[maxn];
long long dis[maxn];
struct edge {
int to, w, nxt, id;
} e[maxn << 1];
void init() {
cnt = 0;
memset(head, -1, sizeof(head));
}
void add(int u, int v, int w, int id) {
e[cnt].to = v;
e[cnt].w = w;
e[cnt].id = id;
e[cnt].nxt = head[u];
head[u] = cnt++;
}
void spfa(int s) {
memset(pre, 0, sizeof(pre));
memset(vis, 0, sizeof(vis));
for (int i = 0; i <= n; i++) dis[i] = inf;
queue<int> que;
que.push(s);
dis[s] = 0, vis[s] = 1;
while (!que.empty()) {
int u = que.front();
que.pop();
vis[u] = 0;
for (int i = head[u]; ~i; i = e[i].nxt) {
int v = e[i].to;
if (dis[v] > dis[u] + e[i].w) {
dis[v] = dis[u] + e[i].w;
pre[v] = e[i].id;
if (!vis[v]) {
vis[v] = 1;
que.push(v);
}
} else if (dis[v] == dis[u] + e[i].w) {
if (e[i].w < val[pre[v]]) {
pre[v] = e[i].id;
if (!vis[v]) {
vis[v] = 1;
que.push(v);
}
}
}
}
}
}
int main() {
int m;
while (~scanf("%d%d", &n, &m)) {
init();
for (int i = 1; i <= m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
add(u, v, w, i);
add(v, u, w, i);
val[i] = w;
}
int s;
scanf("%d", &s);
spfa(s);
long long sum = 0;
for (int i = 1; i <= n; i++)
if (pre[i]) sum += val[pre[i]];
cout << sum << endl;
for (int i = 1; i <= n; i++)
if (pre[i]) printf("%d ", pre[i]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 100;
const long long INF = 1LL << 60;
struct P {
long long d, cost;
int num, v;
P(long long d = 0, long long cost = 0, int num = 0, int v = 0)
: d(d), cost(cost), num(num), v(v) {}
friend bool operator>(const P a, const P b) {
if (a.d != b.d) {
return a.d > b.d;
}
return a.cost > b.cost;
}
};
struct edge {
int to, num, cost;
edge(int to = 0, int num = 0, int cost = 0) : to(to), num(num), cost(cost) {}
};
vector<edge> E[maxn];
vector<int> t;
long long d[maxn];
long long cost[maxn];
long long solve(int u, int n) {
priority_queue<P, vector<P>, greater<P> > q;
fill(cost + 1, cost + n + 1, INF);
fill(d + 1, d + n + 1, INF);
d[u] = cost[u] = 0;
q.push(P(0, 0, -1, u));
long long res = 0;
while (!q.empty()) {
P p = q.top();
q.pop();
int v = p.v;
if (d[v] != p.d || cost[v] != p.cost) {
continue;
}
res += cost[v];
if (p.num != -1) {
t.push_back(p.num + 1);
}
for (int i = 0; i < E[v].size(); ++i) {
edge e = E[v][i];
if ((d[e.to] > d[v] + e.cost) ||
(d[e.to] == d[v] + e.cost && cost[e.to] > e.cost)) {
cost[e.to] = e.cost;
d[e.to] = d[v] + e.cost;
q.push(P(d[e.to], cost[e.to], e.num, e.to));
}
}
}
return res;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int x, y, l;
scanf("%d%d%d", &x, &y, &l);
E[x].push_back(edge(y, i, l));
E[y].push_back(edge(x, i, l));
}
int u;
cin >> u;
printf("%I64d\n", solve(u, n));
for (int i = 0; i < t.size(); ++i) {
printf("%d%c", t[i], (i != t.size() - 1 ? ' ' : '\n'));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
const long long inf = 1e18;
long long dis[maxn], wei[maxn], par_edge[maxn];
set<pair<long long, int> > s;
vector<pair<pair<int, int>, int> > adj[maxn];
int n, m, root;
void input() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b, w;
cin >> a >> b >> w;
adj[a - 1].push_back(make_pair(make_pair(w, b - 1), i));
adj[b - 1].push_back(make_pair(make_pair(w, a - 1), i));
wei[i] = w;
}
cin >> root;
root--;
return;
}
void init() {
for (int i = 0; i < n; i++) dis[i] = inf;
dis[root] = 0;
for (int i = 0; i < n; i++) s.insert(make_pair(dis[i], i));
return;
}
void dijkstra() {
for (int i = 0; i < n; i++) {
int v = (*s.begin()).second;
s.erase(make_pair(dis[v], v));
for (auto x : adj[v]) {
int u = x.first.second, w = x.first.first, index = x.second;
if (dis[u] > dis[v] + w ||
(dis[u] == dis[v] + w && wei[par_edge[u]] > w)) {
s.erase(make_pair(dis[u], u));
dis[u] = dis[v] + w;
s.insert(make_pair(dis[u], u));
par_edge[u] = index;
}
}
}
}
void output() {
long long ans = 0;
for (int i = 0; i < n; i++)
if (i != root) ans += wei[par_edge[i]];
cout << ans << endl;
for (int i = 0; i < n; i++)
if (i != root) cout << par_edge[i] + 1 << " ";
cout << endl;
return;
}
int main() {
input();
init();
dijkstra();
output();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int w;
int id;
int to;
};
struct P {
int id;
long long dis;
P() {}
P(int ids = 0, int diss = 0) : id(ids), dis(diss) {}
bool operator<(const P a) const { return a.dis < dis; }
};
vector<Edge> con[311111];
long long cost[311111];
long long dis[311111];
long long in[311111];
int u, m, n;
void Dijkstra(int x) {
fill(cost, cost + n + 1, 0xffffffffffffff);
fill(dis, dis + n + 1, 0xffffffffffffff);
dis[u] = 0LL;
priority_queue<P> que;
que.push(P(u, dis[u]));
P now(0, 0);
while (que.size()) {
now = que.top();
que.pop();
if (dis[now.id] < now.dis) continue;
for (int i = 0; i < con[now.id].size(); i++) {
Edge e = con[now.id][i];
if ((dis[now.id] + e.w < dis[e.to]) ||
(dis[now.id] + e.w == dis[e.to] && cost[e.to] > e.w)) {
bool flag;
if (dis[now.id] + e.w < dis[e.to])
flag = true;
else
flag = false;
dis[e.to] = dis[now.id] + e.w;
cost[e.to] = e.w;
in[e.to] = e.id;
if (flag) que.push(P(e.to, dis[e.to]));
}
}
}
}
int main() {
cin >> n >> m;
int x, y, w;
Edge e;
for (int i = 1; i <= m; i++) {
cin >> x >> y >> w;
e.id = i;
e.w = w;
e.to = y;
con[x].push_back(e);
e.to = x;
con[y].push_back(e);
}
cin >> u;
Dijkstra(u);
long long sum = 0;
for (int i = 1; i <= n; i++) {
if (i == u) continue;
sum += cost[i];
}
cout << sum << endl;
for (int i = 1; i <= n; i++) {
if (i == u) continue;
cout << in[i] << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long elen, head[300010 << 1], n, m, ans, x, y, z, d[300010 << 1],
vis[300010 << 1], pre[300010 << 1];
priority_queue<pair<long long, long long> > q;
struct node {
long long to, nxt, l;
} edge[300010 << 1];
inline long long read() {
long long x = 0, tag = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') tag = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return x * tag;
}
void add(long long x, long long y, long long z) {
edge[++elen].to = y;
edge[elen].nxt = head[x];
edge[elen].l = z;
head[x] = elen;
}
signed main() {
elen = 1;
edge[1].l = 1000000001;
n = read();
m = read();
for (long long i = 1; i <= m; i++)
x = read(), y = read(), z = read(), add(x, y, z), add(y, x, z);
x = read();
memset(d, 0x3f, sizeof(d));
q.push(pair<long long, long long>(d[x] = 0, x));
for (long long i = 1; i <= n; i++) {
while (vis[q.top().second]) q.pop();
pair<long long, long long> now = q.top();
now.first = -now.first;
q.pop();
vis[now.second] = 1;
for (long long j = head[now.second]; j; j = edge[j].nxt) {
long long to = edge[j].to;
if (d[to] > now.first + edge[j].l ||
(d[to] == now.first + edge[j].l && edge[j].l < edge[pre[to]].l)) {
d[to] = now.first + edge[j].l;
q.push(pair<long long, long long>(-d[to], to));
pre[to] = j;
}
}
}
for (long long i = 1; i <= n; i++)
if (i != x) ans += edge[pre[i]].l;
printf("%lld\n", ans);
for (long long i = 1; i <= n; i++)
if (i != x) printf("%lld ", pre[i] >> 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 10000000000000016;
const long long N = 300005;
long long n, m;
map<pair<long long, long long>, long long> edge;
vector<pair<long long, long long> > adj[N];
long long u, v, w, st, ans = 0;
vector<long long> G;
long long dis[N];
priority_queue<
pair<pair<long long, long long>, pair<long long, long long> >,
vector<pair<pair<long long, long long>, pair<long long, long long> > >,
greater<pair<pair<long long, long long>, pair<long long, long long> > > >
Q;
void dijk(long long st) {
for (long long i = 1; i <= n; i++) dis[i] = inf;
dis[st] = 0;
Q.push(pair<pair<long long, long long>, pair<long long, long long> >(
pair<long long, long long>(0, 0), pair<long long, long long>(st, st)));
pair<pair<long long, long long>, pair<long long, long long> > tp;
pair<long long, long long> ff, ss;
long long sz, nxt;
while (!Q.empty()) {
tp = Q.top();
Q.pop();
ff = tp.first, ss = tp.second;
if (ss.first != st && ff.first >= dis[ss.first]) continue;
dis[ss.first] = ff.first;
if (ss.first != ss.second) {
G.push_back(edge[pair<long long, long long>(min(ss.first, ss.second),
max(ss.first, ss.second))]);
ans += ff.second;
}
sz = adj[ss.first].size();
for (long long i = 0; i < sz; i++) {
nxt = adj[ss.first][i].first;
w = adj[ss.first][i].second;
if (dis[nxt] > dis[ss.first] + w) {
Q.push(pair<pair<long long, long long>, pair<long long, long long> >(
pair<long long, long long>(dis[ss.first] + w, w),
pair<long long, long long>(nxt, ss.first)));
}
}
}
}
int main() {
cin >> n >> m;
for (long long i = 1; i <= m; i++) {
cin >> u >> v >> w;
if (u > v) swap(u, v);
edge[pair<long long, long long>(u, v)] = i;
adj[u].push_back(pair<long long, long long>(v, w));
adj[v].push_back(pair<long long, long long>(u, w));
}
cin >> st;
dijk(st);
cout << ans << "\n";
long long sz = G.size();
for (long long i = 0; i < sz; i++) {
cout << G[i] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + ch - '0';
ch = getchar();
}
return x * f;
}
const long long SIZE = 500005;
long long nxt[SIZE << 1], ver[SIZE << 1], head[SIZE << 1], tot, val[SIZE << 1];
inline void add(long long x, long long y, long long z) {
ver[++tot] = y, val[tot] = z, nxt[tot] = head[x], head[x] = tot;
}
struct node {
long long id, dst;
bool operator<(const node &x) const { return dst > x.dst; }
};
priority_queue<node> q;
long long n, m, d[SIZE], t, pre[SIZE], ans;
bool v[SIZE];
void dijkstra(long long s) {
memset(d, 0x7f, sizeof(d));
d[s] = 0, q.push((node){s, 0});
while (!q.empty()) {
node tmp = q.top();
q.pop();
long long x = tmp.id;
if (v[x]) continue;
v[x] = true;
for (long long i = head[x]; i; i = nxt[i]) {
long long y = ver[i];
if (d[y] > d[x] + val[i])
pre[y] = i, d[y] = d[x] + val[i], q.push((node){y, d[y]});
if (d[y] == d[x] + val[i] && val[pre[y]] > val[i]) pre[y] = i;
}
}
}
int main() {
n = read(), m = read();
for (long long i = 1; i <= m; i++) {
long long x = read(), y = read(), z = read();
add(x, y, z), add(y, x, z);
}
t = read(), dijkstra(t);
for (long long i = 1; i <= n; i++) ans += val[pre[i]];
for (long long i = 1; i <= n; i++) d[i] = (pre[i] + 1) >> 1;
sort(d + 1, d + n + 1);
printf("%lld\n", ans);
for (long long i = 2; i <= n; i++) printf("%lld ", d[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3 * 100000 + 5;
const long long INF = 0x0123456789ABCDEFLL;
vector<pair<pair<long long, long long>, long long> > edges[maxn];
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
Q;
vector<long long> dist(maxn, INF), dad(maxn, -1), D(maxn, -1), W(maxn, -1);
int u;
void dijkstra(int s) {
Q.push(make_pair(0, s));
dist[s] = 0;
while (!Q.empty()) {
pair<int, int> p = Q.top();
Q.pop();
long long here = p.second;
for (vector<pair<pair<long long, long long>, long long> >::iterator it =
edges[here].begin();
it != edges[here].end(); it++) {
if (dist[here] + it->first.second < dist[it->first.first]) {
dist[it->first.first] = dist[here] + it->first.second;
dad[it->first.first] = it->second;
D[it->first.first] = dist[here];
W[it->first.first] = it->first.second;
Q.push(make_pair(dist[it->first.first], it->first.first));
} else if (dist[here] + it->first.second == dist[it->first.first]) {
if (dist[here] > D[it->first.first]) {
dad[it->first.first] = it->second;
D[it->first.first] = dist[here];
W[it->first.first] = it->first.second;
}
}
}
}
}
inline void solve(void) {
long long n, m, x, y, z;
cin >> n >> m;
for (int i = (0); i < (m); i++) {
cin >> x >> y >> z;
edges[x].push_back(pair<pair<int, int>, int>(pair<int, int>(y, z), i + 1));
edges[y].push_back(pair<pair<int, int>, int>(pair<int, int>(x, z), i + 1));
}
cin >> u;
dijkstra(u);
long long x1 = 0;
for (int i = 1; i <= n; i++) {
if (i == u) continue;
x1 += W[i];
}
cout << x1 << endl;
for (int i = 1; i <= n; i++) {
if (i == u) continue;
cout << dad[i] << " ";
}
}
void init() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
}
int main(int argc, const char* argv[]) {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using std::make_pair;
using std::pair;
using std::priority_queue;
using std::sort;
using std::vector;
struct ss {
int to, id;
long long int w;
};
vector<ss> v[300005];
long long int d[300005];
int vis[300005];
int anss[300005], cnt = 0;
struct sss {
long long int d1;
long long int d2;
int id;
int eid;
bool operator<(sss a) const {
if (d1 > a.d1)
return 1;
else if (d1 == a.d1 && d2 > a.d2)
return 1;
return 0;
}
};
priority_queue<sss> q;
int main(void) {
int n, m;
scanf("%d%d", &n, &m);
int i;
for (i = 1; i <= m; i++) {
int a, b;
long long int c;
scanf("%d%d%lld", &a, &b, &c);
ss r;
r.to = b;
r.id = i;
r.w = c;
v[a].push_back(r);
r.to = a;
v[b].push_back(r);
}
int st;
scanf("%d", &st);
for (i = 1; i <= n; i++) {
d[i] = 1000000000000000LL;
vis[i] = 0;
}
d[st] = 0;
sss f;
f.d1 = f.d2 = 0;
f.id = st;
q.push(f);
long long int ans = 0;
for (;;) {
while (!q.empty() && vis[q.top().id]) q.pop();
if (q.empty()) break;
int now = q.top().id;
long long int dis1 = q.top().d1;
ans += q.top().d2;
if (now != st) anss[cnt++] = q.top().eid;
vis[now] = 1;
q.pop();
for (i = 0; i < v[now].size(); i++) {
if (vis[v[now][i].to]) continue;
sss nxt;
nxt.id = v[now][i].to;
nxt.d1 = dis1 + v[now][i].w;
nxt.d2 = v[now][i].w;
nxt.eid = v[now][i].id;
q.push(nxt);
}
}
printf("%lld\n", ans);
sort(anss, anss + cnt);
for (i = 0; i < cnt; i++) printf("%d ", anss[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int MAX = 300012, INF = 1e18;
long long int d[MAX], p[MAX], le[MAX];
long long int n, m, u, w, v, now;
bool flag[MAX];
set<pair<long long int, long long int> > dis;
long long int sum;
vector<pair<long long int, long long int> > g[MAX];
map<pair<long long int, long long int>, long long int> e;
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
long long int t1, t2, t3;
for (long long int i = 1; i <= m; i++) {
cin >> t1 >> t2 >> t3;
e[make_pair(min(t1, t2), max(t1, t2))] = i;
g[t1].push_back(make_pair(t2, t3));
g[t2].push_back(make_pair(t1, t3));
}
cin >> u;
for (long long int i = 1; i <= n; i++) {
le[i] = d[i] = INF, p[i] = -1;
}
le[u] = d[u] = 0, p[u] = 0;
dis.insert(make_pair(0, u));
while (!dis.empty()) {
now = (*dis.begin()).second;
flag[now] = 1;
dis.erase(dis.begin());
for (long long int i = 0; i < g[now].size(); i++) {
v = g[now][i].first;
if (flag[v]) continue;
w = g[now][i].second;
if (d[now] + w < d[v]) {
le[v] = w;
p[v] = now;
if (d[v] != INF) dis.erase(make_pair(d[v], v));
d[v] = d[now] + w;
dis.insert(make_pair(d[v], v));
} else if (d[now] + w == d[v] && w < le[v]) {
p[v] = now;
le[v] = w;
if (d[v] != INF) dis.erase(make_pair(d[v], v));
d[v] = d[now] + w;
dis.insert(make_pair(d[v], v));
}
}
}
for (long long int i = 1; i <= n; i++) sum += le[i];
cout << sum << endl;
for (long long int i = 1; i <= n; i++)
if (p[i]) cout << e[make_pair(min(i, p[i]), max(i, p[i]))] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
template <class A, class B>
ostream& operator<<(ostream& out, const pair<A, B>& a) {
return out << '(' << a.first << ", " << a.second << ')';
}
const long long N = 3e5 + 7;
set<pair<long long, long long> > s;
long long dis[N];
pair<long long, long long> par[N];
vector<pair<pair<long long, long long>, long long> > adj[N];
vector<long long> ans;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m, v, u, w, i, j, sum = 0;
cin >> n >> m;
for (i = 1; i <= m; i++) {
cin >> v >> u >> w;
adj[v].push_back({{u, w}, i});
adj[u].push_back({{v, w}, i});
}
cin >> v;
fill(dis, dis + N, 1000000000000000000LL);
dis[v] = 0;
par[v] = {v, -1};
s.insert({0, v});
for (i = 1; i <= n; i++)
if (i != v) s.insert({1000000000000000000LL, i});
while (!s.empty()) {
v = s.begin()->second;
w = s.begin()->first;
s.erase(s.begin());
sum += w - dis[par[v].first];
if (par[v].second != -1) ans.push_back(par[v].second);
dis[v] = w;
for (auto x : adj[v])
if (dis[v] + x.first.second <= dis[x.first.first])
s.erase({dis[x.first.first], x.first.first}),
dis[x.first.first] = dis[v] + x.first.second,
par[x.first.first] = {v, x.second},
s.insert({dis[x.first.first], x.first.first});
}
cout << sum << endl;
for (size_t _i = (0); _i < ((long long)((ans).size())) + (0); _i++)
cout << ans[_i]
<< (((1) && _i != ((long long)((ans).size())) + (0) - 1) ? ' ' : '\n');
;
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
long long dis[maxn], par[maxn], W[maxn];
vector<pair<pair<int, int>, int> > adj[maxn];
vector<int> ans;
void dij(int u) {
memset(dis, 127, sizeof dis);
set<pair<int, int> > s;
dis[u] = 0;
s.insert(make_pair(0, u));
while (s.size()) {
int v = s.begin()->second;
s.erase(*s.begin());
for (int i = 0; i < adj[v].size(); i++) {
int child = adj[v][i].first.first, w = adj[v][i].first.second,
ver = adj[v][i].second;
if (dis[child] > dis[v] + w or
(dis[child] == dis[v] + w and W[child] > w)) {
W[child] = w;
s.erase(make_pair(dis[child], child));
dis[child] = dis[v] + w;
s.insert(make_pair(dis[child], child));
par[child] = ver;
}
}
}
}
int main() {
long long ww = 0;
int n, m, source, tmp;
cin >> n >> m;
tmp = m;
while (tmp--) {
int fi, se, w;
cin >> fi >> se >> w;
adj[fi].push_back(make_pair(make_pair(se, w), m - tmp));
adj[se].push_back(make_pair(make_pair(fi, w), m - tmp));
}
cin >> source;
dij(source);
for (int i = 1; i <= n; i++)
if (i != source) ans.push_back(par[i]);
sort(ans.begin(), ans.end());
ans.resize(unique(ans.begin(), ans.end()) - ans.begin());
for (int i = 1; i <= n; i++) ww += W[i];
cout << ww << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long lt = 100005;
long long mod = 1000000007;
vector<pair<long long, pair<long long, long long> > > ad[300005];
vector<long long> last(300005);
vector<long long> dist(300005, LLONG_MAX);
vector<long long> visited(300005, 0);
vector<long long> edge(300005);
void dijsktra(long long u) {
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
q;
q.push(make_pair(0, u));
dist[u] = 0;
last[u] = 0;
while (!q.empty()) {
pair<long long, long long> w = q.top();
q.pop();
long long wt = w.first;
long long v = w.second;
if (visited[v] == 1) continue;
visited[v] = 1;
long long i;
for (i = 0; i < (long long)(ad[v]).size(); i++) {
long long x = ad[v][i].first;
long long wtt = ad[v][i].second.first;
long long edgeNum = ad[v][i].second.second;
if (dist[x] > wtt + wt) {
dist[x] = wtt + wt;
last[x] = edgeNum;
q.push(make_pair(dist[x], x));
} else if (dist[x] == wtt + wt) {
if (edge[last[x]] > edge[edgeNum]) {
last[x] = edgeNum;
visited[x] = 0;
q.push(make_pair(dist[x], x));
}
}
}
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m;
cin >> n >> m;
long long i;
for (i = 1; i <= m; i++) {
long long a, b, c;
cin >> a >> b >> c;
ad[a].push_back(make_pair(b, make_pair(c, i)));
ad[b].push_back(make_pair(a, make_pair(c, i)));
edge[i] = c;
}
edge[0] = LLONG_MAX;
long long u;
cin >> u;
dijsktra(u);
vector<long long> ans;
long long anss = 0;
for (i = 1; i <= n; i++) {
if (i == u) continue;
ans.push_back(last[i]);
anss += edge[last[i]];
}
cout << anss << endl;
for (i = 0; i < n - 1; i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 3e5 + 5, inf = 1e18;
vector<pair<pair<long long, long long>, long long>> g[maxn];
long long dist[maxn], pr[maxn];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n, m;
cin >> n >> m;
for (long long i = 0; i < m; ++i) {
long long u, v, w;
cin >> u >> v >> w;
u--, v--;
g[u].push_back({{v, w}, i});
g[v].push_back({{u, w}, i});
}
set<pair<long long, long long>> second;
for (long long i = 0; i < n; ++i) {
dist[i] = inf;
}
long long kek;
cin >> kek;
kek--;
dist[kek] = 0;
for (long long i = 0; i < n; ++i) {
second.insert({dist[i], i});
}
while (!second.empty()) {
long long v = second.begin()->second;
second.erase(second.begin());
for (auto [e, i] : g[v]) {
auto [u, w] = e;
if (dist[u] > dist[v] + w) {
second.erase({dist[u], u});
dist[u] = dist[v] + w;
second.insert({dist[u], u});
}
}
}
long long ans = 0;
vector<long long> a;
for (long long i = 0; i < n; ++i) {
if (i == kek) {
continue;
}
pr[i] = -1;
long long second = -1;
for (auto [e, j] : g[i]) {
if (dist[i] == dist[e.first] + e.second &&
(pr[i] == -1 || e.second < second)) {
second = e.second;
pr[i] = j;
}
}
ans += second;
a.push_back(pr[i] + 1);
}
cout << ans << '\n';
for (auto e : a) {
cout << e << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
int cnt = 0;
long long dis[300005];
int vis[300005], pre[300005];
int h[300005], to[600005], ver[600005], w[600005];
inline int read() {
register int x = 0, f = 1;
register char s = getchar();
while (s > '9' || s < '0') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
return x * f;
}
inline void add(int x, int y, int z) {
to[++cnt] = y;
ver[cnt] = h[x];
w[cnt] = z;
h[x] = cnt;
}
inline void dijistra(int u) {
std::priority_queue<std::pair<long long, int> > Q;
memset(dis, 0x3f, sizeof(dis));
Q.push(std::make_pair(0, u));
dis[u] = 0;
while (Q.size()) {
int x = Q.top().second;
Q.pop();
if (vis[x]) continue;
vis[x] = 1;
for (register int i = h[x]; i; i = ver[i]) {
int y = to[i];
if (dis[y] >= dis[x] + w[i]) {
dis[y] = dis[x] + w[i];
pre[y] = i;
Q.push(std::make_pair(-dis[y], y));
}
}
}
}
int main() {
int n = read(), m = read();
for (register int i = 1; i <= m; ++i) {
int x = read(), y = read(), z = read();
add(x, y, z);
add(y, x, z);
}
int u = read();
dijistra(u);
long long ans = 0;
for (register int i = 1; i <= n; ++i) ans += w[pre[i]];
printf("%lld\n", ans);
for (register int i = 1; i <= n; ++i) pre[i] = (pre[i] + 1) >> 1;
std::sort(pre + 1, pre + 1 + n);
for (register int i = 2; i <= n; ++i) printf("%d ", pre[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 3 * 100000 + 10;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
int head[MaxN], nxt[MaxN << 1], to[MaxN << 1], cost[MaxN << 1], bid[MaxN << 1],
top;
void addedge(int fr, int tt, int co, int id) {
top++;
nxt[top] = head[fr];
to[top] = tt;
head[fr] = top;
cost[top] = co;
bid[top] = id;
}
int n, m, v;
void init() {
scanf("%d%d", &n, &m);
int a, b, w;
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d", &a, &b, &w);
addedge(a, b, w, i);
addedge(b, a, w, i);
}
scanf("%d", &v);
}
int que[MaxN], in[MaxN];
long long dis[MaxN];
bool inq[MaxN];
void solve() {
int lead = 1, tail = 0, now;
for (int i = 1; i <= n; ++i) dis[i] = INF;
dis[v] = 0;
que[++tail] = v;
inq[v] = 1;
for (; lead <= tail; ++lead) {
now = que[lead % n];
inq[now] = 0;
for (int i = head[now]; i; i = nxt[i])
if (dis[to[i]] > dis[now] + (long long)cost[i]) {
dis[to[i]] = dis[now] + (long long)cost[i];
if (!inq[to[i]]) {
que[(++tail) % n] = to[i];
inq[to[i]] = 1;
}
}
}
for (int i = 1; i <= n; ++i)
for (int j = head[i]; j; j = nxt[j])
if (dis[i] + (long long)cost[j] == dis[to[j]] &&
(in[to[j]] == 0 || cost[j] < cost[in[to[j]]])) {
in[to[j]] = j;
}
long long ans = 0;
for (int i = 1; i <= n; ++i) ans += cost[in[i]];
cout << ans << endl;
for (int i = 1; i <= n; ++i)
if (in[i]) printf("%d ", bid[in[i]]);
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.14159265359;
bool vis[300001];
int par[300001];
long long dist[300001];
vector<pair<long long, long long> > adj[300001];
vector<int> ind;
unordered_map<int, int> ma[300001];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
p;
int n, i, l, m;
pair<long long, long long> j;
int k;
cin >> n >> m;
int x, y, w;
for (i = 1; i <= n; i++) dist[i] = 1000000000000000;
for (i = 1; i <= m; i++) {
cin >> x >> y >> w;
ma[x][y] = i;
ma[y][x] = i;
adj[x].push_back(make_pair(w, y));
adj[y].push_back(make_pair(w, x));
}
int start;
cin >> start;
p.push(make_pair(0, start));
dist[start] = 0;
long long ans = 0;
while (!p.empty()) {
j = p.top();
p.pop();
k = j.second;
if (vis[k]) continue;
vis[k] = 1;
if (par[k] != 0) {
ind.push_back(ma[k][par[k]]);
ans += dist[k] - dist[par[k]];
}
for (auto it = adj[k].begin(); it != adj[k].end(); ++it) {
if (!vis[it->second] &&
dist[k] + (long long)(it->first) <= dist[it->second]) {
par[it->second] = k;
dist[it->second] = dist[k] + (long long)(it->first);
p.push(make_pair(dist[it->second], it->second));
}
}
}
cout << ans << "\n";
for (auto it = ind.begin(); it != ind.end(); ++it) cout << *it << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e15;
int main(int argc, char const* argv[]) {
int n, m;
scanf("%d %d", &n, &m);
vector<pair<int, int> > adjacency_list[n];
int edges[m];
long long distance[n];
int previous[n], last_cost[n];
bool visited[n];
for (int i = 0; i < n; i += 1) {
distance[i] = M;
previous[i] = -1;
visited[i] = 0;
}
for (int i = 0; i < m; i += 1) {
int a, b;
scanf("%d %d %d", &a, &b, edges + i);
a--;
b--;
adjacency_list[a].push_back(make_pair(b, i));
adjacency_list[b].push_back(make_pair(a, i));
}
int source;
scanf("%d", &source);
source--;
distance[source] = 0;
previous[source] = -1;
set<pair<long long, pair<int, int> > > que;
que.insert(make_pair(0, make_pair(0, source)));
long long ans = 0;
while (!que.empty()) {
pair<long long, pair<int, int> > present = *(que.begin());
que.erase(que.begin());
int u = present.second.second;
long long dist = present.first;
assert(u < n);
if (visited[u]) {
continue;
}
visited[u] = 1;
for (int i = 0; i < adjacency_list[u].size(); i += 1) {
int v = adjacency_list[u][i].first;
int k = adjacency_list[u][i].second;
assert(v < n);
assert(k < m);
que.erase(make_pair(distance[v], make_pair(last_cost[v], v)));
if (distance[v] > edges[k] + dist ||
(distance[v] == edges[k] + dist && edges[k] < last_cost[v])) {
distance[v] = edges[k] + dist;
previous[v] = k;
last_cost[v] = edges[k];
}
que.insert(make_pair(distance[v], make_pair(last_cost[v], v)));
}
ans += present.second.first;
}
cout << ans << endl;
for (int i = 0; i < n; i += 1) {
if (i != source) {
printf("%d ", previous[i] + 1);
}
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
struct edge {
int u, w, ind;
edge(int u = 0, int w = 0, int ind = 0) : u(u), w(w), ind(ind) {}
};
using namespace std;
const int maxn = 3e5 + 1;
int n, m, s;
long long dist[maxn], wt;
bool mrk[maxn];
vector<edge> g[maxn];
vector<int> res;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v, w;
cin >> u >> v >> w;
g[v].push_back(edge(u, w, i));
g[u].push_back(edge(v, w, i));
}
cin >> s;
fill(dist, dist + n + 1, 1e18 + 7);
dist[s] = 0;
priority_queue<pair<long long, int> > Q;
Q.push(pair<long long, int>(-dist[s], s));
while (Q.empty() == false) {
int v = Q.top().second;
long long d = -Q.top().first;
Q.pop();
if (d != dist[v]) continue;
for (int i = 0; i < g[v].size(); i++) {
int u = g[v][i].u;
long long add = g[v][i].w;
if (d + add < dist[u]) {
dist[u] = d + add;
Q.push(pair<long long, int>(-dist[u], u));
}
}
}
for (int i = 1; i <= n; i++) {
long long w = 1e18 + 7;
int ind = -1;
for (int j = 0; j < g[i].size(); j++) {
int u = g[i][j].u;
long long add = g[i][j].w;
if (dist[i] - add == dist[u] && add < w) {
w = add;
ind = g[i][j].ind;
}
}
if (ind != -1) {
wt += w;
res.push_back(ind);
}
}
cout << wt << endl;
for (int i = 0; i < res.size(); i++) cout << res[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2000000000;
const long long INFll = 10000000000000000ll;
struct e {
int to;
int w;
int num;
};
vector<vector<e> > v;
e new_e(int to, int w, int num) {
e t;
t.to = to;
t.w = w;
t.num = num;
return t;
}
bool b[500100];
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
v.resize(n + 1);
int x, y, z;
for (int i = 0; i < m; i++) {
cin >> x >> y >> z;
v[x].push_back(new_e(y, z, i + 1));
v[y].push_back(new_e(x, z, i + 1));
}
int root;
cin >> root;
priority_queue<pair<pair<long long, long long>, pair<int, int> > > q;
vector<int> ans;
q.push(make_pair(make_pair(0, 0), make_pair(root, 0)));
long long ansv = 0;
long long d1, d2;
while (!q.empty()) {
d1 = -q.top().first.first;
d2 = -q.top().first.second;
x = q.top().second.first;
y = q.top().second.second;
q.pop();
if (b[x]) {
continue;
}
ans.push_back(y);
b[x] = true;
ansv += d2;
for (int i = 0; i < v[x].size(); i++) {
if (b[v[x][i].to]) continue;
q.push(make_pair(make_pair(-d1 - v[x][i].w, -v[x][i].w),
make_pair(v[x][i].to, v[x][i].num)));
}
}
cout << ansv << endl;
for (int i = 1; i < n; i++) {
cout << ans[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long from;
long long to;
long long next;
long long val;
} edge[350000 << 1];
long long n, m, cnt, src, ans;
long long head[350000], visit[350000], dis[350000], pre[350000];
void init() {
memset(head, -1, sizeof(head));
cnt = 0;
}
void addedge(long long from, long long to, long long val) {
edge[++cnt].from = from;
edge[cnt].to = to;
edge[cnt].val = val;
edge[cnt].next = head[from];
head[from] = cnt;
}
void SPFA() {
memset(dis, 0x3f, sizeof(dis));
memset(visit, 0, sizeof(visit));
visit[src] = 1;
dis[src] = 0;
queue<int> Q;
Q.push(src);
while (!Q.empty()) {
long long u = Q.front();
Q.pop();
visit[u] = 0;
for (long long i = head[u]; i != -1; i = edge[i].next) {
long long v = edge[i].to;
if (dis[v] > dis[u] + edge[i].val) {
dis[v] = dis[u] + edge[i].val;
pre[v] = i;
if (!visit[v]) {
visit[v] = 1;
Q.push(v);
}
} else if (dis[v] == dis[u] + edge[i].val &&
edge[i].val < edge[pre[v]].val) {
pre[v] = i;
}
}
}
}
int main() {
init();
scanf("%I64d%I64d", &n, &m);
for (long long i = 1; i <= m; i++) {
long long a, b, c;
scanf("%I64d%I64d%I64d", &a, &b, &c);
addedge(a, b, c);
addedge(b, a, c);
}
scanf("%I64d", &src);
SPFA();
for (long long i = 1; i <= n; i++) {
if (pre[i]) ans += (edge[pre[i]].val);
}
printf("%I64d\n", ans);
for (long long i = 1; i <= n; i++) {
if (pre[i]) printf("%I64d ", (pre[i] + 1) / 2);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
scanf("%d %d", &N, &M);
typedef struct edge {
int num;
int dest;
int dist;
} edge_t;
vector<list<edge_t>> edges(N + 1);
vector<int> edge_distances(M + 1, 0);
for (int m = 0; m < M; m++) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
edge_t edge;
edge.num = m + 1;
edge.dist = w;
edge.dest = v;
edges[u].push_back(edge);
edge.dest = u;
edges[v].push_back(edge);
edge_distances[m + 1] = w;
}
int start;
scanf("%d", &start);
vector<unsigned long long> distance(N + 1, -1);
vector<int> used_edge(N + 1, 0);
distance[start] = 0;
vector<int> is_checked(N + 1, 0);
multimap<pair<unsigned long long, int>, int> nodes;
nodes.insert(pair<pair<unsigned long long, int>, int>(
pair<unsigned long long, int>(distance[start], 0), start));
while (!nodes.empty()) {
auto begin = nodes.begin();
int min_index = begin->second;
unsigned long long min_distance = begin->first.first;
nodes.erase(begin);
if (is_checked[min_index]) continue;
for (auto ie = edges[min_index].begin(); ie != edges[min_index].end();
ie++) {
if (min_distance + ie->dist <= distance[ie->dest]) {
distance[ie->dest] = min_distance + ie->dist;
used_edge[ie->dest] = ie->num;
nodes.insert(pair<pair<unsigned long long, int>, int>(
pair<unsigned long long, int>(distance[ie->dest], ie->dist),
ie->dest));
}
}
is_checked[min_index] = 1;
}
long long distance_sum = 0;
for (int n = 1; n <= N; n++) {
if (used_edge[n]) {
distance_sum += edge_distances[used_edge[n]];
}
}
printf("%lld\n", distance_sum);
for (int n = 1; n <= N; n++) {
if (used_edge[n]) {
printf("%d ", used_edge[n]);
}
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool fs(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;
}
vector<int> node[3 * 1000002];
vector<long long int> cost[3 * 1000002];
long long int total = 0;
int par[3 * 1000002];
long long int d[3 * 1000002];
long long int piv[3 * 1000002];
map<pair<long long int, long long int>, bool> ed;
map<pair<long long int, long long int>, int> cell;
void bfs(int s, int n) {
for (int i = 1; i <= n; i++) {
par[i] = i;
piv[i] = 0;
d[i] = 1000000000000000;
}
d[s] = 0;
queue<int> q;
q.push(s);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < node[u].size(); i++) {
int v = node[u][i];
long long int vcost = d[u] + cost[u][i];
if (vcost < d[v]) {
d[v] = vcost;
total = total - piv[v] + cost[u][i];
ed[pair<long long int, long long int>(par[v], v)] = false;
ed[pair<long long int, long long int>(u, v)] = true;
par[v] = u;
piv[v] = cost[u][i];
q.push(v);
}
if (vcost == d[v] && cost[u][i] < piv[v]) {
d[v] = vcost;
total = total - piv[v] + cost[u][i];
ed[pair<long long int, long long int>(par[v], v)] = false;
ed[pair<long long int, long long int>(u, v)] = true;
par[v] = u;
piv[v] = cost[u][i];
q.push(v);
}
}
}
}
int main() {
int v, e, a, c, b;
fs(v);
fs(e);
for (int i = 1; i <= e; i++) {
fs(a);
fs(b);
fs(c);
node[a].push_back(b);
node[b].push_back(a);
cost[a].push_back(c);
cost[b].push_back(c);
cell[pair<long long int, long long int>(a, b)] = i;
cell[pair<long long int, long long int>(b, a)] = i;
}
fs(a);
bfs(a, v);
cout << total << endl;
for (map<pair<long long int, long long int>, bool>::iterator it = ed.begin();
it != ed.end(); it++)
if (it->second) cout << cell[it->first] << ' ';
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, u, r[300010];
long long d[300010], use[300010];
vector<pair<int, int> > g[300010];
vector<int> a[300010];
bool ds[300010];
void IJK(int u) {
priority_queue<pair<long long, int> > q;
memset(d, 60, sizeof(d));
pair<long long, int> p = make_pair(d[u] = 0, u);
q.push(p);
while (!q.empty()) {
pair<long long, int> p = q.top();
q.pop();
u = p.second;
if (d[u] < -p.first) continue;
for (int i = 0; i < g[u].size(); ++i) {
int v = g[u][i].first;
long long l = g[u][i].second;
if (d[v] < d[u] + l || (d[v] == d[u] + l && l >= use[v])) continue;
use[v] = l;
d[v] = d[u] + g[u][i].second;
r[v] = a[u][i];
q.push(make_pair(-d[v], v));
}
}
}
void take() {
long long total = 0;
for (int i = 1; i <= n; ++i) total += use[i];
printf("%I64d\n", total);
for (int i = 1; i <= n; ++i)
if (i != u) ds[r[i]] = 1;
for (int i = 1; i <= m; ++i)
if (ds[i]) printf("%d ", i);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, x, y, l; i <= m; ++i) {
scanf("%d%d%d", &x, &y, &l);
g[x].push_back(make_pair(y, l));
g[y].push_back(make_pair(x, l));
a[x].push_back(i);
a[y].push_back(i);
}
scanf("%d", &u);
IJK(u);
take();
}
|
#include <bits/stdc++.h>
using namespace std;
const long long A = 1000000000000000LL, N = 328228;
vector<long long> a[N], b[N], e[N];
long long t[2][N * 4], o, w[N], d[N], ko[N], z[N], k[N], v, vo[N], x, y, c, i,
j, n, m;
void modi(long long v, long long l, long long r, long long g, long long h) {
if (l == r) {
t[0][v] = h, t[1][v] = g;
return;
}
long long mid = (l + r) / 2;
if (g <= mid)
modi(v * 2, l, mid, g, h);
else
modi(v * 2 + 1, mid + 1, r, g, h);
if (t[0][v * 2] > t[0][v * 2 + 1])
t[0][v] = t[0][v * 2 + 1], t[1][v] = t[1][v * 2 + 1];
else
t[0][v] = t[0][v * 2], t[1][v] = t[1][v * 2];
}
void deik(long long v) {
long long o, po, k = n, i, j;
for (i = 0; i < n; i++) modi(1, 1, n, i + 1, A), d[i] = A;
d[v] = 0;
modi(1, 1, n, v + 1, 0);
while (k--) {
o = t[0][1], po = t[1][1] - 1;
if (o == A) return;
modi(1, 1, n, po + 1, A);
for (i = 0; i < a[po].size(); i++)
if (d[a[po][i]] > d[po] + b[po][i] ||
(d[a[po][i]] == d[po] + b[po][i] && z[ko[a[po][i]]] > b[po][i])) {
modi(1, 1, n, a[po][i] + 1, d[po] + b[po][i]);
d[a[po][i]] = d[po] + b[po][i], ko[a[po][i]] = e[po][i];
}
}
}
int main() {
cin >> n >> m;
for (i = 0; i < m; i++)
cin >> x >> y >> c, z[i] = c, x--, y--, a[x].push_back(y),
b[x].push_back(c), a[y].push_back(x), b[y].push_back(c),
e[x].push_back(i), e[y].push_back(i);
cin >> v;
v--;
deik(v);
o = 0;
for (i = 0; i < n; i++)
if (i != v) o += z[ko[i]];
cout << o << "\n";
for (i = 0; i < n; i++)
if (i != v && !w[ko[i]]) w[ko[i]] = 1, cout << ko[i] + 1 << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, par;
long long len, dist;
bool operator<(const node &a) const {
if (a.dist < dist)
return true;
else if (a.dist == dist)
return a.len < len;
else
return false;
}
} tmp;
priority_queue<node> pq;
struct edge {
int x, num;
long long dist;
} tt;
vector<edge> adj[300010];
vector<int> res;
int vis[300010], root[300010], n, m, s;
long long dis[300010];
void dijkstra(int u) {
dis[u] = 0;
pq.push({u, u, 0, 0});
while (!pq.empty()) {
tmp = pq.top();
pq.pop();
if (vis[tmp.x]) continue;
vis[tmp.x] = 1;
root[tmp.x] = tmp.par;
for (int i = 0; i < adj[tmp.x].size(); i++) {
tt = adj[tmp.x][i];
if (dis[tt.x] >= tmp.dist + tt.dist && tt.x != tmp.par && !vis[tt.x]) {
dis[tt.x] = tmp.dist + tt.dist;
pq.push({tt.x, tmp.x, tt.dist, dis[tt.x]});
}
}
}
}
int main() {
int a, b;
long long c;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%lld", &a, &b, &c);
adj[a].push_back({b, i, c});
adj[b].push_back({a, i, c});
}
for (int i = 0; i <= n; i++) {
dis[i] = 3000000000000000;
}
scanf("%d", &s);
dijkstra(s);
long long ans = 0;
for (int i = 1; i <= n; i++) {
if (i == s) continue;
for (int j = 0; j < adj[i].size(); j++) {
tt = adj[i][j];
if (tt.x == root[i]) {
res.push_back(tt.num);
ans += tt.dist;
break;
}
}
}
sort(res.begin(), res.end());
printf("%lld\n", ans);
for (int i = 0; i < res.size(); i++) printf("%d ", res[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 3e5 + 5;
vector<tuple<long long, long long, long long> > adj[maxn];
bool vis[maxn];
long long d[maxn];
void solve(long long x) {
long long sum = 0;
static priority_queue<
tuple<long long, long long, long long, long long>,
vector<tuple<long long, long long, long long, long long> >,
greater<tuple<long long, long long, long long, long long> > >
pq;
pq.push(make_tuple(0, 0, x, 0));
while (!pq.empty()) {
auto i = pq.top();
pq.pop();
long long dis = get<0>(i), w = get<1>(i), pos = get<2>(i), e = get<3>(i);
if (dis >= d[pos]) continue;
vis[get<3>(i)] = true;
d[pos] = dis;
sum += get<1>(i);
for (auto i : adj[pos]) {
if ((!vis[get<2>(i)]) and dis + get<0>(i) <= d[get<1>(i)])
pq.push(make_tuple(dis + get<0>(i), get<0>(i), get<1>(i), get<2>(i)));
}
}
cout << sum << '\n';
}
signed main() {
memset(d, 0x3f, sizeof(d));
long long n, m;
cin >> n >> m;
for (long long i = 1; i <= m; i++) {
long long u, v, w;
cin >> u >> v >> w;
adj[u].push_back(make_tuple(w, v, i));
adj[v].push_back(make_tuple(w, u, i));
}
long long start;
cin >> start;
solve(start);
for (long long i = 1; i <= m; i++)
if (vis[i]) cout << i << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') {
f = -1;
}
c = getchar();
}
while (c <= '9' && c >= '0') {
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
}
return x * f;
}
const long long INF = 0x3f3f3f3f3f3f3f3f;
const long long Maxn = 3e5 + 5;
const long long Maxm = 6e5 + 5;
long long n, m, s, cnt, head[Maxn], dis[Maxn], pre[Maxn], ans[Maxn];
bool vis[Maxn];
struct Line {
long long to;
long long w;
long long next;
} edges[Maxm];
inline void Add(long long a, long long b, long long w) {
++cnt;
edges[cnt].to = b;
edges[cnt].w = w;
edges[cnt].next = head[a];
head[a] = cnt;
return;
}
struct Node {
long long id;
long long dist;
bool operator<(const Node &cur) const { return dist > cur.dist; }
};
inline void Dijkstra(long long start) {
priority_queue<Node> pq;
for (register long long i = 1; i <= n; ++i) {
dis[i] = INF;
vis[i] = false;
}
dis[start] = 0;
Node Start = {s, 0};
pq.push(Start);
while (!pq.empty()) {
Node now = pq.top();
pq.pop();
long long u = now.id;
if (vis[u] == true) {
continue;
}
vis[u] = true;
for (register long long i = head[u]; i != 0; i = edges[i].next) {
long long next = edges[i].to, w = edges[i].w;
if (dis[next] > dis[u] + w) {
dis[next] = dis[u] + w;
Node nxt = {next, dis[next]};
pq.push(nxt);
pre[next] = i;
}
if (dis[next] == dis[u] + edges[i].w && edges[i].w < edges[pre[next]].w) {
pre[next] = i;
}
}
}
return;
}
signed main() {
n = read(), m = read();
for (register long long i = 1; i <= m; ++i) {
long long x = read(), y = read(), w = read();
Add(x, y, w), Add(y, x, w);
}
s = read();
Dijkstra(s);
long long sum = 0, tot = 0;
for (register long long i = 1; i <= n; ++i) {
if (i == s) {
continue;
}
long long id = pre[i];
long long w = edges[id].w;
sum += w;
ans[++tot] = id;
}
sort(ans + 1, ans + tot + 1);
printf("%lld\n", sum);
for (register long long i = 1; i <= tot; ++i) {
printf("%lld ", (ans[i] + 1) / 2);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
long long power(long long b, long long e, long long m) {
if (e == 0) return 1;
if (e & 1) return b * power(b * b % m, e / 2, m) % m;
return power(b * b % m, e / 2, m);
}
long long power(long long b, long long e) {
if (e == 0) return 1;
if (e & 1) return b * power(b * b, e / 2);
return power(b * b, e / 2);
}
template <typename T, typename U>
static inline void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static inline void amax(T &x, U y) {
if (x < y) x = y;
}
const int N = 300005;
long long n;
bool vis[N];
map<pair<long long, long long>, long long> mp, we;
long long dis[N], par[N];
vector<pair<long long, long long>> v[N];
void djikstra(long long so) {
set<pair<long long, long long>> s;
par[so] = so;
for (long long i = 1; i <= n; ++i) dis[i] = 2000000000000000000;
dis[so] = 0;
s.insert({0, so});
while (!s.empty()) {
pair<long long, long long> p = *s.begin();
s.erase(s.begin());
for (auto j : v[p.second]) {
if (dis[p.second] + j.second <= dis[j.first]) {
if (dis[j.first] != 2000000000000000000)
s.erase({dis[j.first], j.first});
dis[j.first] = dis[p.second] + j.second;
par[j.first] = p.second;
s.insert({dis[j.first], j.first});
}
}
}
}
int _runtimeTerror_() {
long long m, i;
cin >> n >> m;
for (i = 1; i <= m; ++i) {
long long x, y, w;
cin >> x >> y >> w;
if (x > y) swap(x, y);
mp[{x, y}] = i;
we[{x, y}] = w;
v[x].push_back({y, w}), v[y].push_back({x, w});
}
long long u;
cin >> u;
djikstra(u);
vector<long long> ans;
set<long long> s;
s.insert(u);
long long val = 0;
for (i = 1; i <= n; ++i) {
if (s.count(i)) continue;
long long x = i;
while (par[x] != x && !s.count(x)) {
s.insert(x);
ans.push_back(mp[{min(x, par[x]), max(x, par[x])}]);
val += we[{min(par[x], x), max(par[x], x)}];
x = par[x];
}
}
cout << val << "\n";
for (auto j : ans) cout << j << " ";
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) _runtimeTerror_();
cerr << "\n" << 1.0 * clock() / CLOCKS_PER_SEC;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int maxn = 1e5;
long long int n, m;
long long int src;
vector<vector<pair<long long int, long long int>>> adj;
map<vector<long long int>, pair<long long int, long long int>> mp;
void dij() {
vector<long long int> dp(n + 1, 1e18);
set<vector<long long int>> st;
dp[src] = 0;
st.insert({0, src});
vector<long long int> p(n + 1, -1);
while (st.size()) {
auto it = st.begin();
long long int u = (*it)[1];
st.erase(it);
for (auto x : adj[u]) {
long long int v = x.first;
long long int w = x.second;
if (dp[v] > (w + dp[u])) {
st.erase({dp[v], v});
dp[v] = (w + dp[u]);
p[v] = u;
st.insert({dp[v], v});
} else if (dp[v] == (w + dp[u])) {
long long int p1 = p[v];
long long int np = u;
long long int w1 = mp[{p1, v}].second;
if (w < w1) {
p[v] = u;
}
}
}
}
vector<long long int> res;
long long int ans = 0;
for (long long int i = 1; i <= n; i++) {
if (i == src) {
continue;
} else {
long long int u = i;
long long int v = p[u];
res.push_back(mp[{u, v}].first);
ans += mp[{u, v}].second;
}
}
sort(res.begin(), res.end());
cout << ans << "\n";
for (long long int x : res) {
cout << x << " ";
}
cout << "\n";
}
void runcases(long long int T) {
cin >> n >> m;
adj.resize(n + 1);
for (long long int i = 0; i < m; i++) {
long long int x, y, w;
cin >> x >> y >> w;
mp[{x, y}] = {(i + 1), w};
adj[x].push_back({y, w});
adj[y].push_back({x, w});
mp[{y, x}] = {(i + 1), w};
}
cin >> src;
dij();
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int T = 1;
for (long long int t = 1; t <= T; t++) {
runcases(t);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 99999999999999999l;
const int N = 303030;
vector<pair<int, int> > adj[N];
int par[N];
long long costs[N];
long long dist[N];
bool vis[N];
int n, m, s;
void djikstra(int s) {
for (int i = 0; i <= n; i++) {
dist[i] = inf;
}
dist[s] = 0;
queue<pair<int, long> > pq;
pq.push({0ll, s});
vis[s] = true;
while (!pq.empty()) {
pair<int, long> p = pq.front();
pq.pop();
int n = p.second;
for (int i = 0; i < (int)adj[n].size(); i++) {
int v = adj[n][i].first;
int id = adj[n][i].second;
if (dist[n] + costs[id] < dist[v]) {
dist[v] = dist[n] + costs[id];
par[v] = id;
pq.push({-dist[v], v});
} else if (dist[n] + costs[id] == dist[v]) {
if (costs[id] < costs[par[v]]) par[v] = id;
}
}
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
long long c;
scanf("%d %d %lld", &u, &v, &c);
adj[u].push_back({v, i});
adj[v].push_back({u, i});
costs[i] = c;
}
scanf("%d", &s);
djikstra(s);
long long sum = 0;
for (int i = 1; i <= n; i++) {
if (i != s) sum += costs[par[i]];
}
printf("%lld\n", sum);
for (int i = 1; i <= n; i++) {
if (i != s) {
printf("%d ", par[i]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
long long f = 1;
x = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
x *= f;
}
void write(long long x) {
if (x / 10) write(x / 10);
putchar(x % 10 + 48);
}
void writeln(long long x) {
write(x);
putchar('\n');
}
const long long N = 6e5 + 5, M = 6e5 + 5;
long long tot = 1, nxt[M], to[M], h[N], fa[M], val[M];
void add(long long u, long long v, long long w) {
to[++tot] = v, nxt[tot] = h[u], h[u] = tot, val[tot] = w;
}
struct info {
long long x, dis;
};
bool operator<(info a, info b) { return a.dis > b.dis; }
priority_queue<info> q;
long long n, m;
long long d[N];
void dij(long long s) {
long long ans = 0;
memset(d, 0x3f3f3f3f3f3f3f3f, sizeof(d));
d[s] = 0;
q.push((info){s, 0});
for (long long i = 1; i <= n; i++) {
info tp = q.top();
q.pop();
while (!q.empty() && d[tp.x] != tp.dis) {
tp = q.top();
q.pop();
}
if (d[tp.x] != tp.dis) break;
long long x = tp.x, dis = tp.dis;
for (long long i = h[x]; i != -1; i = nxt[i]) {
long long y = to[i];
if (d[y] > d[x] + val[i]) {
d[y] = d[x] + val[i];
ans = ans - val[fa[y]] + val[i];
fa[y] = i;
q.push((info){y, d[y]});
} else if (d[y] == d[x] + val[i] && val[i] < val[fa[y]]) {
ans = ans - val[fa[y]] + val[i];
fa[y] = i;
}
}
}
writeln(ans);
}
signed main() {
memset(h, -1, sizeof(h));
read(n), read(m);
for (long long i = 1, u, v, w; i <= m; i++) {
read(u), read(v), read(w);
add(u, v, w), add(v, u, w);
}
long long s;
read(s);
dij(s);
for (long long i = 1; i <= n; i++) {
if (i == s) continue;
write(fa[i] >> 1), putchar(' ');
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, u;
struct node {
int v;
int w;
int idx;
long long d;
node(int v, int w, int idx, long long d) : v(v), w(w), idx(idx), d(d) {}
bool operator<(const node& o) const { return (d == o.d ? w > o.w : d > o.d); }
};
vector<node> edges[300010];
long long dis[300010];
long long pre[300010];
bool vis[300010];
long long tot;
vector<int> ans;
void solve() {
memset(vis, false, sizeof(vis));
for (int i = 1; i <= n; ++i) {
dis[i] = 1000000000000000LL;
}
dis[u] = 0;
priority_queue<node> pq;
pq.push(node(u, 0, 0, 0));
while (!pq.empty()) {
node tmp = pq.top();
pq.pop();
if (vis[tmp.v]) continue;
vis[tmp.v] = true;
tot += tmp.w;
if (tmp.v != u) {
ans.push_back(tmp.idx);
}
for (int i = 0; i < edges[tmp.v].size(); ++i) {
node edg = edges[tmp.v][i];
if (vis[edg.v]) continue;
if (dis[edg.v] > tmp.d + edg.w) {
dis[edg.v] = tmp.d + edg.w;
pre[edg.v] = edg.w;
pq.push(node(edg.v, edg.w, edg.idx, tmp.d + (long long)edg.w));
} else if (dis[edg.v] == tmp.d + edg.w && edg.w < pre[edg.v]) {
pq.push(node(edg.v, edg.w, edg.idx, tmp.d + (long long)edg.w));
}
}
}
}
int main() {
int a, b, w;
while (cin >> n >> m) {
for (int i = 1; i <= m; ++i) {
cin >> a >> b >> w;
edges[a].push_back(node(b, w, i, -1));
edges[b].push_back(node(a, w, i, -1));
}
cin >> u;
tot = 0LL;
solve();
cout << tot << endl;
for (int i = 0; i < ans.size(); ++i) {
cout << ans[i];
if (i < ans.size() - 1) {
cout << " ";
} else {
cout << endl;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > g[300007];
vector<pair<pair<long long, long long>, long long> > edge[300007];
long long dist[300007], par[300007], visit[300007], e[300007], src[300007],
dest[300007];
map<pair<long long, long long>, long long> ma;
void djikstra(long long s, long long n) {
long long i;
for (i = 1; i <= n; i++) {
dist[i] = 999999999999999;
visit[i] = 0;
}
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
q;
q.push(make_pair(0, s));
dist[s] = 0;
e[s] = 0;
pair<long long, long long> top;
long long u;
while (!q.empty()) {
top = q.top();
q.pop();
u = top.second;
for (i = 0; i < g[u].size(); i++) {
if (g[u][i].second + top.first < dist[g[u][i].first]) {
dist[g[u][i].first] = g[u][i].second + top.first;
e[g[u][i].first] = g[u][i].second;
par[g[u][i].first] = u;
q.push(make_pair(dist[g[u][i].first], g[u][i].first));
} else if (g[u][i].second + top.first == dist[g[u][i].first]) {
if (g[u][i].second < e[g[u][i].first]) {
e[g[u][i].first] = g[u][i].second;
par[g[u][i].first] = u;
}
}
}
}
}
int main() {
long long n, m, i, x, y, w, s;
cin >> n >> m;
for (i = 1; i <= m; i++) {
cin >> x >> y >> w;
g[x].push_back(make_pair(y, w));
g[y].push_back(make_pair(x, w));
src[i] = x;
dest[i] = y;
}
for (i = 1; i <= n; i++) par[i] = i;
cin >> s;
djikstra(s, n);
long long c = 0;
for (i = 1; i <= n; i++) c += e[i];
cout << c << endl;
for (i = 1; i <= m; i++) {
if (par[src[i]] == dest[i] || par[dest[i]] == src[i]) cout << i << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int base = 100003;
const int maxn = 300005;
struct data {
int u, v;
long long w;
} edge[maxn];
int n, m;
vector<pair<int, int> > ke[maxn];
int useless[maxn], par[maxn];
long long d[maxn], weight[maxn];
void DIJK(int s) {
for (int i = 1; i <= n; ++i) d[i] = weight[i] = 1e18;
d[s] = weight[s] = 0;
priority_queue<pair<long long, int> > PQ;
PQ.push({-d[s], s});
while (PQ.size()) {
int u = PQ.top().second;
long long l = -PQ.top().first;
PQ.pop();
if (l > d[u]) continue;
for (auto p : ke[u]) {
int v = p.first, id = p.second;
long long w = edge[id].w;
if (d[v] > d[u] + w) {
par[v] = id;
d[v] = d[u] + w;
PQ.push({-d[v], v});
} else if (d[v] == d[u] + w) {
par[v] = id;
}
}
}
}
void Solve() {
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
int u, v, w;
cin >> u >> v >> w;
ke[u].push_back({v, i});
ke[v].push_back({u, i});
edge[i] = {u, v, w};
}
int s;
cin >> s;
DIJK(s);
long long ans = 0;
for (int i = 1; i <= n; ++i) ans += edge[par[i]].w;
cout << ans << "\n";
for (int i = 1; i <= n; ++i) {
if (i != s) cout << par[i] << " ";
}
}
void NumTime() {
cerr << "Toi Di Chep Code"
<< "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
if (fopen("CF"
".inp",
"r")) {
freopen(
"CF"
".inp",
"r", stdin);
freopen(
"CF"
".out",
"w", stdout);
}
int test = 1;
NumTime();
while (test--) {
Solve();
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.