text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200010;
vector<pair<int, long long> > vec[MAXN];
long long dis[MAXN];
int n, m;
void Dijkstra() {
set<pair<long long, int> > se;
se.clear();
for (int i = 1; i <= n; i++) se.insert(pair<long long, int>(dis[i], i));
while (!se.empty()) {
int v(se.begin()->second);
se.erase(se.begin());
for (int i = 0; i < vec[v].size(); i++) {
int from(v), to(vec[v][i].first);
long long cost(vec[v][i].second);
if (dis[to] > dis[from] + cost) {
se.erase(pair<long long, int>(dis[to], to));
dis[to] = dis[from] + cost;
se.insert(pair<long long, int>(dis[to], to));
}
}
}
}
int main() {
while (scanf("%d %d", &n, &m) != EOF) {
for (int i = 1; i <= m; i++) {
int from, to;
long long cost;
scanf("%d %d %I64d", &from, &to, &cost);
cost *= 2;
vec[from].push_back(pair<int, long long>(to, cost));
vec[to].push_back(pair<int, long long>(from, cost));
}
for (int i = 1; i <= n; i++) scanf("%I64d", &dis[i]);
Dijkstra();
for (int i = 1; i < n; i++) printf("%I64d ", dis[i]);
printf("%I64d\n", dis[n]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct A {
int to;
long long d;
A() {}
A(int to, long long d) : to(to), d(d) {}
};
vector<A> G[200005];
long long dis[200005] = {};
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0, x, y; i < m; ++i) {
long long v;
scanf("%d%d%lld", &x, &y, &v);
G[x].push_back(A(y, 2 * v));
G[y].push_back(A(x, 2 * v));
}
queue<int> q;
bool inq[200005] = {};
vector<pair<long long, int> > pa;
for (int i = 1; i <= n; ++i) {
long long v;
scanf("%lld", &v);
pa.push_back({v, i});
inq[i] = 1;
dis[i] = v;
}
sort(pa.begin(), pa.end());
for (int i = 0; i < pa.size(); ++i) {
q.push(pa[i].second);
}
while (!q.empty()) {
int fr = q.front();
q.pop();
inq[fr] = 0;
for (auto re : G[fr]) {
long long d = dis[fr] + re.d;
if (d < dis[re.to]) {
dis[re.to] = d;
if (!inq[re.to]) {
inq[re.to] = 1;
q.push(re.to);
}
}
}
}
for (int i = 1; i <= n; ++i) {
printf("%lld", dis[i]);
if (i != n) putchar(' ');
}
puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
vector<pair<int, long long> > e[MAXN];
long long dis[MAXN];
bool vis[MAXN];
void solve(int n, int st) {
for (int i = 1; i <= n; i++) dis[i] = (1LL << 60) - 1, vis[i] = 0;
priority_queue<pair<long long, int> > pq;
pq.push({dis[st] = 0, st});
while (!pq.empty()) {
int u = pq.top().second;
pq.pop();
if (vis[u]) continue;
vis[u] = 1;
for (int i = 0; i < (int)e[u].size(); i++) {
int v = e[u][i].first;
long long c = e[u][i].second;
if (!vis[v] && dis[v] > dis[u] + c) {
dis[v] = dis[u] + c;
pq.push({-dis[v], v});
}
}
}
}
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);
e[u].push_back({v, 2 * w});
e[v].push_back({u, 2 * w});
}
for (int i = 1; i <= n; i++) {
long long a;
scanf("%lld", &a);
e[n + 1].push_back({i, a});
}
solve(n + 1, n + 1);
for (int i = 1; i <= n; i++) printf("%lld%c", dis[i], " \n"[i == n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 600005;
struct node {
long long next, to, val;
} edge[maxn];
long long head[maxn];
long long tot = 0;
long long n, m;
void add(long long u, long long v, long long val) {
edge[++tot].to = v;
edge[tot].val = val;
edge[tot].next = head[u];
head[u] = tot;
}
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
qp;
long long dis[maxn];
long long vis[maxn];
void dijkstra(long long src) {
while (!qp.empty()) qp.pop();
for (long long i = 1; i <= n; ++i) {
dis[i] = 1e14;
vis[i] = 0;
}
dis[src] = 0;
qp.push({0, src});
while (!qp.empty()) {
pair<long long, long long> t = qp.top();
qp.pop();
long long u = t.second;
if (vis[u]) continue;
vis[u] = 1;
for (long long i = head[u]; i; i = edge[i].next) {
if (dis[edge[i].to] > dis[u] + edge[i].val) {
dis[edge[i].to] = dis[u] + edge[i].val;
qp.push({dis[edge[i].to], edge[i].to});
}
}
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (long long i = 1; i <= m; i++) {
long long x, y, z;
cin >> x >> y >> z;
add(x, y, z * 2);
add(y, x, z * 2);
}
for (long long i = 1; i <= n; i++) {
long long x;
cin >> x;
add(0, i, x);
}
dijkstra(0);
for (long long i = 1; i <= n; i++) cout << dis[i] << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
int N, E;
vector<vector<pair<int, long long>>> Adj;
vector<unsigned long long> dist;
void Dijkstra() {
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
pq;
for (int i = 0; i < N; i++) pq.push({dist[i], i});
while (!pq.empty()) {
pair<long long, int> front = pq.top();
pq.pop();
long long d = front.first;
int u = front.second;
if (d > dist[u]) continue;
for (auto j : Adj[u]) {
pair<int, long long> v = j;
if (dist[u] + v.second < dist[v.first]) {
dist[v.first] = dist[u] + v.second;
pq.push({dist[v.first], v.first});
}
}
}
}
int main() {
cin >> N >> E;
Adj.assign(N, vector<pair<int, long long>>());
dist = vector<unsigned long long>(N);
for (int i = 0; i < E; i++) {
int u, v;
long long c;
cin >> u >> v >> c;
u--, v--;
Adj[u].push_back({v, 2 * c});
Adj[v].push_back({u, 2 * c});
}
for (int i = 0; i < N; i++) cin >> dist[i];
Dijkstra();
for (int i = 0; i < N; i++) cout << dist[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, m, cost[200100];
set<pair<long long int, long long int> > D;
vector<long long int> G[200100];
map<pair<long long int, long long int>, long long int> M;
long long int Ans[200100];
bool used[200100];
void dfs(long long int cur) {
used[cur] = 1;
for (long long int to : G[cur]) {
if (!used[to]) {
long long int val = M[make_pair(cur, to)];
if (Ans[to] > val * 2 + Ans[cur]) {
D.erase(make_pair(Ans[to], to));
Ans[to] = val * 2 + Ans[cur];
D.insert(make_pair(Ans[to], to));
}
}
}
while (D.size() != 0) {
D.erase(D.begin());
auto next = D.begin();
if (!used[next->second]) {
dfs(next->second);
}
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
while (m != 0) {
long long int x, y, z;
cin >> x >> y >> z;
G[x].push_back(y);
G[y].push_back(x);
M[make_pair(x, y)] = z;
M[make_pair(y, x)] = z;
m--;
}
for (long long int i = 1; i <= n; i++) {
cin >> cost[i];
Ans[i] = cost[i];
D.insert(make_pair(cost[i], i));
}
auto st = D.begin();
dfs(st->second);
for (long long int i = 1; i <= n; i++) {
cout << Ans[i] << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
const int M = 3e5 + 5;
const long long mod = 1e9 + 7;
priority_queue<pair<long long, int> > Q;
vector<pair<int, long long> > G[N];
long long dis[N];
bool vis[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
long long w;
cin >> u >> v >> w;
G[u].push_back(make_pair(v, w));
G[v].push_back(make_pair(u, w));
}
for (int i = 1; i <= n; i++) {
cin >> dis[i];
Q.push(make_pair(-dis[i], i));
}
while (!Q.empty()) {
pair<int, int> np = Q.top();
Q.pop();
int u = np.second;
if (vis[u]) continue;
vis[u] = 1;
for (pair<int, long long> to : G[u]) {
int v = to.first;
long long w = to.second * 2;
if (dis[v] > dis[u] + w) {
dis[v] = dis[u] + w;
Q.push(make_pair(-dis[v], v));
}
}
}
for (int i = 1; i <= n; i++) {
cout << dis[i] << " ";
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
int M;
struct Edge {
int u;
int v;
long long w;
Edge(int u, int v, long long w) : u(u), v(v), w(w) {}
};
vector<Edge> adj[1 << 18];
long long c[1 << 18];
long long ans[1 << 18];
int ri[1 << 18];
int main() {
scanf("%d %d", &N, &M);
for (int i = 0; i < M; i++) {
int u;
int v;
long long w;
scanf("%d %d %lld", &u, &v, &w);
u--;
v--;
adj[u].emplace_back(u, v, w);
adj[v].emplace_back(v, u, w);
}
for (int i = 0; i < N; i++) {
scanf("%lld", &c[i]);
ans[i] = c[i];
}
auto cmp = [](int a, int b) {
if (ans[a] != ans[b]) return ans[a] < ans[b];
return a < b;
};
set<int, decltype(cmp)> s(cmp);
for (int i = 0; i < N; i++) {
s.insert(i);
}
while (!s.empty()) {
int u = *s.begin();
s.erase(s.begin());
for (Edge& e : adj[u]) {
if (ans[u] + (e.w << 1) < ans[e.v]) {
assert(s.find(e.v) != s.end());
s.erase(s.find(e.v));
ans[e.v] = ans[u] + (e.w << 1);
s.insert(e.v);
}
}
}
for (int i = 0; i < N; i++) {
printf("%lld ", ans[i]);
}
}
|
#include <bits/stdc++.h>
long long Qread() {
long long X = 0;
char C = getchar();
while (C > '9' || C < '0') C = getchar();
while (C >= '0' && C <= '9') {
X = X * 10 + C - '0';
C = getchar();
}
return X;
}
const long long Maxn = 2e5 + 5, Maxm = 2e5 + 5;
long long N, M, Head[Maxn], En = 0;
long long Vis[Maxn], Mdis[Maxn];
struct Edge {
long long Goto, Next;
long long Len;
};
Edge E[Maxm << 2];
void Add(long long X, long long Y, long long L) {
E[++En].Goto = Y;
E[En].Len = L;
E[En].Next = Head[X];
Head[X] = En;
}
struct Dis {
long long X, Len;
};
bool operator<(const Dis& A, const Dis& B) { return A.Len > B.Len; }
std ::priority_queue<Dis> Q;
Dis Make(long long X, long long Len) {
Dis Ans;
Ans.Len = Len, Ans.X = X;
return Ans;
}
void Dijkstra() {
memset(Mdis, 0x3f, sizeof(Mdis)), memset(Vis, 0, sizeof(Vis));
Q.push(Make(0, 0));
Mdis[0] = 0;
while (!Q.empty()) {
Dis Now = Q.top();
Q.pop();
if (Vis[Now.X]) continue;
Vis[Now.X] = 1;
for (long long i = Head[Now.X]; i; i = E[i].Next) {
long long Ndis = Mdis[Now.X] + E[i].Len;
if (Ndis < Mdis[E[i].Goto]) {
Mdis[E[i].Goto] = Ndis;
Q.push(Make(E[i].Goto, Ndis));
}
}
}
}
signed main() {
N = Qread(), M = Qread();
memset(Head, 0, sizeof(Head)), En = 0;
for (long long i = 1; i <= M; ++i) {
long long X = Qread(), Y = Qread(), L = Qread();
Add(X, Y, L << 1), Add(Y, X, L << 1);
}
for (long long i = 1; i <= N; ++i) {
long long K = Qread();
Add(0, i, K);
}
Dijkstra();
for (long long i = 1; i <= N; ++i) printf("%I64d ", Mdis[i]);
fclose(stdin), fclose(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<pair<int, long long>> graf[200010];
int odw[200010] = {0};
long long koszt[200010];
priority_queue<pair<long long, int>> kolejka;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < (m); ++i) {
int t1, t2;
long long t3;
cin >> t1 >> t2 >> t3;
graf[t1].push_back({t2, t3});
graf[t2].push_back({t1, t3});
}
for (int i = 1; i <= (n); i++) {
long long t2;
cin >> t2;
koszt[i] = t2;
kolejka.push({-t2, i});
}
while (!kolejka.empty()) {
int top = kolejka.top().second;
kolejka.pop();
if (odw[top]) continue;
odw[top] = 1;
for (int i = 0; i < (((int)(graf[top]).size())); ++i) {
int v = graf[top][i].first;
long long b = graf[top][i].second;
if ((!odw[v]) && (koszt[v] > koszt[top] + b * 2)) {
koszt[v] = koszt[top] + b * 2;
kolejka.push({-koszt[v], v});
}
}
}
for (int i = 1; i <= (n); i++) cout << koszt[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long t, n, m, dp[200050];
pair<long long, long long> v[200050];
vector<pair<long long, long long> > grafo[200050];
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (long long i = 1, a, b, c; i <= m; i++) {
cin >> a >> b >> c;
grafo[a].push_back(pair<long long, long long>(b, 2 * c));
grafo[b].push_back(pair<long long, long long>(a, 2 * c));
}
for (long long i = 1, x; i <= n; i++) cin >> x, v[i] = {x, i}, dp[i] = x;
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq;
for (long long i = 1; i <= n; i++) pq.push({dp[i], i});
while (!pq.empty()) {
long long x = pq.top().second, d = pq.top().first;
pq.pop();
if (d > dp[x]) continue;
for (auto v : grafo[x]) {
if (dp[v.first] > dp[x] + v.second) {
dp[v.first] = dp[x] + v.second;
pq.push({dp[v.first], v.first});
}
}
}
for (long long i = 1; i <= n; i++) cout << dp[i] << " \n"[i == n];
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
struct node {
pair<long long, long long> x;
long long y;
node* l = nullptr;
node* r = nullptr;
node(pair<long long, long long> x) : x(x) { y = rand(); }
};
node* merge(node* a, node* b) {
if (a == nullptr) return b;
if (b == nullptr) return a;
if (a->y > b->y) {
a->r = merge(a->r, b);
return a;
}
b->l = merge(a, b->l);
return b;
}
pair<node*, node*> split(node* a, pair<long long, long long> b) {
if (a == nullptr) return {nullptr, nullptr};
if (a->x <= b) {
pair<node*, node*> tmp = split(a->r, b);
a->r = tmp.first;
return {a, tmp.second};
} else {
pair<node*, node*> tmp = split(a->l, b);
a->l = tmp.second;
return {tmp.first, a};
}
}
pair<long long, long long> getmin(node* a) {
if (a->l == nullptr) return a->x;
return getmin(a->l);
}
node* add(node* a, pair<long long, long long> x) {
pair<node*, node*> tmp = split(a, x);
node* b = new node(x);
tmp.first = merge(tmp.first, b);
tmp.second = merge(tmp.first, tmp.second);
return tmp.second;
}
node* pop(node* a, pair<long long, long long> x) {
if (a->x == x) {
a = merge(a->l, a->r);
return a;
}
if (a->x > x) {
a->l = pop(a->l, x);
} else {
a->r = pop(a->r, x);
}
return a;
}
signed main() {
node* s = nullptr;
long long n, m;
cin >> n >> m;
vector<vector<pair<long long, long long>>> a(n);
for (long long i = 0; i < m; ++i) {
long long x, y, v;
cin >> x >> y >> v;
a[x - 1].emplace_back(y - 1, 2 * v);
a[y - 1].emplace_back(x - 1, 2 * v);
}
vector<long long> d(n);
for (long long i = 0; i < n; ++i) {
cin >> d[i];
s = add(s, {d[i], i});
}
for (long long _ = 0; _ < n; ++_) {
pair<long long, long long> now = getmin(s);
s = pop(s, now);
for (auto i : a[now.second]) {
if (d[i.first] > d[now.second] + i.second) {
s = pop(s, {d[i.first], i.first});
d[i.first] = d[now.second] + i.second;
s = add(s, {d[i.first], i.first});
}
}
}
for (long long i : d) {
cout << i << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200051;
struct Edge {
int t;
long long c;
int nxt;
} g[MAXN * 3];
struct Node {
int id;
long long di;
bool operator<(const Node &o) const { return di > o.di; }
};
int n, m, gsz;
int fte[MAXN];
long long dis[MAXN];
void addedge(int x, int y, long long z) {
g[++gsz] = (Edge){y, z, fte[x]};
fte[x] = gsz;
}
void dijkstra() {
memset(dis, 0x3f, sizeof(dis));
priority_queue<Node> q;
dis[0] = 0;
q.push((Node){0, 0});
while (!q.empty()) {
Node nw = q.top();
q.pop();
if (nw.di > dis[nw.id]) continue;
for (int i = fte[nw.id]; i; i = g[i].nxt) {
Node nxtn = (Node){g[i].t, nw.di + g[i].c};
if (nxtn.di >= dis[nxtn.id]) continue;
dis[nxtn.id] = nxtn.di;
q.push(nxtn);
}
}
}
int main() {
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);
addedge(u, v, w * 2);
addedge(v, u, w * 2);
}
for (int i = 1; i <= n; i++) {
long long a;
scanf("%lld", &a);
addedge(0, i, a);
}
dijkstra();
for (int i = 1; i <= n; i++) printf("%lld ", dis[i]);
putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, a, b, x, i = 1, ij[200001];
vector<long long> y(200001);
vector<vector<long long> > tab(200001);
vector<vector<long long> > e(200001);
long long h[2 * 200001], h2[2 * 200001], ih = 1;
void pop() {
h[1] = h[ih - 1], h2[1] = h2[ih - 1], ih--;
long long j = 1, c;
while (j < ih) {
if (j * 2 < ih && h[j * 2] < h[j] &&
(h[j * 2 + 1] >= h[j * 2] || j * 2 + 1 >= ih))
c = h[j], h[j] = h[j * 2], h[j * 2] = c, c = h2[j], h2[j] = h2[j * 2],
h2[j * 2] = c, j = j * 2;
else if (j * 2 + 1 < ih && h[j * 2 + 1] < h[j] && h[j * 2 + 1] < h[j * 2])
c = h[j], h[j] = h[j * 2 + 1], h[j * 2 + 1] = c, c = h2[j],
h2[j] = h2[j * 2 + 1], h2[j * 2 + 1] = c, j = j * 2 + 1;
else
break;
}
}
void push(long long a, long long v) {
h[ih] = a, h2[ih] = v, ih++;
long long j = ih - 1, c;
while (j > 1) {
if (h[j / 2] > h[j])
c = h[j], h[j] = h[j / 2], h[j / 2] = c, c = h2[j], h2[j] = h2[j / 2],
h2[j / 2] = c, j /= 2;
else
break;
}
}
bool check[200001];
vector<long long> d(200001);
vector<long long> full_dijkstra(vector<vector<long long> > tab,
vector<vector<long long> > e, long long s) {
long long x, j = 0, y;
d[s] = 0;
push(0, s);
while (ih > 1) {
x = h[1], y = h2[1];
pop();
if (check[y] == 1) continue;
check[y] = 1, d[y] = x;
while (j < ij[y]) {
if (check[tab[y][j]] == 0 && y == 0)
push(x + e[y][j], tab[y][j]);
else if (check[tab[y][j]] == 0)
push(x + 2 * e[y][j], tab[y][j]);
j++;
}
j = 0;
}
return d;
}
int main() {
scanf("%lld %lld", &n, &m);
while (m--) {
scanf("%lld %lld %lld", &a, &b, &x);
tab[a].push_back(b), tab[b].push_back(a);
e[a].push_back(x), e[b].push_back(x);
ij[a]++, ij[b]++;
}
while (i <= n) {
scanf("%lld", &a);
tab[0].push_back(i);
e[0].push_back(a);
ij[0]++;
i++;
}
y = full_dijkstra(tab, e, 0);
for (long long j = 1; j <= n; j++) printf("%lld\n", y[j]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long mi(long long a, long long b) { return a > b ? b : a; }
inline long long ma(long long a, long long b) { return a > b ? a : b; }
long long ans[200005], val[200005];
bool vis[200005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
long long n, m;
cin >> n >> m;
vector<pair<long long, long long>> adj[200005];
for (long long(i) = (0); (i) < (m); (i)++) {
long long a, b, c;
cin >> a >> b >> c;
a--;
b--;
adj[a].push_back({b, c});
adj[b].push_back({a, c});
}
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
pq;
for (long long(i) = (0); (i) < (n); (i)++) {
cin >> val[i];
pq.push({val[i], i});
ans[i] = val[i];
}
while (!pq.empty()) {
pair<long long, long long> cur = pq.top();
pq.pop();
if (vis[cur.second]) continue;
vis[cur.second] = true;
for (auto xd : adj[cur.second]) {
if (cur.first + 2 * xd.second < ans[xd.first]) {
ans[xd.first] = cur.first + 2 * xd.second;
pq.push({ans[xd.first], xd.first});
}
}
}
for (long long(i) = (0); (i) < (n); (i)++) cout << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 100;
std::vector<pair<long long, long long> > gr[N];
long long vis[N];
long long ans[N];
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long n;
long long m;
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long x, y, w;
cin >> x >> y >> w;
w = w * 2;
gr[x].push_back({y, w});
gr[y].push_back({x, w});
}
set<pair<long long, long long> > s;
for (long long i = 1; i <= n; i++) {
long long x;
cin >> x;
s.insert({x, i});
ans[i] = x;
}
while (s.size() > 0) {
auto x = *(s.begin());
s.erase(x);
vis[x.second] = 1;
for (auto w : gr[x.second]) {
if (vis[w.first]) continue;
if (ans[w.first] > ans[x.second] + w.second) {
s.erase({ans[w.first], w.first});
ans[w.first] = ans[x.second] + w.second;
s.insert({ans[w.first], w.first});
}
}
}
for (long long i = 1; i < n + 1; i++) cout << ans[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long nodes, edges;
vector<pair<long long, long long>> adj[200005];
long long dist[200005];
long long arr[200005];
void Dijkstra() {
set<pair<long long, long long>> q;
for (int i = 1; i <= nodes; i++) {
dist[i] = arr[i];
q.insert({dist[i], i});
}
while (!q.empty()) {
long long v = q.begin()->second;
q.erase(q.begin());
for (auto u : adj[v]) {
if (dist[u.second] > dist[v] + u.first) {
q.erase({dist[u.second], u.second});
dist[u.second] = dist[v] + u.first;
q.insert({dist[u.second], u.second});
}
}
}
}
int main() {
scanf("%lld%lld", &nodes, &edges);
for (int i = 0; i < edges; i++) {
long long a, b, w;
scanf("%lld%lld%lld", &a, &b, &w);
w *= 2;
adj[a].push_back({w, b});
adj[b].push_back({w, a});
}
for (int i = 1; i <= nodes; i++) {
scanf("%lld", &arr[i]);
}
Dijkstra();
for (int i = 1; i <= nodes; i++) {
printf("%lld ", dist[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, u, v;
long long w, p;
vector<pair<long long, int>> G[200005];
int main(int argc, const char* argv[]) {
cin >> N >> M;
vector<long long> distance(N + 1);
priority_queue<pair<long long, int>, vector<pair<long long, int>>> pq;
for (int i = 1; i <= M; i++) {
cin >> u >> v >> w;
G[u].push_back(make_pair(w, v));
G[v].push_back(make_pair(w, u));
}
for (int i = 1; i <= N; i++) {
cin >> distance[i];
pq.push(make_pair(-distance[i], i));
}
while (!pq.empty()) {
pair<long long, int> front = pq.top();
pq.pop();
long long d = -front.first;
int u = front.second;
if (d > distance[u]) continue;
for (int j = 0; j < (int)G[u].size(); j++) {
pair<long long, int> v = G[u][j];
if (distance[u] + 2 * v.first < distance[v.second]) {
distance[v.second] = distance[u] + 2 * v.first;
pq.push(make_pair(-distance[v.second], v.second));
}
}
}
for (int i = 1; i <= N; i++) {
cout << distance[i] << (i == N ? "\n" : " ");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
const long long INF = 1e18 + 7;
struct Edge {
int from, to;
long long dist;
};
struct HeapNode {
long long d;
int u;
bool operator<(const HeapNode& rhs) const { return d > rhs.d; }
};
struct Dijkstra {
int n, m;
vector<Edge> edges;
vector<int> G[maxn];
bool done[maxn];
long long d[maxn];
long long p[maxn];
void init(int n) {
this->n = n;
for (int i = 0; i < n; i++) G[i].clear();
edges.clear();
}
void AddEdge(int from, int to, long long dist) {
edges.push_back((Edge){from, to, dist});
m = edges.size();
G[from].push_back(m - 1);
}
void dijkstra(int s) {
priority_queue<HeapNode> Q;
for (int i = 0; i < n; i++) d[i] = INF;
d[s] = 0;
memset(done, 0, sizeof done);
Q.push((HeapNode){0, s});
while (!Q.empty()) {
HeapNode x = Q.top();
Q.pop();
int u = x.u;
if (done[u]) continue;
done[u] = true;
for (int i = 0; i < G[u].size(); i++) {
Edge& e = edges[G[u][i]];
if (d[e.to] > d[u] + e.dist) {
d[e.to] = d[u] + e.dist;
p[e.to] = G[u][i];
Q.push((HeapNode){d[e.to], e.to});
}
}
}
}
};
Dijkstra solver;
int main() {
int m;
scanf("%d%d", &solver.n, &m);
solver.n++;
solver.init(solver.n);
for (int i = 0; i < m; i++) {
int u, v;
long long d;
scanf("%d%d%I64d", &u, &v, &d);
solver.AddEdge(u, v, d * 2);
solver.AddEdge(v, u, d * 2);
}
for (int i = 1; i <= solver.n - 1; i++) {
long long x;
scanf("%I64d", &x);
solver.AddEdge(0, i, x);
solver.AddEdge(i, 0, x);
}
solver.dijkstra(0);
for (int i = 1; i < solver.n; i++) printf("%I64d ", solver.d[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > v[200005];
long long wt[200005];
int n;
void djkshtra() {
set<pair<long long, int> > s;
for (long long i = 1; i < n + 1; i++) {
s.insert(make_pair(wt[i], i));
}
while (!s.empty()) {
pair<long long, int> p;
p = *(s.begin());
s.erase(s.begin());
long long xx;
int yy;
xx = p.first;
yy = p.second;
for (int i = 0; i < v[yy].size(); i++) {
int zz = v[yy][i].first;
long long dis = v[yy][i].second;
if (wt[zz] > dis + wt[yy]) {
s.erase(s.find(make_pair(wt[zz], zz)));
wt[zz] = dis + wt[yy];
s.insert(make_pair(wt[zz], zz));
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
int m;
cin >> m;
while (m--) {
int x, y;
long long w;
cin >> x >> y >> w;
v[x].push_back(make_pair(y, 2 * w));
v[y].push_back(make_pair(x, 2 * w));
}
for (long long i = 1; i < n + 1; i++) {
cin >> wt[i];
}
djkshtra();
for (long long i = 1; i < n + 1; i++) {
cout << wt[i] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
istream& in = cin;
int n, m;
vector<pair<long long, long long> > V[200010];
vector<pair<long long, long long> > city;
long long cost[200010];
void input() {
in >> n >> m;
for (int i = 1; i <= m; ++i) {
long long u, v, w;
scanf("%lld%lld%lld", &u, &v, &w);
V[u].push_back(make_pair(v, w));
V[v].push_back(make_pair(u, w));
}
for (int i = 1; i <= n; ++i) {
scanf("%lld", &cost[i]);
}
}
long long dp[200010];
bool cmp(pair<long long, long long>& a, pair<long long, long long>& b) {
return a.first > b.first;
}
int main() {
int TEST_CASE = 1;
while (TEST_CASE-- > 0) {
input();
for (int i = 1; i <= n; ++i) dp[i] = cost[i];
priority_queue<pair<long long, long long> > Q;
for (int i = 1; i <= n; ++i) {
Q.push(make_pair(-cost[i], i));
}
while (!Q.empty()) {
pair<long long, long long> u = Q.top();
Q.pop();
u.first = -u.first;
if (u.first == dp[u.second]) {
for (pair<long long, long long> son : V[u.second]) {
if (dp[son.first] > dp[u.second] + 2 * son.second) {
dp[son.first] = dp[u.second] + 2 * son.second;
Q.push(make_pair(-dp[son.first], son.first));
}
}
}
}
for (int i = 1; i <= n; ++i) printf("%lld ", dp[i]);
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, long long> > a[200020];
long long d[200020], z;
int n, m, x, y;
void add(int x, int y, long long z) { a[x].push_back(make_pair(y, z)); }
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d%lld", &x, &y, &z);
add(x, y, 2 * z);
add(y, x, 2 * z);
}
for (int i = 1; i <= n; i++) {
scanf("%lld", &z);
add(0, i, z);
}
memset(d, 0x3f, sizeof d);
d[0] = 0;
set<pair<long long, int> > s;
s.insert(make_pair(0LL, 0));
while (s.size()) {
pair<long long, int> u = *s.begin();
s.erase(s.begin());
for (auto i : a[u.second]) {
if (d[i.first] > d[u.second] + i.second) {
s.erase(make_pair(d[i.first], i.first));
d[i.first] = d[u.second] + i.second;
s.insert(make_pair(d[i.first], i.first));
}
}
}
for (int i = 1; i <= n; i++) {
printf("%lld%c", d[i], i == n ? '\n' : ' ');
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200020;
int n, m;
int done[N];
long long d[N];
vector<pair<int, long long> > e[N];
bool minimize(long long &x, long long y) {
if (x > y) {
x = y;
return true;
}
return false;
}
int main() {
scanf("%d%d", &n, &m);
while (m--) {
int u, v;
long long w;
scanf("%d%d%lld", &u, &v, &w);
e[u].emplace_back(v, w);
e[v].emplace_back(u, w);
}
set<pair<long long, int> > foo;
for (int i = 1; i <= n; ++i) {
long long w;
scanf("%lld", &w);
foo.emplace(d[i] = w, i);
}
while (foo.size()) {
int x = foo.begin()->second;
foo.erase(foo.begin());
if (done[x]) continue;
done[x] = 1;
for (auto p : e[x]) {
int y = p.first;
long long w = p.second;
if (minimize(d[y], d[x] + w + w)) {
foo.emplace(d[y], y);
}
}
}
for (int i = 1; i <= n; ++i) {
printf("%lld ", d[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <typename... Vectors>
void resizeVectors(int newSize, Vectors&... vectors) {
(vectors.resize(newSize), ...);
}
void resizeVectors(int unusedNewSize) {}
template <typename... Vectors>
void readEntryHelper(int i, Vectors&... vectors) {
((cin >> vectors[i]), ...);
}
template <typename... Vectors>
void readVectors(int count, Vectors&... vectors) {
(resizeVectors(count, (vectors, ...)));
for (int i = 0; i < count; ++i) {
(readEntryHelper(i, (vectors, ...)));
}
}
using ll = signed long long;
using ld = long double;
void $main();
int main() {
int numTests = 1;
if (0) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
cin >> numTests;
} else {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
}
for (int i = 0; i < numTests; ++i) {
$main();
if (0) {
cout << "-----\n";
}
}
}
using P = ll;
struct Node {
P value;
int il, ir;
int ansi;
Node* nl = nullptr;
Node* nr = nullptr;
bool leaf() const { return ir - il == 1; }
void push() {
if (!leaf()) {
value = min(nl->value, nr->value);
if (value == nl->value) {
ansi = nl->ansi;
} else {
ansi = nr->ansi;
}
}
}
};
Node* build(int l, int r) {
Node* n = new Node;
n->il = l;
n->ir = r;
n->ansi = l;
if (r - l > 1) {
int m = (l + r) / 2;
n->nl = build(l, m);
n->nr = build(m, r);
n->push();
}
return n;
}
pair<P, int> extract(Node* node, int ql, int qr) {
if (ql >= node->ir || node->il >= qr) return {1e18, -1};
if (ql <= node->il && node->ir <= qr) {
auto ret = make_pair(node->value, node->ansi);
return ret;
}
auto ret = min(extract(node->nl, ql, qr), extract(node->nr, ql, qr));
node->push();
return ret;
}
void update(Node* node, int i, P x) {
if (i >= node->ir || node->il >= i + 1) return;
if (i <= node->il && node->ir <= i + 1) {
node->value = x;
return;
}
update(node->nl, i, x);
update(node->nr, i, x);
node->push();
}
void $main() {
int n, m;
cin >> n >> m;
vector<vector<pair<int, ll>>> g(n);
for (int i = 0; i < m; ++i) {
int u, v;
ll w;
cin >> u >> v >> w;
--u;
--v;
g[u].emplace_back(v, w);
g[v].emplace_back(u, w);
}
vector<ll> a;
readVectors(n, a);
vector<ll> ans(a);
Node* tree = build(0, n);
for (int i = 0; i < n; ++i) {
update(tree, i, ans[i]);
}
int nextFree = n;
while (nextFree > 0) {
auto t = extract(tree, 0, n);
auto [ev, v] = t;
auto ansv = ev;
assert(ansv == ans[v]);
--nextFree;
update(tree, v, 1e18);
for (auto edge : g[v]) {
ll nans = ans[v] + 2 * edge.second;
ll& cans = ans[edge.first];
if (cans > nans) {
cans = nans;
update(tree, edge.first, cans);
}
}
}
for (ll x : ans) cout << x << " ";
cout << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int Z = (int)3e3 + 228;
const int N = (int)2e5 + 228;
const int INF = (int)1e9 + 5;
const int MOD = (int)1e9 + 7;
vector<pair<int, long long> > g[N];
long long a[N], dist[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x, y;
long long w;
cin >> x >> y >> w;
g[x].push_back({y, w});
g[y].push_back({x, w});
}
set<pair<long long, int> > Q;
for (int i = 1; i <= n; i++) {
cin >> a[i];
dist[i] = a[i];
Q.insert({dist[i], i});
}
while (!Q.empty()) {
int v = Q.begin()->second;
long long cost = Q.begin()->first;
Q.erase(Q.begin());
for (auto to : g[v]) {
if (dist[v] + 2 * to.second < dist[to.first]) {
Q.erase({dist[to.first], to.first});
dist[to.first] = dist[v] + 2 * to.second;
Q.insert({dist[to.first], to.first});
}
}
}
for (int i = 1; i <= n; i++) {
cout << dist[i] << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> p[300005], q[300005], b(500005), f(500005);
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int bpow(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % 998244353;
a = (a * a) % 998244353;
b >>= 1;
}
return res % 998244353;
}
void fact(long long int i) {
f[0] = 1;
for (long long int k = 1; k <= i; k++) {
(f[k] = f[k - 1] * k) %= 998244353;
}
}
long long int isprime(long long int n) {
if (n == 1) return 0;
for (long long int i = 2; i <= sqrt(n); i++)
if (n % i == 0) return 0;
return 1;
}
long long int find(long long int x) {
if (f[x] == x)
return x;
else
return f[x] = find(f[x]);
}
bool cmp(long long int x, long long int y) { return x < y; }
void check() {
cout << "HI"
<< "\n";
}
long long int comb(long long int i, long long int j) {
if (j > i) return 0;
long long int k = f[i];
long long int g = (f[j] * (f[i - j])) % 998244353;
long long int h = bpow(g, 998244353 - 2);
return (k * h) % 998244353;
}
pair<long double, long double> az(long double a, long double b, long double c,
long double d, long double u) {
long double x1 = (a - c) * cos(u) - (b - d) * sin(u) + c;
long double y1 = (a - c) * sin(u) + (b - d) * cos(u) + d;
return {x1, y1};
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
t = 1;
while (t--) {
long long int n, m;
cin >> n >> m;
for (long long int i = 0; i < m; i++) {
long long int x, y, z;
cin >> x >> y >> z;
p[x].push_back(y);
q[x].push_back(z);
p[y].push_back(x);
q[y].push_back(z);
}
for (long long int i = 1; i <= n; i++) {
cin >> f[i];
}
set<pair<long long int, long long int>> s;
for (long long int i = 1; i <= n; i++) {
s.insert({f[i], i});
}
while (s.size() > 0) {
auto it = s.begin();
long long int u = it->second;
s.erase(it);
for (long long int j = 0; j < p[u].size(); j++) {
long long int v = p[u][j];
if (f[v] > f[u] + 2 * q[u][j]) {
s.erase({f[v], v});
f[v] = f[u] + 2 * q[u][j];
s.insert({f[v], v});
}
}
}
for (long long int i = 1; i <= n; i++) {
cout << f[i] << " ";
}
cout << "\n";
}
}
|
#include <bits/stdc++.h>
std::vector<int> a[200005];
std::vector<long long> b[200005];
int n, m, vis[200005], s;
long long dis[200005];
void add(int x, int y, long long v) {
a[x].push_back(y);
b[x].push_back(v);
}
void dijkstra(int s) {
std::priority_queue<std::pair<long long, int> > pq;
for (int i = 1; i <= n + 1; i++) vis[i] = 0, dis[i] = 1000000000000000000;
dis[s] = 0;
pq.push(std::make_pair(-dis[s], s));
while (!pq.empty()) {
int v = pq.top().second;
pq.pop();
if (vis[v]) continue;
vis[v] = 1;
for (int i = 0; i < a[v].size(); i++) {
int u = a[v][i];
long long w = b[v][i];
if (dis[v] + w < dis[u])
dis[u] = dis[v] + w, pq.push(std::make_pair(-dis[u], u));
}
}
}
int main() {
scanf("%d%d", &n, &m);
s = n + 1;
for (int i = 1; i <= m; i++) {
int x, y;
long long v;
scanf("%d%d%lld", &x, &y, &v);
add(x, y, v * 2);
add(y, x, v * 2);
}
for (int i = 1; i <= n; i++) {
long long x;
scanf("%lld", &x);
add(s, i, x);
}
dijkstra(s);
for (int i = 1; i <= n; i++) printf("%lld ", dis[i]);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
const int INF = 570000000;
struct Edge {
int vertex;
long long weight;
Edge(int v, long long w) {
vertex = v;
weight = w;
}
};
vector<vector<Edge>> gr;
vector<long long> cost;
vector<long long> distances;
void make_Dijkstra() {
set<pair<long long, int>> heap;
for (int i = 0; i < n; ++i) {
heap.insert(make_pair(distances[i], i));
}
while (!heap.empty()) {
int v = heap.begin()->second;
heap.erase(heap.begin());
for (Edge e : gr[v]) {
int nv = e.vertex;
long long weight = e.weight;
if (distances[nv] > distances[v] + weight) {
heap.erase(make_pair(distances[nv], nv));
distances[nv] = distances[v] + weight;
heap.insert(make_pair(distances[nv], nv));
}
}
}
}
int main() {
cin >> n >> m;
gr.assign(n, vector<Edge>());
distances.resize(n);
cost.resize(n);
while (m) {
int a_from, b_to;
long long w;
cin >> a_from >> b_to >> w;
Edge e1(b_to - 1, w * 2);
Edge e2(a_from - 1, w * 2);
gr[a_from - 1].push_back(e1);
gr[b_to - 1].push_back(e2);
--m;
}
for (int i = 0; i < n; ++i) {
long long cost_of_consert;
cin >> cost_of_consert;
cost[i] = cost_of_consert;
distances[i] = cost_of_consert;
}
make_Dijkstra();
for (int i = 0; i < n; ++i) {
cout << distances[i] << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 100;
std::set<pair<long long, long long>> gr[N];
long long vis[N];
long long ans[N];
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long n;
long long m;
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long x, y, w;
cin >> x >> y >> w;
w = w * 2;
gr[x].insert({y, w});
gr[y].insert({x, w});
}
set<pair<long long, long long>> s;
for (long long i = 1; i <= n; i++) {
long long x;
cin >> x;
s.insert({x, i});
ans[i] = x;
}
while (s.size() > 0) {
auto x = *(s.begin());
s.erase(x);
vis[x.second] = 1;
std::vector<pair<long long, long long>> v;
for (auto w : gr[x.second]) {
v.push_back(w);
if (ans[w.first] > ans[x.second] + w.second) {
s.erase({ans[w.first], w.first});
ans[w.first] = ans[x.second] + w.second;
s.insert({ans[w.first], w.first});
}
}
for (auto w : v) {
gr[x.second].erase(w);
gr[w.first].erase({x.second, w.second});
}
}
for (long long i = 1; i < n + 1; i++) cout << ans[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int64_t INF = 1LL << 62;
int64_t a[N];
vector<pair<int, int64_t>> g[N];
vector<int64_t> dijkstra(vector<pair<int, int64_t>> g[], int n) {
vector<int64_t> arrival(n, INF), departure(n, INF);
vector<int> vis(n), parent(n);
set<pair<int64_t, int>> s;
for (int i = 0; i < n; i++) {
arrival[i] = a[i];
s.insert({arrival[i], i});
}
while (!s.empty()) {
auto [ignore, u] = *s.begin();
s.erase(s.begin());
vis[u] = 1;
departure[u] = arrival[u];
for (auto [v, w] : g[u]) {
if (arrival[v] > departure[u] + w) {
s.erase({arrival[v], v});
arrival[v] = departure[u] + w;
s.insert({arrival[v], v});
parent[v] = u;
}
}
}
return arrival;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, i, m, u, v;
int64_t w;
cin >> n >> m;
while (m--) {
cin >> u >> v >> w;
u--, v--, w *= 2;
g[u].push_back({v, w});
g[v].push_back({u, w});
}
for (i = 0; i < n; ++i) cin >> a[i];
for (auto it : dijkstra(g, n)) cout << it << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200009;
const int MOD = 1e9 + 7;
vector<pair<int, int64_t>> V[maxn];
int vis[maxn];
int64_t cst[maxn];
int main() {
ios_base::sync_with_stdio(false), cout.tie(0), cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int64_t u, v, w;
cin >> u >> v >> w;
V[u].emplace_back(v, w);
V[v].emplace_back(u, w);
}
priority_queue<pair<int64_t, int>> que;
for (int i = 1; i <= n; ++i) {
cin >> cst[i];
que.emplace(-cst[i], i);
}
while (((int)(que).size())) {
auto p = que.top();
que.pop();
if (vis[p.second]) continue;
vis[p.second] = 1;
for (auto edge : V[p.second]) {
if (cst[edge.first] > cst[p.second] + 2 * edge.second) {
cst[edge.first] = cst[p.second] + 2 * edge.second;
que.emplace(-cst[edge.first], edge.first);
}
}
}
for (int i = 1; i <= n; ++i) {
cout << cst[i] << " ";
}
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 300000;
const long long inf = 1LL << 60;
struct edge {
long long from, to, dist;
edge(long long u, long long v, long long d) : from(u), to(v), dist(d) {}
};
struct HeapNode {
long long d;
long long u;
HeapNode(long long a, long long b) : d(a), u(b) {}
bool operator<(const HeapNode &rhs) const { return d > rhs.d; }
};
struct Dijkstra {
int n, m;
vector<edge> edges;
vector<int> G[maxn];
bool done[maxn];
long long d[maxn];
int p[maxn];
void init(int n) {
this->n = n;
for (int i = 0; i < n; ++i) G[i].clear();
edges.clear();
}
void add_edge(int from, int to, long long dist) {
edges.push_back(edge(from, to, dist));
m = edges.size();
G[from].push_back(m - 1);
}
void dijkstra(int s) {
priority_queue<HeapNode> Q;
for (int i = 0; i < n; ++i) d[i] = inf;
d[s] = 0;
Q.push(HeapNode(0, s));
memset(done, 0, sizeof(done));
while (!Q.empty()) {
HeapNode x = Q.top();
Q.pop();
int u = x.u;
if (done[u]) continue;
done[u] = true;
for (unsigned i = 0; i < G[u].size(); ++i) {
edge &e = edges[G[u][i]];
if (d[e.to] > d[u] + e.dist) {
d[e.to] = d[u] + e.dist;
p[e.to] = G[u][i];
Q.push(HeapNode(d[e.to], e.to));
}
}
}
}
} graph;
int main() {
int n, m;
scanf("%d %d", &n, &m);
graph.init(n + 10);
const int s = n + 5;
for (int i = 0; i < m; ++i) {
long long x, y, w;
scanf("%lld %lld %lld", &x, &y, &w);
graph.add_edge(x, y, w * 2);
graph.add_edge(y, x, w * 2);
}
for (int i = 1; i <= n; ++i) {
long long a;
scanf("%lld", &a);
graph.add_edge(s, i, a);
}
graph.dijkstra(s);
for (int i = 1; i <= n; ++i) printf("%lld ", graph.d[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 200001;
int n, m;
long long a[MX];
vector<pair<long long, long long>> adj[MX];
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
todo;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
long long v, u, w;
cin >> v >> u >> w;
adj[v].push_back({u, w}), adj[u].push_back({v, w});
}
for (int i = 1; i <= n; i++) {
cin >> a[i];
todo.push({a[i], i});
}
while (todo.size()) {
auto x = todo.top();
todo.pop();
if (x.first != a[x.second]) continue;
for (auto y : adj[x.second])
if (x.first + 2 * y.second < a[y.first]) {
todo.push({a[y.first] = x.first + 2 * y.second, y.first});
}
}
for (int i = 1; i <= n; i++) cout << a[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int INF = 1000 * 1000 * 1000 + 7;
const long long LINF = INF * (long long)INF;
const int MAX = 2 * 100000 + 47;
vector<pair<int, long long> > G[MAX];
long long D[MAX];
long long A[MAX];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = (0); i < (m); i++) {
int u, v;
long long w;
scanf("%d%d%I64d", &u, &v, &w);
--u, --v;
G[u].push_back(make_pair(v, w));
G[v].push_back(make_pair(u, w));
}
for (int i = (0); i < (n); i++) scanf("%I64d", A + i);
for (int i = (0); i < (n); i++) D[i] = LINF;
set<pair<long long, int> > S;
for (int i = (0); i < (n); i++) {
D[i] = A[i];
S.insert(make_pair(A[i], i));
}
while (!S.empty()) {
int v = S.begin()->second;
S.erase(S.begin());
long long d = D[v];
for (int i = (0); i < ((int)G[v].size()); i++) {
int to = G[v][i].first;
long long w = 2 * G[v][i].second;
if (d + w < D[to]) {
S.erase(make_pair(D[to], to));
D[to] = d + w;
S.insert(make_pair(D[to], to));
}
}
}
for (int i = (0); i < (n); i++) {
printf("%I64d ", D[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> v[200004], v1[200004];
multiset<long long> s;
int n, m, x, y, i, k, j;
long long z, c, w, q, a[200004];
multiset<long long>::iterator it;
int main() {
scanf("%d %d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d %d %I64d", &x, &y, &c);
c = (1LL) * c * 2;
v[x].push_back(c);
v[y].push_back(c);
v1[x].push_back(y);
v1[y].push_back(x);
}
for (i = 1; i <= n; i++) {
scanf("%I64d", &z);
z = (1LL) * z * 1000000 + i;
s.insert(z);
a[i] = z;
}
for (i = 1; i <= n; i++) {
z = *s.begin();
w = (1LL) * z % 1000000;
z = (1LL) * z / 1000000;
k = v[w].size();
k--;
for (j = 0; j <= k; j++) {
q = (0LL) + z + v[w][j];
q = (1LL) * q * 1000000 + v1[w][j];
if (q < a[v1[w][j]]) {
it = s.find(a[v1[w][j]]);
s.erase(it);
a[v1[w][j]] = (0LL) + q;
s.insert(a[v1[w][j]]);
}
}
s.erase(s.begin());
}
for (i = 1; i <= n; i++) {
a[i] = (1LL) * a[i] / 1000000;
printf("%I64d ", a[i]);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const long long inf = (long long)1e18;
int n, m, cnt, last[N];
long long dis[N];
bool vis[N];
struct edge {
int to, next;
long long w;
} e[N * 4];
priority_queue<pair<long long, int> > que;
void addedge(int u, int v, long long w) {
e[++cnt].to = v;
e[cnt].w = w;
e[cnt].next = last[u];
last[u] = cnt;
e[++cnt].to = u;
e[cnt].w = w;
e[cnt].next = last[v];
last[v] = cnt;
}
void dij() {
for (int i = 1; i <= n; i++) dis[i] = inf;
que.push(make_pair(0, 0));
while (!que.empty()) {
int x = que.top().second;
que.pop();
while (!que.empty() && vis[x]) x = que.top().second, que.pop();
if (vis[x]) break;
vis[x] = 1;
for (int i = last[x]; i; i = e[i].next)
if (dis[x] + e[i].w < dis[e[i].to]) {
dis[e[i].to] = dis[x] + e[i].w;
que.push(make_pair(-dis[e[i].to], e[i].to));
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
long long z;
scanf("%d%d%I64d", &x, &y, &z);
addedge(x, y, z * 2);
}
for (int i = 1; i <= n; i++) {
long long w;
scanf("%I64d", &w);
addedge(0, i, w);
}
dij();
for (int i = 1; i <= n; i++) printf("%I64d ", dis[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 200010;
long long n, m, head[maxn], to[maxn * 2], nextt[maxn * 2], w[maxn * 2],
tot = 1, vis[maxn], ans[maxn];
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
q;
void add(long long x, long long y, long long z) {
w[tot] = z;
to[tot] = y;
nextt[tot] = head[x];
head[x] = tot++;
}
int main() {
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);
add(a, b, 2 * c);
add(b, a, 2 * c);
}
for (long long i = 1; i <= n; i++) {
long long t;
scanf("%I64d", &t);
q.push(make_pair(t, i));
}
while (!q.empty()) {
pair<long long, long long> u = q.top();
q.pop();
if (vis[u.second]) continue;
vis[u.second] = 1;
ans[u.second] = u.first;
for (long long i = head[u.second]; i; i = nextt[i]) {
long long v = to[i];
q.push(make_pair(u.first + w[i], v));
}
}
for (long long i = 1; i <= n; i++) printf("%I64d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7, N = 2e5 + 5;
struct edge {
long long vertex, cost;
edge(long long tt, long long cc) {
vertex = tt;
cost = cc;
}
};
vector<edge> g[N];
long long n, m, a[N], d[N];
set<pair<long long, long long>> q;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
long long v, u, w;
cin >> v >> u >> w;
g[v - 1].push_back(edge(u - 1, w));
g[u - 1].push_back(edge(v - 1, w));
}
for (int i = 0; i < n; i++) {
cin >> a[i];
d[i] = a[i];
q.insert(make_pair(d[i], i));
}
while (!q.empty()) {
int v = q.begin()->second;
q.erase(q.begin());
for (edge to : g[v]) {
if (d[to.vertex] > d[v] + to.cost * 2) {
q.erase(make_pair(d[to.vertex], to.vertex));
d[to.vertex] = d[v] + to.cost * 2;
q.insert(make_pair(d[to.vertex], to.vertex));
}
}
}
for (int i = 0; i < n; i++) {
cout << d[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &x, T2 y) {
if (y < x) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1 &x, T2 y) {
if (y > x) x = y;
}
const int MAXN = 2e5 + 1;
vector<pair<int, long long>> g[MAXN];
long long a[MAXN], ans[MAXN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL), cout.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int u, v;
long long w;
cin >> u >> v >> w;
g[u].push_back({v, w});
g[v].push_back({u, w});
}
set<pair<long long, int>> second;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
second.insert({a[i], i});
ans[i] = a[i];
}
while (!second.empty()) {
int v = second.begin()->second;
second.erase(second.begin());
for (auto i : g[v]) {
long long cval = ans[v] + 2 * i.second;
if (ans[i.first] > cval) {
second.erase({ans[i.first], i.first});
ans[i.first] = cval;
second.insert({ans[i.first], i.first});
}
}
}
for (int i = 1; i <= n; ++i) cout << ans[i] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct travis {
long long v, c;
travis(long long a, long long b) {
v = a;
c = b;
}
bool operator<(const travis &b) const { return c > b.c; }
};
vector<travis> E[200020];
long long n, m, u, v, w, tmp, dist[200020], vis[200020];
void insert(long long u, long long v, long long w) {
E[u].push_back(travis(v, w));
}
void Dijkstra(long long s, long long n) {
memset(vis, 0, sizeof(vis));
memset(dist, 0x3f, sizeof(dist));
priority_queue<travis> q;
while (!q.empty()) q.pop();
q.push(travis(s, 0));
dist[s] = 0;
while (!q.empty()) {
travis now = q.top();
q.pop();
long long u = now.v;
if (vis[u]) continue;
vis[u] = true;
for (int i = 0; i < E[u].size(); i++) {
long long v = E[u][i].v, c = E[u][i].c;
if (!vis[v] && dist[v] > dist[u] + c) {
dist[v] = dist[u] + c;
q.push(travis(v, dist[v]));
}
}
}
}
int main() {
scanf("%lld%lld", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%lld%lld%lld", &u, &v, &w);
insert(u, v, w + w);
insert(v, u, w + w);
}
for (int i = 1; i <= n; i++) {
scanf("%lld", &tmp);
insert(i, n + 1, tmp);
insert(n + 1, i, tmp);
}
Dijkstra(n + 1, n + 1);
for (int i = 1; i <= n; i++) printf("%lld ", dist[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void preprocess(void) { return; }
vector<vector<pair<int, long long>>> adj;
vector<long long> dis;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(20);
preprocess();
int n, m;
cin >> n >> m;
adj.resize(n + 2, vector<pair<int, long long>>(0));
for (auto i = (0); i < m; i++) {
int u, v;
long long w;
cin >> u >> v >> w;
adj[u].push_back({v, 2 * w});
adj[v].push_back({u, 2 * w});
};
vector<long long> a(n + 1);
for (auto i = (0); i < n; i++) cin >> a[i + 1];
;
for (auto i = (1); i < n + 1; i++) {
adj[i].push_back({n + 1, a[i]});
adj[n + 1].push_back({i, a[i]});
};
priority_queue<pair<long long, long long>> pq;
dis.resize(n + 2, 1000000007 * 1LL * 1000000007);
dis[n + 1] = 0;
pq.push({0, n + 1});
vector<int> vis(n + 2);
while (!pq.empty()) {
auto x = pq.top();
x.first = -x.first;
if (vis[x.second] == 1) {
pq.pop();
continue;
}
vis[x.second] = 1;
;
pq.pop();
for (auto y : adj[x.second]) {
if (!vis[y.first]) {
if (dis[y.first] > x.first + y.second) {
dis[y.first] = x.first + y.second;
pq.push({-dis[y.first], y.first});
}
}
}
}
for (auto i = (1); i < n + 1; i++) cout << dis[i] << " ";
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int head[500005], cur, n, m;
long long dis[500005], d[500005];
struct EDGE {
int t, next;
long long c;
} e[2 * 500005];
priority_queue<pair<long long, int> > que;
void add(int a, int b, long long c) {
cur++;
e[cur].t = b;
e[cur].next = head[a];
e[cur].c = c;
head[a] = cur;
}
void Put_it(int i, long long D) {
if (D >= dis[i]) return;
dis[i] = D;
que.push(make_pair(-dis[i], i));
}
void SPFA() {
while (!que.empty()) {
int now = que.top().second;
long long nowx = que.top().first;
que.pop();
if (dis[now] != -nowx) continue;
for (int h = head[now]; h != -1; h = e[h].next) {
int newx = e[h].t;
Put_it(newx, dis[now] + e[h].c);
}
}
}
signed main() {
scanf("%d%d", &n, &m);
memset(head, -1, sizeof(head));
for (int i = 1; i <= m; i++) {
int a, b;
long long c;
scanf("%d%d%I64d", &a, &b, &c);
add(a, b, 2 * c);
add(b, a, 2 * c);
}
for (int i = 1; i <= n; i++) {
scanf("%I64d", &d[i]);
dis[i] = 1e18;
Put_it(i, d[i]);
}
SPFA();
for (int i = 1; i <= n; i++) printf("%I64d ", dis[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using Pl = pair<ll, ll>;
using vi = vector<int>;
using vvi = vector<vi>;
const int mod = 1e9 + 7, INF = 1 << 30;
const double EPS = 1e-12, PI = 3.1415926535897932384626;
const ll lmod = 1e9 + 7, LINF = 1LL << 60;
const int MAX_N = 200005;
template <typename T>
T inf;
template <>
constexpr int inf<int> = 1 << 30;
template <>
constexpr ll inf<ll> = 1LL << 60;
using Cost = ll;
using Node = int;
struct Edge {
Cost cost;
Node to;
Edge(Cost cost, Node to) : cost(cost), to(to) {}
};
using Graph = vector<vector<Edge>>;
vector<Cost> dijkstra(Graph &graph, vector<Cost> cost) {
using Pcn = pair<Cost, Node>;
priority_queue<Pcn, vector<Pcn>, greater<Pcn>> que;
vector<Cost> dist(graph.size(), inf<Cost>);
for (int i = 0; i < graph.size(); i++) {
dist[i] = cost[i];
que.push(Pcn(cost[i], i));
}
while (!que.empty()) {
Pcn p = que.top();
que.pop();
Node v = p.second;
if (dist[v] < p.first) continue;
for (Edge e : graph[v]) {
if (dist[v] + e.cost < dist[e.to]) {
dist[e.to] = dist[v] + e.cost;
que.push(Pcn(dist[e.to], e.to));
}
}
}
return dist;
}
int main() {
int N, M;
cin >> N >> M;
Graph g(N);
for (int i = 0; i < M; i++) {
int u, v;
ll c;
scanf("%d%d%lld", &u, &v, &c);
u--;
v--;
g[u].push_back(Edge(2LL * c, v));
g[v].push_back(Edge(2LL * c, u));
}
vector<Cost> co(N);
for (int i = 0; i < N; i++) scanf("%lld", &co[i]);
auto dist = move(dijkstra(g, co));
for (int i = 0; i < N; i++) cout << dist[i] << " ";
cout << "" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, u;
const long long maxn = 3e5 + 10;
const long long mod = 1e9 + 7;
const long long inf = 1e18;
long long d[maxn], a[maxn];
vector<pair<long long, long long> > adj[maxn];
void dijkstra() {
set<pair<long long, long long> > st;
for (long long i = 0; i <= n; i++) {
st.insert(make_pair(d[i], i));
}
while (!st.empty()) {
long long v = st.begin()->second;
st.erase(st.begin());
for (auto i : adj[v]) {
long long u = i.first;
long long w = i.second;
if (d[u] > (2 * w) + d[v]) {
st.erase(make_pair(d[u], u));
d[u] = (2 * w) + d[v];
st.insert(make_pair(d[u], u));
}
}
}
}
int32_t main() {
cin >> n >> m;
for (long long i = 1; i <= m; i++) {
long long a, b, w;
cin >> a >> b >> w;
adj[a].push_back(make_pair(b, w));
adj[b].push_back(make_pair(a, w));
}
for (long long i = 1; i <= n; i++) {
cin >> a[i];
d[i] = a[i];
}
dijkstra();
for (long long i = 1; i <= n; i++) {
cout << d[i] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e5 + 4;
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq;
vector<pair<long long, long long> > g[MAXN];
long long n, m, a[MAXN];
bool used[MAXN];
long long dist[MAXN];
int main() {
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long x, y, z;
cin >> x >> y >> z;
g[x].push_back({y, z});
g[y].push_back({x, z});
}
for (int i = 1; i <= n; i++) {
cin >> a[i];
pq.push({a[i], i});
dist[i] = a[i];
}
while (!pq.empty()) {
long long u = pq.top().second;
pq.pop();
if (used[u]) continue;
used[u] = 1;
for (long long i = 0; i < g[u].size(); i++) {
if (dist[g[u][i].first] > dist[u] + 2 * g[u][i].second) {
dist[g[u][i].first] = dist[u] + 2 * g[u][i].second;
pq.push({dist[g[u][i].first], g[u][i].first});
}
}
}
for (long long i = 1; i <= n; i++) {
cout << dist[i] << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 100;
vector<pair<long long, long long> > g[N];
long long a[N];
long long d[N];
set<pair<long long, long long> > pq;
void dijkstra() {
while (!pq.empty()) {
auto u = pq.begin();
auto v = *u;
pq.erase(u);
for (auto x : g[v.second]) {
long long to = x.first;
long long wt = x.second;
long long dist = 2 * wt + d[v.second];
if (d[to] > dist) {
if (pq.count({d[to], to})) pq.erase({d[to], to});
d[to] = dist;
pq.insert({dist, to});
}
}
}
return;
}
int main(int argc, char const *argv[]) {
long long n, m;
cin >> n >> m;
long long u, v, w;
for (long long i = 1; i <= m; i++) {
cin >> u >> v >> w;
g[u].push_back({v, w});
g[v].push_back({u, w});
}
for (long long i = 1; i <= n; i++) {
cin >> a[i];
d[i] = a[i];
pq.insert({a[i], i});
}
dijkstra();
for (long long i = 1; i <= n; i++) {
cout << d[i] << ' ';
}
cout << '\n';
}
|
#include <bits/stdc++.h>
const long long INF = 0x3f3f3f3f3f3f3f3f, MAXN = 2e5 + 10;
long long a[MAXN];
struct edge {
long long v, w;
};
int main() {
int n, m;
scanf("%d%d", &n, &m);
std::vector<std::vector<edge> > G(n + 1, std::vector<edge>());
for (int i = 1; i <= m; ++i) {
long long u, v, w;
scanf("%lld%lld%lld", &u, &v, &w);
w *= 2;
G[u].push_back({v, w});
G[v].push_back({u, w});
}
for (int i = 1; i <= n; ++i) {
scanf("%lld", &a[i]);
G[0].push_back({i, a[i]});
G[i].push_back({0, a[i]});
}
std::priority_queue<std::pair<long long, long long>,
std::vector<std::pair<long long, long long> >,
std::greater<std::pair<long long, long long> > >
que;
std::vector<long long> dis(n + 1, INF);
que.push({0, 0});
dis[0] = 0;
while (!que.empty()) {
std::pair<long long, long long> p = que.top();
que.pop();
int d = p.first, u = p.second;
if (dis[u] < d) continue;
for (auto &i : G[u])
if (dis[i.v] > dis[u] + i.w)
dis[i.v] = dis[u] + i.w, que.push({dis[i.v], i.v});
}
for (int i = 1; i <= n; ++i) printf("%lld ", dis[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node;
typedef pair<unsigned long long, node*> wn;
struct node {
vector<wn> chs;
unsigned long long w;
};
const int maxn = 2e5;
node nds[maxn];
bool vst[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
unsigned long long w;
cin >> u >> v >> w;
nds[u - 1].chs.push_back(wn(w, nds + v - 1));
nds[v - 1].chs.push_back(wn(w, nds + u - 1));
}
priority_queue<wn, vector<wn>, greater<wn> > q;
for (int i = 0; i < n; i++) {
cin >> nds[i].w;
q.push(wn(nds[i].w, nds + i));
}
while (!q.empty()) {
node* u = q.top().second;
q.pop();
if (vst[u - nds]) continue;
vst[u - nds] = true;
for (auto wni : u->chs) {
unsigned long long w = wni.first;
node* v = wni.second;
unsigned long long tw = 2 * w + u->w;
if (tw < v->w) {
v->w = tw;
q.push(wn(v->w, v));
}
}
}
for (int i = 0; i < n; i++) cout << nds[i].w << " ";
cout << endl;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <typename... Vectors>
void resizeVectors(int newSize, Vectors&... vectors) {
(vectors.resize(newSize), ...);
}
void resizeVectors(int unusedNewSize) {}
template <typename... Vectors>
void readEntryHelper(int i, Vectors&... vectors) {
((cin >> vectors[i]), ...);
}
template <typename... Vectors>
void readVectors(int count, Vectors&... vectors) {
(resizeVectors(count, (vectors, ...)));
for (int i = 0; i < count; ++i) {
(readEntryHelper(i, (vectors, ...)));
}
}
using ll = signed long long;
using ld = long double;
void $main();
int main() {
int numTests = 1;
if (0) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
cin >> numTests;
} else {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
}
for (int i = 0; i < numTests; ++i) {
$main();
if (0) {
cout << "-----\n";
}
}
}
using P = ll;
struct Node {
P value;
int il, ir;
int ansi;
Node* nl = nullptr;
Node* nr = nullptr;
bool leaf() const { return ir - il == 1; }
void push() {
if (!leaf()) {
value = min(nl->value, nr->value);
if (value == nl->value) {
ansi = nl->ansi;
} else {
ansi = nr->ansi;
}
}
}
};
Node* build(int l, int r) {
Node* n = new Node;
n->il = l;
n->ir = r;
n->ansi = l;
if (r - l > 1) {
int m = (l + r) / 2;
n->nl = build(l, m);
n->nr = build(m, r);
n->push();
}
return n;
}
template <typename Callback>
void iterateFundamentals(Node* node, int ql, int qr, const Callback& cb) {
node->push();
if (ql >= node->ir || node->il >= qr) return;
if (ql <= node->il && node->ir <= qr) {
cb(node);
return;
}
iterateFundamentals(node->nl, ql, qr, cb);
iterateFundamentals(node->nr, ql, qr, cb);
node->push();
}
pair<P, int> get(Node* u, int ql, int qr) {
P ans;
int ansi = -1;
bool ans_set = false;
iterateFundamentals(u, ql, qr, [&ans, &ans_set, &ansi](Node* v) {
if (!ans_set || ans > v->value) {
ans_set = true;
ans = v->value;
ansi = v->ansi;
}
});
return {ans, ansi};
}
void update(Node* u, int i, P x) {
iterateFundamentals(u, i, i + 1, [x](Node* v) { v->value = x; });
}
void assign(Node* u, int i, int j) {
P val = get(u, j, j + 1).first;
update(u, i, val);
}
void $main() {
int n, m;
cin >> n >> m;
vector<vector<pair<int, ll>>> g(n);
for (int i = 0; i < m; ++i) {
int u, v;
ll w;
cin >> u >> v >> w;
--u;
--v;
g[u].emplace_back(v, w);
g[v].emplace_back(u, w);
}
vector<ll> a;
readVectors(n, a);
vector<ll> ans(a);
Node* tree = build(0, n);
for (int i = 0; i < n; ++i) {
update(tree, i, ans[i]);
}
int nextFree = n;
while (nextFree > 0) {
auto t = get(tree, 0, n);
auto [ev, v] = t;
auto ansv = ev;
P badEntry;
badEntry = (P)1e18;
update(tree, v, badEntry);
assert(ansv == ans[v]);
--nextFree;
for (auto edge : g[v]) {
ll nans = ans[v] + 2 * edge.second;
ll& cans = ans[edge.first];
if (cans > nans) {
cans = nans;
update(tree, edge.first, cans);
}
}
}
for (ll x : ans) cout << x << " ";
cout << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
vector<pair<long long, int> > E[N];
long long dis[N];
bool vis[N];
int n, m;
void Dij() {
memset(dis, 0x3f, sizeof(dis));
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
q.push(pair<long long, int>(0, 0));
dis[0] = 0;
while (!q.empty()) {
pair<long long, int> f = q.top();
q.pop();
if (vis[f.second]) continue;
vis[f.second] = 1;
for (auto i : E[f.second]) {
int t = i.second;
long long w = i.first;
if (!vis[t]) {
if (dis[t] > dis[f.second] + w) {
dis[t] = dis[f.second] + w;
q.push(pair<long long, int>(dis[t], t));
}
}
}
}
for (int i = 1; i <= n; i++) printf("%I64d%c", dis[i], (i == n) ? '\n' : ' ');
}
int main() {
scanf("%d%d", &n, &m);
int f, t;
long long w;
for (int i = 0; i < m; i++) {
scanf("%d%d%I64d", &f, &t, &w);
E[f].push_back(pair<long long, int>(2 * w, t));
E[t].push_back(pair<long long, int>(2 * w, f));
}
for (int i = 0; i < n; i++) {
scanf("%I64d", &w);
E[0].push_back(pair<long long, int>(w, i + 1));
}
Dij();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
const int Mod = 1e9 + 7;
const int N = 2e5 + 100;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
inline long long dpow(long long a, long long b) {
long long r = 1, t = a;
while (b) {
if (b & 1) r = (r * t) % Mod;
b >>= 1;
t = (t * t) % Mod;
}
return r;
}
inline long long fpow(long long a, long long b) {
long long r = 1, t = a;
while (b) {
if (b & 1) r = (r * t);
b >>= 1;
t = (t * t);
}
return r;
}
vector<pair<long long, int>> G[N];
long long dis[N], a[N];
bool vis[N];
int n, m;
void Dijkstra() {
memset(dis, LINF, sizeof(dis));
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
q;
for (int i = 1; i <= n; i++) {
scanf("%lld", &dis[i]);
q.push({dis[i], i});
}
while (!q.empty()) {
pair<long long, int> now = q.top();
q.pop();
int u = now.second;
if (vis[u]) continue;
vis[u] = true;
for (auto it : G[u]) {
int v = it.second;
long long w = it.first;
if (dis[v] > dis[u] + w) {
dis[v] = dis[u] + w;
q.push({dis[v], v});
}
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
long long w;
scanf("%d %d %lld", &u, &v, &w);
G[u].push_back({2 * w, v});
G[v].push_back({2 * w, u});
}
Dijkstra();
for (int i = 1; i <= n; i++) printf("%lld ", dis[i]);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, dis[400005], vis[400005];
struct road {
long long v, w;
bool operator<(const road &b) const { return w > b.w; }
road(long long ax, long long ay) {
v = ax;
w = ay;
}
road() {}
};
vector<road> t[400005];
priority_queue<road> q;
int main() {
scanf("%lld%lld", &n, &m);
for (long long i = 1; i <= m; i++) {
long long u, v, w;
scanf("%lld%lld%lld", &u, &v, &w);
t[u].push_back(road(v, w * 2));
t[v].push_back(road(u, w * 2));
}
for (long long i = 1; i <= n; i++) {
long long w;
scanf("%lld", &w);
t[0].push_back(road(i, w));
dis[i] = 1e18 + 9;
}
m += n;
q.push(road(0, 0));
while (!q.empty()) {
long long x = q.top().v;
q.pop();
if (vis[x]) {
continue;
}
vis[x] = 1;
for (long long i = 0; i < t[x].size(); i++) {
long long y = t[x][i].v;
if (dis[y] > dis[x] + t[x][i].w) {
dis[y] = dis[x] + t[x][i].w;
q.push(road(y, dis[y]));
}
}
}
for (long long i = 1; i <= n; i++) {
cout << dis[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long n, m;
cin >> n >> m;
long long d[n + 1], pr[n + 1];
vector<pair<long long, long long>> g[n + 1];
set<pair<long long, long long>> q;
for (long long i = 0; i < m; i++) {
long long x, y, w;
cin >> x >> y >> w;
g[x].push_back({2 * w, y});
g[y].push_back({2 * w, x});
}
for (long long i = 1; i <= n; i++) {
cin >> pr[i];
d[i] = pr[i];
q.emplace(d[i], i);
}
while (!q.empty()) {
long long v = q.begin()->second, xx = q.begin()->first;
q.erase(q.begin());
if (xx > d[v]) continue;
for (long long j = 0; j < g[v].size(); ++j) {
long long to = g[v][j].second, len = g[v][j].first;
if (d[v] + len < d[to]) {
q.erase(make_pair(d[to], to));
d[to] = d[v] + len;
q.insert(make_pair(d[to], to));
}
}
}
for (long long i = 1; i <= n; i++) cout << d[i] << " ";
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
long long dist[N], a[N];
vector<vector<pair<int, long long> > > g(N);
int n, m;
void dij() {
priority_queue<pair<long long, int> > pq;
for (int i = 1; i <= n; i++) {
pq.push(make_pair(-a[i], i));
dist[i] = a[i];
}
while (pq.size()) {
pair<long long, int> t = pq.top();
pq.pop();
int node = t.second;
if (dist[node] != -t.first) continue;
for (int i = 0; i < g[node].size(); i++) {
int v = g[node][i].first;
long long w = g[node][i].second;
if (dist[v] > dist[node] + w) {
dist[v] = dist[node] + w;
pq.push(make_pair(-dist[v], v));
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
long long w;
int u, v;
cin >> u >> v >> w;
g[u].push_back(make_pair(v, w * 2));
g[v].push_back(make_pair(u, w * 2));
}
for (int i = 1; i <= n; i++) cin >> a[i];
dij();
for (int i = 0; i < n; i++) cout << dist[i + 1] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void read(T& x) {
short f = 1;
char ch = getchar();
x = 0;
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
x *= f;
}
long long head[1000010], ver[1000010], Next[1000010], edge[1000010], tot;
void add(long long x, long long y, long long z) {
ver[++tot] = y;
Next[tot] = head[x];
head[x] = tot;
edge[tot] = z;
}
long long n, m;
long long x, y, z;
long long d[1000010];
bool v[1000010];
priority_queue<pair<long long, long long> > q;
void DJ(long long x) {
memset(v, 0, sizeof v);
memset(d, 0x3f, sizeof d);
d[x] = 0;
q.push(make_pair(0, x));
while (!q.empty()) {
x = q.top().second, q.pop();
if (v[x]) continue;
v[x] = 1;
for (long long i = head[x]; i; i = Next[i]) {
long long y = ver[i], z = edge[i];
if (d[y] > d[x] + z) {
d[y] = d[x] + z;
q.push(make_pair(-d[y], y));
}
}
}
}
signed main() {
read(n), read(m);
while (m--) {
read(x), read(y), read(z);
z <<= 1ll;
add(x, y, z), add(y, x, z);
}
for (long long i = 1; i <= n; i++) {
read(x);
add(0, i, x);
}
DJ(0);
for (long long i = 1; i <= n; i++) printf("%lld ", d[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const int Mod = 1000000007;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
const double e = exp(1);
const double PI = acos(-1);
const double ERR = 1e-10;
int n, cnt;
int head[maxn];
long long d[maxn];
bool vis[maxn];
struct edge {
int v, nxt;
long long w;
} Edge[6 * maxn];
struct node {
long long d;
int id;
node(long long _d, int _id) : d(_d), id(_id) {}
const bool operator<(const node b) const { return d > b.d; }
};
void init() {
for (int i = 0; i <= n; i++) head[i] = -1;
cnt = 0;
}
void addedge(int u, int v, long long w) {
Edge[cnt].v = v;
Edge[cnt].w = w;
Edge[cnt].nxt = head[u];
head[u] = cnt++;
}
priority_queue<node> que;
void Dijkstra() {
memset(d, 0x3f, sizeof(d));
d[0] = 0;
que.push(node(d[0], 0));
while (!que.empty()) {
node now = que.top();
que.pop();
if (vis[now.id]) continue;
vis[now.id] = true;
for (int i = head[now.id]; i != -1; i = Edge[i].nxt) {
int v = Edge[i].v;
long long w = Edge[i].w;
if (d[v] > d[now.id] + w) {
d[v] = d[now.id] + w;
que.push(node(d[v], v));
}
}
}
}
int main() {
int m, u, v;
long long w;
scanf("%d%d", &n, &m);
init();
for (int i = 1; i <= m; i++) {
scanf("%d%d%lld", &u, &v, &w);
addedge(u, v, 2 * w);
addedge(v, u, 2 * w);
}
for (int i = 1; i <= n; i++) {
scanf("%lld", &w);
addedge(0, i, w);
addedge(i, 0, w);
}
Dijkstra();
for (int i = 1; i <= n; i++) {
if (i > 1) printf(" ");
printf("%lld", d[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200200;
vector<long long int> g[N], e[N];
set<pair<long long int, long long int> > S;
int n, m;
long long int d[N];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
long long int x, y, z;
cin >> x >> y >> z;
g[x].push_back(y);
e[x].push_back(z);
g[y].push_back(x);
e[y].push_back(z);
}
for (int i = 1; i <= n; i++) {
cin >> d[i];
S.insert(make_pair(d[i], i));
}
while (S.size() != 0) {
int u = S.begin()->second;
S.erase(S.begin());
for (int i = 0; i < g[u].size(); i++) {
long long int v = g[u][i];
long long int cost = e[u][i];
if (cost * 2 + d[u] < d[v]) {
S.erase(make_pair(d[v], v));
d[v] = cost * 2 + d[u];
S.insert(make_pair(d[v], v));
}
}
}
for (int i = 1; i <= n; i++) {
cout << d[i] << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long int n, m, x, y, w, i, t, length, u;
cin >> n >> m;
vector<vector<pair<unsigned long long int, unsigned long long int>>> adj(n);
vector<unsigned long long int> dist(n, 1e13);
while (m--)
scanf(" %llu%llu%llu", &x, &y, &w), adj[x - 1].push_back({y - 1, 2 * w}),
adj[y - 1].push_back({x - 1, 2 * w});
priority_queue<pair<unsigned long long int, unsigned long long int>,
vector<pair<unsigned long long int, unsigned long long int>>,
greater<pair<unsigned long long int, unsigned long long int>>>
q;
for (i = 0; i < n; i++) scanf(" %llu", &w), q.push({w, i});
while (!q.empty()) {
pair<unsigned long long int, unsigned long long int> p = q.top();
q.pop();
u = p.second, length = p.first;
if (length > dist[u])
continue;
else
dist[u] = length;
for (i = 0; i < adj[u].size(); i++) {
pair<unsigned long long int, unsigned long long int> l = adj[u][i];
w = l.second, t = l.first;
if (dist[u] + w < dist[t]) q.push({dist[u] + w, t});
}
}
for (i = 0; i < n; i++) printf("%llu ", dist[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double PI = acosl(-1);
bool compare_int(int a, int b) { return (a > b); }
bool compare_string(string a, string b) { return a.size() < b.size(); }
bool compare_pair(const pair<int, int> &a, const pair<int, int> &b) {
if (a.second == b.second)
return a.first < b.first;
else
return (a.second > b.second);
}
bool cmp(pair<string, int> x, pair<string, int> y) {
return (x.second < y.second);
}
void NA() {
printf("NO\n");
exit(0);
}
void YA() {
printf("YES\n");
exit(0);
}
const int N = 2e5 + 5;
long long int dis[N], a[N];
vector<pair<int, long long int> > g[N];
int n, m;
void dijkstra() {
priority_queue<pair<long long int, int> > pq;
for (int i = 0; i < n; i++) {
dis[i] = a[i];
pq.push({-dis[i], i});
}
while (!pq.empty()) {
auto t = pq.top();
pq.pop();
int u = t.second;
long long int d = -t.first;
if (dis[u] < d) continue;
for (auto it : g[u]) {
int v = it.first;
long long int w = it.second;
if (dis[v] > dis[u] + w) {
dis[v] = dis[u] + w;
pq.push({-dis[v], v});
}
}
}
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int u, v, w;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%lld %lld %lld", &u, &v, &w);
u--, v--;
w *= 2;
g[u].push_back({v, w});
g[v].push_back({u, w});
}
for (int i = 0; i < n; i++) scanf("%lld", &a[i]);
dijkstra();
for (int i = 0; i < n; i++) printf("%lld ", dis[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
long long int inp[200004];
vector<pair<long long int, long long int>> graph[200004];
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>>>
minHeap;
cin >> n >> m;
while (m--) {
int u, v;
long long int weight;
cin >> u >> v >> weight;
weight *= 2;
graph[u].push_back({v, weight});
graph[v].push_back({u, weight});
}
for (int i = 1; i <= n; i++) cin >> inp[i];
for (int i = 1; i <= n; i++) minHeap.push({inp[i], i});
while (minHeap.empty() == false) {
long long int temp = minHeap.top().second;
long long int pre = minHeap.top().first;
minHeap.pop();
if (inp[temp] != pre) continue;
for (auto i : graph[temp]) {
int to = i.first;
long long int w = i.second;
if (inp[to] > pre + w) {
inp[to] = pre + w;
minHeap.push({inp[to], to});
}
}
}
for (int i = 1; i <= n; i++) cout << inp[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > g[200001];
long long d[200001];
set<pair<long long, long long> > s;
set<pair<long long, long long> >::iterator it;
int main() {
long long n, m;
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (long long k = 1, x, y, z; k <= m; k++) {
cin >> x >> y >> z;
g[x].push_back({y, z});
g[y].push_back({x, z});
}
for (int k = 1; k <= n; k++) {
cin >> d[k];
s.insert({d[k], k});
}
while (!s.empty()) {
pair<long long, long long> x = *s.begin();
s.erase(s.begin());
for (pair<long long, long long> k : g[x.second]) {
if (d[k.first] > d[x.second] + k.second * 2) {
s.erase({d[k.first], k.first});
d[k.first] = d[x.second] + k.second * 2;
s.insert({d[k.first], k.first});
}
}
}
for (int k = 1; k <= n; k++) cout << d[k] << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long spf[10];
long long fac[10];
void sieve() {
spf[1] = 1;
for (long long i = 2; i < 10; i++) spf[i] = i;
for (long long i = 4; i < 10; i += 2) spf[i] = 2;
for (long long i = 3; i * i < 10; i++) {
if (spf[i] == i) {
for (long long j = i * i; j < 10; j += i)
if (spf[j] == j) spf[j] = i;
}
}
}
map<long long, long long> getfactor(long long a) {
map<long long, long long> m;
while (a > 1) {
m[spf[a]]++;
a /= spf[a];
}
return m;
}
long long power(long long x, long long y, long long p) {
long long res = 1;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long inverse(long long a, long long p) { return power(a, p - 2, p); }
long long ncr(long long n, long long r, long long p) {
if (r == 0) return 1;
return (fac[n] * inverse(fac[r], p) % p * inverse(fac[n - r], p) % p) % p;
}
void solve() {
long long n, m, d;
cin >> n >> m >> d;
long long a[m];
for (long long i = 0; i < m; i++) cin >> a[i];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m;
cin >> n >> m;
vector<pair<long long, long long> > v[n + 1];
for (long long i = 0; i < m; i++) {
long long x, y, w;
cin >> x >> y >> w;
v[x].push_back(make_pair(y, w + w));
v[y].push_back(make_pair(x, w + w));
}
long long a[n + 1], ans[n + 1];
set<pair<long long, long long> > s;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
ans[i] = a[i];
s.insert(make_pair(ans[i], i));
}
while (s.size() > 0) {
auto it = s.begin();
long long val = it->first, ind = it->second;
for (long long i = 0; i < v[ind].size(); i++) {
long long l = v[ind][i].first;
long long wei = v[ind][i].second;
if (ans[ind] + wei < ans[l]) {
s.erase(make_pair(ans[l], l));
s.insert(make_pair(ans[ind] + wei, l));
ans[l] = ans[ind] + wei;
}
}
s.erase(it);
}
for (long long i = 1; i <= n; i++) cout << ans[i] << " ";
cout << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
long long to, v;
edge() {}
edge(long long _to, long long _v) {
to = _to;
v = _v;
}
};
vector<edge> G[200010];
long long n, m, f[200010];
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
Q;
int main() {
long long i, x, y, z;
scanf("%lld%lld", &n, &m);
for (i = 0; i < m; i++) {
scanf("%lld%lld%lld", &x, &y, &z);
G[x].push_back(edge(y, z));
G[y].push_back(edge(x, z));
}
for (i = 1; i <= n; i++) {
scanf("%lld", &f[i]);
Q.push(make_pair(f[i], i));
}
pair<long long, long long> p;
while (!Q.empty()) {
p = Q.top();
Q.pop();
x = p.second;
if (p.first != f[x]) continue;
for (i = 0; i < G[x].size(); i++) {
y = G[x][i].to;
z = f[x] + 2 * G[x][i].v;
if (z < f[y]) {
f[y] = z;
Q.push(make_pair(f[y], y));
}
}
}
for (i = 1; i <= n; i++) printf("%lld ", f[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 50;
long long dist[N];
vector<pair<int, long long> > graph[N];
int n, m;
void djistra(void) {
set<pair<long long, int> > s;
for (int i = 1; i <= n; i++) {
s.insert({dist[i], i});
}
while (!s.empty()) {
pair<int, int> temp = *(s.begin());
s.erase(s.begin());
int u = temp.second;
for (int i = 0; i < graph[u].size(); i++) {
int to = graph[u][i].first;
if (dist[to] > graph[u][i].second + dist[u]) {
s.erase(s.find({dist[to], to}));
dist[to] = dist[u] + graph[u][i].second;
s.insert({dist[to], to});
}
}
}
return;
}
int main(void) {
cin >> n >> m;
for (int i = 0; i < m; i++) {
long long u, v, w;
cin >> u >> v >> w;
w = w * 2;
graph[u].push_back({v, w});
graph[v].push_back({u, w});
}
for (int i = 1; i <= n; i++) cin >> dist[i];
djistra();
for (int i = 1; i <= n; i++) cout << dist[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
struct Node {
int next, to;
long long dis;
} edge[N];
int Head[N], tot;
int n, m;
void Add(int x, int y, long long z) {
edge[++tot].to = y;
edge[tot].next = Head[x];
edge[tot].dis = z;
Head[x] = tot;
}
struct Edge {
long long dis;
int num;
Edge(int x, long long y) {
num = x;
dis = y;
}
bool operator<(const Edge& a) const { return a.dis < dis; }
};
long long dis[N];
int vis[N];
priority_queue<Edge> q;
void dijkstra(int x) {
for (int i = 1; i <= n + 1; ++i) dis[i] = 2e13;
memset(vis, 0, sizeof(vis));
q.push(Edge(x, 0));
dis[x] = 0;
while (!q.empty()) {
Edge top = q.top();
q.pop();
if (vis[top.num]) continue;
vis[top.num] = 1;
int u = top.num;
for (int i = Head[u]; i; i = edge[i].next) {
int v = edge[i].to;
if (dis[v] > dis[u] + edge[i].dis) {
dis[v] = dis[u] + edge[i].dis;
q.push(Edge(v, dis[v]));
}
}
}
}
long long cost[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
int x, y;
long long z;
scanf("%d%d%lld", &x, &y, &z);
Add(x, y, 2 * z);
Add(y, x, 2 * z);
}
for (int i = 1; i <= n; ++i) {
scanf("%lld", &cost[i]);
Add(n + 1, i, cost[i]);
}
dijkstra(n + 1);
for (int i = 1; i <= n; ++i) printf("%lld ", dis[i]);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<string> split(const string& s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) v.emplace_back(x);
return move(v);
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cerr << it->substr((*it)[0] == ' ', it->length()) << " = " << a << '\t';
err(++it, args...);
}
const int NN = 2e5 + 2;
long long int a[NN];
vector<int> adj[NN];
vector<long long int> cost[NN];
bool solved[NN];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, i, j, k, u, v;
cin >> n >> m;
long long int c, b;
for (i = 0; i < m; i++) {
cin >> u >> v >> c;
adj[u].push_back(v);
adj[v].push_back(u);
cost[u].push_back(c);
cost[v].push_back(c);
}
set<pair<long long int, int>> cont;
long long int ans[n + 2];
for (i = 1; i < n + 1; i++) {
cin >> a[i];
cont.insert({a[i], i});
ans[i] = a[i];
}
while (!cont.empty()) {
auto it = cont.begin();
u = (*it).second;
c = (*it).first;
ans[u] = c;
cont.erase(it);
solved[u] = 1;
for (i = 0; i < adj[u].size(); i++) {
v = adj[u][i];
if (!solved[v] && c + 2 * cost[u][i] < ans[v]) {
it = cont.find({ans[v], v});
cont.erase(it);
ans[v] = c + 2 * cost[u][i];
cont.insert({ans[v], v});
}
}
}
for (i = 1; i < n + 1; i++) cout << ans[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = (long long)1e9 + 10;
const long long linf = (long long)1e18 + 10;
const long long mod = (long long)(1e9 + 7);
const long long dx[] = {0, 1, 0, -1};
const long long dy[] = {1, 0, -1, 0};
const long long ddx[] = {0, 1, 1, 1, 0, -1, -1, -1};
const long long ddy[] = {1, 1, 0, -1, -1, -1, 0, 1};
const double eps = 1e-10;
struct oreno_initializer {
oreno_initializer() {
cin.tie(0);
ios::sync_with_stdio(0);
}
} oreno_initializer;
long long n, m, l, r, c, a[200200], d[200200];
vector<pair<long long, long long>> e[200200];
void dijkstra(vector<pair<long long, long long>> g[]) {
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
que;
for (long long(i) = (0); (i) < (n); ++(i)) d[i] = a[i], que.push({a[i], i});
while (!que.empty()) {
pair<long long, long long> p = que.top();
que.pop();
long long v = p.second, dis = p.first;
if (d[v] < dis) continue;
for (long long i = 0; i < g[v].size(); ++i) {
long long to = g[v][i].first, cost = g[v][i].second;
if (d[to] > d[v] + cost) {
d[to] = d[v] + cost;
que.push(make_pair(d[to], to));
}
}
}
}
signed main() {
cin >> n >> m;
for (long long(i) = (0); (i) < (m); ++(i)) {
cin >> l >> r >> c;
l--, r--, c *= 2;
e[l].push_back({r, c}), e[r].push_back({l, c});
}
for (long long(i) = (0); (i) < (n); ++(i)) cin >> a[i];
dijkstra(e);
for (long long(i) = (0); (i) < (n); ++(i))
cout << d[i] << (i == n - 1 ? '\n' : ' ');
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e5 + 10;
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 * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
long long n, m;
vector<pair<long long, long long> > G[MAXN];
bool vis[MAXN];
long long dis[MAXN];
void dijkstra() {
priority_queue<pair<long long, long long> > q;
for (long long i = 1; i <= n; i++) {
dis[i] = 1e18;
}
q.push(make_pair(0, 0));
dis[0] = 0;
while (!q.empty()) {
long long u = q.top().second;
q.pop();
if (!vis[u]) {
vis[u] = 1;
for (long long i = 0; i < G[u].size(); i++) {
long long v = G[u][i].first;
if (dis[v] > dis[u] + G[u][i].second) {
dis[v] = dis[u] + G[u][i].second;
q.push(make_pair(-dis[v], v));
}
}
}
}
}
signed main() {
long long i;
n = read(), m = read();
for (i = 1; i <= m; i++) {
long long x = read(), y = read(), z = read();
z = z << 1;
G[x].push_back(make_pair(y, z));
G[y].push_back(make_pair(x, z));
}
for (i = 1; i <= n; i++) {
long long z = read();
G[0].push_back(make_pair(i, z));
}
dijkstra();
for (i = 1; i <= n; i++) {
printf("%lld ", dis[i]);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5, M = 1e5 + 5, OO = 1e15;
vector<pair<long long, long long>> d[N];
long long dis[N];
long long previ[N], c[N];
bitset<N> visited;
void dijkstra(long long src) {
dis[src] = c[src];
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
q;
q.push({c[src], src});
while (!q.empty()) {
long long u = q.top().second;
long long uc = q.top().first;
q.pop();
visited[u] = 1;
if (dis[u] != uc) continue;
for (auto neig : d[u]) {
long long oo = neig.first;
long long v = neig.second;
if (dis[v] > dis[u] + oo) {
dis[v] = min(dis[u] + oo, c[v]);
q.push({dis[v], v});
}
}
}
}
int main() {
long long u, v, n, m, cost;
visited.reset();
cin >> n >> m;
for (long long i = 0; i < m; i++) {
cin >> u >> v >> cost;
u--, v--;
cost *= 2;
d[u].push_back({cost, v});
d[v].push_back({cost, u});
}
for (int i = 0; i < n; i++) {
cin >> cost;
c[i] = cost;
}
fill(dis, dis + N, OO);
for (int i = 0; i < n; i++) {
if (!visited[i]) {
dijkstra(i);
}
}
for (int i = 0; i < n; i++) {
cout << dis[i] << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
vector<vector<pair<long long, long long>>> adj;
vector<long long> dist;
vector<bool> visited;
void djikstra(long long src) {
set<pair<long long, long long>> s;
s.insert({0, src});
while (!s.empty()) {
long long u = s.begin()->second;
s.erase(s.begin());
if (visited[u])
continue;
else
visited[u] = true;
for (auto x : adj[u]) {
long long v = x.first;
long long w = x.second;
if (dist[v] > (dist[u] + w)) {
dist[v] = dist[u] + w;
s.insert({dist[v], v});
}
}
}
}
void solve() {
long long n, m;
cin >> n >> m;
adj.resize(n + 1);
dist.resize(n + 1, LLONG_MAX);
visited.resize(n + 1, false);
for (long long i = 0; i < m; ++i) {
long long u, v, w;
cin >> u >> v >> w;
adj[u].push_back({v, 2 * w});
adj[v].push_back({u, 2 * w});
}
for (long long i = 0; i < n; ++i) {
long long temp;
cin >> temp;
adj[0].push_back({i + 1, temp});
}
dist[0] = 0;
djikstra(0);
for (long long i = 1; i <= n; ++i) {
cout << dist[i] << " ";
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
long long i, j;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
vector<pair<long long, long long> > g[N];
bool vis[N];
long long dist[N];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m;
cin >> n >> m;
for (long long i = 1; i <= m; i++) {
long long u, v, w;
cin >> u >> v >> w;
w *= 2;
g[u].push_back({w, v});
g[v].push_back({w, u});
}
set<pair<long long, long long> > s;
for (long long i = 1; i <= n; i++) {
cin >> dist[i];
s.insert({dist[i], i});
}
while (!s.empty()) {
cout << "\n\n\n";
pair<long long, long long> front = *s.begin();
s.erase(front);
long long cur_weight = front.first;
long long cur_node = front.second;
if (vis[cur_node]) {
continue;
}
vis[cur_node] = true;
for (pair<long long, long long> p : g[cur_node]) {
long long edge_weight = p.first;
long long next_node = p.second;
if (edge_weight + dist[cur_node] < dist[next_node]) {
dist[next_node] = edge_weight + dist[cur_node];
s.insert({dist[next_node], next_node});
}
}
}
for (long long i = 1; i <= n; i++) cout << dist[i] << " ";
cout << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
class Compare {
public:
bool operator()(pair<long long, int> x, pair<long long, int> y) {
return x.first > y.first;
}
};
vector<long long> mat[200010], cost[200010];
long long dis[200010];
priority_queue<pair<long long, int>, vector<pair<long long, int> >, Compare>
que;
int n, m;
void dijkstra(int p) {
dis[p] = 0;
que.push(make_pair(dis[p], p));
while (!que.empty()) {
pair<long long, int> use = que.top();
p = use.second;
que.pop();
if (use.first != dis[p]) continue;
for (int i = 0; i <= (int)mat[p].size() - 1; i++) {
int x = mat[p][i];
if (dis[x] > dis[p] + cost[p][i]) {
dis[x] = dis[p] + cost[p][i];
que.push(make_pair(dis[x], x));
}
}
}
return;
}
void prin() {
for (int i = 1; i <= n; i++) cout << dis[i] << ' ';
cout << endl;
}
void dijkstra_input() {
long long x, y, z;
for (int i = 1; i <= m; i++) {
cin >> x >> y >> z;
mat[x].push_back(y);
cost[x].push_back(z + z);
mat[y].push_back(x);
cost[y].push_back(z + z);
}
long long v = 1000000000000000000;
for (int i = 1; i <= n; i++) {
cin >> x;
mat[0].push_back(i);
cost[0].push_back(x);
mat[i].push_back(0);
cost[i].push_back(x);
dis[i] = v;
}
dijkstra(0);
prin();
return;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
dijkstra_input();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mx = 2e5 + 10;
struct E {
long long v, w;
};
struct Q {
long long u, sum;
bool operator<(Q b) const { return sum > b.sum; }
};
vector<E> G[mx];
long long val[mx];
long long dis[mx];
long long n, m;
int inq[mx];
void spfa() {
priority_queue<Q> q;
for (int i = 1; i <= n; ++i) dis[i] = val[i], q.push({i, val[i]}), inq[i] = 0;
while (!q.empty()) {
Q p = q.top();
q.pop();
if (!inq[p.u]) {
inq[p.u] = 1;
for (auto V : G[p.u]) {
long long v = V.v, w = V.w;
if (p.sum + w < dis[v]) {
dis[v] = p.sum + w;
q.push({v, p.sum + w});
}
}
}
}
}
int main() {
int ok = 0;
scanf("%lld%lld", &n, &m);
for (int i = 1; i <= m; ++i) {
long long u, v, w;
scanf("%lld%lld%lld", &u, &v, &w);
G[u].push_back({v, 2 * w});
G[v].push_back({u, 2 * w});
}
for (int i = 1; i <= n; ++i) scanf("%lld", &val[i]);
spfa();
for (int i = 1; i <= n; ++i) printf("%lld ", dis[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 200001;
int n, m;
long long dist[MX];
vector<pair<long long, long long>> adj[MX];
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
p;
void dijkstra() {
while (!p.empty()) {
pair<long long, long long> x = p.top();
p.pop();
if (x.first != dist[x.second]) continue;
for (auto y : adj[x.second]) {
if (dist[y.first] > x.first + 2 * y.second) {
dist[y.first] = x.first + 2 * y.second;
p.push(pair<long long, long long>(dist[y.first], y.first));
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 0; i < m; i++) {
long long v, u, w;
cin >> v >> u >> w;
adj[u].push_back(pair<long long, long long>(v, w));
adj[v].push_back(pair<long long, long long>(u, w));
}
for (int i = 1; i <= n; i++) {
cin >> dist[i];
p.push(pair<long long, long long>(dist[i], i));
}
dijkstra();
for (int i = 1; i <= n; i++) cout << dist[i] << " ";
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long v, w;
};
bool operator<(node a, node b) { return a.w > b.w; }
const int N = 2e5 + 10;
vector<node> g[N];
priority_queue<node> q;
bool vis[N];
long long dis[N];
int main() {
int n, m;
while (scanf("%d%d", &n, &m) == 2) {
memset(vis, 0, sizeof(vis));
memset(dis, 0, sizeof(dis));
node t;
long long a, b, c;
for (int i = 0; i < m; i++) {
scanf("%lld%lld%lld", &a, &b, &c);
t.v = b;
t.w = 2 * c;
g[a].push_back(t);
t.v = a;
g[b].push_back(t);
}
while (!q.empty()) q.pop();
for (int i = 1; i <= n; i++) {
scanf("%lld", &a);
dis[i] = a;
t.v = i;
t.w = a;
q.push(t);
}
while (!q.empty()) {
node t = q.top();
q.pop();
if (vis[t.v]) continue;
vis[t.v] = 1;
for (int i = 0; i < g[t.v].size(); i++) {
long long to = g[t.v][i].v;
if (!vis[to] && dis[to] > t.w + g[t.v][i].w) {
dis[to] = t.w + g[t.v][i].w;
node p;
p.v = to;
p.w = dis[to];
q.push(p);
}
}
}
for (int i = 1; i <= n; i++) {
printf("%lld ", dis[i]);
}
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10, mod = 1e9 + 7;
vector<pair<long long, long long> > g[N];
long long a[N], dis[N];
set<pair<long long, long long> > s;
void bfs() {
while (s.size()) {
auto x = *s.begin();
s.erase(s.begin());
int u = x.second;
long long d = x.first;
for (auto y : g[u]) {
if (dis[y.first] > d + 2ll * y.second) {
s.erase({dis[y.first], y.first});
dis[y.first] = d + 2ll * y.second;
s.insert({dis[y.first], y.first});
}
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
long long w;
cin >> u >> v >> w;
u--;
v--;
g[u].push_back({v, w});
g[v].push_back({u, w});
}
for (int i = 0; i < n; i++) {
cin >> a[i];
dis[i] = a[i];
s.insert({dis[i], i});
}
bfs();
for (int i = 0; i < n; i++) cout << dis[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double PI = acosl(-1);
bool compare_int(int a, int b) { return (a > b); }
bool compare_string(string a, string b) { return a.size() < b.size(); }
bool compare_pair(const pair<int, int> &a, const pair<int, int> &b) {
if (a.second == b.second)
return a.first < b.first;
else
return (a.second > b.second);
}
bool cmp(pair<string, int> x, pair<string, int> y) {
return (x.second < y.second);
}
void NA() {
printf("NO\n");
exit(0);
}
void YA() {
printf("YES\n");
exit(0);
}
const int N = 2e5 + 5;
long long int dis[N], a[N];
vector<pair<int, long long int> > g[N];
int n, m;
void dijkstra() {
priority_queue<pair<long long int, int> > pq;
for (int i = 0; i < n; i++) {
dis[i] = a[i];
pq.push({-dis[i], i});
}
while (!pq.empty()) {
auto t = pq.top();
pq.pop();
int u = t.second;
long long int d = -t.first;
if (dis[u] < d) continue;
for (auto it : g[u]) {
int v = it.first;
long long int w = it.second;
if (dis[v] > dis[u] + w) {
dis[v] = dis[u] + w;
pq.push({-dis[v], v});
}
}
}
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int u, v, w;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> u >> v >> w;
u--, v--;
w *= 2;
g[u].push_back({v, w});
g[v].push_back({u, w});
}
for (int i = 0; i < n; i++) cin >> a[i];
dijkstra();
for (int i = 0; i < n; i++) cout << dis[i] << ' ';
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int const N = 200020;
int nodes, edge;
vector<tuple<int, long long, bool> > graph[N];
priority_queue<pair<long long, int> > q;
long long cost[N], best[N];
bool vis[N];
void dfs() {
while (!q.empty()) {
int node = q.top().second;
long long curr = -q.top().first;
q.pop();
if (vis[node]) continue;
vis[node] = 1;
for (int i = 0; i < graph[node].size(); i++) {
tuple<int, long long, bool> el = graph[node][i];
if (2 * get<1>(el) + curr < best[get<0>(el)]) {
best[get<0>(el)] = 2 * get<1>(el) + curr;
q.push(make_pair(-best[get<0>(el)], get<0>(el)));
}
}
}
}
int main() {
scanf("%d%d", &nodes, &edge);
for (int i = 0; i < edge; i++) {
int temp, temp1;
long long c;
scanf("%d%d%lld", &temp, &temp1, &c);
temp--;
temp1--;
graph[temp].push_back(make_tuple(temp1, c, 0));
graph[temp1].push_back(make_tuple(temp, c, 0));
}
for (int i = 0; i < nodes; i++) {
scanf("%lld", best + i);
q.push(make_pair(-best[i], i));
}
dfs();
for (int i = 0; i < nodes; i++) {
printf("%lld ", best[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, E;
vector<vector<pair<int, long long>>> AdjList;
int main() {
cin >> N >> E;
AdjList.assign(N, vector<pair<int, long long>>());
for (int i = 0; i < E; i++) {
int u, v;
long long c;
cin >> u >> v >> c;
u--, v--;
AdjList[u].push_back({v, 2 * c});
AdjList[v].push_back({u, 2 * c});
}
vector<unsigned long long> dist(N, LONG_LONG_MAX);
for (int i = 0; i < N; i++) cin >> dist[i];
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
pq;
for (int i = 0; i < N; i++) pq.push({dist[i], i});
while (!pq.empty()) {
pair<long long, int> front = pq.top();
pq.pop();
long long d = front.first;
int u = front.second;
if (d > dist[u]) continue;
for (auto j : AdjList[u]) {
pair<int, long long> v = j;
if (dist[u] + v.second < dist[v.first]) {
dist[v.first] = dist[u] + v.second;
pq.push({dist[v.first], v.first});
}
}
}
for (int i = 0; i < N; i++) cout << dist[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
struct Neighbour {
int index;
long long int cost;
};
void RelaxCostsDFS(std::vector<std::vector<Neighbour>> neighbours,
std::vector<long long int>& costs, const int index) {
for (auto& neighbour : neighbours[index]) {
if (neighbour.cost * 2 + costs[index] < costs[neighbour.index]) {
costs[neighbour.index] = neighbour.cost * 2 + costs[index];
RelaxCostsDFS(neighbours, costs, neighbour.index);
}
}
}
int main() {
int n;
int m;
std::cin >> n >> m;
std::vector<std::vector<Neighbour>> neighbours(n);
for (int i = 0; i < m; ++i) {
int v, u;
long long int w;
std::cin >> v >> u >> w;
--v;
--u;
neighbours[v].push_back({u, w});
neighbours[u].push_back({v, w});
}
std::vector<long long int> costs(n);
std::set<std::pair<long long int, int>> costs_indices;
for (int i = 0; i < n; ++i) {
std::cin >> costs[i];
costs_indices.insert({costs[i], i});
}
while (costs_indices.size() > 0) {
auto cur_pair = *costs_indices.begin();
int index = cur_pair.second;
costs_indices.erase(cur_pair);
for (auto& neighbour : neighbours[index]) {
if (costs[neighbour.index] > costs[index] + 2 * neighbour.cost) {
costs_indices.erase({costs[neighbour.index], neighbour.index});
costs[neighbour.index] = costs[index] + 2 * neighbour.cost;
costs_indices.insert({costs[neighbour.index], neighbour.index});
}
}
}
for (int i = 0; i < n; ++i) {
std::cout << costs[i];
if (i + 1 < n) {
std::cout << " ";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m;
vector<vector<pair<long long, long long> > > adj;
vector<long long> dis;
class comp {
public:
bool operator()(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return a.first > b.first;
}
};
void dijkstra() {
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >, comp>
pal;
for (long long i = 1; i <= n; i++) pal.push({dis[i], i});
while (!pal.empty()) {
long long u = pal.top().second;
pal.pop();
for (auto x : adj[u]) {
long long v = x.first;
long long wt = x.second;
if (dis[v] > dis[u] + wt) {
dis[v] = dis[u] + wt;
pal.push({dis[v], v});
}
}
}
for (long long i = 1; i <= n; i++) cout << dis[i] << " ";
}
void dijkstra_sets() {
set<pair<long long, long long> > baby;
for (long long i = 1; i <= n; i++) baby.insert({dis[i], i});
while (!baby.empty()) {
long long u = baby.begin()->second;
baby.erase(baby.begin());
for (auto x : adj[u]) {
long long v = x.first;
long long wt = x.second;
if (dis[v] > dis[u] + wt) {
baby.erase({dis[v], v});
dis[v] = dis[u] + wt;
baby.insert({dis[v], v});
}
}
}
for (long long i = 1; i <= n; i++) cout << dis[i] << " ";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
adj.resize(n + 1);
for (long long i = 1; i <= m; i++) {
long long u, v, w;
cin >> u >> v >> w;
adj[u].push_back({v, 2 * w});
adj[v].push_back({u, 2 * w});
}
dis.resize(n + 1);
for (long long i = 1; i <= n; i++) cin >> dis[i];
dijkstra_sets();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<bool> visited;
vector<long long int> dis;
vector<long long int> cost;
void dijkstras(long long int u, vector<pair<long long int, long long int>>* adj,
long long int n) {
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>>>
heap;
for (long long int i = 0; i < n; i++) {
heap.push({dis[i], i});
}
while (!heap.empty()) {
pair<long long int, long long int> x = heap.top();
heap.pop();
if (visited[x.second]) continue;
visited[x.second] = true;
for (long long int i = 0; i < adj[x.second].size(); i++) {
if (dis[adj[x.second][i].first] > x.first + 2 * adj[x.second][i].second) {
dis[adj[x.second][i].first] = x.first + 2 * adj[x.second][i].second;
if (dis[adj[x.second][i].first] != 1e18)
heap.push({dis[adj[x.second][i].first], adj[x.second][i].first});
}
}
}
}
int main() {
long long int n, m;
cin >> n >> m;
vector<pair<long long int, long long int>> adj[n];
for (long long int i = 0; i < m; i++) {
long long int x, y, z;
cin >> x >> y >> z;
adj[x - 1].push_back({y - 1, z});
adj[y - 1].push_back({x - 1, z});
}
dis.resize(n);
cost.resize(n);
visited.assign(n, false);
long long int source = -1;
long long int maxcost = 1e18;
for (long long int i = 0; i < n; i++) {
cin >> cost[i];
dis[i] = cost[i];
if (dis[i] < maxcost) {
source = i;
maxcost = dis[i];
}
}
dijkstras(source, adj, n);
for (long long int i = 0; i < n; i++) {
cout << dis[i] << " ";
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
priority_queue<pair<long long, long long>> q;
long long ans[200010];
bool col[200010];
vector<pair<long long, long long>> adj[200010];
int main() {
long long n, m, a, b, c;
scanf("%lld %lld", &n, &m);
while (m--) {
scanf("%lld %lld %lld", &a, &b, &c);
adj[a].push_back({b, -c});
adj[b].push_back({a, -c});
}
for (long long i = 1; i <= n; i++) {
scanf("%lld", &c);
q.push({-c, i});
}
pair<long long, long long> u, v;
while (!q.empty()) {
u = q.top();
q.pop();
if (ans[u.second]) continue;
ans[u.second] = -u.first;
col[u.second] = true;
for (auto nowNode : adj[u.second]) {
v.second = nowNode.first;
v.first = u.first + 2ll * nowNode.second;
q.push(v);
}
}
for (long long i = 1; i <= n; i++) printf("%lld ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long int, long long int> > v[500001];
long long int dist[500001];
class comp {
public:
bool operator()(pair<long long, long long> a, pair<long long, long long> b) {
return a.second > b.second;
}
};
int main() {
std::ios::sync_with_stdio(false);
int T;
T = 1;
while (T--) {
long long int n, i, j, m, a, b, c;
cin >> n >> m;
while (m > 0) {
cin >> a >> b >> c;
v[a].push_back({b, c});
v[b].push_back({a, c});
--m;
}
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >, comp>
pq;
long long int ar[n + 1];
for (i = 1; i <= n; ++i) {
cin >> ar[i];
pq.push({i, ar[i]});
dist[i] = ar[i];
}
pair<long long int, long long int> x;
while (!pq.empty()) {
x = pq.top();
pq.pop();
if (dist[x.first] < x.second) continue;
for (i = 0; i < v[x.first].size(); ++i) {
if (2 * v[x.first][i].second + x.second < dist[v[x.first][i].first]) {
dist[v[x.first][i].first] = x.second + 2 * v[x.first][i].second;
pq.push({v[x.first][i].first, dist[v[x.first][i].first]});
}
}
}
for (i = 1; i <= n; ++i) cout << dist[i] << " ";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
const int maxn = 2e5 + 6;
const double eps = 1e-6;
using namespace std;
bool eq(const double &a, const double &b) { return fabs(a - b) < eps; }
bool ls(const double &a, const double &b) { return a + eps < b; }
bool le(const double &a, const double &b) { return eq(a, b) || ls(a, b); }
long long gcd(long long a, long long b) { return a == 0 ? b : gcd(b % a, a); };
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long kpow(long long a, long long b) {
long long res = 1;
a %= mod;
if (b < 0) return 1;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
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 * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, m;
int v[maxn];
long long dis[maxn];
long long a[maxn];
vector<pair<long long, int> > G[maxn];
void dij() {
memset(v, false, sizeof(v));
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
while (q.size()) q.pop();
for (int i = 1; i < (n + 1); ++i)
dis[i] = 1e18 + 9, G[n + 1].push_back(make_pair(a[i], i));
q.push(make_pair(0, n + 1));
while (!q.empty()) {
pair<long long, int> u = q.top();
q.pop();
if (v[u.second]) continue;
v[u.second] = 1;
for (int j = 0; j < (G[u.second].size()); ++j) {
int vs = G[u.second][j].second;
int us = u.second;
if (!v[vs] && dis[vs] > G[u.second][j].first + dis[us]) {
dis[vs] = G[u.second][j].first + dis[us];
q.push(make_pair(dis[vs], vs));
}
}
}
for (int i = 1; i < (n + 1); ++i) printf("%lld%c", dis[i], " \n"[i == n]);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < (m); ++i) {
int u, v;
long long c;
scanf("%d%d%lld", &u, &v, &c);
G[u].push_back(make_pair(2 * c, v));
G[v].push_back(make_pair(2 * c, u));
}
for (int i = 1; i < (n + 1); ++i) scanf("%lld", &a[i]);
dij();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
q;
stringstream ssin;
const long long LINF = 0x7fffffffffffffffll;
const long long N = 1e6 + 5, M = 2e6 + 5, mod = 1e9 + 7, INF = 0x3f3f3f3f;
long long n, m, idx;
long long e[M], ne[M], w[M], h[N];
long long a[N], d[N];
bool vis[N];
inline long long read() {
char c = getchar();
long long x = 0, f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
void add(long long a, long long b, long long c) {
e[idx] = b;
w[idx] = c;
ne[idx] = h[a];
h[a] = idx++;
}
void dij() {
for (int i = 1; i < N; ++i) d[i] = 1e18;
q.push({0, 0});
d[0] = 0;
while (!q.empty()) {
pair<long long, long long> t = q.top();
q.pop();
int u = t.second;
if (vis[u]) continue;
vis[u] = 1;
for (int i = h[u]; ~i; i = ne[i]) {
long long v = e[i], z = w[i];
if (d[u] + z < d[v]) {
d[v] = d[u] + z;
q.push({d[v], v});
}
}
}
}
int main() {
n = read();
m = read();
memset(h, -1, sizeof h);
;
for (int i = 1; i <= m; ++i) {
long long u, v, w;
u = read();
v = read();
w = read();
u++;
v++;
w = w * 2;
add(u, v, w);
add(v, u, w);
}
for (int i = 2; i <= n + 1; ++i) {
a[i] = read();
add(0, i, a[i]);
add(i, 0, a[i]);
}
dij();
for (int i = 2; i <= n + 1; ++i) cout << d[i] << " ";
puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200050;
struct jz {
int u;
long long dis;
jz(const int &U = 0, const long long &D = 0) : u(U), dis(D) {}
bool operator<(const jz &X) const { return dis > X.dis; }
};
int n, m;
int fir[MAXN], eNd[MAXN << 1], nExt[MAXN << 1], ed = 0;
bool vis[MAXN];
long long dis[MAXN], len[MAXN << 1];
template <typename Ty>
void read1n(Ty &x) {
char ch = getchar();
while (ch < '0' || '9' < ch) ch = getchar();
for (x = 0; '0' <= ch && ch <= '9'; ch = getchar())
x = (x << 1) + (x << 3) + ch - '0';
return;
}
void addedge(int u, int v, long long w) {
eNd[++ed] = v;
nExt[ed] = fir[u];
fir[u] = ed;
len[ed] = w;
eNd[++ed] = u;
nExt[ed] = fir[v];
fir[v] = ed;
len[ed] = w;
return;
}
int main() {
int u, v;
long long w;
priority_queue<jz> q;
memset(vis, false, sizeof(vis));
read1n(n);
read1n(m);
for (int i = 1; i <= m; i++) {
read1n(u);
read1n(v);
read1n(w);
addedge(u, v, w * 2LL);
}
for (int i = 1; i <= n; i++) {
read1n(dis[i]);
q.push(jz(i, dis[i]));
}
for (int cnt = 1; cnt <= n; cnt++) {
while (vis[q.top().u] || dis[q.top().u] != q.top().dis) q.pop();
u = q.top().u;
q.pop();
vis[u] = true;
for (int i = fir[u]; i; i = nExt[i])
if (dis[u] + len[i] < dis[eNd[i]]) {
dis[eNd[i]] = dis[u] + len[i];
q.push(jz(eNd[i], dis[eNd[i]]));
}
}
for (int i = 1; i <= n; i++) cout << dis[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 1000;
typedef pair<long long, long long> P;
struct edge {
long long to, cost;
};
vector<edge> g[maxn];
long long vis[maxn];
long long dis[maxn];
long long n, m;
void dijkstra() {
long long s = 0;
memset(dis, 0x3f, sizeof(dis));
dis[s] = 0;
memset(vis, 0, sizeof(vis));
priority_queue<P, vector<P>, greater<P> > que;
que.push({0, s});
while (!que.empty()) {
P p = que.top();
que.pop();
int v = p.second;
if (vis[v]) continue;
vis[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
edge e = g[v][i];
if (dis[e.to] > dis[v] + e.cost) {
dis[e.to] = dis[v] + e.cost;
que.push({dis[e.to], e.to});
}
}
}
}
int main(void) {
cin.tie(0);
std::ios::sync_with_stdio(false);
cin >> n >> m;
for (long long i = 1; i <= m; i++) {
long long x, y, c;
cin >> x >> y >> c;
g[x].push_back({y, 2 * c});
g[y].push_back({x, 2 * c});
}
for (long long i = 1; i <= n; i++) {
long long _c;
cin >> _c;
g[0].push_back({i, _c});
}
dijkstra();
for (long long i = 1; i <= n; i++) {
cout << dis[i] << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int to[N << 2], nex[N << 2], beg[N], cnt;
long long w[N << 2], a[N], dis[N];
int vis[N];
int n, m;
void addedge(int u, int v, long long wt) {
to[++cnt] = v;
nex[cnt] = beg[u];
w[cnt] = wt;
beg[u] = cnt;
}
void dijkstra(int u) {
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
q;
dis[u] = 0;
q.push(pair<long long, long long>(0, u));
while (!q.empty()) {
pair<long long, long long> tmp = q.top();
q.pop();
if (vis[tmp.second] == 1) {
continue;
}
vis[tmp.second] = 1;
for (int i = beg[tmp.second]; i; i = nex[i]) {
int v = to[i];
if (dis[v] > dis[tmp.second] + w[i]) {
dis[v] = dis[tmp.second] + w[i];
q.push(pair<long long, long long>(dis[v], v));
}
}
}
}
int main() {
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);
addedge(u, v, w * 2);
addedge(v, u, w * 2);
}
for (int i = 1; i <= n; i++) {
scanf("%lld", a + i);
addedge(0, i, a[i]);
}
memset(dis, 0x3f, sizeof(dis));
dijkstra(0);
for (int i = 1; i <= n; i++) {
printf("%lld ", dis[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pll = pair<ll, ll>;
const ll MOD = 1e9 + 7;
vector<vector<pll>> edges;
void solve() {
ll n, m;
cin >> n >> m;
edges.resize(n);
for (int i = 0, _n = (m); i < _n; i++) {
ll u, v, w;
cin >> u >> v >> w;
u--;
v--;
edges[u].push_back({v, w});
edges[v].push_back({u, w});
}
vector<long long> a(n), ans;
for (int i = 0, _n = (n); i < _n; i++) cin >> a[i];
ans = a;
set<pll> second;
map<ll, ll> make_pair;
for (int i = 0, _n = (n); i < _n; i++) {
second.insert({a[i], i});
make_pair[i] = a[i];
}
vector<bool> vis(n, 0);
while (!second.empty()) {
auto root = *(second.begin());
second.erase(second.begin());
for (auto& child : edges[root.second]) {
if (vis[child.first]) continue;
ll to = child.first;
ll wt = child.second;
if (2 * wt + root.first < make_pair[to]) {
second.erase({make_pair[to], to});
make_pair[to] = 2 * wt + root.first;
second.insert({make_pair[to], to});
}
}
vis[root.second] = 1;
}
for (auto& elem : make_pair) {
cout << elem.second << ' ';
}
cout << '\n';
return;
}
int main(int argc, char** argv) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200 * 1000 + 13;
const long long INF64 = 1e18;
int n, m;
long long a[N];
vector<pair<int, long long>> g[N];
long long dist[N];
void Dijkstra() {
set<pair<long long, int>> q;
for (int i = 0; i < int(n); i++) {
dist[i] = a[i];
q.insert({dist[i], i});
}
while (!q.empty()) {
int v = q.begin()->second;
q.erase(q.begin());
for (auto it : g[v]) {
int u = it.first;
long long w = it.second;
if (dist[u] > dist[v] + w) {
q.erase({dist[u], u});
dist[u] = dist[v] + w;
q.insert({dist[u], u});
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int _ = 0; _ < int(m); _++) {
int f, t;
long long w;
scanf("%d%d%lld", &f, &t, &w);
--f, --t;
w *= 2;
g[f].push_back({t, w});
g[t].push_back({f, w});
}
for (int i = 0; i < int(n); i++) {
scanf("%lld", &a[i]);
}
Dijkstra();
for (int i = 0; i < int(n); i++) printf("%lld ", dist[i]);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
vector<vector<pair<long long, long long>>> adj;
vector<long long> dist;
vector<bool> visited;
void djikstra(long long src) {
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
s;
s.push({0, src});
while (!s.empty()) {
long long u = s.top().second;
long long d_u = dist[u];
s.pop();
if (visited[u])
continue;
else
visited[u] = true;
for (auto x : adj[u]) {
long long v = x.first;
long long w = x.second;
if (dist[v] > (dist[u] + w)) {
dist[v] = dist[u] + w;
s.push({dist[v], v});
}
}
}
}
void solve() {
long long n, m;
cin >> n >> m;
adj.resize(n + 1);
dist.resize(n + 1, LLONG_MAX);
visited.resize(n + 1, false);
for (long long i = 0; i < m; ++i) {
long long u, v, w;
cin >> u >> v >> w;
adj[u].push_back({v, 2 * w});
adj[v].push_back({u, 2 * w});
}
for (long long i = 0; i < n; ++i) {
long long temp;
cin >> temp;
adj[0].push_back({i + 1, temp});
}
dist[0] = 0;
djikstra(0);
for (long long i = 1; i <= n; ++i) {
cout << dist[i] << " ";
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
long long i, j;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 200019;
long long n, m, head[maxn], to[maxn * 2], nextt[maxn * 2], w[maxn * 2],
tot = 1, vis[maxn], ans[maxn];
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
q;
void add(long long x, long long y, long long z) {
w[tot] = z;
to[tot] = y;
nextt[tot] = head[x];
head[x] = tot++;
}
int main() {
scanf("%lld%lld", &n, &m);
for (long long i = 1; i <= m; i++) {
long long a, b, c;
scanf("%lld%lld%lld", &a, &b, &c);
add(a, b, 2 * c);
add(b, a, 2 * c);
}
for (long long i = 1; i <= n; i++) {
long long t;
scanf("%lld", &t);
q.push(make_pair(t, i));
}
while (!q.empty()) {
pair<long long, long long> u = q.top();
q.pop();
if (vis[u.second]) continue;
vis[u.second] = 1;
ans[u.second] = u.first;
for (long long i = head[u.second]; i; i = nextt[i]) {
long long v = to[i];
q.push(make_pair(u.first + w[i], v));
}
}
for (long long i = 1; i <= n; i++) printf("%lld ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n, m;
long long dis[maxn];
vector<pair<long long, int> > adj[maxn];
bool mrk[maxn];
set<pair<long long, int> > Q;
void dijkstra() {
for (int i = 1; i <= n; ++i) Q.insert({dis[i], i});
while (!Q.empty()) {
int v = Q.begin()->second;
Q.erase(Q.begin());
if (mrk[v]) continue;
mrk[v] = true;
for (auto i : adj[v]) {
long long w = i.first;
int u = i.second;
if (dis[u] > dis[v] + w) {
dis[u] = dis[v] + w;
Q.insert({dis[u], u});
}
}
}
}
int main() {
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({w + w, v});
adj[v].push_back({w + w, u});
}
for (int i = 1; i <= n; ++i) scanf("%lld", &dis[i]);
dijkstra();
for (int i = 1; i <= n; ++i) printf("%lld ", dis[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct cmp {
bool operator()(const pair<int, long long>& a,
const pair<int, long long>& b) const {
return a.second > b.second;
}
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<vector<pair<int, long long> > > g(n);
for (int i = 0; i < m; ++i) {
long long u, v, w;
cin >> u >> v >> w;
--u;
--v;
w *= 2;
g[u].push_back({v, w});
g[v].push_back({u, w});
}
priority_queue<pair<int, long long>, vector<pair<int, long long> >, cmp> q;
vector<long long> d(n);
for (int i = 0; i < n; ++i) {
cin >> d[i];
q.push({i, d[i]});
}
while (!q.empty()) {
pair<int, long long> p = q.top();
q.pop();
long long u = p.first, w = p.second;
if (w == d[u]) {
for (int i = 0; i < g[u].size(); ++i) {
if (d[g[u][i].first] > w + g[u][i].second) {
d[g[u][i].first] = w + g[u][i].second;
q.push({g[u][i].first, d[g[u][i].first]});
}
}
}
}
for (int i = 0; i < n; ++i) cout << d[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 1;
vector<pair<long long, long long> > g[N];
set<pair<long long, long long> > q;
long long dist[N];
int main() {
cin.tie(0);
cout.tie(0);
long long n, m, u, v, w;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> u >> v >> w;
u--;
v--;
w = w * 2;
g[u].push_back({v, w});
g[v].push_back({u, w});
}
for (int i = 0; i < n; i++) {
cin >> dist[i];
q.insert({dist[i], i});
}
while (!q.empty()) {
auto now = *q.begin();
auto u = now.second;
q.erase(q.begin());
for (auto v : g[u]) {
if (dist[v.first] > dist[u] + v.second) {
q.erase({dist[v.first], v.first});
dist[v.first] = dist[u] + v.second;
q.insert({dist[v.first], v.first});
}
}
}
for (int i = 0; i < n; i++) cout << dist[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
long long quickpow(long long a, long long b) {
long long ans = 1;
while (b > 0) {
if (b % 2) ans = ans * a;
b = b / 2;
a = a * a;
}
return ans;
}
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
long long n, m, head[200005], to[200005 * 2], nxt[200005 * 2];
long long w[200005 * 2], tot = 1;
long long vis[200005], ans[200005];
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
q;
void addedge(long long u, long long v, long long val) {
w[tot] = val;
to[tot] = v;
nxt[tot] = head[u];
head[u] = tot++;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (long long i = 1; i <= m; i++) {
long long a, b, c;
cin >> a >> b >> c;
addedge(a, b, 2 * c);
addedge(b, a, 2 * c);
}
for (long long i = 1; i <= n; i++) {
long long t;
cin >> t;
q.push(make_pair(t, i));
}
while (!q.empty()) {
pair<long long, long long> u = q.top();
q.pop();
if (vis[u.second]) continue;
vis[u.second] = 1;
ans[u.second] = u.first;
for (long long i = head[u.second]; i; i = nxt[i]) {
long long v = to[i];
q.push(make_pair(u.first + w[i], v));
}
}
for (long long i = 1; i <= n; i++) {
cout << ans[i] << ' ';
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <typename... Vectors>
void resizeVectors(int newSize, Vectors&... vectors) {
(vectors.resize(newSize), ...);
}
void resizeVectors(int unusedNewSize) {}
template <typename... Vectors>
void readEntryHelper(int i, Vectors&... vectors) {
((cin >> vectors[i]), ...);
}
template <typename... Vectors>
void readVectors(int count, Vectors&... vectors) {
(resizeVectors(count, (vectors, ...)));
for (int i = 0; i < count; ++i) {
(readEntryHelper(i, (vectors, ...)));
}
}
using ll = signed long long;
using ld = long double;
void $main();
int main() {
int numTests = 1;
if (0) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
cin >> numTests;
} else {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
}
for (int i = 0; i < numTests; ++i) {
$main();
if (0) {
cout << "-----\n";
}
}
}
void $main() {
int n, m;
cin >> n >> m;
vector<vector<pair<int, ll>>> g(n);
for (int i = 0; i < m; ++i) {
int u, v;
ll w;
cin >> u >> v >> w;
--u;
--v;
g[u].emplace_back(v, w);
g[v].emplace_back(u, w);
}
vector<ll> a;
readVectors(n, a);
vector<ll> ans(a);
set<pair<ll, int>> q;
for (int i = 0; i < n; ++i) {
q.emplace(ans[i], i);
}
while (q.size()) {
auto ev = *q.begin();
q.erase(ev);
auto [ansv, v] = ev;
if (ansv > ans[v]) continue;
for (auto edge : g[v]) {
ll nans = ans[v] + 2 * edge.second;
ll& cans = ans[edge.first];
if (cans > nans) {
cans = nans;
q.emplace(cans, edge.first);
}
}
}
for (ll x : ans) cout << x << " ";
cout << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-ffloat-store")
#pragma GCC optimize("-fno-defer-pop")
long long int power(long long int a, long long int b, long long int m) {
if (b == 0) return 1;
if (b == 1) return a % m;
long long int t = power(a, b / 2, m) % m;
t = (t * t) % m;
if (b & 1) t = ((t % m) * (a % m)) % m;
return t;
}
long long int modInverse(long long int a, long long int m) {
return power(a, m - 2, m);
}
vector<pair<long long int, long long int> > vc[3000005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int i, j, k, l, n, m;
cin >> n >> m;
long long int a, b, c;
for (i = 1; i <= m; i++) {
cin >> a >> b >> c;
c = c * 2;
vc[a].push_back({b, c});
vc[b].push_back({a, c});
}
long long int ar[n + 1];
for (i = 1; i <= n; i++) {
cin >> ar[i];
}
set<pair<long long int, long long int> > qe;
long long int dt[n + 1];
for (i = 1; i <= n; i++) {
dt[i] = ar[i];
qe.insert({dt[i], i});
}
while (qe.size() > 0) {
pair<long long int, long long int> p = (*qe.begin());
qe.erase(qe.begin());
for (auto it : vc[p.second]) {
long long int v = it.first, w = it.second;
if (dt[v] > dt[p.second] + w) {
qe.erase({dt[v], v});
dt[v] = dt[p.second] + w;
qe.insert({dt[v], v});
}
}
}
for (i = 1; i <= n; i++) {
cout << dt[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
const int maxm = 150005;
const int mod = 100000000;
int n, m;
struct edge {
int to, nxt;
long long len;
} e[4 * maxn];
int head[maxn];
int tot;
void adde(int u, int v, long long l) {
e[tot].to = v;
e[tot].len = l;
e[tot].nxt = head[u];
head[u] = tot++;
}
long long dis[maxn];
bool vis[maxn];
struct node {
int id;
long long dis;
node(int u, long long d) {
id = u;
dis = d;
}
bool operator<(const node b) const { return dis > b.dis; }
};
void dij() {
memset(dis, 0x3f, sizeof(dis));
dis[0] = 0;
priority_queue<node> que;
que.push(node(0, 0));
while (!que.empty()) {
node cnt = que.top();
int u = cnt.id;
que.pop();
if (vis[u]) continue;
vis[u] = 1;
for (int i = head[u]; i != -1; i = e[i].nxt) {
int v = e[i].to;
if (vis[v]) continue;
if (dis[v] > dis[u] + e[i].len) {
dis[v] = dis[u] + e[i].len;
que.push(node(v, dis[v]));
}
}
}
}
long long a, b, c, val;
int main() {
memset(head, -1, sizeof(head));
tot = 0;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%lld%lld%lld", &a, &b, &c);
adde(a, b, 2 * c);
adde(b, a, 2 * c);
}
for (int i = 1; i <= n; i++) {
scanf("%lld", &val);
adde(0, i, val);
}
dij();
for (int i = 1; i <= n; i++) {
printf("%lld ", dis[i]);
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.