text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const int mod = 1e9 + 7;
const int N = 1e3 + 10;
bool vis[N];
long long dist[N], dis[N][N];
int par[N];
vector<int> G[N];
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
q;
long long dijkstra(int node, int lol, int he = 1) {
for (int i = 0; i <= N - 1; ++i) dist[i] = INF;
memset(vis, 0, sizeof(vis));
memset(par, -1, sizeof(par));
dist[node] = 0;
q.push({dist[node], node});
while (!q.empty()) {
int u = q.top().second;
q.pop();
if (vis[u]) continue;
vis[u] = 1;
for (auto p : G[u]) {
if (he == 0 && dis[u][p] == 0) continue;
if (dist[p] > dist[u] + dis[u][p]) {
par[p] = u;
dist[p] = dist[u] + dis[u][p];
q.push({dist[p], p});
}
}
}
return dist[lol];
}
set<pair<int, int> > E;
vector<pair<int, int> > EE;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, m, L, s, t;
cin >> n >> m >> L >> s >> t;
for (int i = 0; i <= m - 1; ++i) {
int u, v, w;
cin >> u >> v >> w;
G[u].push_back(v);
G[v].push_back(u);
dis[u][v] = w;
dis[v][u] = w;
if (!w) E.insert({u, v});
EE.push_back({u, v});
}
long long l = dijkstra(s, t, 0);
if (l < L) {
cout << "NO\n";
return 0;
}
for (auto e : E) {
dis[e.first][e.second] = dis[e.second][e.first] = 1;
}
l = dijkstra(s, t);
if (l > L) {
cout << "NO\n";
return 0;
}
while (l < L) {
int lol = t;
set<pair<int, int> > hehe;
while (lol != s) {
int p = par[lol];
hehe.insert({p, lol});
hehe.insert({lol, p});
lol = p;
}
for (auto it : E) {
if (hehe.find(it) == hehe.end()) {
dis[it.first][it.second] = INF;
dis[it.second][it.first] = INF;
}
}
for (auto it : E) {
if (hehe.find(it) != hehe.end()) {
dis[it.first][it.second] += (L - l);
dis[it.second][it.first] += (L - l);
break;
}
}
l = dijkstra(s, t);
}
cout << "YES\n";
for (auto e : EE) {
cout << e.first << " " << e.second << " " << dis[e.first][e.second] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const int N = 10100;
struct HeapNode {
long long d;
int u;
bool operator<(const HeapNode &u) const { return d > u.d; }
};
struct Edge {
int u, v, claim;
long long cost;
};
int n, m, L, s, t;
int done[N];
long long dis[N];
vector<int> g[N];
vector<Edge> edges;
long long dijkstra(int s, int t) {
memset(done, 0, sizeof done);
for (int i = 0; i < n; ++i) dis[i] = INF;
dis[s] = 0;
priority_queue<HeapNode> q;
q.push((HeapNode){0, s});
while (!q.empty()) {
HeapNode x = q.top();
q.pop();
int u = x.u;
if (done[u]) continue;
done[u] = 1;
for (int i = 0; i < (int)g[u].size(); ++i) {
Edge &e = edges[g[u][i]];
int to = u ^ e.u ^ e.v;
if (!done[to] && dis[to] > dis[u] + e.cost) {
dis[to] = dis[u] + e.cost;
q.push((HeapNode){dis[to], to});
}
}
}
return dis[t];
}
int main() {
cin >> n >> m >> L >> s >> t;
edges.resize(m);
for (int i = 0; i < m; ++i) {
Edge &e = edges[i];
cin >> e.u >> e.v >> e.claim;
if (e.claim != 0) e.cost = e.claim;
g[e.u].push_back(i);
g[e.v].push_back(i);
}
try {
for (int i = 0; i < m; ++i)
if (edges[i].claim == 0) edges[i].cost = INF;
if (dijkstra(s, t) < L) throw 1;
for (int i = 0; i < m; ++i)
if (edges[i].claim == 0) edges[i].cost = 1;
if (dijkstra(s, t) > L) throw 2;
long long now = dijkstra(s, t);
for (int i = 0; i < m; ++i)
if (edges[i].claim == 0) {
edges[i].cost += L - now;
now = dijkstra(s, t);
if (now == L) break;
}
assert(now == L);
puts("YES");
for (int i = 0; i < m; ++i)
cout << edges[i].u << " " << edges[i].v << " " << edges[i].cost << endl;
} catch (int e) {
puts("NO");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 10000000000000000;
const long long maxM = 100000 + 10;
long long d1;
bool er[maxM];
vector<long long> paths1;
struct Edge {
long long from, to;
long long dist;
};
struct HeapNode {
long long d;
long long u;
bool operator<(const HeapNode& rhs) const { return d > rhs.d; }
};
vector<Edge> edges;
vector<long long> G[maxM];
bool done[maxM];
long long d[maxM];
long long p[maxM];
long long id[maxM];
struct Dijkstra {
long long n, m;
void init(long long n) {
this->n = n;
for (long long i = 0; i < n; i++) G[i].clear();
edges.clear();
}
void AddEdge(long long from, long long to, long long dist, long long ff) {
edges.push_back((Edge){from, to, dist});
m = edges.size();
G[from].push_back(m - 1);
id[m - 1] = ff;
}
void dijkstra(long long s) {
priority_queue<HeapNode> Q;
for (long long 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();
long long u = x.u;
if (done[u]) continue;
done[u] = true;
for (long long 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});
}
}
}
}
void GetShortestPaths(long long s, long long u) {
dijkstra(s);
if (d[u] >= INF) {
d1 = d[u];
return;
}
for (long long i = u; i <= u; i++) {
d1 = d[i];
paths1.clear();
long long t = i;
paths1.push_back(t);
while (t != s) {
paths1.push_back(edges[p[t]].from);
t = edges[p[t]].from;
}
reverse(paths1.begin(), paths1.end());
}
}
};
Dijkstra solver;
Edge ei[maxM];
int main() {
long long n, m, s, t;
long long L;
while (~scanf("%lld%lld%lld%lld%lld", &n, &m, &L, &s, &t)) {
memset(er, 0, sizeof(er));
for (long long i = 0; i < m; i++) {
scanf("%lld%lld%lld", &ei[i].from, &ei[i].to, &ei[i].dist);
if (ei[i].dist == 0) er[i] = 1;
}
solver.init(n);
for (long long i = 0; i < m; i++) {
if (er[i]) ei[i].dist = L;
solver.AddEdge(ei[i].from, ei[i].to, ei[i].dist, 0);
solver.AddEdge(ei[i].to, ei[i].from, ei[i].dist, 0);
}
solver.GetShortestPaths(s, t);
if (d1 < L)
printf("NO\n");
else if (d1 == L) {
printf("YES\n");
for (long long i = 0; i < m; i++)
printf("%lld %lld %lld\n", ei[i].from, ei[i].to, ei[i].dist);
} else {
solver.init(n);
for (long long i = 0; i < m; i++) {
if (er[i]) {
ei[i].dist = 1;
solver.AddEdge(ei[i].from, ei[i].to, ei[i].dist, i + 1);
solver.AddEdge(ei[i].to, ei[i].from, ei[i].dist, i + 1);
} else {
solver.AddEdge(ei[i].from, ei[i].to, ei[i].dist, 0);
solver.AddEdge(ei[i].to, ei[i].from, ei[i].dist, 0);
}
}
solver.GetShortestPaths(s, t);
if (d1 > L)
printf("NO\n");
else if (d1 == L) {
printf("YES\n");
for (long long i = 0; i < m; i++)
printf("%lld %lld %lld\n", ei[i].from, ei[i].to, ei[i].dist);
} else {
for (;;) {
long long add = L - d1;
for (long long i = 0; i < paths1.size(); i++) {
long long u = paths1[i];
bool ok = false;
for (long long j = 0; j < G[u].size(); j++) {
long long ee = G[u][j];
if (id[ee] && edges[ee].to == paths1[i + 1]) {
edges[ee].dist += add;
ei[id[ee] - 1].dist = edges[ee].dist;
ok = true;
break;
}
}
if (ok) break;
}
solver.GetShortestPaths(s, t);
if (d1 < L) continue;
printf("YES\n");
for (long long i = 0; i < m; i++) {
printf("%lld %lld %lld\n", ei[i].from, ei[i].to, ei[i].dist);
}
break;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int break_point() {
char c;
while ((c = getchar()) != '\n')
;
return 0;
}
template <typename T>
void read_integer(T &r) {
bool sign = 0;
r = 0;
char c;
while (1) {
c = getchar();
if (c == '-') {
sign = 1;
break;
}
if (c != ' ' && c != '\n') {
r = c - '0';
break;
}
}
while (1) {
c = getchar();
if (c == ' ' || c == '\n') break;
r = r * 10 + (c - '0');
}
if (sign) r = -r;
}
long long binpowmod(long long a, long long b, long long mod) {
if (b == 0) return 1;
long long c = binpowmod(a, b >> 1, mod);
return (((c * c) % mod) * (b & 1 ? a : 1)) % mod;
}
long long binpow(long long a, long long b) {
if (b == 0) return 1;
long long c = binpow(a, b >> 1);
return c * c * (b & 1 ? a : 1);
}
inline int getbit(int x, int b) { return (x >> b) & 1; }
inline int setbit(int x, int b) { return x | (1 << b); }
inline void _setbit(int &x, int b) { x = setbit(x, b); }
inline long long setbit(long long x, int b) { return x | (1ll << b); }
inline void _setbit(long long &x, int b) { x = setbit(x, b); }
inline int unsetbit(int x, int b) { return x & (INT_MAX - (1 << b)); }
inline void _unsetbit(int &x, int b) { x = unsetbit(x, b); }
inline int countbit(int x) {
x = x - ((x >> 1) & 0x55555555);
x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
return ((x + (x >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
}
inline long long countbit(long long x) {
return countbit(int(x & INT_MAX)) + countbit(int(x >> 32) & INT_MAX);
}
inline void printbit(int x, int len) {
for (int i = len - 1; i >= 0; i--) printf("%d", getbit(x, i));
}
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
template <typename A, typename B>
ostream &operator<<(ostream &stream, const pair<A, B> &p) {
stream << "{" << p.first << "," << p.second << "}";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const vector<A> &v) {
stream << "[";
for (auto itr = v.begin(); itr != v.end(); itr++) stream << *itr << " ";
stream << "]";
return stream;
}
template <typename A, typename B>
ostream &operator<<(ostream &stream, const map<A, B> &v) {
stream << "[";
for (auto itr = v.begin(); itr != v.end(); itr++) stream << *itr << " ";
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const set<A> &v) {
stream << "[";
for (auto itr = v.begin(); itr != v.end(); itr++) stream << *itr << " ";
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const stack<A> &v) {
stack<A> st = v;
stream << "[";
while (!st.empty()) {
stream << st.top() << " ";
st.pop();
}
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const priority_queue<A> &v) {
priority_queue<A> q = v;
stream << "[";
while (!q.empty()) {
stream << q.top() << " ";
q.pop();
}
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const queue<A> &v) {
queue<A> q = v;
stream << "[";
while (!q.empty()) {
stream << q.front() << " ";
q.pop();
}
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const deque<A> &v) {
deque<A> q = v;
stream << "[";
while (!q.empty()) {
stream << q.front() << " ";
q.pop_front();
}
stream << "]";
return stream;
}
void run();
int main() {
srand(time(NULL));
run();
return 0;
}
const int mod = 1e9 + 7;
const int N = 1003;
struct Edge {
int a, b;
long long cost;
Edge(int _a = 0, int _b = 0, long long _cost = 0)
: a(_a), b(_b), cost(_cost) {}
int to(int from) { return from == a ? b : a; }
};
vector<int> g[N];
vector<Edge> e;
vector<long long> d(N, LLONG_MAX);
vector<int> p(N, -1);
vector<bool> u(N * 100, false);
long long dejkstra(int s, int t, int n, bool f = false) {
std::fill(d.begin(), d.begin() + n, LLONG_MAX);
priority_queue<pair<long long, int> > q;
d[s] = 0;
q.push({0, s});
while (!q.empty()) {
int v = q.top().second;
long long dist = -q.top().first;
q.pop();
if (dist != d[v]) continue;
for (int i = 0; i < ((int)g[v].size()); ++i) {
auto edg = e[g[v][i]];
if (edg.cost == 0 && f) continue;
long long cost = max(1ll, edg.cost);
if (d[edg.to(v)] > d[v] + cost) {
d[edg.to(v)] = d[v] + cost;
p[edg.to(v)] = g[v][i];
q.push({-d[edg.to(v)], edg.to(v)});
}
}
}
0 ? (cout << "d[t]"
<< " = " << (d[t]) << "\n")
: cout;
return d[t];
}
void run() {
int n, m, L, s, t;
scanf("%d%d", &n, &m);
scanf("%d%d%d", &L, &s, &t);
int a, b, c;
for (int i = 0; i < m; ++i) {
scanf("%d%d%d", &a, &b, &c);
g[a].push_back(((int)e.size()));
g[b].push_back(((int)e.size()));
e.push_back(Edge(a, b, c));
}
if (dejkstra(s, t, n, true) < L) {
printf("NO\n");
return;
}
while (dejkstra(s, t, n) <= L) {
int v = t;
vector<int> vct;
while (v != s) {
int id = p[v];
if (e[id].cost == 0) {
vct.push_back(id);
u[id] = 1;
}
v = e[id].to(v);
}
if (vct.empty()) break;
int need = L - d[t];
e[vct.back()].cost = 1 + need;
}
if (dejkstra(s, t, n) != L) {
printf("NO\n");
return;
}
for (int i = 0; i < m; ++i)
if (e[i].cost == 0) e[i].cost = u[i] ? 1ll : 1ll << 50;
printf("YES\n");
for (int i = 0; i < m; ++i) printf("%d %d %lld\n", e[i].a, e[i].b, e[i].cost);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 4;
struct Edge {
int v, cost, i;
};
vector<Edge> adj[N];
Edge parent[N];
long long dijkstra(int source, int destination) {
long long dist[N];
memset(parent, -1, sizeof parent);
memset(dist, 0x3f, sizeof dist);
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
q;
q.push({0, source});
while (!q.empty()) {
auto cur = q.top();
q.pop();
long long cost = cur.first;
int node = cur.second;
if (dist[node] < cost) continue;
dist[node] = cost;
for (auto child : adj[node]) {
if (dist[child.v] > cost + child.cost) {
parent[child.v] = {node, child.cost, child.i};
dist[child.v] = cost + child.cost;
q.push({cost + child.cost, child.v});
}
}
}
return dist[destination];
}
int u[N], v[N], c[N];
bool erased[N];
int zeros(int t) {
int node = t;
int ret = 0;
while (~parent[node].v) {
if (erased[parent[node].i]) ++ret;
node = parent[node].v;
}
return ret;
}
int main() {
int n, m, l, s, t;
scanf("%d %d %d %d %d", &n, &m, &l, &s, &t);
for (int i = 0; i < m; ++i) {
scanf("%d %d %d", u + i, v + i, c + i);
erased[i] = c[i] == 0;
if (!c[i]) c[i] = 1;
adj[u[i]].push_back({v[i], c[i], i});
adj[v[i]].push_back({u[i], c[i], i});
}
long long dis;
int temp = 1e3;
while (temp--) {
dis = dijkstra(s, t);
if (dis == l) break;
if (dis > l) {
puts("NO");
return 0;
}
int node = t;
bool first = false;
bool leave[N] = {};
while (~parent[node].v) {
if (erased[parent[node].i]) {
leave[parent[node].i] = true;
if (!first++)
c[parent[node].i] = max(1, c[parent[node].i] + l - (int)dis);
}
node = parent[node].v;
}
for (int i = 0; i < m; ++i)
if (erased[i] && !leave[i]) c[i] = 2e9;
for (int i = 0; i < n; ++i)
for (auto &child : adj[i]) child.cost = c[child.i];
}
if (dis != l) {
puts("NO");
} else {
puts("YES");
for (int i = 0; i < m; ++i) printf("%d %d %d\n", u[i], v[i], c[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long long nmax = 1e3 + 5;
const long long mod = 1e9 + 7;
const long long mod1 = 998244353;
const long long inf = 1e18;
long long n, m, L, s, t, dist[1005], dist1[1005], tab[1005][1005],
pop[1005][1005], tab1[1005][1005];
vector<pair<long long, long long>> nod[1005];
vector<long long> road[1005];
void djkstra(long long s) {
multiset<pair<long long, long long>> dadoamne;
for (auto it : nod[s]) {
dadoamne.insert({it.second, it.first});
dist[it.first] = it.second;
}
while (dadoamne.empty() == false) {
auto it = dadoamne.begin();
for (auto it1 : nod[it->second]) {
if (((it->first) + it1.second) < dist[it1.first]) {
if (dist[it1.first] != inf)
dadoamne.erase(dadoamne.find({dist[it1.first], it1.first}));
dist[it1.first] = (it->first) + it1.second;
dadoamne.insert({dist[it1.first], it1.first});
}
}
dadoamne.erase(it);
}
}
void djkstra2(long long s) {
multiset<pair<long long, long long>> dadoamne;
for (long long i = 0; i < n; i++) dist1[i] = inf;
dist1[s] = 0;
for (auto it : nod[s]) {
dadoamne.insert({it.second, it.first});
dist1[it.first] = it.second;
road[it.first].push_back(s);
}
while (dadoamne.empty() == false) {
auto it = dadoamne.begin();
for (auto it1 : nod[it->second]) {
if (((it->first) + it1.second) < dist1[it1.first]) {
if (dist1[it1.first] != inf) {
dadoamne.erase(dadoamne.find({dist1[it1.first], it1.first}));
road[it1.first].pop_back();
}
dist1[it1.first] = (it->first) + it1.second;
dadoamne.insert({dist1[it1.first], it1.first});
road[it1.first].push_back(it->second);
}
}
dadoamne.erase(it);
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> L >> s >> t;
for (long long i = 0; i < n; i++) dist[i] = inf;
dist[s] = 0;
for (long long i = 1; i <= m; i++) {
long long x, y, z;
cin >> x >> y >> z;
if (z == 0) {
nod[x].push_back({y, inf});
nod[y].push_back({x, inf});
tab[x][y] = 1;
tab[y][x] = 1;
} else {
nod[x].push_back({y, z});
nod[y].push_back({x, z});
}
}
djkstra(s);
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < nod[i].size(); j++) {
if (nod[i][j].second == inf) nod[i][j].second = 1;
}
}
if (dist[t] < L) return cout << "NO", 0;
for (long long i = 0; i < n; i++) dist1[i] = inf;
dist1[s] = 0;
djkstra2(s);
if (dist1[t] > L) return cout << "NO", 0;
long long curr = t;
while (curr != s) {
long long y = road[curr][0];
if (tab[curr][y] == 1) {
tab1[curr][y] = 1;
tab1[y][curr] = 1;
}
curr = y;
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < nod[i].size(); j++) {
if (tab[i][nod[i][j].first] == 1 && tab1[i][nod[i][j].first] == 0)
nod[i][j].second = inf;
}
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < nod[i].size(); j++) {
if (dist1[t] == L) break;
if (tab[i][nod[i][j].first] == 1 && tab1[i][nod[i][j].first] == 1) {
nod[i][j].second += (L - dist1[t]);
for (long long r = 0; r < nod[nod[i][j].first].size(); r++) {
if (nod[nod[i][j].first][r].first == i)
nod[nod[i][j].first][r].second += (L - dist1[t]);
}
djkstra2(s);
}
}
if (dist1[t] == L) break;
}
cout << "YES" << '\n';
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < nod[i].size(); j++) {
if (pop[i][nod[i][j].first] == 0)
cout << i << ' ' << nod[i][j].first << ' ' << nod[i][j].second << '\n';
pop[i][nod[i][j].first] = 1;
pop[nod[i][j].first][i] = 1;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1010;
const int N = 1e5 + 10;
struct node {
int v;
long long cost;
node(int vi = 0, long long ci = 0) : v(vi), cost(ci) {}
};
vector<node> vec[2][MAXN];
void addedge(int id, int u, int v, long long w) {
vec[id][u].push_back(node(v, w));
}
int vis[MAXN];
long long dist[MAXN];
int L[N], R[N];
long long V[MAXN][MAXN];
int fa[N];
bool spfa(int id, int start, int n) {
memset(vis, 0, sizeof(vis));
for (int i = 0; i < n; i++) dist[i] = 0x3f3f3f3f, fa[i] = i;
vis[start] = 1, dist[start] = 0;
queue<int> que;
while (!que.empty()) que.pop();
que.push(start);
while (!que.empty()) {
int u = que.front();
que.pop();
vis[u] = 0;
for (int i = 0; i < vec[id][u].size(); i++) {
int v = vec[id][u][i].v;
long long w = V[u][v];
if (dist[v] > dist[u] + abs(w)) {
dist[v] = dist[u] + abs(w);
fa[v] = u;
if (!vis[v]) {
vis[v] = 1;
que.push(v);
}
}
}
}
return true;
}
void FUZHI(int n, int m, int s, int t, int l) {
int x = t, flag = 0;
while (1) {
int y = fa[x];
if (V[x][y] == -1) {
V[x][y] = V[y][x] = -2;
}
if (y == fa[y]) break;
x = y;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (V[i][j] == -1) V[i][j] = 0x3f3f3f3f;
}
}
x = t;
while (1) {
int y = fa[x];
if (V[x][y] == -2) {
V[x][y] = V[y][x] = -1;
}
if (y == fa[y]) break;
x = y;
}
}
bool solve(int n, int s, int t, int l) {
spfa(0, s, n);
int x = t, flag = 0;
if (dist[t] == l) return true;
while (1) {
int y = fa[x];
if (!flag && V[x][y] < 0) {
long long w = abs(V[x][y]);
V[x][y] = V[y][x] = w + l - dist[t];
flag = 1;
}
if (y == fa[y]) break;
x = y;
}
return false;
}
int main() {
int n, m, l, s, t;
scanf("%d%d%d%d%d", &n, &m, &l, &s, &t);
for (int i = 0; i < m; i++) {
int u, v;
long long w;
scanf("%d%d%I64d", &u, &v, &w);
if (w) {
addedge(1, u, v, w);
addedge(1, v, u, w);
}
if (w == 0) w = -1;
addedge(0, u, v, w);
addedge(0, v, u, w);
L[i] = u, R[i] = v;
V[u][v] = V[v][u] = w;
}
spfa(1, s, n);
if (dist[t] < l) {
printf("NO\n");
return 0;
}
if (dist[t] == l) {
printf("YES\n");
for (int i = 0; i < m; i++) {
int u = L[i], v = R[i];
long long w = V[u][v];
if (w == -1) w = 0x3f3f3f3f;
printf("%d %d %I64d\n", u, v, w);
}
return 0;
}
spfa(0, s, n);
FUZHI(n, m, s, t, l);
if (dist[t] > l) {
printf("NO\n");
return 0;
}
solve(n, s, t, l);
while (!solve(n, s, t, l)) solve(n, s, t, l);
printf("YES\n");
for (int i = 0; i < m; i++) {
int u = L[i], v = R[i];
long long w = V[u][v];
if (w < 0) w = -w;
printf("%d %d %I64d\n", u, v, w);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int Day12[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int prime100[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43,
47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103};
template <typename T>
inline bool isLeap(T y) {
return (y % 400 == 0) || (y % 100 ? y % 4 == 0 : false);
}
template <typename T>
inline T GCD(T a, T b) {
a = abs(a);
b = abs(b);
if (a < b) swap(a, b);
while (b) {
a = a % b;
swap(a, b);
}
return a;
}
template <typename T>
inline T LCM(T x, T y) {
T tp = GCD(x, y);
if ((x / tp) * 1. * y > 9e18) return 9e18;
return (x / tp) * y;
}
template <typename T>
inline T BIGMOD(T A, T B, T M = 1000000007) {
T ret = 1;
while (B) {
if (B & 1) ret = (ret * A) % M;
A = (A * A) % M;
B = B >> 1;
}
return ret;
}
template <typename T>
inline T BigMod(T A, T B, T M) {
T ret = 1;
while (B) {
if (B & 1) ret = (ret * A) % M;
A = (A * A) % M;
B = B >> 1;
}
return ret;
}
long long int MySqrt(long long int n) {
long long int p = sqrt(n);
if ((p + 1) * (p + 1) <= n)
return p + 1;
else if (p * p <= n)
return p;
else
return p - 1;
}
long long int MyPow(long long int x, long long int n) {
if (n == 0)
return 1;
else if (n % 2 == 0)
return MyPow(x * x, n / 2);
else
return x * MyPow(x * x, ((n - 1) / 2));
}
long long int modInverse(long long int n) {
return BIGMOD(n, (long long int)1000000007 - 2) % 1000000007;
}
long long BIG = 10000000000;
std::vector<pair<int, int>> G[1005];
std::vector<int> V;
long long Dis[1005];
int n, m, src, ter;
struct Node {
int U, V, W;
} Edge[100005];
void DJK() {
for (int i = 0; i <= n; i++) Dis[i] = BIG;
priority_queue<pair<int, int>> PQ;
PQ.push(make_pair(0, src));
Dis[src] = 0;
while (!PQ.empty()) {
int u = PQ.top().second;
long long taka = PQ.top().first * (-1);
PQ.pop();
int sz = G[u].size();
for (int i = 0; i < sz; i++) {
int v = G[u][i].second;
long long ok = G[u][i].first;
if (Dis[u] + ok < Dis[v] && ok > 0) {
Dis[v] = Dis[u] + ok;
PQ.push(make_pair(Dis[v] * (-1), v));
}
}
}
}
int main(int argc, char const *argv[]) {
long long L;
scanf("%d%d", &(n), &(m));
scanf("%lld", &(L));
scanf("%d%d", &(src), &(ter));
for (int i = 0; i < m; i++) {
int u, v;
long long w;
cin >> u >> v >> w;
G[u].push_back(make_pair(w, v));
G[v].push_back(make_pair(w, u));
int x = min(u, v);
int y = max(u, v);
Edge[i].U = x, Edge[i].V = y, Edge[i].W = w;
if (w == 0) V.push_back(i);
}
DJK();
if (Dis[ter] < L) {
printf("NO\n");
exit(0);
}
int sz = V.size();
for (int i = 0; i < sz; i++) {
int index = V[i];
if (Dis[ter] <= L) {
Edge[index].W = BIG;
continue;
}
int u = Edge[index].U;
int v = Edge[index].V;
int w = 1;
G[u].push_back(make_pair(w, v));
G[v].push_back(make_pair(w, u));
DJK();
if (Dis[ter] > L) {
Edge[index].W = 1;
} else {
Edge[index].W = (L - Dis[ter]) + 1;
}
}
DJK();
if (Dis[ter] <= L) {
printf("YES\n");
for (int i = 0; i < m; i++)
printf("%d %d %d\n", Edge[i].U, Edge[i].V, Edge[i].W);
} else
printf("NO\n");
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, asked, s, t;
struct edge {
int cost, to, rev;
bool mark;
};
vector<edge> g[1010];
struct node {
int x;
long long y;
};
vector<node> p;
bool operator>(node a, node b) { return a.y > b.y; };
priority_queue<node, vector<node>, greater<node> > q;
long long d[1010];
int last[1010];
void dij(int s, int t) {
memset(d, -1, sizeof(d));
memset(last, -1, sizeof(last));
node newnode, nownode;
d[s] = 0;
newnode.x = s;
newnode.y = d[s];
q.push(newnode);
while (!q.empty()) {
nownode = q.top();
q.pop();
if (nownode.y != d[nownode.x]) continue;
for (int i = 0; i < g[nownode.x].size(); i++)
if (nownode.y + g[nownode.x][i].cost < d[g[nownode.x][i].to] ||
d[g[nownode.x][i].to] == -1) {
d[g[nownode.x][i].to] = nownode.y + g[nownode.x][i].cost;
last[g[nownode.x][i].to] = nownode.x;
newnode.x = g[nownode.x][i].to;
newnode.y = d[g[nownode.x][i].to];
q.push(newnode);
}
}
}
void print() {
cout << "YES" << endl;
for (int i = 0; i < p.size(); i++)
cout << p[i].x << ' ' << g[p[i].x][int(p[i].y)].to << ' '
<< g[p[i].x][int(p[i].y)].cost << endl;
}
int main() {
cin >> n >> m >> asked >> s >> t;
int i, x, y;
long long z;
edge newedge;
node newnode;
for (i = 0; i < m; i++) {
cin >> x >> y >> z;
if (z != 0) {
newedge.cost = z;
newedge.mark = 0;
} else {
newedge.cost = 1;
newedge.mark = 1;
}
newedge.to = y;
g[x].push_back(newedge);
g[x][g[x].size() - 1].rev = g[y].size();
newedge.to = x;
g[y].push_back(newedge);
g[y][g[y].size() - 1].rev = g[x].size() - 1;
newnode.x = x;
newnode.y = g[x].size() - 1;
p.push_back(newnode);
}
long long tmp;
int cnt;
while (1) {
dij(s, t);
x = t;
tmp = asked - d[t];
cnt = 0;
if (tmp == 0) {
print();
break;
}
if (tmp < 0) {
cout << "NO\n";
return 0;
}
while (x != s && tmp != 0) {
if (last[x] == -1) break;
for (i = 0; i < g[x].size(); i++)
if (g[x][i].to == last[x]) {
if (!g[x][i].mark) break;
g[x][i].cost += tmp;
tmp = 0;
if (g[x][i].cost > 1000000000) {
tmp = g[x][i].cost - 1000000000;
g[x][i].cost = 1000000000;
}
g[g[x][i].to][g[x][i].rev].cost = g[x][i].cost;
cnt++;
break;
}
x = last[x];
}
if (tmp > 0 || cnt == 0) {
cout << "NO\n";
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int a;
long long d;
node() {}
node(int _a, long long _d) : a(_a), d(_d) {}
bool operator<(const node &o) const { return d > o.d; }
};
struct edge {
int a, b;
long long d;
edge() {}
edge(int aa, int bb, int dd) : a(aa), b(bb), d(dd) {}
};
vector<node> table[1005];
vector<edge> tt, in;
long long ee[1005][1005];
long long dist[1005];
long long maxint = 2000000000;
bool spec[1005][1005];
int done[1005];
int from[1005];
int n, m;
priority_queue<node> Q;
void dijk1(int s) {
while (!Q.empty()) Q.pop();
for (int i = 0; i < n; i++) {
dist[i] = maxint;
done[i] = 0;
from[i] = -1;
}
dist[s] = 0;
from[s] = s;
Q.push(node(s, 0));
node tmp;
int cnt = 0;
int w, u;
while (!Q.empty() && cnt < n) {
if (done[Q.top().a] == 1) {
Q.pop();
continue;
}
tmp = Q.top();
Q.pop();
u = tmp.a;
for (int i = 0; i < table[u].size(); i++) {
w = table[u][i].a;
if (dist[w] > dist[u] + ee[u][w]) {
from[w] = u;
dist[w] = dist[u] + ee[u][w];
Q.push(node(w, dist[w]));
}
}
done[u] = 1;
cnt++;
}
}
int main() {
int L, s, t;
scanf("%d%d%d%d%d", &n, &m, &L, &s, &t);
int a, b, c;
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &a, &b, &c);
if (c == 0) {
tt.push_back(edge(a, b, c));
spec[a][b] = true;
spec[b][a] = true;
continue;
}
in.push_back(edge(a, b, c));
ee[a][b] = c;
ee[b][a] = c;
table[a].push_back(node(b, c));
table[b].push_back(node(a, c));
}
dijk1(s);
if (dist[t] < L) {
printf("NO");
return 0;
} else if (dist[t] == L) {
printf("YES\n");
for (int i = 0; i < in.size(); i++) {
printf("%d %d %I64d \n", in[i].a, in[i].b, in[i].d);
}
for (int i = 0; i < tt.size(); i++) {
printf("%d %d 1\n", tt[i].a, tt[i].b);
}
return 0;
}
for (int i = 0; i < tt.size(); i++) {
a = tt[i].a;
b = tt[i].b;
ee[a][b] = 1;
ee[b][a] = 1;
table[a].push_back(node(b, 1));
table[b].push_back(node(a, 1));
}
dijk1(s);
if (dist[t] > L) {
printf("NO");
return 0;
}
for (int i = 0; i < tt.size(); i++) {
a = tt[i].a;
b = tt[i].b;
ee[a][b] = L + 1;
ee[b][a] = L + 1;
}
a = t;
while (a != s) {
b = from[a];
if (spec[a][b]) {
ee[a][b] = 1;
ee[b][a] = 1;
}
a = b;
}
long long sum;
while (dist[t] < L) {
dijk1(s);
if (dist[t] == L) break;
a = t;
while (a != s) {
b = from[a];
if (spec[a][b]) {
ee[a][b] += L - dist[t];
ee[b][a] += L - dist[t];
break;
}
a = b;
}
}
printf("YES\n");
for (int i = 0; i < in.size(); i++) {
printf("%d %d %I64d \n", in[i].a, in[i].b, in[i].d);
}
for (int i = 0; i < tt.size(); i++) {
printf("%d %d %I64d \n", tt[i].a, tt[i].b, ee[tt[i].a][tt[i].b]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
void Read(int &n) {
int sign = 1;
n = 0;
char c;
do {
c = getchar();
} while (!isdigit(c) && c != '-');
if (c == '-') {
c = getchar();
sign = -1;
}
do {
n = n * 10 + c - 48;
c = getchar();
} while (isdigit(c));
n *= sign;
}
void Read(long long &n) {
int sign = 1;
n = 0;
char c;
do {
c = getchar();
} while (!isdigit(c) && c != '-');
if (c == '-') {
c = getchar();
sign = -1;
}
do {
n = n * 10ll + c - 48;
c = getchar();
} while (isdigit(c));
n *= sign;
}
void Write(int n) {
if (n == 0)
putchar('0');
else if (n < 0)
putchar('-'), n = -n;
char C[30];
int d = 0;
while (n) {
C[++d] = (n % 10) + 48;
n /= 10;
}
for (int i = d; i >= 1; --i) putchar(C[i]);
}
void Write(long long n) {
if (n == 0)
putchar('0');
else if (n < 0)
putchar('-'), n = -n;
char C[30];
int d = 0;
while (n) {
C[++d] = (n % 10ll) + 48;
n /= 10ll;
}
for (int i = d; i >= 1; --i) putchar(C[i]);
}
const int maxn = 1005;
const int maxm = 5e6 + 5;
const long long INFL = 1e18;
struct Edge {
int u, v, w;
Edge() {}
Edge(int u, int v, int w) : u(u), v(v), w(w) {}
} E[maxm];
vector<pair<int, int> > adj[maxn];
int n, m, L, s, t;
int T[maxn];
long long d[maxn];
long long dist[maxn][maxn];
long long Pre_Dijkstra() {
set<pair<long long, int> > S;
for (int i = 0; i <= n; ++i) d[i] = INFL;
d[s] = 0;
S.clear();
S.insert(pair<long long, int>(0, s));
while (S.size()) {
pair<long long, int> temp = *S.begin();
S.erase(S.begin());
int u = temp.second;
for (int k = 0; k < adj[u].size(); ++k) {
int v = adj[u][k].first;
if (dist[u][v] == -1) continue;
int w = abs(dist[u][v]);
if (d[v] > d[u] + (long long)w) {
S.erase(pair<long long, int>(d[v], v));
d[v] = d[u] + (long long)w;
S.insert(pair<long long, int>(d[v], v));
}
}
}
return d[t];
}
long long Dijkstra() {
set<pair<long long, int> > S;
S.clear();
for (int i = 0; i <= n; ++i) d[i] = INFL;
d[s] = 0;
S.insert(pair<long long, int>(d[s], s));
T[s] = 0;
while (S.size()) {
pair<long long, int> temp = *S.begin();
S.erase(S.begin());
int u = temp.second;
for (int k = 0; k < adj[u].size(); ++k) {
int v = adj[u][k].first;
int w = abs(dist[u][v]);
if (d[v] > d[u] + (long long)w) {
S.erase(pair<long long, int>(d[v], v));
T[v] = u;
d[v] = d[u] + (long long)w;
S.insert(pair<long long, int>(d[v], v));
}
}
}
int v = t;
while (T[v] != 0) {
if (dist[T[v]][v] < 0) {
dist[T[v]][v] = -2;
dist[v][T[v]] = -2;
}
v = T[v];
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (dist[i][j] == -1) dist[i][j] = INFL;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (dist[i][j] == -2) dist[i][j] = -1;
return d[t];
}
int Pow[10];
int Count(int v) {
int d = 0;
while (v) d++, v /= 10;
return d;
}
bool Relax() {
set<pair<long long, int> > S;
S.clear();
for (int i = 1; i <= n; ++i) d[i] = INFL;
d[s] = 0;
T[s] = 0;
S.insert(pair<long long, int>(0, s));
while (S.size()) {
pair<long long, int> temp = *S.begin();
S.erase(S.begin());
int u = temp.second;
for (int k = 0; k < adj[u].size(); ++k) {
int v = adj[u][k].first;
long long w = abs(dist[u][v]);
if (d[v] > d[u] + w) {
S.erase(pair<long long, int>(d[v], v));
d[v] = d[u] + w;
T[v] = u;
S.insert(pair<long long, int>(d[v], v));
}
}
}
if (d[t] == L) return 1;
int v = t;
bool meet = 0;
while (T[v] != 0) {
int u = T[v];
if (!meet && dist[u][v] < 0) {
dist[u][v] = abs(dist[u][v]) + L - d[t];
dist[v][u] = abs(dist[v][u]) + L - d[t];
meet = 1;
}
if (meet) break;
v = T[v];
}
return 0;
}
int main() {
Read(n);
Read(m);
Read(L);
Read(s);
Read(t);
s++;
t++;
for (int i = 1; i <= m; ++i) {
int u, v, w;
Read(u);
Read(v);
Read(w);
u++;
v++;
E[i] = Edge(u, v, w);
dist[u][v] = w;
dist[v][u] = w;
if (w == 0) {
dist[u][v] = -1;
dist[v][u] = -1;
}
adj[u].push_back(pair<int, int>(v, w));
adj[v].push_back(pair<int, int>(u, w));
}
long long SPath1 = Pre_Dijkstra();
if (SPath1 < L) {
puts("NO");
return 0;
}
if (SPath1 == L) {
puts("YES");
for (int i = 1; i <= m; ++i) {
Write(E[i].u - 1);
putchar(' ');
Write(E[i].v - 1);
putchar(' ');
if (E[i].w == 0)
Write(INFL);
else
Write(E[i].w);
putchar('\n');
}
return 0;
}
long long SPath2 = Dijkstra();
if (SPath2 > L) {
puts("NO");
return 0;
}
puts("YES");
bool k = Relax();
while (!k) k = Relax();
for (int i = 1; i <= m; ++i) {
Write(E[i].u - 1);
putchar(' ');
Write(E[i].v - 1);
putchar(' ');
Write(abs(dist[E[i].u][E[i].v]));
putchar('\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int uu, vv;
long long dis;
} v[20005], temp;
int flag[10005], fm = 0, n, m, root[1005], fa[20005], s, t;
long long ans[1005];
bool life[1005];
queue<int> q;
void go() {
int now, tt;
memset(ans, 0, sizeof(ans));
ans[s] = 1;
q.push(s);
life[s] = 1;
while (!q.empty()) {
now = q.front();
q.pop();
tt = root[now];
life[now] = 0;
while (tt) {
if (ans[now] + v[tt].dis < ans[v[tt].vv] || !ans[v[tt].vv]) {
ans[v[tt].vv] = ans[now] + v[tt].dis;
if (!life[v[tt].vv]) {
life[v[tt].vv] = 1;
q.push(v[tt].vv);
}
}
tt = fa[tt];
}
}
return;
}
void ok() {
printf("YES\n");
for (int i = 1; i <= m; i++) {
printf("%d %d %I64d\n", v[i].uu, v[i].vv, v[i].dis);
}
}
int main() {
long long L, dis;
int uu, vv;
int nl = 1, nr = L, mid;
cin >> n >> m >> L >> s >> t;
for (int i = 1; i <= m; i++) {
scanf("%d%d%I64d", &uu, &vv, &dis);
temp.uu = uu;
temp.vv = vv;
temp.dis = dis;
v[i] = temp;
if (dis == 0) flag[fm++] = i;
fa[i] = root[uu];
root[uu] = i;
temp.uu = vv;
temp.vv = uu;
v[i + m] = temp;
fa[i + m] = root[vv];
root[vv] = i + m;
}
L++;
for (int i = 0; i < fm; i++) v[flag[i]].dis = v[flag[i] + m].dis = 1;
go();
if (ans[t] == L)
ok();
else {
if (ans[t] > L)
printf("NO\n");
else {
for (int i = 0; i < fm; i++) v[flag[i]].dis = v[flag[i] + m].dis = L;
go();
if (ans[t] == L)
ok();
else {
if (ans[t] < L)
printf("NO\n");
else {
for (int i = 0; i < fm; i++) {
v[flag[i]].dis = v[flag[i] + m].dis = 1;
go();
if (ans[t] <= L) {
if (ans[t] == L)
ok();
else {
nl = 1;
nr = L;
while (1) {
mid = (nl + nr) / 2;
v[flag[i]].dis = v[flag[i] + m].dis = mid;
go();
if (ans[t] == L) {
ok();
break;
} else {
if (ans[t] < L)
nl = mid;
else
nr = mid;
}
}
}
break;
}
}
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = int(1e3) + 10;
int n, m, s, t;
long long int L;
vector<int> v[N];
vector<pair<int, pair<int, long long int> > > edge;
vector<long long int> w[N];
long long int dist[N];
int p[N];
long long int mw[N][N];
map<pair<int, int>, long long int> cnt;
bool ok = false;
long long int INF = 1e18;
void solve(long long int k) {
for (int i = 0; i < n; i++) dist[i] = INF;
memset(p, -1, sizeof p);
priority_queue<pair<long long int, int> > pq;
pq.push({0LL, s});
dist[s] = 0LL;
p[s] = s;
while (!pq.empty()) {
int u = pq.top().second;
pq.pop();
if (u == t) break;
for (int i = 0; i < v[u].size(); i++) {
int adj = v[u][i];
long long int peso = mw[u][adj];
if (peso == 0LL) peso = k;
if (dist[adj] > dist[u] + peso) {
dist[adj] = dist[u] + peso;
pq.push({-dist[adj], adj});
p[adj] = u;
}
}
}
}
int main() {
scanf("%d %d %lld %d %d", &n, &m, &L, &s, &t);
for (int i = 0; i < m; i++) {
int x, y;
long long int z;
scanf("%d %d %lld", &x, &y, &z);
v[x].push_back(y);
w[x].push_back(z);
v[y].push_back(x);
w[y].push_back(z);
edge.push_back({x, {y, z}});
mw[x][y] = mw[y][x] = z;
}
solve(0);
if (dist[t] > L) {
printf("NO\n");
return 0;
}
solve(1);
if (dist[t] > L) {
printf("NO\n");
return 0;
}
long long int l = 1, r = L;
for (int k = 0; k < 200; k++) {
long long int mid = (l + r) / 2;
solve(mid);
if (dist[t] <= L) {
l = mid;
} else
r = mid;
}
solve(l);
long long int ans = dist[t];
for (int i = t; i != s; i = p[i]) {
int x = i;
int y = p[i];
long long int peso = mw[x][y];
if (!peso && !ok) {
ok = true;
cnt[{x, y}] = cnt[{y, x}] = (L - ans) + l;
mw[x][y] = mw[y][x] = (L - ans) + l;
} else if (!peso && ok) {
cnt[{x, y}] = cnt[{y, x}] = l;
mw[x][y] = mw[y][x] = l;
} else {
cnt[{x, y}] = cnt[{y, x}] = peso;
}
}
solve(L + 1);
if (dist[t] != L) {
printf("NO\n");
return 0;
}
printf("YES\n");
for (int i = 0; i < m; i++) {
int x = edge[i].first;
int y = edge[i].second.first;
long long int z = mw[x][y];
if (cnt.find({x, y}) == cnt.end()) {
if (z == 0) {
printf("%d %d %lld", x, y, L + 1);
} else {
printf("%d %d %lld", x, y, z);
}
} else if (cnt.find({x, y}) != cnt.end()) {
printf("%d %d %lld", x, y, cnt[{x, y}]);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
const long long int INF = 1e18;
int n, m, s, t, vis[1010], path[1010], err;
long long int L, d[1010], d2[1010];
int w[1010][1010];
void dijk() {
int cnt = 0, u;
long long int mn;
for (int i = 0; i < n; i++) d[i] = INF;
d[s] = 0;
while (cnt < n) {
mn = INF;
for (int i = 0; i < n; i++)
if (vis[i] != 1 && d[i] < mn) {
mn = d[i];
u = i;
}
vis[u] = 1, cnt++;
for (int i = 0; i < n; i++)
if (w[u][i] > 0 && d[i] > d[u] + w[u][i]) d[i] = d[u] + w[u][i];
}
return;
}
void dijk2() {
int cnt = 0, u;
long long int mn;
for (int i = 0; i < n; i++) d2[i] = INF, vis[i] = 0;
d2[s] = 0;
while (cnt < n) {
mn = INF;
for (int i = 0; i < n; i++)
if (vis[i] != 1 && d2[i] < mn) {
mn = d2[i];
u = i;
}
vis[u] = 1, cnt++;
for (int i = 0; i < n; i++) {
if (w[u][i] > 0 && d2[i] > d2[u] + w[u][i])
d2[i] = d2[u] + w[u][i], path[i] = u;
if (w[u][i] == -1 && d2[i] > d2[u] + 1) d2[i] = d2[u] + 1, path[i] = u;
}
}
return;
}
int main() {
scanf("%d%d%I64d%d%d", &n, &m, &L, &s, &t);
for (int i = 0; i < m; i++) {
int u, v, wt;
scanf("%d%d%d", &u, &v, &wt);
if (wt != 0)
w[u][v] = wt, w[v][u] = wt;
else
w[u][v] = -1, w[v][u] = -1;
}
dijk();
dijk2();
if (d[t] < L || d2[t] > L)
printf("NO");
else {
int track = t;
long long int tot = L;
while (track != s) {
int u = track, v = path[track];
if (w[u][v] == -1) {
if (tot - d[v] > INF) {
err = -1;
break;
}
if (tot > d[v])
w[u][v] = tot - d[v], w[v][u] = tot - d[v];
else
w[u][v] = 1, w[v][u] = 1;
}
track = path[track];
tot -= w[u][v];
}
if (err == -1)
printf("NO");
else {
printf("YES\n");
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (w[i][j] > 0) printf("%d %d %d\n", i, j, w[i][j]);
if (w[i][j] == -1) printf("%d %d %d\n", i, j, L + 1);
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct A {
int fr, to, th;
long long d;
A() {}
A(int a, int b, long long c, int d) : fr(a), to(b), d(c), th(d) {}
};
const int N = 1003;
vector<A> edge, G[N], ze, all, ori;
int from[N];
long long dis[N];
void SPFA(int x) {
queue<int> q;
q.push(x);
for (int i = 0; i < N; ++i) dis[i] = 1e15;
dis[x] = 0;
bool inq[N] = {};
while (!q.empty()) {
int fr = q.front();
q.pop();
inq[fr] = 0;
for (A e : G[fr]) {
if (dis[e.to] > dis[e.fr] + all[e.th].d) {
dis[e.to] = dis[e.fr] + all[e.th].d;
if (!inq[e.to]) {
inq[e.to] = 1;
q.push(e.to);
}
from[e.to] = e.th;
}
}
}
}
int main() {
int n, m, s, t;
long long L;
scanf("%d%d%lld%d%d", &n, &m, &L, &s, &t);
for (int i = 0, x, y; i < m; ++i) {
long long d;
scanf("%d%d%lld", &x, &y, &d);
if (!d)
ze.push_back(A(x, y, d, i));
else
edge.push_back(A(x, y, d, i));
all.push_back(A(x, y, d, i));
ori.push_back(A(x, y, d, i));
}
for (auto e : edge) {
G[e.fr].push_back(e);
G[e.to].push_back(A(e.to, e.fr, e.d, e.th));
}
SPFA(s);
if (dis[t] < L) {
puts("NO");
return 0;
}
if (dis[t] == L) {
puts("YES");
for (auto e : all) {
printf("%d %d %lld\n", e.fr, e.to, e.d ? e.d : (long long)(1e15));
}
return 0;
}
for (int i = 0; i < ze.size(); ++i) {
ze[i].d = 1;
A e = ze[i];
all[e.th].d = 1;
G[e.fr].push_back(e);
G[e.to].push_back(A(e.to, e.fr, e.d, e.th));
}
SPFA(s);
if (dis[t] > L) {
puts("NO");
return 0;
}
while (dis[t] != L) {
vector<int> use;
int p = t;
while (p != s) {
if (!ori[from[p]].d) {
use.push_back(from[p]);
}
A e = ori[from[p]];
p = p == e.fr ? e.to : e.fr;
}
long long di = (L - dis[t]) / use.size(), mo = (L - dis[t]) % use.size();
all[use[0]].d += di + mo;
for (int i = 1; i < use.size(); ++i) all[use[i]].d += di;
SPFA(s);
}
puts("YES");
for (auto e : all) {
printf("%d %d %lld\n", e.fr, e.to, e.d);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 10000000000000000;
const int maxN = 1000 + 10;
const int maxM = 20000 + 10;
long long d1;
bool er[maxM];
vector<int> paths1;
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; }
};
vector<Edge> edges;
vector<int> G[maxN];
bool done[maxN];
long long d[maxN];
int p[maxM];
int id[maxM];
struct Dijkstra {
int n, m;
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, int ff) {
edges.push_back((Edge){from, to, dist});
m = edges.size();
G[from].push_back(m - 1);
id[m - 1] = ff;
}
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});
}
}
}
}
void GetShortestPaths(int s, int u) {
dijkstra(s);
if (d[u] >= INF) {
d1 = d[u];
return;
}
for (int i = u; i <= u; i++) {
d1 = d[i];
paths1.clear();
int t = i;
paths1.push_back(t);
while (t != s) {
paths1.push_back(edges[p[t]].from);
t = edges[p[t]].from;
}
reverse(paths1.begin(), paths1.end());
}
}
};
Dijkstra solver;
Edge ei[10000 + 10];
int main() {
int n, m, s, t;
long long L;
while (~scanf("%d%d%lld%d%d", &n, &m, &L, &s, &t)) {
memset(er, 0, sizeof(er));
for (long long i = 0; i < m; i++) {
scanf("%d%d%lld", &ei[i].from, &ei[i].to, &ei[i].dist);
if (ei[i].dist == 0) er[i] = 1;
}
solver.init(n);
for (int i = 0; i < m; i++) {
if (er[i]) ei[i].dist = L;
solver.AddEdge(ei[i].from, ei[i].to, ei[i].dist, 0);
solver.AddEdge(ei[i].to, ei[i].from, ei[i].dist, 0);
}
solver.GetShortestPaths(s, t);
if (d1 < L)
printf("NO\n");
else if (d1 == L) {
printf("YES\n");
for (long long i = 0; i < m; i++)
printf("%d %d %lld\n", ei[i].from, ei[i].to, ei[i].dist);
} else {
solver.init(n);
for (int i = 0; i < m; i++) {
if (er[i]) {
ei[i].dist = 1;
solver.AddEdge(ei[i].from, ei[i].to, ei[i].dist, i + 1);
solver.AddEdge(ei[i].to, ei[i].from, ei[i].dist, i + 1);
} else {
solver.AddEdge(ei[i].from, ei[i].to, ei[i].dist, 0);
solver.AddEdge(ei[i].to, ei[i].from, ei[i].dist, 0);
}
}
solver.GetShortestPaths(s, t);
if (d1 > L)
printf("NO\n");
else if (d1 == L) {
printf("YES\n");
for (int i = 0; i < m; i++)
printf("%d %d %lld\n", ei[i].from, ei[i].to, ei[i].dist);
} else {
for (;;) {
long long add = L - d1;
for (int i = 0; i < paths1.size(); i++) {
int u = paths1[i];
bool ok = false;
for (int j = 0; j < G[u].size(); j++) {
int ee = G[u][j];
if (id[ee] && edges[G[u][j]].to == paths1[i + 1]) {
edges[ee].dist += add;
ei[id[ee] - 1].dist = edges[ee].dist;
ok = true;
break;
}
}
if (ok) break;
}
solver.GetShortestPaths(s, t);
if (d1 < L) continue;
printf("YES\n");
for (int i = 0; i < m; i++) {
printf("%d %d %lld\n", ei[i].from, ei[i].to, ei[i].dist);
}
break;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int u, v;
int w;
int other(int node) { return (u == node) ? v : u; }
};
int n, m, second, e;
int used[1003], parent[1003];
edge E[10004];
int dis[1003];
int L;
vector<int> g[1003];
void djkstra(int second, int e) {
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
Q;
for (int i = 0; i < n; i++) {
dis[i] = (2000000000 >> 1) + 1;
used[i] = 0;
}
dis[second] = 0;
Q.push(make_pair(0, second));
while (!Q.empty() && (!used[e])) {
pair<int, int> cur = Q.top();
Q.pop();
used[cur.second] = 1;
for (int i = 0; i < g[cur.second].size(); i++) {
int idx = g[cur.second][i];
int to = E[idx].other(cur.second);
if (!used[to] && E[idx].w + dis[cur.second] < dis[to]) {
dis[to] = E[idx].w + dis[cur.second];
Q.push(make_pair(dis[to], to));
parent[to] = idx;
}
}
}
}
bool cmp(edge e1, edge e2) { return e1.w > e2.w; }
int main() {
scanf("%d", &n);
scanf("%d", &m);
scanf("%d", &L);
scanf("%d", &second);
scanf("%d", &e);
for (int i = 1; i <= m; i++) {
scanf("%d", &E[i].u);
scanf("%d", &E[i].v);
scanf("%d", &E[i].w);
}
sort(E + 1, E + m + 1, cmp);
int last = 0;
for (int i = 1; i <= m; i++) {
if (E[i].w == 0) break;
g[E[i].u].push_back(i);
g[E[i].v].push_back(i);
last = i;
}
djkstra(second, e);
if (dis[e] < L) {
puts("NO");
return 0;
}
for (int i = last + 1; i <= m; i++) {
E[i].w = 1;
g[E[i].u].push_back(i);
g[E[i].v].push_back(i);
}
djkstra(second, e);
if (dis[e] > L) {
puts("NO");
return 0;
}
puts("YES");
for (int i = last + 1; i <= m; i++) {
E[i].w = L;
}
int node = e;
while (node != second) {
int idx = parent[node];
if (idx > last) {
E[idx].w = 1;
}
node = E[idx].other(node);
}
while (dis[e] < L) {
node = e;
while (node != second) {
int idx = parent[node];
if (idx > last) {
E[idx].w += (L - dis[e]);
break;
}
node = E[idx].other(node);
}
djkstra(second, e);
}
for (int i = 1; i <= m; i++) {
printf("%d %d %d\n", E[i].u, E[i].v, E[i].w);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
void maximize(T &x, U y) {
if (x < y) x = y;
}
template <class T, class U>
void minimize(T &x, U y) {
if (x > y) x = y;
}
template <class T>
T Abs(T x) {
return (x < 0 ? -x : x);
}
template <class T>
T safe_sqrt(T x) {
return sqrt(max(x, (T)0));
}
template <class T, class U, class V>
T addmod(T x, U k, V MOD) {
return ((x + k) % MOD + MOD) % MOD;
}
template <class T, class U, class V>
T submod(T x, U k, V MOD) {
return ((x - k) % MOD + MOD) % MOD;
}
template <class T, class U, class V>
T mul(T x, U y, V MOD) {
return (long long)x * y % MOD;
}
namespace task {
const long long inf = 1e18;
const int N = 1e3 + 3;
vector<pair<int, int> > adj[N];
struct E {
int u, v, w;
E() {}
E(int _u, int _v, int _w) : u(_u), v(_v), w(_w) {}
} edge[10 * N];
int n, m, L, s, t;
long long dist[2][N];
bool mark[10 * N];
void print() {
puts("YES");
for (int i = 1; i <= m; ++i)
printf("%d %d %d\n", edge[i].u - 1, edge[i].v - 1, edge[i].w);
}
void dijkstra1() {
priority_queue<pair<long long, int> > heap;
fill(dist[0] + 1, dist[0] + 1 + n, inf);
dist[0][t] = 0;
heap.push(make_pair(dist[0][t], t));
while (!heap.empty()) {
pair<long long, int> top = heap.top();
heap.pop();
int u = top.second;
if (dist[0][u] != -top.first) continue;
for (auto e : adj[u])
if (dist[0][u] + edge[e.second].w < dist[0][e.first])
dist[0][e.first] = dist[0][u] + edge[e.second].w,
heap.push(make_pair(-dist[0][e.first], e.first));
}
}
void dijkstra2() {
priority_queue<pair<long long, int> > heap;
fill(dist[1] + 1, dist[1] + 1 + n, inf);
dist[1][s] = 0;
heap.push(make_pair(dist[1][s], s));
while (!heap.empty()) {
pair<long long, int> top = heap.top();
heap.pop();
int u = top.second;
if (dist[1][u] != -top.first) continue;
for (auto e : adj[u])
if (dist[1][u] + edge[e.second].w < dist[1][e.first] and
dist[1][u] + edge[e.second].w + dist[0][e.first] < L) {
if (mark[e.second])
edge[e.second].w +=
L - (dist[1][u] + edge[e.second].w + dist[0][e.first]);
else {
dist[1][e.first] = dist[1][u] + edge[e.second].w;
heap.push(make_pair(-dist[1][e.first], e.first));
}
}
}
}
void solve() {
scanf("%d%d%d%d%d", &n, &m, &L, &s, &t);
++s, ++t;
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d", &edge[i].u, &edge[i].v, &edge[i].w);
++edge[i].u, ++edge[i].v;
if (!edge[i].w) edge[i].w = 1, mark[i] = true;
adj[edge[i].u].push_back(make_pair(edge[i].v, i));
adj[edge[i].v].push_back(make_pair(edge[i].u, i));
}
dijkstra1();
if (dist[0][s] > L) puts("NO"), exit(0);
if (dist[0][s] == L) print(), exit(0);
dijkstra2();
if (dist[1][t] == inf)
print();
else
puts("NO");
}
} // namespace task
int main(void) { task::solve(); }
|
#include <bits/stdc++.h>
using namespace std;
int n, m, L, s, t;
const long long LMAX = (long long)1e9;
const long long INF = (long long)1e15;
void nope() {
cout << "NO" << '\n';
exit(0);
}
struct ed {
int u, v, w;
int al;
} E[10100];
long long d[1010];
int p[1010], pe[1010];
vector<pair<int, int> > G[1010];
void djk(int s) {
fill(d, d + n + 1, INF);
fill(p, p + n + 1, -1);
fill(pe, pe + n + 1, -1);
set<pair<long long, int> > pq;
d[s] = 0;
pq.emplace(d[s], s);
while (!pq.empty()) {
int u = pq.begin()->second;
pq.erase(pq.begin());
long long du = d[u];
for (auto& v : G[u]) {
long long rlx = du + E[v.second].w;
if (rlx < d[v.first]) {
pq.erase({d[v.first], v.first});
d[v.first] = rlx;
p[v.first] = u;
pe[v.first] = v.second;
pq.emplace(d[v.first], v.first);
}
}
}
}
void yep() {
cout << "YES" << '\n';
for (int e = 1; e <= m; e++) {
cout << E[e].u << ' ' << E[e].v << ' ' << E[e].w << '\n';
}
exit(0);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> n >> m >> L >> s >> t;
for (int u, v, w, e = 1; e <= m; e++) {
cin >> u >> v >> w;
E[e] = {u, v, w, w == 0};
G[u].push_back({v, e});
G[v].push_back({u, e});
}
for (int e = 1; e <= m; e++)
if (E[e].al) E[e].w = 1;
djk(s);
if (p[t] == -1 or d[t] > L) nope();
if (d[t] == L) yep();
while (d[t] < L) {
int diff = L - d[t];
int v = t;
bool inc = 0;
for (; v >= 0; v = p[v])
if (E[pe[v]].al) {
E[pe[v]].w += diff;
E[pe[v]].al = 0;
inc = 1;
break;
}
if (!inc) break;
djk(s);
}
if (d[t] != L) nope();
yep();
return 0;
};
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int N = 100031;
long long n, m, s, t, l;
long long a[N], b[N], w[N];
long long flag[N];
vector<int> g[N];
void run_locker(int val) {
for (int i = 0; i < m; i++) {
if (flag[i]) w[i] = val;
}
}
int used[N];
long long dist[N];
int par[N];
int get_other(int edge_id, int v_id) {
if (a[edge_id] == v_id) return b[edge_id];
return a[edge_id];
}
long long get_solution() {
for (int i = 1; i <= n; i++) {
used[i] = 0;
dist[i] = 1e18;
}
dist[s] = 0;
set<pair<long long, long long> > S;
set<pair<long long, long long> >::iterator it;
for (int i = 1; i <= n; i++) {
S.insert(make_pair(dist[i], i));
}
while (S.size()) {
it = S.begin();
pair<long long, long long> p = *it;
S.erase(it);
int qv = p.second;
for (int i = 0; i < g[qv].size(); i++) {
int id = g[qv][i];
int to = get_other(id, qv);
long long qd = dist[qv] + w[id];
if (dist[to] > qd) {
S.erase(make_pair(dist[to], to));
dist[to] = qd;
par[to] = id;
S.insert(make_pair(dist[to], to));
}
}
}
return dist[t];
}
vector<int> get_path() {
vector<int> res;
int cur = t;
while (cur != s) {
res.push_back(par[cur]);
cur = get_other(par[cur], cur);
}
return res;
}
vector<int> purify(vector<int> v) {
vector<int> res;
for (int i = 0; i < v.size(); i++) {
int id = v[i];
if (flag[id]) res.push_back(id);
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> l >> s >> t;
++s;
++t;
for (int i = 0; i < m; i++) {
cin >> a[i] >> b[i] >> w[i];
++a[i];
++b[i];
g[a[i]].push_back(i);
g[b[i]].push_back(i);
if (w[i] == 0) flag[i] = 1;
}
run_locker((int)1e9 + 1e6);
long long Q = get_solution();
if (Q < l) {
cout << "NO" << endl;
return 0;
}
run_locker(1);
Q = get_solution();
if (Q > l) {
cout << "NO" << endl;
return 0;
}
vector<int> V;
for (int i = 0; i < m; i++) {
if (flag[i]) V.push_back(i);
}
while (true) {
long long Q = get_solution();
if (Q == l) break;
long long L, R;
L = 0;
R = 1e15;
while (L < R) {
long long mid = L + R + 1;
mid /= 2;
int C = V.size();
for (int i = 0; i < V.size(); i++) {
int id = V[i];
w[id] += mid / C;
if (i < mid % C) w[id]++;
}
long long QQ = get_solution();
if (QQ > l) {
R = mid - 1;
} else {
L = mid;
}
for (int i = 0; i < V.size(); i++) {
int id = V[i];
w[id] -= mid / C;
if (i < mid % C) w[id]--;
}
}
for (int i = 0; i < V.size(); i++) {
int id = V[i];
w[id] += L / V.size();
if (i < L % V.size()) w[id]++;
}
}
cout << "YES" << endl;
for (int i = 0; i < m; i++) {
--a[i];
--b[i];
cout << a[i] << " " << b[i] << " " << w[i] << endl;
}
cin.get();
cin.get();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void cmax(T& a, T b) {
a = max(a, b);
}
template <typename T>
void cmin(T& a, T b) {
a = min(a, b);
}
void _BG(const char* s) {}
template <typename T, typename... TT>
void _BG(const char* s, T a, TT... b) {
for (int c = 0; *s && (c || *s != ','); ++s) {
cerr << *s;
switch (*s) {
case '(':
case '[':
case '{':
++c;
break;
case ')':
case ']':
case '}':
--c;
break;
}
}
cerr << " = " << a;
if (*s) {
cerr << ", ";
_BG(++s, b...);
} else
cerr << endl;
}
bool RD(void) { return true; }
bool RD(char& a) { return scanf(" %c", &a) == 1; }
bool RD(char* a) { return scanf("%s", a) == 1; }
bool RD(double& a) { return scanf("%lf", &a) == 1; }
bool RD(int& a) { return scanf("%d", &a) == 1; }
bool RD(long long& a) { return scanf("%lld", &a) == 1; }
template <typename T, typename... TT>
bool RD(T& a, TT&... b) {
return RD(a) && RD(b...);
}
void PT(const char a) { putchar(a); }
void PT(const char* a) { fputs(a, stdout); }
void PT(char* a) { fputs(a, stdout); }
void PT(const double a) { printf("%.16f", a); }
void PT(const int a) { printf("%d", a); }
void PT(const long long a) { printf("%lld", a); }
template <char sep = ' ', char end = '\n'>
void PL(void) {
if (end) PT(end);
}
template <char sep = ' ', char end = '\n', typename T, typename... TT>
void PL(const T a, const TT... b) {
PT(a);
if (sizeof...(b) && sep) PT(sep);
PL<sep, end>(b...);
}
const int N = 1234, M = 12345;
const long long inf = 1e18;
struct edge {
int u, v;
long long w;
bool f;
int go(int x) { return u ^ v ^ x; }
} e[M];
vector<int> g[N];
int n, m, s, t;
long long L, d[N];
int pr[N];
long long sp() {
fill_n(d, n, inf);
fill_n(pr, n, -1);
d[s] = 0;
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
pq;
pq.push({0, s});
while (((int)pq.size())) {
int u;
long long w;
tie(w, u) = pq.top();
pq.pop();
if (w > d[u]) continue;
if (u == t) break;
for (int i : g[u]) {
int v = e[i].go(u);
w = d[u] + e[i].w;
if (w < d[v]) {
d[v] = w;
pr[v] = i;
pq.push({w, v});
}
}
}
return d[t];
}
int main() {
RD(n, m, L, s, t);
for (int i(0), _B(m); i < _B; ++i) {
RD(e[i].u, e[i].v, e[i].w);
if (!e[i].w) {
e[i].w = 1;
e[i].f = 1;
} else {
g[e[i].u].push_back(i);
g[e[i].v].push_back(i);
}
}
if (sp() < L) {
PL("NO");
return 0;
}
for (int i(0), _B(m); i < _B; ++i)
if (e[i].f) {
g[e[i].u].push_back(i);
g[e[i].v].push_back(i);
}
long long w = sp();
if (w > L) {
PL("NO");
return 0;
}
for (; w < L; w = sp()) {
for (int k = t; k != s; k = e[pr[k]].go(k)) {
int i = pr[k];
if (e[i].f) {
e[i].w += L - w;
break;
}
}
}
PL("YES");
for (int i(0), _B(m); i < _B; ++i) PL(e[i].u, e[i].v, e[i].w);
}
|
#include <bits/stdc++.h>
using namespace std;
void read_file(bool outToFile = true) {}
const int nMax = 1000 + 9;
const int mMax = 10000 + 9;
const long long OO = 1LL * 1000000000 * 1000000000 + 1;
const long long wMax = 1LL * 1000000000 * 1000000000;
int n, m, L, src, dst;
pair<pair<int, int>, long long> E[mMax];
bool is[mMax];
vector<vector<int> > G;
long long SP[nMax];
int par[nMax];
long long 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++) SP[i] = OO;
memset(par, -1, sizeof par);
SP[src] = 0;
par[src] = -2;
PQ.push(make_pair(0, src));
while (!PQ.empty()) {
pair<long long, int> top = PQ.top();
PQ.pop();
int u = top.second;
long long d = top.first;
if (d > SP[u]) continue;
for (int i = 0, sz = G[u].size(); i < sz; i++) {
pair<pair<int, int>, long long> e = E[G[u][i]];
int v = e.first.first == u ? e.first.second : e.first.first;
long long w = e.second;
if (SP[v] <= SP[u] + w) continue;
SP[v] = SP[u] + w;
PQ.push(make_pair(SP[v], v));
par[v] = G[u][i];
}
}
return SP[dst];
}
void run_dijkstra(int u) {
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
PQ;
PQ.push(make_pair(SP[u], u));
while (!PQ.empty()) {
pair<long long, int> top = PQ.top();
PQ.pop();
int u = top.second;
long long d = top.first;
if (d > SP[u]) continue;
for (int i = 0, sz = G[u].size(); i < sz; i++) {
pair<pair<int, int>, long long> e = E[G[u][i]];
int v = e.first.first == u ? e.first.second : e.first.first;
long long w = e.second;
if (SP[v] <= SP[u] + w) continue;
SP[v] = SP[u] + w;
PQ.push(make_pair(SP[v], v));
}
}
}
int main() {
read_file();
while (scanf("%d%d", &n, &m) != EOF) {
scanf("%d%d%d", &L, &src, &dst);
memset(is, 0, sizeof is);
G.assign(n, vector<int>());
for (int i = 0; i < m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
E[i] = pair<pair<int, int>, long long>(make_pair(u, v), w);
is[i] = w == 0 ? 1 : 0;
if (!is[i]) {
G[u].push_back(i);
G[v].push_back(i);
}
}
long long sp = dijkstra();
if (sp < L) {
printf("NO\n");
continue;
} else if (sp == L) {
printf("YES\n");
for (int i = 0; i < m; i++) {
int u, v;
long long w;
u = E[i].first.first, v = E[i].first.second;
w = E[i].second;
if (w == 0) w = wMax;
printf("%d %d %lld\n", u, v, w);
}
continue;
}
bool done = false;
for (int i = 0; i < m; i++) {
if (!is[i]) continue;
int u = E[i].first.first, v = E[i].first.second;
long long &w = E[i].second;
if (done) {
w = wMax;
continue;
}
w = 1;
G[u].push_back(i);
G[v].push_back(i);
if (llabs(SP[u] - SP[v]) <= 1) {
continue;
}
if (SP[u] > SP[v]) swap(u, v);
run_dijkstra(u);
if (SP[dst] > L) continue;
w += L - SP[dst];
done = true;
}
if (!done) {
printf("NO\n");
continue;
}
printf("YES\n");
for (int i = 0; i < m; i++) {
int u, v;
long long w;
u = E[i].first.first, v = E[i].first.second;
w = E[i].second;
assert(0 <= w && w <= wMax);
printf("%d %d %lld\n", u, v, w);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, m, l, s, t, a, b, weight, inf = 2e18;
vector<vector<long long int>> adj1(1005), adj2(1005);
vector<long long int> d(1005), p(1005);
long long int fixedd[1005][1005], variable[1005][1005];
void dijkstra(vector<long long int> &d, vector<long long int> &p) {
d.assign(n + 1, inf);
p.assign(n + 1, -1);
set<pair<long long int, long long int>> S;
S.insert({0, s});
d[s] = 0;
while (!S.empty()) {
pair<long long int, long long int> x = *S.begin();
S.erase(S.begin());
for (int y : adj1[x.second]) {
if (d[x.second] + fixedd[x.second][y] < d[y]) {
S.erase({d[y], y});
d[y] = d[x.second] + fixedd[x.second][y];
S.insert({d[y], y});
p[y] = x.second;
}
}
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> l >> s >> t;
memset(fixedd, 0, sizeof(fixedd));
memset(variable, 0, sizeof(variable));
for (long long int i = 0; i < m; i++) {
cin >> a >> b >> weight;
if (weight == 0) {
adj2[a].push_back(b);
adj2[b].push_back(a);
variable[a][b] = 1;
variable[b][a] = 1;
} else {
adj1[a].push_back(b);
adj1[b].push_back(a);
fixedd[a][b] = weight;
fixedd[b][a] = weight;
}
}
dijkstra(d, p);
if (d[t] < l) {
cout << "NO\n";
return 0;
}
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < adj2[i].size(); j++) {
adj1[i].push_back(adj2[i][j]);
fixedd[i][adj2[i][j]] = 1;
}
}
dijkstra(d, p);
if (d[t] > l) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
while (d[t] != l) {
long long int x = t;
while (p[x] != -1) {
if (variable[x][p[x]]) {
fixedd[x][p[x]] += l - d[t];
fixedd[p[x]][x] += l - d[t];
break;
} else
x = p[x];
}
dijkstra(d, p);
}
long long int done[1005][1005];
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < n; j++) {
if (done[i][j] == 0 && done[j][i] == 0 && fixedd[i][j] != 0) {
cout << i << " " << j << " " << fixedd[i][j] << '\n';
done[i][j] = 1;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<pair<long long, long long>, long long> > vf;
vector<pair<long long, long long> > adj[1008];
vector<int> num[1008];
long long n;
long long m;
long long l;
long long s, t;
long long st[10008], nd[10008], val[10008];
int var[10008] = {0};
long long vis[1008] = {0};
void dfs(long long u) {
if (vis[u]) return;
vis[u] = 1;
long long sz = adj[u].size();
for (int j = 0; j < sz; j++) {
pair<long long, long long> v = adj[u][j];
dfs((long long)v.first);
}
}
int main() {
scanf("%lld", &n);
scanf("%lld", &m);
scanf("%lld", &l);
scanf("%lld", &s);
scanf("%lld", &t);
for (long long i = 0; i < m; i++) {
long long u, v;
long long w;
scanf("%lld", &u);
scanf("%lld", &v);
scanf("%lld", &w);
st[i] = u;
nd[i] = v;
val[i] = w;
if (!w) var[i] = 1;
adj[u].push_back(pair<long long, long long>(v, w));
num[u].push_back(i);
adj[v].push_back(pair<long long, long long>(u, w));
num[v].push_back(i);
}
dfs(s);
if (!vis[t]) {
cout << "NO";
return 0;
}
vector<long long> dist;
dist.resize(1008, 1000000000000000000ll);
dist[s] = 0;
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq;
pq.push(pair<long long, long long>(0, s));
while (!pq.empty()) {
pair<long long, long long> front = pq.top();
pq.pop();
long long d = front.first, u = front.second;
if (d > dist[u]) continue;
for (long long j = 0; j < (long long)adj[u].size(); j++) {
pair<long long, long long> v = adj[u][j];
long long ex = 1000000000000000000ll;
if (v.second == 0)
;
else
ex = v.second;
if (dist[u] + ex < dist[v.first]) {
dist[v.first] = dist[u] + ex;
pq.push(pair<long long, long long>(dist[v.first], v.first));
}
}
}
if (dist[t] < l) {
cout << "NO";
return 0;
} else if (dist[t] == l) {
printf("YES\n");
for (long long i = 0; i < m; i++) {
long long ex = (val[i] ? val[i] : 1000000000000000000ll);
printf("%llu %llu %llu\n", st[i], nd[i], ex);
}
return 0;
}
while (!pq.empty()) pq.pop();
dist.clear();
dist.resize(1008, 1000000000000000000ll);
dist[t] = 0;
pq.push(pair<long long, long long>(0, t));
while (!pq.empty()) {
pair<long long, long long> front = pq.top();
pq.pop();
long long d = front.first, u = front.second;
if (d > dist[u]) continue;
for (long long j = 0; j < (long long)adj[u].size(); j++) {
pair<long long, long long> v = adj[u][j];
long long ex = max(v.second, 1ll);
if (dist[u] + ex < dist[v.first]) {
dist[v.first] = dist[u] + ex;
pq.push(pair<long long, long long>(dist[v.first], v.first));
}
}
}
if (dist[s] > l) {
cout << "NO";
return 0;
}
while (!pq.empty()) pq.pop();
vector<int> diss(1008, 1000000007);
diss[s] = 0;
pq.push(pair<long long, long long>(0, s));
while (!pq.empty()) {
pair<long long, long long> front = pq.top();
pq.pop();
long long d = front.first, u = front.second;
if (d > diss[u]) continue;
for (long long j = 0; j < (long long)adj[u].size(); j++) {
pair<long long, long long> v = adj[u][j];
if (var[num[u][j]]) {
val[num[u][j]] = v.second =
max(val[num[u][j]], max(1ll, l - dist[v.first] - diss[u]));
}
long long ex = v.second;
if (diss[u] + ex < diss[v.first]) {
diss[v.first] = diss[u] + ex;
pq.push(pair<long long, long long>(diss[v.first], v.first));
}
}
}
printf("YES");
printf("\n");
for (int i = 0; i < m; i++) {
printf("%llu %llu %llu\n", st[i], nd[i], (val[i] ? val[i] : l));
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> adia[1100];
int costsg;
int n, m;
int S, T, l;
int dist[1100];
vector<pair<pair<int, int>, pair<int, int>>> alone;
int cbin();
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> l >> S >> T;
int a, b, c;
while (m--) {
cin >> a >> b >> c;
if (c == 0) alone.push_back({{a, adia[a].size()}, {b, adia[b].size()}});
adia[a].push_back({b, c});
adia[b].push_back({a, c});
}
costsg = 100;
int p(0), q(1 << 30);
while (q) {
if (p + q <= 1000 * 1000 * 1100) {
costsg = p + q;
int x(cbin());
if (x <= l) p += q;
}
q >>= 1;
}
costsg = p;
if (cbin() > l || p == 0) {
cout << "NO";
return 0;
}
costsg = p + 1;
if (cbin() < l) {
cout << "NO";
return 0;
}
for (auto i : alone) {
adia[i.first.first][i.first.second].second =
adia[i.second.first][i.second.second].second = p;
}
int punere(p);
p = 0, q = 1 << 20;
while (q) {
if (p + q <= alone.size()) {
for (int i(0); i < p + q; i++)
adia[alone[i].first.first][alone[i].first.second].second++,
adia[alone[i].second.first][alone[i].second.second].second++;
int x(cbin());
for (int i(0); i < p + q; i++)
adia[alone[i].first.first][alone[i].first.second].second--,
adia[alone[i].second.first][alone[i].second.second].second--;
if (x <= l) p += q;
}
q >>= 1;
}
for (int i(0); i < p; i++)
adia[alone[i].first.first][alone[i].first.second].second++,
adia[alone[i].second.first][alone[i].second.second].second++;
cout << "YES\n";
for (int i(0); i < n; i++) {
for (auto j : adia[i]) {
if (j.first > i) cout << i << ' ' << j.first << ' ' << j.second << '\n';
}
}
return 0;
}
int cbin() {
for (int i(0); i <= n; i++) dist[i] = 1e9 + 100;
priority_queue<pair<int, int>> q;
q.push({0, S});
while (!q.empty()) {
int t(q.top().first), x(q.top().second);
t *= -1;
q.pop();
if (dist[x] < t) continue;
if (x == T) return dist[x];
for (auto i : adia[x]) {
if (!i.second) i.second = costsg;
if (dist[i.first] > t + i.second) {
dist[i.first] = t + i.second;
q.push({-dist[i.first], i.first});
}
}
}
return 2 * 1000 * 1000 * 1000;
}
|
#include <bits/stdc++.h>
using namespace std;
using ii = pair<long long int, long long int>;
const long long int N = 1000 + 5, INF = 1e18, M = 10000 + 5;
vector<long long int> G[N];
vector<ii> g[N];
long long int dist[N][N], d1[N], d2[N], U[M], V[M], W[M], p[N];
long long int n, m, s, t, L;
void djk() {
priority_queue<ii, vector<ii>, greater<ii> > q;
q.push({0, s});
d1[s] = 0;
while (!q.empty()) {
long long int u = q.top().second, d = q.top().first;
q.pop();
for (auto& it : g[u]) {
long long int v = it.first, w = it.second;
if (d1[u] + w < d1[v]) {
d1[v] = d1[u] + w;
q.push({d1[v], v});
}
}
}
}
bool djk2() {
priority_queue<ii, vector<ii>, greater<ii> > q;
q.push({0, s});
d2[s] = 0;
while (!q.empty()) {
long long int u = q.top().second, d = q.top().first;
q.pop();
for (long long int v : G[u]) {
long long int w = dist[u][v];
if (d2[u] + abs(w) < d2[v]) {
d2[v] = d2[u] + abs(w);
p[v] = u;
q.push({d2[v], v});
}
}
}
if (d2[t] > L) {
return false;
}
long long int cur = t;
while (cur != s) {
long long int par = p[cur];
if (dist[cur][par] < 0) {
dist[par][cur] = dist[cur][par] = -2;
}
cur = p[cur];
}
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < n; j++) {
if (dist[i][j] == -1) {
dist[i][j] = INF;
}
}
}
cur = t;
while (cur != s) {
long long int par = p[cur];
if (dist[cur][par] < 0) {
dist[par][cur] = dist[cur][par] = -1;
}
cur = p[cur];
}
return true;
}
bool relax() {
for (long long int i = 0; i < n; i++) {
d2[i] = INF;
}
priority_queue<ii, vector<ii>, greater<ii> > q;
q.push({0, s});
d2[s] = 0;
while (!q.empty()) {
long long int u = q.top().second, d = q.top().first;
q.pop();
for (auto& v : G[u]) {
long long int w = dist[u][v];
if (d2[u] + abs(w) < d2[v]) {
d2[v] = d2[u] + abs(w);
p[v] = u;
q.push({d2[v], v});
}
}
}
if (d2[t] == L) {
return true;
}
long long int cur = t;
bool check = false;
while (cur != s) {
long long int par = p[cur];
if (dist[cur][par] < 0 and !check) {
dist[cur][par] = dist[par][cur] = abs(dist[par][cur]) + L - d2[t];
check = true;
}
if (check) {
break;
}
cur = p[cur];
}
return false;
}
int32_t main() {
cin.tie(0)->sync_with_stdio(0);
cin >> n >> m >> L >> s >> t;
for (long long int i = 0; i <= n; i++) {
d1[i] = d2[i] = INF;
}
for (long long int i = 0, u, v; i < m; i++) {
cin >> u >> v >> W[i];
U[i] = u, V[i] = v;
if (W[i] != 0) {
g[u].push_back({v, W[i]});
g[v].push_back({u, W[i]});
G[u].push_back(v);
G[v].push_back(u);
dist[u][v] = dist[v][u] = W[i];
} else {
G[u].push_back(v);
G[v].push_back(u);
dist[u][v] = dist[v][u] = -1;
}
}
djk();
if (d1[t] < L) {
cout << "NO\n";
return 0;
}
if (d1[t] == L) {
cout << "YES\n";
for (long long int i = 0; i < m; i++) {
cout << U[i] << " " << V[i] << " ";
cout << ((W[i] == 0) ? INF : W[i]) << "\n";
}
return 0;
}
if (!djk2()) {
cout << "NO\n";
return 0;
}
while (!relax()) {
relax();
}
cout << "YES\n";
for (long long int i = 0; i < m; i++) {
cout << U[i] << " " << V[i] << " " << abs(dist[U[i]][V[i]]) << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
const int maxm = 10010;
const int INF = 1e9;
const long long inf = 1e17;
struct edge {
int u, v, w;
};
edge E[maxm];
int ans[maxn][maxn], pre[maxn];
vector<pair<int, int> > vec[maxn];
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
Q;
long long dis[maxn];
bool vis[maxn];
int n, m, L, s, t;
inline void dijkstra() {
fill(dis, dis + maxn, inf);
memset(vis, 0, sizeof(vis));
memset(pre, -1, sizeof(pre));
Q.push(make_pair(dis[s] = 0, s));
while (!Q.empty()) {
int u = Q.top().second;
Q.pop();
if (vis[u]) continue;
vis[u] = 1;
for (auto &elem : vec[u]) {
if (!vis[elem.first] && dis[elem.first] > dis[u] + elem.second) {
pre[elem.first] = u;
Q.push(make_pair(dis[elem.first] = dis[u] + elem.second, elem.first));
}
}
}
}
inline bool check() {
for (int i = 1; i <= n; ++i) vec[i].clear();
for (int i = 0; i < m; ++i) {
vec[E[i].u].emplace_back(E[i].v, E[i].w ? E[i].w : INF);
vec[E[i].v].emplace_back(E[i].u, E[i].w ? E[i].w : INF);
}
dijkstra();
if (dis[t] < L) return 0;
for (int i = 1; i <= n; ++i) vec[i].clear();
for (int i = 0; i < m; ++i) {
vec[E[i].u].emplace_back(E[i].v, max(1, E[i].w));
vec[E[i].v].emplace_back(E[i].u, max(1, E[i].w));
}
dijkstra();
if (dis[t] > L) return 0;
int l = 1, r = INF, mid, u = 0, v = 0;
while (l < r) {
mid = l + r >> 1;
for (int i = 1; i <= n; ++i) vec[i].clear();
for (int i = 0; i < m; ++i) {
vec[E[i].u].emplace_back(E[i].v, E[i].w ? E[i].w : mid);
vec[E[i].v].emplace_back(E[i].u, E[i].w ? E[i].w : mid);
}
dijkstra();
if (dis[t] >= L)
r = mid;
else
l = mid + 1;
}
for (int i = 1; i <= n; ++i) vec[i].clear();
for (int i = 0; i < m; ++i) {
vec[E[i].u].emplace_back(E[i].v, E[i].w ? E[i].w : l);
vec[E[i].v].emplace_back(E[i].u, E[i].w ? E[i].w : l);
}
dijkstra();
assert(dis[t] >= L);
for (int i = t; i != -1; i = pre[i]) {
if (pre[i] == -1) break;
if (ans[pre[i]][i] == 0) {
u = pre[i], v = i;
break;
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j < i; ++j) {
if (ans[i][j] == 0) {
ans[i][j] = ans[j][i] = l;
}
}
}
if (u && v) {
ans[u][v] -= dis[t] - L;
ans[v][u] -= dis[t] - L;
}
return 1;
}
int main() {
while (~scanf("%d%d%d%d%d", &n, &m, &L, &s, &t)) {
++s, ++t;
memset(ans, -1, sizeof(ans));
for (int i = 0; i < m; ++i) {
scanf("%d%d%d", &E[i].u, &E[i].v, &E[i].w);
++E[i].u, ++E[i].v;
ans[E[i].u][E[i].v] = ans[E[i].v][E[i].u] = E[i].w;
}
if (!check()) {
puts("NO");
continue;
}
puts("YES");
for (int i = 0; i < m; ++i)
printf("%d %d %d\n", E[i].u - 1, E[i].v - 1, ans[E[i].u][E[i].v]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x3f3f3f3f3f3f3f3f;
const int MOD = 1e9 + 7;
const int maxn = 2e4 + 10;
const int maxv = 1e3 + 10;
const double eps = 1e-9;
int n, m, s, t;
long long L;
int cnt, pnt[maxn], nxt[maxn], head[maxv], from[maxn];
long long cost[maxn];
bool can[maxn];
void add_edge(int u, int v, long long val) {
from[cnt] = u;
pnt[cnt] = v;
cost[cnt] = val;
nxt[cnt] = head[u];
if (!cost[cnt]) can[cnt] = true;
head[u] = cnt++;
}
void print() {
for (int i = 0; i < cnt; i++) {
cout << from[i] << ' ' << pnt[i] << ' ' << cost[i] << endl;
}
}
void change(long long x) {
for (int i = 0; i < cnt; i++) {
if (can[i]) cost[i] = x;
}
}
int vis[maxv];
long long dis[maxv];
int pedge[maxn];
long long dij() {
memset(dis, 0x3f, sizeof dis);
dis[s] = 0;
memset(vis, 0, sizeof vis);
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq;
pq.push(pair<long long, long long>(0, s));
while (pq.size()) {
auto cur = pq.top();
pq.pop();
int u = cur.second;
long long d = cur.first;
vis[u] = 1;
if (dis[u] < d) continue;
for (int i = head[u]; ~i; i = nxt[i]) {
int v = pnt[i];
if (dis[v] > dis[u] + cost[i]) {
dis[v] = dis[u] + cost[i];
if (!vis[v]) pq.push(pair<long long, long long>(dis[v], v));
pedge[v] = i ^ 1;
}
}
}
return dis[t];
}
int main() {
cnt = 0;
memset(head, -1, sizeof head);
memset(can, 0, sizeof can);
cin >> n >> m >> L >> s >> t;
for (int i = 0; i < m; i++) {
int u, v;
long long val;
cin >> u >> v >> val;
add_edge(u, v, val);
add_edge(v, u, val);
}
change(inf);
if (dij() < L) {
puts("NO");
return 0;
}
change(1);
if (dij() > L) {
puts("NO");
return 0;
}
int allss = 0;
while (1) {
long long now = dij();
if (now >= L) break;
for (int cur = t; cur != s; cur = pnt[pedge[cur]]) {
int i = pedge[cur];
if (can[i]) {
cost[i] = cost[i ^ 1] += L - now;
break;
}
}
}
puts("YES");
for (int i = 0; i < cnt; i += 2) {
printf("%d %d %lld\n", from[i], pnt[i], cost[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int DI[] = {-1, 0, 1, 0};
const int DJ[] = {0, 1, 0, -1};
const int MAXINT = 0x7fffffff;
const int BIGINT = 0x20000000;
const long long MAXLL = 0x7fffffffffffffffLL;
const long long BIGLL = 0x2000000000000000LL;
template <typename T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <typename T>
T powmod(T a, T b, T m) {
T r = 1;
a %= m;
for (; b; b >>= 1) {
if (b & 1) r = r * a % m;
a = a * a % m;
}
return r;
}
template <typename W>
vector<W> Dijkstra(vector<unordered_map<int, W>>& edge, W inf, int s,
vector<int>& parent) {
int n = edge.size();
vector<W> dis(n, inf);
set<pair<W, int>> Q;
dis[s] = 0;
Q.insert(make_pair(0, s));
while (!Q.empty()) {
auto p = Q.begin();
int u = p->second;
Q.erase(p);
for (auto& p : edge[u]) {
int v = p.first;
W w = p.second;
if (dis[u] + w < dis[v]) {
if (dis[v] < inf) {
Q.erase(make_pair(dis[v], v));
}
parent[v] = u;
dis[v] = dis[u] + w;
Q.insert(make_pair(dis[v], v));
}
}
}
return dis;
}
int main() {
ios::sync_with_stdio(false);
int N, M, S, T;
long long L;
cin >> N >> M >> L >> S >> T;
vector<unordered_map<int, long long>> edge(N), cand(N);
for (int i = 0; i < M; ++i) {
int a, b;
long long w;
cin >> a >> b >> w;
if (w) {
edge[a][b] = edge[b][a] = w;
} else {
cand[a][b] = cand[b][a] = 1;
}
}
vector<int> parent(N);
vector<long long> dis = Dijkstra(edge, BIGLL, S, parent);
if (dis[T] < L) {
cout << "NO" << endl;
return 0;
}
for (int i = 0; i < N; ++i)
for (auto& p : cand[i]) edge[i][p.first] = p.second;
dis = Dijkstra(edge, BIGLL, S, parent);
if (dis[T] > L) {
cout << "NO" << endl;
return 0;
}
while (dis[T] < L) {
int v = T;
while (v != S) {
int u = parent[v];
if (cand[u].find(v) != cand[u].end()) {
edge[u][v] += L - dis[T];
edge[v][u] += L - dis[T];
break;
}
v = u;
}
dis = Dijkstra(edge, BIGLL, S, parent);
}
cout << "YES" << endl;
for (int i = 0; i < N; ++i)
for (auto& p : edge[i])
if (i < p.first) {
cout << i << ' ' << p.first << ' ' << p.second << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1100, inf = 1e9 + 1;
int e, head[N], done[N], dist[N];
int n, m, L, s, t;
struct Edge {
int v, w, nx;
} edges[N * N];
void init() {
e = 0;
memset(head, -1, sizeof head);
}
void add_edge(int u, int v, int w) {
edges[e] = (Edge){v, w, head[u]};
head[u] = e++;
}
struct Node {
int u, d;
bool operator<(const Node& o) const { return d > o.d; }
};
void dijkstra() {
for (int i = 0; i < n; i++) dist[i] = inf, done[i] = 0;
priority_queue<Node> pq;
pq.push((Node){s, 0});
dist[s] = 0;
while (!pq.empty()) {
Node x = pq.top();
pq.pop();
int u = x.u;
if (done[u]) continue;
done[u] = 1;
for (int i = head[u]; ~i; i = edges[i].nx) {
int v = edges[i].v;
int w = edges[i].w;
if (dist[v] > dist[u] + w) {
dist[v] = dist[u] + w;
pq.push((Node){v, dist[v]});
}
}
}
}
vector<Edge> v1, v2;
int check(int x) {
init();
for (int i = 0; i < (int)v1.size(); i++) {
add_edge(v1[i].v, v1[i].w, v1[i].nx);
add_edge(v1[i].w, v1[i].v, v1[i].nx);
}
for (int i = 0; i < x; i++) {
add_edge(v2[i].v, v2[i].w, 1);
add_edge(v2[i].w, v2[i].v, 1);
}
dijkstra();
return dist[t];
}
int main() {
scanf("%d%d%d%d%d", &n, &m, &L, &s, &t);
for (int i = 0; i < m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
if (w)
v1.push_back((Edge){u, v, w});
else
v2.push_back((Edge){u, v, w});
}
int L1 = check(0), L2 = check(v2.size());
if (L1 < L || L2 > L) {
puts("NO");
return 0;
}
if (L1 == L) {
puts("YES");
for (int i = 0; i < (int)v1.size(); i++)
printf("%d %d %d\n", v1[i].v, v1[i].w, v1[i].nx);
for (int i = 0; i < (int)v2.size(); i++)
printf("%d %d %d\n", v2[i].v, v2[i].w, inf);
return 0;
}
int low = 0, high = v2.size();
while (high - low > 1) {
int M = (low + high) / 2;
if (check(M) <= L)
high = M;
else
low = M;
}
int nowL = check(high);
puts("YES");
for (int i = 0; i < (int)v1.size(); i++)
printf("%d %d %d\n", v1[i].v, v1[i].w, v1[i].nx);
for (int i = 0; i < high - 1; i++) printf("%d %d %d\n", v2[i].v, v2[i].w, 1);
printf("%d %d %d\n", v2[high - 1].v, v2[high - 1].w, L - nowL + 1);
for (int i = high; i < (int)v2.size(); i++)
printf("%d %d %d\n", v2[i].v, v2[i].w, inf);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
const int N = 100005;
const double PI = 4 * atan(1);
const double eps = 1e-7;
const long long oo = 1e18;
const int AlPHA = 26, B = 30;
long long n, m, L, sr, t;
long long adj[1005][1005];
long long yes[1005][1005];
long long dist[1005];
vector<long long> ad[N];
bool vis[1005];
vector<pair<long long, long long> > v;
void dijkstra(long long src) {
set<pair<long long, long long> > ss;
pair<long long, long long> ras;
for (int i = 0; i < n; i++) {
dist[i] = 1e17;
vis[i] = 0;
}
dist[src] = 0;
ss.insert(make_pair(0, src));
while (!ss.empty()) {
ras = *(ss.begin());
ss.erase(ss.begin());
src = ras.second;
long long w = ras.first;
if (vis[src]) continue;
vis[src] = 1;
for (auto u : ad[src]) {
if (dist[u] > w + adj[src][u]) {
dist[u] = w + adj[src][u];
ss.insert(make_pair(dist[u], u));
}
}
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m >> L >> sr >> t;
for (int i = 0; i < m; i++) {
long long x, y, z;
cin >> x >> y >> z;
ad[x].push_back(y);
ad[y].push_back(x);
if (z > 0) {
adj[x][y] = adj[y][x] = z;
} else {
adj[x][y] = adj[y][x] = 1;
yes[x][y] = yes[y][x] = 1;
v.push_back(make_pair(x, y));
}
}
dijkstra(sr);
long long x = dist[t];
long long i = 0;
while (i < v.size() && x < L) {
long long y = L - x + 1;
adj[v[i].first][v[i].second] = adj[v[i].second][v[i].first] = y;
dijkstra(sr);
x = dist[t];
i++;
}
if (x != L) {
cout << "NO";
return 0;
} else {
cout << "YES\n";
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (adj[i][j]) cout << i << " " << j << " " << adj[i][j] << "\n";
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, S, T;
vector<pair<int, int>> adj[1100], e;
bool un[10100];
long long L, cost[1100], value[10100];
bool inq[1100];
queue<int> q;
long long go() {
for (int i = (0); i < (N); i++) cost[i] = 1e18;
cost[S] = 0, q.push(S), inq[S] = 1;
while (q.size()) {
int i = q.front();
q.pop();
inq[i] = 0;
for (auto j : adj[i])
if (cost[j.first] > cost[i] + value[j.second]) {
cost[j.first] = cost[i] + value[j.second];
if (!inq[j.first]) q.push(j.first), inq[j.first] = 1;
}
}
return cost[T];
}
int main() {
scanf("%d %d %lld %d %d", &N, &M, &L, &S, &T);
for (int i = (0); i < (M); i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
e.push_back(make_pair(a, b));
value[i] = c;
adj[a].push_back(make_pair(b, i));
adj[b].push_back(make_pair(a, i));
if (!c) un[i] = 1;
}
for (int i = (0); i < (M); i++)
if (un[i]) {
value[i] = 1;
}
long long best = go();
for (int i = (0); i < (M); i++)
if (un[i]) {
value[i] = 2e9;
}
long long worst = go();
if (L < best || L > worst) return puts("NO"), 0;
puts("YES");
if (worst > L) {
for (int i = (0); i < (M); i++)
if (un[i]) {
value[i] = 1;
long long g = go();
if (g <= L) {
value[i] = 1 + (L - g);
break;
}
}
}
assert(go() == L);
for (int i = (0); i < (M); i++) {
int a, b;
tie(a, b) = e[i];
printf("%d %d %lld\n", a, b, value[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e15;
int n, m, s, t;
long long L;
long long dst[3][1007];
struct edge {
int to;
long long w;
bool q;
edge() {}
edge(int to, long long w, bool q) : to(to), w(w), q(q) {}
};
vector<edge> adj[1007];
bool G[1007][1007];
void dijkstra(int x) {
dst[1][x] = 0;
priority_queue<pair<long long, int> > pq;
pq.push(make_pair(0, x));
while (!pq.empty()) {
int u = pq.top().second;
long long w = -pq.top().first;
pq.pop();
if (w != dst[1][u]) continue;
for (auto b : adj[u]) {
int v = b.to;
long long dw = b.w;
if (dst[1][v] > dst[1][u] + dw) {
dst[1][v] = dst[1][u] + dw;
pq.push(make_pair(-dst[1][v], v));
}
}
}
}
void dijkstra1() {
priority_queue<pair<long long, int> > pq;
dst[0][s] = 0;
pq.push(make_pair(0, s));
while (!pq.empty()) {
int u = pq.top().second;
long long w = -pq.top().first;
pq.pop();
if (dst[0][u] != w) continue;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i].to;
long long nw = adj[u][i].w;
bool e = adj[u][i].q;
if (G[u][v]) continue;
if (e) {
if (L - dst[1][v] - w <= 0)
adj[u][i].w = 1000000000;
else
adj[u][i].w = L - dst[1][v] - w;
G[v][u] = 1;
nw = adj[u][i].w;
}
if (dst[0][v] > dst[0][u] + nw) {
dst[0][v] = dst[0][u] + nw;
pq.push(make_pair(-dst[0][v], v));
}
}
}
}
int main() {
cin >> n >> m >> L >> s >> t;
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
bool q = 0;
if (w == 0) {
w = 1;
q = 1;
}
adj[u].push_back(edge(v, w, q));
adj[v].push_back(edge(u, w, q));
}
fill(dst[0], dst[0] + n + 1, inf);
fill(dst[1], dst[1] + n + 1, inf);
dijkstra(t);
if (dst[1][s] > L) {
printf("NO\n");
return 0;
}
dijkstra1();
fill(dst[1], dst[1] + n + 1, inf);
dijkstra(s);
if (dst[1][t] != L) {
printf("NO\n");
return 0;
}
printf("YES\n");
for (int i = 0; i < n; i++) {
for (auto x : adj[i]) {
if (G[i][x.to]) continue;
G[x.to][i] = 1;
printf("%d %d %lld\n", i, x.to, x.w);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const string task = "rvq";
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
int n, m, s, t;
vector<pair<long long, long long> > adj[10005];
vector<int> todo;
long long v[10005], u[10005], w[10005], d[10005], L;
void dijkstra() {
for (int i = int(0); i <= int(n); i++) d[i] = (1ll << 60);
d[s] = 0ll;
priority_queue<pair<long long, long long> > pq;
pq.push({0, s});
while (!pq.empty()) {
long long x = pq.top().second;
long long tt = -pq.top().first;
pq.pop();
if (d[x] < tt) continue;
for (auto i : adj[x]) {
if (d[i.first] > d[x] + i.second) {
d[i.first] = d[x] + i.second;
pq.push({-d[i.first], i.first});
}
}
}
}
long long check(long long x) {
for (auto i : todo) {
w[i] = 1 + min(x, 1000000000LL);
x -= w[i] - 1;
}
for (int i = int(0); i <= int(n); i++) adj[i].clear();
for (int i = int(1); i <= int(m); i++) {
adj[v[i]].push_back({u[i], w[i]});
adj[u[i]].push_back({v[i], w[i]});
}
dijkstra();
return d[t];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> L >> s >> t;
for (int i = int(1); i <= int(m); i++) {
cin >> v[i] >> u[i] >> w[i];
if (w[i] == 0) todo.push_back(i);
}
long long l = 0, d = 1000000000LL * todo.size(), mid, ans = -1;
if (check(0) > L || check(d) < L) {
cout << "NO\n";
return 0;
}
while (l <= d) {
mid = (l + d) / 2ll;
if (check(mid) <= L) {
ans = mid;
l = mid + 1;
} else
d = mid - 1;
}
check(ans);
cout << "YES\n";
for (int i = int(1); i <= int(m); i++) {
cout << v[i] << ' ' << u[i] << ' ' << w[i] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 10000000000000000;
const int maxN = 1000 + 10;
const int maxM = 20000 + 10;
long long d1;
int er[maxM];
vector<int> paths1;
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; }
};
vector<Edge> edges;
vector<int> G[maxN];
bool done[maxN];
long long d[maxN];
int p[maxM];
struct Dijkstra {
int n, m;
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});
}
}
}
}
void GetShortestPaths(int s, int u) {
dijkstra(s);
if (d[u] >= INF) {
d1 = d[u];
return;
}
for (int i = u; i <= u; i++) {
d1 = d[i];
paths1.clear();
int t = i;
paths1.push_back(t);
while (t != s) {
paths1.push_back(edges[p[t]].from);
t = edges[p[t]].from;
}
reverse(paths1.begin(), paths1.end());
}
}
};
Dijkstra solver;
Edge ei[10000 + 10];
int main() {
int n, m, s, t;
long long L;
while (~scanf("%d%d%lld%d%d", &n, &m, &L, &s, &t)) {
memset(er, 0, sizeof(er));
int er_cnt = 0;
for (long long i = 0; i < m; i++) {
scanf("%d%d%lld", &ei[i].from, &ei[i].to, &ei[i].dist);
if (ei[i].dist == 0) {
er[i] = ++er_cnt;
}
}
solver.init(n);
for (int i = 0; i < m; i++) {
if (er[i]) ei[i].dist = L;
solver.AddEdge(ei[i].from, ei[i].to, ei[i].dist);
solver.AddEdge(ei[i].to, ei[i].from, ei[i].dist);
}
solver.GetShortestPaths(s, t);
if (d1 < L)
printf("NO\n");
else if (d1 == L) {
printf("YES\n");
for (long long i = 0; i < m; i++)
printf("%d %d %lld\n", ei[i].from, ei[i].to, ei[i].dist);
} else {
solver.init(n);
for (int i = 0; i < m; i++) {
if (er[i]) ei[i].dist = 1;
solver.AddEdge(ei[i].from, ei[i].to, ei[i].dist);
solver.AddEdge(ei[i].to, ei[i].from, ei[i].dist);
}
solver.GetShortestPaths(s, t);
if (d1 > L)
printf("NO\n");
else if (d1 == L) {
printf("YES\n");
for (int i = 0; i < m; i++)
printf("%d %d %lld\n", ei[i].from, ei[i].to, ei[i].dist);
} else {
int x = 1, y = er_cnt, ans;
while (x <= y) {
int mid = (x + y) / 2;
solver.init(n);
for (int i = 0; i < m; i++) {
if (1 <= er[i] && er[i] <= mid)
ei[i].dist = 1;
else if (er[i] > mid)
ei[i].dist = L;
solver.AddEdge(ei[i].from, ei[i].to, ei[i].dist);
solver.AddEdge(ei[i].to, ei[i].from, ei[i].dist);
}
solver.GetShortestPaths(s, t);
if (d1 <= L) {
ans = mid;
y = mid - 1;
} else
x = mid + 1;
}
solver.init(n);
for (int i = 0; i < m; i++) {
if (1 <= er[i] && er[i] <= ans)
ei[i].dist = 1;
else if (er[i] > ans)
ei[i].dist = L;
solver.AddEdge(ei[i].from, ei[i].to, ei[i].dist);
solver.AddEdge(ei[i].to, ei[i].from, ei[i].dist);
}
solver.GetShortestPaths(s, t);
long long add = L - d1;
long long pre, cnt = 0, now;
printf("YES\n");
for (int i = 0; i < m; i++) {
if (er[i] != ans)
printf("%d %d %lld\n", ei[i].from, ei[i].to, ei[i].dist);
else
printf("%d %d %lld\n", ei[i].from, ei[i].to, ei[i].dist + add);
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, s, t, l, rest;
long long d[1010], d2[1010], w[10010];
bool zeredg[10010];
pair<long long, long long> edg[10010];
vector<vector<long long> > edglist;
void dijkstra(long long dist[], bool sec) {
set<pair<long long, long long> > najbl;
dist[s] = 0;
najbl.insert({0, s});
for (long long i = 0; i < n; ++i) {
if (s != i) {
dist[i] = 1e18;
najbl.insert({dist[i], i});
}
}
while (najbl.size()) {
long long v = najbl.begin()->second;
najbl.erase(najbl.begin());
for (auto i : edglist[v]) {
long long u = edg[i].first + edg[i].second - v;
if (sec and dist[u] > dist[v] + w[i] and zeredg[i] and
w[i] < d[u] + rest - dist[v]) {
w[i] = d[u] + rest - dist[v];
}
if (dist[u] > dist[v] + w[i]) {
najbl.erase({dist[u], u});
dist[u] = dist[v] + w[i];
najbl.insert({dist[u], u});
}
}
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> m >> l >> s >> t;
vector<long long> vi;
edglist.resize(n, vi);
for (long long i = 0; i < m; ++i) {
long long u, v, e;
cin >> u >> v >> e;
edglist[u].push_back(i);
edglist[v].push_back(i);
edg[i] = {u, v};
if (e) {
w[i] = e;
} else {
w[i] = 1;
zeredg[i] = 1;
}
}
dijkstra(d, 0);
if (d[t] > l) {
cout << "NO";
return 0;
} else if (d[t] == l) {
cout << "YES\n";
for (long long i = 0; i < m; ++i) {
cout << edg[i].first << " " << edg[i].second << " " << w[i] << "\n";
}
return 0;
}
rest = l - d[t];
dijkstra(d2, 1);
if (d2[t] != l) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
for (long long i = 0; i < m; ++i) {
cout << edg[i].first << " " << edg[i].second << " " << w[i] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, s, t;
long long val[20010], dis[2000], l;
int sum = 0, des[20010], nxt[20010], e[20010], fst[2000];
int pre[2000], pree[2000];
bool b[20010], f[20010];
void add(int x, int y, long long z) {
des[++sum] = y, val[sum] = z, nxt[sum] = fst[x], fst[x] = sum,
e[sum] = sum + 1;
if (z == 0) val[sum] = 233333333333, b[sum] = 1;
des[++sum] = x, val[sum] = z, nxt[sum] = fst[y], fst[y] = sum,
e[sum] = sum - 1;
if (z == 0) val[sum] = 233333333333, b[sum] = 1;
}
void pr() {
memset(f, 0, sizeof f);
for (int i = 1; i <= sum; ++i)
if (!f[i]) {
printf("%d %d %I64d\n", des[e[i]], des[i], val[i]);
f[i] = f[e[i]] = 1;
}
}
int main() {
scanf("%d%d%I64d%d%d", &n, &m, &l, &s, &t);
memset(b, 0, sizeof b);
for (int i = 1; i <= m; ++i) {
int x, y;
long long z;
scanf("%d%d%I64d", &x, &y, &z);
add(x, y, z);
}
for (int i = 0; i < n; ++i) dis[i] = 233333333333;
queue<int> q;
q.push(s);
dis[s] = 0;
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = fst[x]; i; i = nxt[i]) {
int y = des[i];
if (dis[x] + val[i] < dis[y]) dis[y] = dis[x] + val[i], q.push(y);
}
}
if (dis[t] < l) {
printf("NO");
return 0;
}
if (dis[t] == l) {
printf("YES\n");
pr();
return 0;
}
for (int i = 1; i <= sum; ++i)
if (b[i]) val[i] = 1;
for (int i = 0; i < n; ++i) dis[i] = 233333333333;
q.push(s);
dis[s] = 0;
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = fst[x]; i; i = nxt[i]) {
int y = des[i];
if (dis[x] + val[i] < dis[y]) {
dis[y] = dis[x] + val[i], pre[y] = x, pree[y] = i;
q.push(y);
}
}
}
if (dis[t] > l) {
printf("NO");
return 0;
}
while (dis[t] < l) {
for (int i = t; i != s; i = pre[i]) {
if (b[pree[i]]) {
val[pree[i]] += l - dis[t], val[e[pree[i]]] += l - dis[t];
break;
}
}
for (int i = 0; i < n; ++i) dis[i] = 233333333333;
q.push(s);
dis[s] = 0;
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = fst[x]; i; i = nxt[i]) {
int y = des[i];
if (dis[x] + val[i] < dis[y]) {
dis[y] = dis[x] + val[i], pre[y] = x, pree[y] = i;
q.push(y);
}
}
}
}
printf("YES\n");
pr();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, L, S, T;
int st[20010], ed[20010], w[20010];
int last[1010], tot;
struct edge {
int t, next, w;
bool flag;
} e[20010 * 2];
void add(int from, int to, int w) {
e[++tot].t = to, e[tot].next = last[from], e[tot].w = w, last[from] = tot;
e[++tot].t = from, e[tot].next = last[to], e[tot].w = w, last[to] = tot;
}
int q[10 * 20010];
long long d[2][1010];
bool in[1010];
void spfa(int s, long long *dis) {
int l = 0, r = 0;
for (int i = 0; i < n; i++) dis[i] = 2147483647;
q[r++] = s, dis[s] = 0;
while (l < r) {
int now = q[l++];
in[now] = false;
for (int h = last[now]; h; h = e[h].next) {
int to = e[h].t;
if (dis[now] + e[h].w < dis[to]) {
dis[to] = dis[now] + e[h].w;
if (!in[to]) in[to] = true, q[r++] = to;
}
}
}
}
struct node {
int id, w;
node(int _id, int _w) { id = _id, w = _w; }
friend bool operator<(const node &u, const node &v) { return u.w > v.w; }
};
priority_queue<node> Q;
bool use[1010];
long long dist[1010];
void work(int s) {
for (int i = 0; i < n; i++) dist[i] = 2147483647;
dist[s] = 0;
memset(use, 0, sizeof(use));
while (!Q.empty()) {
node now = Q.top();
Q.pop();
if (use[now.id]) continue;
use[now.id] = true;
for (int h = last[now.id]; h; h = e[h].next) {
int to = e[h].t;
if (s == S && e[h].flag) {
if (dist[now.id] + d[1][to] + e[h].w <= L)
e[h].w = e[h ^ 1].w = L - dist[now.id] - d[1][to];
}
if (dist[now.id] + e[h].w < dist[to]) dist[to] = dist[now.id] + e[h].w;
Q.push(node(to, dist[to]));
}
}
}
int main() {
scanf("%d%d%d%d%d", &n, &m, &L, &S, &T);
tot = 1;
for (int i = 1; i <= m; i++) scanf("%d%d%d", &st[i], &ed[i], &w[i]);
for (int i = 1; i <= m; i++) add(st[i], ed[i], w[i]);
for (int i = 2; i <= tot; i++)
if (!e[i].w) e[i].flag = 1;
for (int i = 2; i <= tot; i++)
if (!e[i].w) e[i].w = 1;
Q.push(node(T, 0));
work(T);
for (int i = 0; i < n; i++) d[1][i] = dist[i];
Q.push(node(S, 0));
work(S);
for (int i = 2; i <= tot; i += 2)
if (e[i].flag) w[i / 2] = e[i].w;
if (dist[T] != L) return puts("NO"), 0;
puts("YES");
for (int i = 1; i <= m; i++) printf("%d %d %d\n", st[i], ed[i], w[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ii = pair<long long int, long long int>;
const long long int N = 1000 + 5, INF = 1e18, M = 10000 + 5;
vector<long long int> G[N];
vector<ii> g[N];
long long int dist[N][N], d1[N], d2[N], U[M], V[M], W[M], p[N];
long long int n, m, s, t, L;
void djk() {
priority_queue<ii, vector<ii>, greater<ii> > q;
q.push({0, s});
d1[s] = 0;
while (!q.empty()) {
long long int u = q.top().second, d = q.top().first;
q.pop();
for (auto& it : g[u]) {
long long int v = it.first, w = it.second;
if (d + w < d1[v]) {
d1[v] = d + w;
q.push({d1[v], v});
}
}
}
}
bool djk2() {
priority_queue<ii, vector<ii>, greater<ii> > q;
q.push({0, s});
d2[s] = 0;
while (!q.empty()) {
long long int u = q.top().second, d = q.top().first;
q.pop();
for (long long int v : G[u]) {
long long int w = dist[u][v];
if (d + abs(w) < d2[v]) {
d2[v] = d + abs(w);
p[v] = u;
q.push({d2[v], v});
}
}
}
if (d2[t] > L) {
return false;
}
long long int cur = t;
while (cur != s) {
long long int par = p[cur];
if (dist[cur][par] < 0) {
dist[par][cur] = dist[cur][par] = -2;
}
cur = p[cur];
}
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < n; j++) {
if (dist[i][j] == -1) {
dist[i][j] = INF;
}
}
}
cur = t;
while (cur != s) {
long long int par = p[cur];
if (dist[cur][par] < 0) {
dist[par][cur] = dist[cur][par] = -1;
}
cur = p[cur];
}
return true;
}
bool relax() {
for (long long int i = 0; i < n; i++) {
d2[i] = INF;
}
priority_queue<ii, vector<ii>, greater<ii> > q;
q.push({0, s});
d2[s] = 0;
while (!q.empty()) {
long long int u = q.top().second, d = q.top().first;
q.pop();
for (auto& v : G[u]) {
long long int w = dist[u][v];
if (d + abs(w) < d2[v]) {
d2[v] = d + abs(w);
p[v] = u;
q.push({d2[v], v});
}
}
}
if (d2[t] == L) {
return true;
}
long long int cur = t;
bool check = false;
while (cur != s) {
long long int par = p[cur];
if (dist[cur][par] < 0 and !check) {
dist[cur][par] = dist[par][cur] = abs(dist[par][cur]) + L - d2[t];
check = true;
}
if (check) {
break;
}
cur = p[cur];
}
return false;
}
int32_t main() {
cin.tie(0)->sync_with_stdio(0);
cin >> n >> m >> L >> s >> t;
for (long long int i = 0; i <= n; i++) {
d1[i] = d2[i] = INF;
}
for (long long int i = 0, u, v; i < m; i++) {
cin >> u >> v >> W[i];
U[i] = u, V[i] = v;
if (W[i] != 0) {
g[u].push_back({v, W[i]});
g[v].push_back({u, W[i]});
G[u].push_back(v);
G[v].push_back(u);
dist[u][v] = dist[v][u] = W[i];
} else {
G[u].push_back(v);
G[v].push_back(u);
dist[u][v] = dist[v][u] = -1;
}
}
djk();
if (d1[t] < L) {
cout << "NO\n";
return 0;
}
if (d1[t] == L) {
cout << "YES\n";
for (long long int i = 0; i < m; i++) {
cout << U[i] << " " << V[i] << " ";
cout << ((W[i] == 0) ? INF : W[i]) << "\n";
}
return 0;
}
if (!djk2()) {
cout << "NO\n";
return 0;
}
while (!relax()) {
relax();
}
cout << "YES\n";
for (long long int i = 0; i < m; i++) {
cout << U[i] << " " << V[i] << " " << abs(dist[U[i]][V[i]]) << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mult(int x, int y) {
long long int ans, x1 = (long long int)x, y1 = (long long int)y;
ans = (x1 * y1) % 1000000007;
return (int)ans;
}
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int lcm(int a, int b) { return a * (b / gcd(a, b)); }
long long int pow1(long long int a, long long int b) {
long long int ans = 1;
while (b > 0) {
if (b & 1) ans = (ans * a) % 1000000007;
a = (a * a) % 1000000007;
b >>= 1;
}
return ans;
}
int mina(int arr[], int n) {
int x = arr[0], i, pos = 0;
for (i = 1; i < n; i++) {
if (arr[i] < x) {
x = arr[i];
pos = i;
}
}
return x;
}
int maxa(int arr[], int n) {
int x = arr[0], i, pos = 0;
for (i = 1; i < n; i++) {
if (arr[i] > x) {
x = arr[i];
pos = i;
}
}
return x;
}
vector<vector<pair<long long int, long long int> > > v;
vector<long long int> dist;
multiset<pair<long long int, long long int> > pq;
vector<long long int> prev1;
vector<pair<long long int, long long int> > e;
long long int w[10005];
int f[10005];
bool vis[10005];
long long int dijkstra(long long int n, long long int src, long long int des) {
pq.clear();
int i;
for (i = 0; i < n + 2; i++) dist[i] = LLONG_MAX, vis[i] = false;
;
pq.insert(make_pair(0, src));
dist[src] = 0;
prev1[src] = -1;
pair<long long int, long long int> front;
long long int d, ver;
while (pq.size()) {
front = *pq.begin();
pq.erase(pq.begin());
d = front.first;
ver = front.second;
if (vis[ver]) continue;
vis[ver] = true;
if (ver == des) break;
for (vector<pair<long long int, long long int> >::iterator itr =
v[ver].begin();
itr != v[ver].end(); itr++) {
long long int ind = (*itr).first, v1 = (*itr).second;
if (vis[v1]) continue;
if (dist[ver] + w[ind] < dist[v1]) {
prev1[v1] = ind;
dist[v1] = dist[ver] + w[ind];
pq.insert(make_pair(dist[v1], v1));
}
}
}
return dist[des];
}
bool fun(long long int st, long long int dest, long long int add) {
long long int curr = dest;
while (curr != st) {
long long int ind = prev1[curr];
if (f[ind] == 1) {
w[ind] += add;
return true;
}
if (curr == e[ind].second)
curr = e[ind].first;
else
curr = e[ind].second;
}
return false;
}
int main() {
ios::sync_with_stdio(false);
long long int x, y, w1, n, i, m, l, s, t;
cin >> n >> m >> l >> s >> t;
v.resize(n + 4);
dist.resize(n + 4);
prev1.resize(n + 4);
for (i = 0; i < m; i++) {
cin >> x >> y >> w1;
v[x].push_back(make_pair(i, y));
v[y].push_back(make_pair(i, x));
e.push_back(make_pair(x, y));
w[i] = w1;
if (!w[i]) w[i]++, f[i] = 1;
}
while (true) {
long long int d = dijkstra(n, s, t);
if (d > l) {
cout << "NO" << endl;
return 0;
}
if (d == l) break;
if (fun(s, t, l - d) == false) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
for (i = 0; i < m; i++)
cout << e[i].first << " " << e[i].second << " " << w[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000;
const long long INF = 1e18;
vector<pair<int, int> > v[MAXN + 1];
priority_queue<pair<long long, int> > q;
long long dist[MAXN + 1];
int cnt = 0;
long long* ret;
long long value[10001];
bool ck[1001][1001];
bool change;
void djik(int s, int e, int I) {
change = false;
for (int i = 0; i < 1001; i++) dist[i] = INF;
dist[s] = 0;
q.push(make_pair(0LL, s));
while (!q.empty()) {
long long cost = -q.top().first;
int x = q.top().second;
q.pop();
if (cost > dist[x]) continue;
for (int i = 0; i < v[x].size(); i++) {
if (value[v[x][i].second] >= INF && cnt < I) {
ret = &value[v[x][i].second];
*ret = 1;
cnt++;
change = true;
}
long long weight = cost + value[v[x][i].second];
int next = v[x][i].first;
if (dist[next] > weight) {
dist[next] = weight;
q.push(make_pair(-weight, next));
}
}
}
}
int main() {
int n, m, L, s, e;
int zerocnt = 0;
scanf("%d %d %d %d %d", &n, &m, &L, &s, &e);
for (int i = 0; i < m; i++) {
int a, b;
long long w;
scanf("%d %d %lld", &a, &b, &w);
if (w == 0) {
w = 1e18;
zerocnt++;
}
value[i] = w;
v[a].push_back(make_pair(b, i));
v[b].push_back(make_pair(a, i));
}
djik(s, e, 0);
if (dist[e] < L) {
printf("NO");
return 0;
} else if (dist[e] == L) {
printf("YES\n");
for (int j = 0; j < n; j++) {
for (int k = 0; k < v[j].size(); k++) {
if (!ck[j][v[j][k].first])
printf("%d %d %lld\n", j, v[j][k].first, value[v[j][k].second]);
ck[j][v[j][k].first] = ck[v[j][k].first][j] = true;
}
}
return 0;
}
for (int i = 1; i <= zerocnt; i++) {
djik(s, e, i);
if (dist[e] <= L) {
printf("YES\n");
if (change) *ret += L - dist[e];
for (int j = 0; j < n; j++) {
for (int k = 0; k < v[j].size(); k++) {
if (!ck[j][v[j][k].first])
printf("%d %d %lld\n", j, v[j][k].first, value[v[j][k].second]);
ck[j][v[j][k].first] = ck[v[j][k].first][j] = true;
}
}
return 0;
}
}
printf("NO");
}
|
#include <bits/stdc++.h>
using namespace std;
using ii = pair<long long int, long long int>;
const long long int N = 1000 + 5, INF = 1e18, M = 10000 + 5;
vector<long long int> G[N];
vector<ii> g[N];
long long int dist[N][N], d1[N], d2[N], U[M], V[M], W[M], p[N];
long long int n, m, s, t, L;
void djk() {
priority_queue<ii, vector<ii>, greater<ii> > q;
q.push({0, s});
d1[s] = 0;
while (!q.empty()) {
long long int u = q.top().second;
q.pop();
for (auto& it : g[u]) {
long long int v = it.first, w = it.second;
if (d1[u] + w < d1[v]) {
d1[v] = d1[u] + w;
q.push({d1[v], v});
}
}
}
}
bool djk2() {
priority_queue<ii, vector<ii>, greater<ii> > q;
q.push({0, s});
d2[s] = 0;
while (!q.empty()) {
long long int u = q.top().second;
q.pop();
for (long long int v : G[u]) {
long long int w = dist[u][v];
if (d2[u] + abs(w) < d2[v]) {
d2[v] = d2[u] + abs(w);
p[v] = u;
q.push({d2[v], v});
}
}
}
if (d2[t] > L) {
return false;
}
long long int cur = t;
while (cur != s) {
long long int par = p[cur];
if (dist[cur][par] < 0) {
dist[par][cur] = dist[cur][par] = -2;
}
cur = p[cur];
}
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < n; j++) {
if (dist[i][j] == -1) {
dist[i][j] = INF;
}
}
}
cur = t;
while (cur != s) {
long long int par = p[cur];
if (dist[cur][par] < 0) {
dist[par][cur] = dist[cur][par] = -1;
}
cur = p[cur];
}
return true;
}
bool relax() {
for (long long int i = 0; i < n; i++) {
d2[i] = INF;
}
priority_queue<ii, vector<ii>, greater<ii> > q;
q.push({0, s});
d2[s] = 0;
while (!q.empty()) {
long long int u = q.top().second;
q.pop();
for (auto& v : G[u]) {
long long int w = dist[u][v];
if (d2[u] + abs(w) < d2[v]) {
d2[v] = d2[u] + abs(w);
p[v] = u;
q.push({d2[v], v});
}
}
}
if (d2[t] == L) {
return true;
}
long long int cur = t;
while (cur != s) {
long long int par = p[cur];
if (dist[cur][par] < 0) {
dist[cur][par] = dist[par][cur] = abs(dist[par][cur]) + L - d2[t];
break;
}
cur = p[cur];
}
return false;
}
int32_t main() {
cin.tie(0)->sync_with_stdio(0);
cin >> n >> m >> L >> s >> t;
for (long long int i = 0; i <= n; i++) {
d1[i] = d2[i] = INF;
}
for (long long int i = 0, u, v; i < m; i++) {
cin >> u >> v >> W[i];
U[i] = u, V[i] = v;
if (W[i] != 0) {
g[u].push_back({v, W[i]});
g[v].push_back({u, W[i]});
G[u].push_back(v);
G[v].push_back(u);
dist[u][v] = dist[v][u] = W[i];
} else {
G[u].push_back(v);
G[v].push_back(u);
dist[u][v] = dist[v][u] = -1;
}
}
djk();
if (d1[t] < L) {
cout << "NO\n";
return 0;
}
if (d1[t] == L) {
cout << "YES\n";
for (long long int i = 0; i < m; i++) {
cout << U[i] << " " << V[i] << " ";
cout << ((W[i] == 0) ? INF : W[i]) << "\n";
}
return 0;
}
if (!djk2()) {
cout << "NO\n";
return 0;
}
while (!relax()) {
relax();
}
cout << "YES\n";
for (long long int i = 0; i < m; i++) {
cout << U[i] << " " << V[i] << " " << abs(dist[U[i]][V[i]]) << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T input() {
T ans = 0, m = 1;
char c = ' ';
while (!((c >= '0' && c <= '9') || c == '-')) c = getchar();
if (c == '-') m = -1, c = getchar();
while (c >= '0' && c <= '9') {
ans = ans * 10 + (c - '0'), c = getchar();
}
return ans * m;
}
template <typename T>
void read(T& a) {
a = input<T>();
}
template <typename T, typename... R>
void read(T& a, R&... r) {
a = input<T>();
read(r...);
}
const int N = 1e3 + 12;
const int M = 1e4 + 12;
const long long INF = 2e18;
int x[M], y[M], w[M];
bool emp[M];
long long dist1[N], dist2[N];
vector<int> g[N];
int n, m, L, s, t;
long long need;
void dijk(long long* dist, bool fl) {
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
dist[s] = 0;
q.push({0, s});
while (!q.empty()) {
int v = q.top().second;
long long d = q.top().first;
q.pop();
if (d > dist[v]) continue;
for (auto i : g[v]) {
int u = x[i] + y[i] - v;
if (fl && emp[i] && d + w[i] < dist[u] && d + w[i] < dist1[u] + need) {
w[i] = dist1[u] + need - d;
}
if (d + w[i] < dist[u]) {
dist[u] = d + w[i];
q.push({dist[u], u});
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
read(n, m, L, s, t);
for (int i = 0; i < m; ++i) {
read(x[i], y[i], w[i]);
g[x[i]].push_back(i);
g[y[i]].push_back(i);
if (!w[i]) {
emp[i] = w[i] = 1;
}
}
for (int i = 0; i < n; ++i) {
dist1[i] = dist2[i] = INF;
}
dijk(dist1, 0);
if (dist1[t] > L) {
cout << "NO\n";
return 0;
}
need = L - dist1[t];
dijk(dist2, 1);
if (dist2[t] != L) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
for (int i = 0; i < m; ++i) {
cout << x[i] << " " << y[i] << " " << w[i] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
template <typename T>
void dout(string name, int idx, T arg) {
cerr << name << " = " << to_string(arg);
}
template <typename T1, typename... T2>
void dout(string names, int idx, T1 arg, T2... args) {
cerr << names.substr(0, names.find(',')) << " = " << to_string(arg) << ", ";
dout(names.substr(names.find(',') + 2), idx + 1, args...);
}
const long long inf = (long long)1e18;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m, L, beg, end;
cin >> n >> m >> L >> beg >> end;
vector<vector<pair<int, long long>>> g(n);
vector<int> deleted(m);
vector<array<pair<int, int>, 2>> where(m);
for (int i = 0; i < m; i++) {
int a, b;
long long w;
cin >> a >> b >> w;
if (w == 0) {
deleted[i] = 1;
w = inf;
}
where[i][0] = make_pair(a, g[a].size());
where[i][1] = make_pair(b, g[b].size());
g[a].emplace_back(b, w);
g[b].emplace_back(a, w);
}
auto Dijkstra = [&]() {
set<pair<long long, int>> s;
vector<long long> d(n, inf);
d[beg] = 0;
for (int i = 0; i < n; i++) {
if (d[i] < inf) {
s.insert(make_pair(d[i], i));
}
}
while (!s.empty()) {
int v = s.begin()->second;
s.erase(s.begin());
for (const auto& [u, w] : g[v]) {
if (d[v] + w < d[u]) {
if (d[u] < inf) {
s.erase(make_pair(d[u], u));
}
d[u] = d[v] + w;
s.insert(make_pair(d[u], u));
}
}
}
return d[end];
};
if (Dijkstra() < L) {
cout << "NO" << '\n';
exit(0);
}
for (int v = 0; v < n; v++) {
for (auto& [u, w] : g[v]) {
if (w == inf) {
w = 1;
}
}
}
if (Dijkstra() > L) {
cout << "NO" << '\n';
exit(0);
}
int low = 0, high = m - 1, mid;
while (low < high) {
mid = (low + high) >> 1;
for (int j = 0; j <= mid; j++) {
if (deleted[j]) {
g[where[j][0].first][where[j][0].second].second = 1;
g[where[j][1].first][where[j][1].second].second = 1;
}
}
for (int j = mid + 1; j < m; j++) {
if (deleted[j]) {
g[where[j][0].first][where[j][0].second].second = inf;
g[where[j][1].first][where[j][1].second].second = inf;
}
}
if (Dijkstra() <= L) {
high = mid;
} else {
low = mid + 1;
}
}
for (int j = 0; j <= low; j++) {
if (deleted[j]) {
g[where[j][0].first][where[j][0].second].second = 1;
g[where[j][1].first][where[j][1].second].second = 1;
}
}
for (int j = low + 1; j < m; j++) {
if (deleted[j]) {
g[where[j][0].first][where[j][0].second].second = inf;
g[where[j][1].first][where[j][1].second].second = inf;
}
}
long long r = L - Dijkstra();
assert(r >= 0);
if (deleted[low]) {
g[where[low][0].first][where[low][0].second].second = 1 + r;
g[where[low][1].first][where[low][1].second].second = 1 + r;
}
cout << "YES" << '\n';
for (int j = 0; j < m; j++) {
assert(g[where[j][0].first][where[j][0].second].second ==
g[where[j][1].first][where[j][1].second].second);
cout << where[j][0].first << ' ' << where[j][1].first << ' '
<< g[where[j][0].first][where[j][0].second].second << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ii = pair<long long int, long long int>;
const long long int N = 1000 + 5, INF = 1e18, M = 10000 + 5;
vector<long long int> G[N];
vector<ii> g[N];
long long int dist[N][N], d1[N], d2[N], U[M], V[M], W[M], p[N];
long long int n, m, s, t, L;
void djk() {
priority_queue<ii, vector<ii>, greater<ii> > q;
q.push({0, s});
d1[s] = 0;
while (!q.empty()) {
long long int u = q.top().second;
q.pop();
for (auto& it : g[u]) {
long long int v = it.first, w = it.second;
if (d1[u] + w < d1[v]) {
d1[v] = d1[u] + w;
q.push({d1[v], v});
}
}
}
}
bool djk2() {
priority_queue<ii, vector<ii>, greater<ii> > q;
q.push({0, s});
d2[s] = 0;
while (!q.empty()) {
long long int u = q.top().second;
q.pop();
for (long long int v : G[u]) {
long long int w = dist[u][v];
if (d2[u] + abs(w) < d2[v]) {
d2[v] = d2[u] + abs(w);
p[v] = u;
q.push({d2[v], v});
}
}
}
if (d2[t] > L) {
return false;
}
long long int cur = t;
while (cur != s) {
long long int par = p[cur];
if (dist[cur][par] < 0) {
dist[par][cur] = dist[cur][par] = -2;
}
cur = p[cur];
}
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < n; j++) {
if (dist[i][j] == -1) {
dist[i][j] = INF;
}
}
}
cur = t;
while (cur != s) {
long long int par = p[cur];
if (dist[cur][par] < 0) {
dist[par][cur] = dist[cur][par] = -1;
}
cur = p[cur];
}
return true;
}
bool relax() {
priority_queue<ii, vector<ii>, greater<ii> > q;
q.push({0, s});
for (long long int i = 0; i < n; i++) {
d2[i] = INF;
}
d2[s] = 0;
while (!q.empty()) {
long long int u = q.top().second;
q.pop();
for (auto& v : G[u]) {
long long int w = dist[u][v];
if (d2[u] + abs(w) < d2[v]) {
d2[v] = d2[u] + abs(w);
p[v] = u;
q.push({d2[v], v});
}
}
}
if (d2[t] == L) {
return true;
}
long long int cur = t;
while (cur != s) {
long long int par = p[cur];
if (dist[cur][par] < 0) {
dist[cur][par] = dist[par][cur] = abs(dist[par][cur]) + L - d2[t];
break;
}
cur = p[cur];
}
return false;
}
int32_t main() {
cin.tie(0)->sync_with_stdio(0);
cin >> n >> m >> L >> s >> t;
for (long long int i = 0; i <= n; i++) {
d1[i] = d2[i] = INF;
}
for (long long int i = 0, u, v; i < m; i++) {
cin >> u >> v >> W[i];
U[i] = u, V[i] = v;
if (W[i] != 0) {
g[u].push_back({v, W[i]});
g[v].push_back({u, W[i]});
G[u].push_back(v);
G[v].push_back(u);
dist[u][v] = dist[v][u] = W[i];
} else {
G[u].push_back(v);
G[v].push_back(u);
dist[u][v] = dist[v][u] = -1;
}
}
djk();
if (d1[t] < L) {
cout << "NO\n";
return 0;
}
if (d1[t] == L) {
cout << "YES\n";
for (long long int i = 0; i < m; i++) {
cout << U[i] << " " << V[i] << " ";
cout << ((W[i] == 0) ? INF : W[i]) << "\n";
}
return 0;
}
if (!djk2()) {
cout << "NO\n";
return 0;
}
while (!relax()) {
relax();
}
cout << "YES\n";
for (long long int i = 0; i < m; i++) {
cout << U[i] << " " << V[i] << " " << abs(dist[U[i]][V[i]]) << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, next, v, mk;
} e[20010 << 2];
int head[20010];
int cnt;
int n, m, l, s, E;
int t, h;
int dis[20010], vis[20010], q[20010];
void link(int x, int y, int z, int w) {
e[cnt] = (edge){y, head[x], z, w};
head[x] = cnt++;
}
void add(int x, int y, int z, int w) {
link(x, y, z, w);
link(y, x, z, w);
}
void SPFA() {
memset(vis, 0, sizeof(vis));
memset(dis, 63, sizeof(dis));
h = 0;
q[t = 1] = s;
vis[s] = 1;
dis[s] = 0;
while (h != t) {
int now = q[h = h % n + 1];
vis[now] = 0;
for (int i = head[now]; ~i; i = e[i].next) {
int y = e[i].to;
if (dis[y] > dis[now] + e[i].v) {
dis[y] = dis[now] + e[i].v;
if (!vis[y]) {
vis[y] = 1;
q[t = t % n + 1] = y;
}
}
}
}
}
int main() {
memset(head, -1, sizeof(head));
scanf("%d%d%d%d%d", &n, &m, &l, &s, &E);
for (int i = 0, x, y, z; i < m; i++) {
scanf("%d%d%d", &x, &y, &z);
add(x, y, z ? z : 1, z == 0);
}
SPFA();
if (dis[E] > l) {
printf("NO");
return 0;
}
for (int k = 0; k < n; k++)
for (int i = head[k]; ~i; i = e[i].next)
if (i & 1)
if (e[i].mk) {
if (dis[E] == l) goto YJY;
e[i ^ 1].v = e[i].v = l - dis[E] + 1;
SPFA();
}
if (dis[E] != l) {
printf("NO");
return 0;
}
YJY : {
printf("YES\n");
for (int k = 0; k < n; k++)
for (int i = head[k]; ~i; i = e[i].next)
if (i & 1) printf("%d %d %d\n", e[i ^ 1].to, e[i].to, e[i].v);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 10000 + 16;
int head[maxn];
struct Edge {
int v, next;
long long w;
bool f;
} edge[maxn * 2];
int cnt;
int n, m, s, t;
long long L;
int inque[maxn];
long long d[maxn];
int vis[maxn];
void add(int u, int v, long long w, bool f) {
edge[cnt].v = v;
edge[cnt].w = w;
edge[cnt].f = f;
edge[cnt].next = head[u];
head[u] = cnt++;
}
void add_edge(int u, int v, long long w, bool f) {
add(u, v, w, f);
add(v, u, w, f);
}
void init() {
cnt = 0;
memset(head, -1, sizeof(head));
}
void spfa(int s) {
memset(vis, 0, sizeof(vis));
memset(d, INF, sizeof(d));
memset(inque, false, sizeof(inque));
queue<int> Q;
d[s] = 0;
Q.push(s);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
inque[u] = false;
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].v;
long long w = edge[i].w;
if (d[v] > d[u] + w) {
d[v] = d[u] + w;
if (!inque[v]) {
inque[v] = true;
Q.push(v);
if (vis[v] == n) {
return;
}
}
}
}
}
}
bool cal() {
memset(vis, 0, sizeof(vis));
queue<int> q;
q.push(s);
vis[s] = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].v;
if (v == t) return true;
if (vis[v]) continue;
vis[v] = 1;
q.push(v);
}
}
return false;
}
bool solve() {
spfa(s);
if (d[t] > L) return false;
for (int u = 0; u < n; u++) {
for (int i = head[u]; i != -1; i = edge[i].next) {
if (!edge[i].f || (i & 1)) continue;
if (d[t] == L) return true;
edge[i].w = edge[i ^ 1].w = L - d[t] + 1;
spfa(s);
}
}
return d[t] == L;
}
int main() {
cin >> n >> m >> L >> s >> t;
init();
int u, v;
long long w;
for (int i = 0; i < m; i++) {
cin >> u >> v >> w;
add_edge(u, v, (w ? w : 1), w == 0);
}
if (!cal() || !solve()) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
for (int j = head[i]; j != -1; j = edge[j].next) {
if (!(j & 1)) printf("%d %d %I64d\n", i, edge[j].v, edge[j].w);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300010;
const long long mod = 1000000007;
int n, m, p[N], s, t, back[N];
long long L;
long long cost[N];
long long weight[N];
bool vis[N];
struct edge {
int v, idx;
long long cost;
int parent;
edge(int _v, int _parent, int _idx, long long _cost) {
v = _v;
idx = _idx;
cost = _cost;
parent = _parent;
}
edge(int _v, int _idx) {
v = _v;
idx = _idx;
}
bool operator<(const edge &rhs) const { return cost > rhs.cost; }
};
struct state {
int u, v;
long long cost;
state() {}
state(int _u, int _v, long long _cost) {
u = _u;
v = _v;
cost = _cost;
}
};
vector<edge> g[N];
state e[N];
bool empty[N];
vector<int> used;
bool have[N];
void reset() {
for (int i = 0; i <= n; i++) {
cost[i] = 1e18;
vis[i] = 0;
p[i] = -1;
back[i] = -1;
}
}
void dijsktra(int u) {
reset();
priority_queue<edge> q;
cost[u] = 0;
q.push(edge(u, -1, -1, 0));
while (!q.empty()) {
edge cur = q.top();
q.pop();
if (vis[cur.v]) continue;
vis[cur.v] = 1;
p[cur.v] = cur.parent;
back[cur.v] = cur.idx;
for (int i = 0; i < g[cur.v].size(); i++) {
edge nxt = g[cur.v][i];
if (cost[nxt.v] > cost[cur.v] + weight[nxt.idx] && weight[nxt.idx]) {
cost[nxt.v] = cost[cur.v] + weight[nxt.idx];
q.push(edge(nxt.v, cur.v, nxt.idx, cost[nxt.v]));
}
}
}
}
int main() {
scanf("%d%d%lld%d%d", &n, &m, &L, &s, &t);
for (int i = 0; i < m; ++i) {
scanf("%d%d%lld", &e[i].u, &e[i].v, &weight[i]);
if (!weight[i]) empty[i] = true;
g[e[i].u].push_back(edge(e[i].v, i));
g[e[i].v].push_back(edge(e[i].u, i));
}
dijsktra(s);
if (cost[t] < L) {
puts("NO");
} else {
for (int i = 0; i < m; i++) {
if (empty[i]) weight[i] = 1;
}
dijsktra(s);
if (cost[t] > L) {
puts("NO");
} else {
puts("YES");
while (1) {
dijsktra(s);
if (cost[t] == L) {
break;
} else {
int curS = t;
int chng;
while (curS != s) {
used.push_back(back[curS]);
have[used.back()] = true;
if (empty[used.back()]) {
chng = used.back();
}
curS = p[curS];
}
weight[chng] += L - cost[t];
for (int i = 0; i < m; i++) {
if (!have[i] && empty[i]) {
weight[i] = 2e9;
}
}
while (!used.empty() && used.back()) {
have[used.back()] = 0;
used.pop_back();
}
}
}
for (int i = 0; i < m; ++i) {
printf("%d %d %lld\n", e[i].u, e[i].v, weight[i]);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const unsigned long long maxn = 1000 + 10;
const int INF = 0x3f3f3f3f;
const double eps = 1e-10;
const double pi = acos(-1.0);
int g[maxn][maxn];
struct haha {
int x, y, w;
} p[maxn * 10], p0[maxn * 10];
struct Edge {
int from, to, dist;
};
struct HeapNode {
int d, 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];
int 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 AddEdge(int from, int to, int 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;
p[s] = -1;
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] = e.from;
Q.push((HeapNode){d[e.to], e.to});
}
}
}
}
} dij;
int main() {
int n, m, L, s, t;
int cnt = 0, cnt2 = 0;
scanf("%d %d %d %d %d", &n, &m, &L, &s, &t);
dij.init(n);
for (int i = 0; i < m; ++i) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
g[u][v] = g[v][u] = w;
if (w) {
p[cnt].x = u;
p[cnt].w = w;
p[cnt++].y = v;
dij.AddEdge(u, v, w);
dij.AddEdge(v, u, w);
} else {
p0[cnt2].x = u;
p0[cnt2].w = 0;
p0[cnt2++].y = v;
}
}
dij.dijkstra(s);
if (dij.d[t] < L) return 0 * puts("NO");
if (dij.d[t] == L) {
puts("YES");
for (int i = 0; i < cnt; ++i) {
printf("%d %d %d\n", p[i].x, p[i].y, p[i].w);
}
for (int i = 0; i < cnt2; ++i) {
printf("%d %d %d\n", p0[i].x, p0[i].y, INF);
}
return 0;
}
int pos = -1;
for (int i = 0; i < cnt2; ++i) {
dij.AddEdge(p0[i].x, p0[i].y, 1);
dij.AddEdge(p0[i].y, p0[i].x, 1);
dij.dijkstra(s);
if (dij.d[t] > L) continue;
pos = i;
break;
}
if (pos == -1) return 0 * puts("NO");
puts("YES");
for (int i = 0; i < cnt; ++i) {
printf("%d %d %d\n", p[i].x, p[i].y, p[i].w);
}
for (int i = 0; i < pos; ++i) printf("%d %d %d\n", p0[i].x, p0[i].y, 1);
printf("%d %d %d\n", p0[pos].x, p0[pos].y, L - dij.d[t] + 1);
for (int i = pos + 1; i < cnt2; ++i)
printf("%d %d %d\n", p0[i].x, p0[i].y, INF);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = pow(10ll, 18);
struct Edge {
long long u, v, w;
Edge(long long u0, long long v0, long long w0) : u(u0), v(v0), w(w0) {}
};
long long other_node(long long u, const Edge &edge) {
return edge.u == u ? edge.v : edge.u;
}
unordered_map<long long, bool> missing_edge;
vector<Edge> edges;
vector<vector<long long>> graph;
long long L;
long long start, target;
void print_graph(const vector<Edge> &edges) {
for (const auto &p : edges) {
cout << p.u << " " << p.v << " " << p.w << endl;
}
}
void shortest_path(vector<long long> &path, long long &len) {
long long n = graph.size();
vector<long long> dist(n, INF);
vector<long long> prev(n, -1);
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
que;
dist[start] = 0;
que.push({0, start});
while (!que.empty()) {
auto p = que.top();
que.pop();
long long d = p.first, u = p.second;
if (d > dist[u]) {
continue;
}
for (auto edge_ind : graph[u]) {
long long v = other_node(u, edges[edge_ind]), w = edges[edge_ind].w;
if (w != INF && dist[u] + w < dist[v]) {
dist[v] = dist[u] + w;
prev[v] = edge_ind;
que.push({dist[v], v});
}
}
}
path.clear();
len = dist[target];
if (prev[target] == -1) {
return;
}
long long cur = target;
while (prev[cur] != -1) {
path.push_back(prev[cur]);
cur = other_node(cur, edges[prev[cur]]);
}
}
void solve() {
for (auto &p : missing_edge) {
edges[p.first].w = INF;
}
vector<long long> path;
long long len;
shortest_path(path, len);
if (len < L) {
cout << "NO" << endl;
return;
}
if (len == L) {
cout << "YES" << endl;
print_graph(edges);
return;
}
for (auto &p : missing_edge) {
edges[p.first].w = 1;
}
shortest_path(path, len);
if (len > L) {
cout << "NO" << endl;
return;
}
if (len < L) {
for (auto edge_ind : path) {
if (missing_edge.find(edge_ind) != missing_edge.end()) {
missing_edge[edge_ind] = true;
}
}
for (auto &p : missing_edge) {
if (!p.second) {
edges[p.first].w = INF;
}
}
while (len < L) {
for (auto edge_ind : path) {
if (missing_edge.find(edge_ind) != missing_edge.end()) {
edges[edge_ind].w += L - len;
break;
}
}
shortest_path(path, len);
}
}
cout << "YES" << endl;
print_graph(edges);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
while (true) {
long long n, m;
cin >> n >> m >> L >> start >> target;
if (!cin) {
break;
}
graph.assign(n, {});
edges.clear();
edges.reserve(m);
missing_edge.clear();
for (long long i = 0; i < m; ++i) {
long long u, v, w;
cin >> u >> v >> w;
edges.push_back(Edge(u, v, w));
graph[u].push_back(i);
graph[v].push_back(i);
if (w == 0) {
missing_edge[i] = false;
}
}
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, L, start, endP;
vector<vector<long long> > edges;
vector<vector<long long> > neighbors;
vector<vector<long long> > paths;
long long weights[1000][1000] = {0};
long long dijk() {
vector<long long> distances(n, LLONG_MAX);
distances[start] = 0;
vector<bool> visited(n, false);
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq;
pq.push({0, start});
while (!pq.empty()) {
long long currentWeight = pq.top().first;
long long currentNode = pq.top().second;
pq.pop();
if (visited[currentNode]) continue;
visited[currentNode] = true;
if (currentNode == endP) break;
for (long long i = 0; i < neighbors[currentNode].size(); i++) {
long long currNeighbor = neighbors[currentNode][i];
long long currDist = weights[currentNode][currNeighbor];
if (currDist == -1) continue;
if (currentWeight + currDist < distances[currNeighbor])
distances[currNeighbor] = currentWeight + currDist;
if (!visited[currNeighbor])
pq.push({distances[currNeighbor], currNeighbor});
}
}
return distances[endP];
}
long long dijk2() {
vector<long long> distances(n, LLONG_MAX);
distances[start] = 0;
vector<bool> visited(n, false);
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq;
pq.push({0, start});
paths[start].push_back(start);
while (!pq.empty()) {
long long currentWeight = pq.top().first;
long long currentNode = pq.top().second;
pq.pop();
if (visited[currentNode]) continue;
visited[currentNode] = true;
if (currentNode == endP) break;
for (long long i = 0; i < neighbors[currentNode].size(); i++) {
long long currNeighbor = neighbors[currentNode][i];
long long currDist = weights[currentNode][currNeighbor];
if (currDist == -1) currDist = 1;
if (currentWeight + currDist < distances[currNeighbor]) {
distances[currNeighbor] = currentWeight + currDist;
paths[currNeighbor] = paths[currentNode];
paths[currNeighbor].push_back(currNeighbor);
}
if (!visited[currNeighbor])
pq.push({distances[currNeighbor], currNeighbor});
}
}
return distances[endP];
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> L >> start >> endP;
edges.resize(m);
neighbors.resize(n);
paths.resize(n);
long long from, to, weight;
for (long long i = 0; i < m; i++) {
cin >> from >> to >> weight;
if (weight == 0) weight = -1;
weights[from][to] = weight;
weights[to][from] = weight;
edges[i] = {from, to, weight};
neighbors[from].push_back(to);
neighbors[to].push_back(from);
}
long long currMin = dijk();
if (currMin < L) {
cout << "NO" << endl;
return 0;
}
long long newMin = dijk2();
if (newMin > L) {
cout << "NO" << endl;
return 0;
}
for (long long i = 1; i < paths[endP].size(); i++) {
long long prev = paths[endP][i - 1];
long long curr = paths[endP][i];
if (weights[prev][curr] == -1) {
weights[prev][curr] = -2;
weights[curr][prev] = -2;
}
}
for (long long i = 0; i < edges.size(); i++) {
long long from = edges[i][0];
long long to = edges[i][1];
long long weight = weights[from][to];
if (weight == -1) {
weights[from][to] = 999999999999;
weights[to][from] = 999999999999;
}
}
for (long long i = 1; i < paths[endP].size(); i++) {
long long prev = paths[endP][i - 1];
long long curr = paths[endP][i];
if (weights[prev][curr] == -2) {
weights[prev][curr] = -1;
weights[curr][prev] = -1;
}
}
while (newMin != L) {
long long diff = L - newMin;
for (long long i = 1; i < paths[endP].size(); i++) {
long long prev = paths[endP][i - 1];
long long curr = paths[endP][i];
if (weights[prev][curr] == -1) {
weights[prev][curr] = diff + 1;
weights[curr][prev] = diff + 1;
break;
}
}
paths.clear();
paths.resize(n);
newMin = dijk2();
}
for (long long i = 1; i < paths[endP].size(); i++) {
long long prev = paths[endP][i - 1];
long long curr = paths[endP][i];
if (weights[prev][curr] == -1) {
weights[prev][curr] = 1;
weights[curr][prev] = 1;
}
}
cout << "YES" << endl;
for (long long i = 0; i < edges.size(); i++) {
long long from = edges[i][0];
long long to = edges[i][1];
long long weight = weights[from][to];
if (weight == -1) weight = 999999999999;
cout << from << ' ' << to << ' ' << weight << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
const int N = 1010, M = 20010;
const long long inf = 1LL << 50;
int to[M], next[M], head[N], num[M], tot, h, t, n, m, k, q[N + 10];
long long dis[N], ans = inf;
int x[M], y[M], pre[N], d[M], from[M], S, T, L;
bool vis[M], can[M], flag;
void add(const int &x, const int &y, const int &z) {
to[++tot] = y;
next[tot] = head[x];
num[head[x] = tot] = z;
from[tot] = x;
}
void spfa() {
memset(pre, -1, sizeof(pre));
for (int i = 0; i < n; ++i) dis[i] = inf;
vis[S] = 1;
for (dis[q[h = t = 1] = S] = 0; h != (t + 1) % N; h = (h + 1) % N) {
for (int i = head[q[h]]; i; i = next[i])
if (dis[q[h]] + num[i] < dis[to[i]]) {
dis[to[i]] = dis[q[h]] + num[i];
pre[to[i]] = i;
if (!vis[to[i]]) vis[q[t = (t + 1) % N] = to[i]] = 1;
}
vis[q[h]] = 0;
}
}
void retry() {
for (int i = T; i != S && pre[i] != -1; i = from[pre[i]])
vis[pre[i] + 1 >> 1] = 0;
tot = flag = 0;
memset(head, 0, sizeof(head));
for (int i = 1; i <= m; ++i) add(x[i], y[i], d[i]), add(y[i], x[i], d[i]);
spfa();
for (int i = T; i != S && pre[i] != -1; i = from[pre[i]]) {
vis[pre[i] + 1 >> 1] = 1;
if (can[pre[i] + 1 >> 1]) flag = 1;
}
}
int main() {
scanf("%d%d%d%d%d", &n, &m, &L, &S, &T);
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d", x + i, y + i, d + i);
if (d[i] == 0)
d[i] = can[i] = 1;
else {
add(x[i], y[i], d[i]);
add(y[i], x[i], d[i]);
}
}
spfa();
if (dis[T] < L) {
puts("NO");
return 0;
}
if (dis[T] == L) {
puts("YES");
for (int i = 1; i <= m; ++i) printf("%d %d %d\n", x[i], y[i], d[i]);
return 0;
}
retry();
if (dis[T] > L) {
puts("NO");
return 0;
}
while (dis[T] != L) {
long long del = L - dis[T] + 1;
for (int i = 1; i <= m; ++i) {
if (can[i]) {
if (vis[i] && flag) d[i] = del, flag = 0;
if (!vis[i]) d[i] = L + 1, can[i] = 0;
}
}
retry();
}
puts("YES");
for (int i = 1; i <= m; ++i) printf("%d %d %d\n", x[i], y[i], d[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void read_file(bool outToFile = true) {}
const int nMax = 1000 + 9;
const int mMax = 10000 + 9;
const long long OO = 1LL * 1000000000 * 1000000000 + 1;
const long long wMax = 1LL * 1000000000 * 1000000000;
int n, m, L, src, dst;
pair<pair<int, int>, long long> E[mMax];
bool is[mMax];
vector<vector<int> > G;
long long SP[nMax];
void print(bool what) {
if (what == 0) {
printf("NO\n");
return;
}
printf("YES\n");
for (int i = 0; i < m; i++) {
int u, v;
long long w;
u = E[i].first.first, v = E[i].first.second;
w = E[i].second;
assert(1 <= w && w <= wMax);
printf("%d %d %lld\n", u, v, w);
}
}
void run_dijkstra(int u) {
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
PQ;
PQ.push(make_pair(SP[u], u));
while (!PQ.empty()) {
pair<long long, int> top = PQ.top();
PQ.pop();
int u = top.second;
long long d = top.first;
if (d > SP[u]) continue;
for (int i = 0, sz = G[u].size(); i < sz; i++) {
pair<pair<int, int>, long long> e = E[G[u][i]];
int v = e.first.first == u ? e.first.second : e.first.first;
long long w = e.second;
if (SP[v] <= SP[u] + w) continue;
SP[v] = SP[u] + w;
PQ.push(make_pair(SP[v], v));
}
}
}
int main() {
read_file();
while (scanf("%d%d", &n, &m) != EOF) {
scanf("%d%d%d", &L, &src, &dst);
memset(is, 0, sizeof is);
G.assign(n, vector<int>());
for (int i = 0; i < m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
E[i] = pair<pair<int, int>, long long>(make_pair(u, v), w);
is[i] = w == 0 ? 1 : 0;
if (!is[i]) {
G[u].push_back(i);
G[v].push_back(i);
}
}
for (int i = 0; i < n; i++) SP[i] = OO;
SP[src] = 0;
run_dijkstra(src);
long long sp = SP[dst];
if (sp < L) {
print(0);
continue;
} else if (sp == L) {
for (int i = 0; i < m; i++)
if (is[i]) E[i].second = wMax;
print(1);
continue;
}
bool done = false;
for (int i = 0; i < m; i++) {
if (!is[i]) continue;
int u = E[i].first.first, v = E[i].first.second;
long long &w = E[i].second;
if (done) {
w = wMax;
continue;
}
w = 1;
G[u].push_back(i);
G[v].push_back(i);
if (llabs(SP[u] - SP[v]) <= 1) {
continue;
}
if (SP[u] > SP[v]) swap(u, v);
run_dijkstra(u);
if (SP[dst] > L) continue;
w += L - SP[dst];
done = true;
}
print(done);
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[2000];
long long cost[2000][2000];
bool is_special[2000][2000];
int main(void) {
int n, m, L, s, t;
scanf("%i %i %i %i %i", &n, &m, &L, &s, &t);
vector<int> from(m), to(m);
for (int i = 0; i < m; i++) {
int u, v, w;
scanf("%i %i %i", &u, &v, &w);
from[i] = u;
to[i] = v;
is_special[u][v] = is_special[v][u] = (w == 0) ? true : false;
if (w == 0) w++;
g[u].push_back(v);
g[v].push_back(u);
cost[u][v] = cost[v][u] = w;
}
long long shortest_path = 1LL << 60;
bool rep = true;
while (rep) {
vector<long long> dist(n);
vector<bool> seen(n);
vector<int> parent(n);
for (int i = 0; i < n; i++) {
dist[i] = 1LL << 60;
seen[i] = false;
parent[i] = -1;
}
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
Q;
dist[s] = 0;
Q.push(pair<long long, int>(0, s));
while (!Q.empty()) {
pair<long long, int> top = Q.top();
Q.pop();
int u = top.second;
if (seen[u]) continue;
seen[u] = true;
for (int v : g[u]) {
long long w = cost[u][v];
if (dist[v] > dist[u] + w) {
dist[v] = dist[u] + w;
parent[v] = u;
Q.push(pair<long long, int>(dist[v], v));
}
}
}
shortest_path = dist[t];
if (dist[t] > L) {
puts("NO");
return 0;
} else if (dist[t] == L) {
break;
}
rep = false;
int cur = t;
while (cur != s) {
int p = parent[cur];
if (is_special[cur][p]) {
cost[p][cur] = cost[cur][p] += L - dist[t];
rep = true;
break;
}
cur = parent[cur];
}
}
if (shortest_path == L) {
puts("YES");
for (int i = 0; i < m; i++) {
printf("%i %i %lld\n", from[i], to[i], cost[from[i]][to[i]]);
}
} else {
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e3 + 3;
vector<int> G[MAXN];
int n, m, l;
long long d[MAXN];
int father[MAXN];
int vis[MAXN][MAXN], cost[MAXN][MAXN], valid[MAXN][MAXN], cam[MAXN][MAXN];
int s, t;
long long dijk() {
priority_queue<pair<int, int> > pq;
pq.push({0, s});
d[s] = 0;
father[s] = -1;
while (!pq.empty()) {
int u = pq.top().second;
pq.pop();
if (u == t) return d[u];
for (auto v : G[u]) {
int c = cost[u][v];
if (!c) continue;
if (d[v] == -1 || d[v] > d[u] + c) {
d[v] = d[u] + c;
father[v] = u;
pq.push({-d[v], v});
}
}
}
return l + 1;
}
int main() {
scanf("%d %d", &n, &m);
scanf("%d %d %d", &l, &s, &t);
for (int i = (int)0; i < (int)m; i++) {
int u, v, w;
scanf("%d %d", &u, &v);
scanf("%d", &w);
G[u].push_back(v);
G[v].push_back(u);
cost[u][v] = w;
cost[v][u] = w;
}
memset(d, -1, sizeof(d));
long long ans = dijk();
if (ans < l) {
printf("NO\n");
return 0;
}
for (int u = (int)0; u < (int)n; u++) {
for (int j = (int)0; j < (int)G[u].size(); j++) {
int v = G[u][j];
if (cost[u][v] == 0) cost[u][v] = 1, valid[u][v] = 1;
}
}
memset(d, -1, sizeof(d));
long long ans1 = dijk();
if (ans1 > l) {
printf("NO\n");
return 0;
}
vector<pair<int, int> > vec;
int curr = t;
while (curr != -1) {
int v = father[curr];
if (valid[curr][v])
cam[curr][v] = 1, cam[v][curr] = 1, vec.push_back({curr, v});
curr = v;
}
for (int u = (int)0; u < (int)n; u++)
for (int v = (int)0; v < (int)n; v++)
if (valid[u][v] && !cam[u][v]) cost[u][v] = l + 1;
int p = 0;
ans = ans1;
while (p < vec.size()) {
int u = vec[p].first, v = vec[p].second;
int lo = 0, hi = l;
while (lo < hi) {
int mid = (lo + hi + 1) / 2;
memset(d, -1, sizeof(d));
cost[u][v] += mid;
cost[v][u] += mid;
long long curr = dijk();
if (curr == l) {
cost[u][v] -= mid;
cost[v][u] -= mid;
lo = mid;
break;
} else if (curr != ans + mid || curr > l)
hi = mid - 1;
else
lo = mid;
cost[u][v] -= mid;
cost[v][u] -= mid;
}
cost[u][v] += lo;
cost[v][u] += lo;
p++;
memset(d, -1, sizeof(d));
ans = dijk();
if (ans == l) break;
}
printf("YES\n");
for (int u = (int)0; u < (int)n; u++) {
for (auto v : G[u]) {
if (vis[u][v]) continue;
vis[u][v] = 1;
vis[v][u] = 1;
int w = cost[u][v];
printf("%d %d %d\n", u, v, w);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, l, s, t, u, v, w;
long long ste[1010];
long long sts[1010];
vector<pair<long long, long long> > pa[1010];
void opa() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < pa[i].size(); j++) {
if (i < pa[i][j].second) {
cout << i << ' ' << pa[i][j].second << ' ';
cout << (pa[i][j].first > 0 ? pa[i][j].first : 10000000000000000)
<< '\n';
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> l >> s >> t;
for (int i = 0; i < m; i++) {
cin >> u >> v >> w;
pa[u].push_back({w, v});
pa[v].push_back({w, u});
}
memset(ste, -1, sizeof ste);
memset(sts, -1, sizeof sts);
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq;
while (!pq.empty()) pq.pop();
pq.push({0, t});
while (!pq.empty()) {
long long now = pq.top().second;
long long np = pq.top().first;
pq.pop();
if (ste[now] != -1) continue;
ste[now] = np;
for (int i = 0; i < pa[now].size(); i++) {
int nex = pa[now][i].second;
long long len = pa[now][i].first;
if (ste[nex] == -1 && len != 0) {
pq.push({np + len, nex});
}
}
}
if (ste[s] != -1) {
if (ste[s] < l) {
cout << "NO\n";
return 0;
}
if (ste[s] == l) {
cout << "YES\n";
opa();
return 0;
}
}
while (!pq.empty()) pq.pop();
pq.push({0, s});
bool done = 0;
while (!pq.empty()) {
long long now = pq.top().second;
long long np = pq.top().first;
pq.pop();
if (sts[now] != -1) continue;
sts[now] = np;
for (int i = 0; i < pa[now].size(); i++) {
int nex = pa[now][i].second;
long long len = pa[now][i].first;
if (sts[nex] == -1) {
if (len != 0) {
pq.push({np + len, nex});
} else {
if (ste[nex] != -1 && sts[now] + ste[nex] < l) {
pa[now][i].first = l - sts[now] - ste[nex];
for (int j = 0; j < pa[nex].size(); j++) {
if (pa[nex][j].second == now) {
pa[nex][j].first = pa[now][i].first;
break;
}
}
done = 1;
break;
} else {
pa[now][i].first = 1;
for (int j = 0; j < pa[nex].size(); j++) {
if (pa[nex][j].second == now) {
pa[nex][j].first = pa[now][i].first;
break;
}
}
pq.push({np + pa[now][i].first, nex});
}
}
}
}
if (done) break;
}
if (done) {
cout << "YES\n";
opa();
} else
cout << "NO\n";
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, L, s, t;
vector<pair<long long, long long> > adj[1111];
vector<long long> todo;
long long w[11111], u[11111], v[11111], d[1111];
void dijkstra() {
for (long long i = 0; i <= n; i++) d[i] = (1LL << 60);
d[s] = 0LL;
priority_queue<pair<long long, long long> > pq;
pq.push({0, s});
while (!pq.empty()) {
long long x = pq.top().second;
long long t = -pq.top().first;
pq.pop();
if (d[x] < t) continue;
for (auto i : adj[x]) {
if (d[i.first] > d[x] + i.second) {
d[i.first] = d[x] + i.second;
pq.push({-d[i.first], i.first});
}
}
}
}
long long check(long long x) {
for (auto i : todo) {
w[i] = 1 + min(x, 1000000000LL);
x -= w[i] - 1;
}
for (long long i = 0; i <= n; i++) adj[i].clear();
for (long long i = 0; i < m; i++) {
adj[v[i]].push_back({u[i], w[i]});
adj[u[i]].push_back({v[i], w[i]});
}
dijkstra();
return d[t];
}
int main() {
scanf("%lld%lld%lld%lld%lld", &n, &m, &L, &s, &t);
for (long long i = 0; i < m; i++) {
long long a, b, c;
scanf("%lld%lld%lld", u + i, v + i, w + i);
if (w[i] == 0) todo.push_back(i);
}
long long l = 0, d = 1000000000LL * todo.size(), mid, ans = -1;
if (check(0) > L || check(d) < L) {
printf("NO\n");
return 0;
}
while (l <= d) {
mid = (l + d) / 2;
if (check(mid) <= L) {
ans = mid;
l = mid + 1;
} else
d = mid - 1;
}
check(ans);
printf("YES\n");
for (long long i = 0; i < m; i++) {
printf("%lld %lld %lld\n", u[i], v[i], w[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct E {
int v, id;
long long c;
};
vector<E> G[1000];
long long d2s[1000], d2t[1000];
bool mark[1000];
const long long INF = (long long)1e15;
int u[10000], v[10000];
long long c[10000];
int main() {
int n, m, l, s, t;
scanf("%d%d%d%d%d", &n, &m, &l, &s, &t);
for (int i = 0; i < m; i++) {
scanf("%d%d%lld", u + i, v + i, c + i);
G[u[i]].push_back(E{v[i], i, c[i]});
G[v[i]].push_back(E{u[i], i, c[i]});
}
fill(d2t, d2t + n, INF);
memset(mark, 0, sizeof(mark));
d2t[t] = 0;
for (int i = 0; i < n; i++) {
int Minj = -1;
long long Min = INF;
for (int j = 0; j < n; j++) {
if (!mark[j] && d2t[j] < Min) {
Minj = j;
Min = d2t[j];
}
}
if (Minj < 0) break;
mark[Minj] = 1;
for (E &e : G[Minj]) {
if (e.c == 0) continue;
if (d2t[e.v] > Min + e.c) d2t[e.v] = Min + e.c;
}
}
fill(d2s, d2s + n, INF);
memset(mark, 0, sizeof(mark));
d2s[s] = 0;
for (int i = 0; i < n; i++) {
int Minj = -1;
long long Min = INF;
for (int j = 0; j < n; j++) {
if (!mark[j] && d2s[j] < Min) {
Minj = j;
Min = d2s[j];
}
}
if (Minj < 0) break;
mark[Minj] = 1;
for (E &e : G[Minj]) {
if (e.c == 0) {
if (c[e.id] != 0)
e.c = c[e.id];
else if (d2t[e.v] == INF) {
e.c = 1;
c[e.id] = e.c;
} else {
e.c = l - d2t[e.v] - Min;
if (e.c <= 0) {
e.c = 1;
}
c[e.id] = e.c;
}
}
if (d2s[e.v] > Min + e.c) d2s[e.v] = Min + e.c;
}
}
if (d2s[t] != l) {
puts("NO");
return 0;
}
puts("YES");
for (int i = 0; i < m; i++) {
if (c[i] == 0) c[i] = 1;
printf("%d %d %lld\n", u[i], v[i], c[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T abs(T t) {
return t < 0 ? -t : t;
}
const long long modn = 1000000007;
inline long long mod(long long x) { return x % modn; }
const int MAXN = 212345;
int n, m;
long long k;
pair<long long, long long> s[MAXN];
long long p[MAXN], t;
long long test(long long c) {
long long ans = 0;
for (int a = 1; a <= m; a++) {
if (c < (p[a] - p[a - 1])) return LLONG_MAX;
if (c > 2 * (p[a] - p[a - 1])) {
ans += p[a] - p[a - 1];
} else {
ans +=
2 * (p[a] - p[a - 1]) - min(p[a] - p[a - 1], (c - (p[a] - p[a - 1])));
}
};
return ans;
}
int main() {
scanf("%d%d%lld%lld", &n, &m, &k, &t);
for (int a = 0; a < n; a++) {
scanf("%lld%lld", &s[a].first, &s[a].second);
}
p[0] = 0;
for (int a = 1; a <= m; a++) {
scanf("%lld", &p[a]);
}
p[m + 1] = k;
m++;
sort(p, p + m + 1);
long long i = 1, j = 5e9;
while (i < j) {
long long m = (i + j) / 2ll;
if (test(m) <= t)
j = m;
else
i = m + 1;
};
long long res = LLONG_MAX;
for (int a = 0; a < n; a++) {
if (s[a].second >= i && s[a].first < res) {
res = s[a].first;
}
}
if (res != LLONG_MAX)
printf("%lld\n", res);
else
puts("-1");
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1000005;
long long s, t, n, c[N], v[N], k, g[N];
signed main() {
ios::sync_with_stdio(false);
cin >> n >> k >> s >> t;
for (long long i = 1; i <= n; i++) cin >> c[i] >> v[i];
for (long long i = 1; i <= k; i++) cin >> g[i];
sort(g + 1, g + k + 1);
g[k + 1] = s;
long long l = 1, r = 2e9;
while (l < r) {
long long mid = (l + r) / 2;
long long sum = 0;
long long flag = 1;
for (long long i = 1; i <= k + 1; i++) {
long long len = g[i] - g[i - 1];
long long x = 2 * len - mid;
if (x > len) {
flag = 0;
break;
}
x = max(x, 0ll);
sum += x + len;
}
if (sum > t) flag = 0;
if (flag)
r = mid;
else
l = mid + 1;
}
long long ans = 1e18;
for (long long i = 1; i <= n; i++)
if (v[i] >= r) ans = min(ans, c[i]);
if (ans == 1e18)
cout << -1;
else
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 228228, INF = 1e9 + 228 + 666 + 1337;
int n, k, s, t;
int c[N], v[N], a[N];
bool can(int m) {
int x = s;
int i = k;
int tim = 0;
while (i >= 0 && x > 0) {
int dist = x - a[i];
if (m < dist) {
return false;
}
int f = min(dist, m - dist);
tim += (f + (dist - f) * 2);
x = a[i];
--i;
}
return tim <= t;
}
int main() {
scanf("%d %d %d %d", &n, &k, &s, &t);
for (int i = 0; i < n; ++i) {
scanf("%d %d", &c[i], &v[i]);
}
vector<int> g(k);
for (int i = 0; i < k; ++i) {
scanf("%d", &g[i]);
}
sort(g.begin(), g.end());
for (int i = 0; i < k; ++i) {
a[i + 1] = g[i];
}
int l = 0, r = INF;
while (r - l > 1) {
int m = (l + r) / 2;
if (can(m)) {
r = m;
} else {
l = m;
}
}
int vmin = r;
int min_cost = INF;
for (int i = 0; i < n; ++i) {
if (v[i] >= vmin) {
min_cost = min(min_cost, c[i]);
}
}
if (min_cost == INF) {
printf("-1\n");
return 0;
}
printf("%d\n", min_cost);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long s, t;
long long c[1000000];
long long v[1000000];
long long pos[1000000];
long long len[1000000];
int can(long long v) {
long long tm = 0;
for (int i = 0; i <= k; i++) {
if (v < len[i]) return 0;
tm += 2 * len[i] - min(len[i], v - len[i]);
}
return tm <= t;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k >> s >> t;
for (int i = 0; i < n; i++) cin >> c[i] >> v[i];
for (int i = 1; i <= k; i++) cin >> pos[i];
sort(pos + 1, pos + 1 + k);
for (int i = 1; i <= k; i++) len[i] = pos[i] - pos[i - 1];
len[k + 1] = s - pos[k];
k++;
long long l = 0;
long long r = 100000000000;
long long m;
if (!can(r)) {
cout << -1 << endl;
return 0;
}
while (r - l > 1) {
m = (l + r) / 2;
if (can(m))
r = m;
else
l = m;
}
if (can(l))
m = l;
else
m = r;
long long ans = 1000000000000000000;
for (int i = 0; i < n; i++) {
if (v[i] >= m) ans = min(ans, c[i]);
}
if (ans < 1000000000000000000)
cout << ans << endl;
else
cout << -1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T SQR(T x) {
return x * x;
}
template <typename T>
inline void UPDATE_MIN(T &x, T y) {
if (y < x) {
x = y;
}
}
template <typename T>
inline void UPDATE_MAX(T &x, T y) {
if (x < y) {
x = y;
}
}
template <typename T>
inline int ARGMAX(T cont) {
return max_element(cont.begin(), cont.end()) - cont.begin();
}
template <typename T>
inline int ARGMIN(T cont) {
return min_element(cont.begin(), cont.end()) - cont.begin();
}
template <typename T>
inline int hamming(T x) {
return __builtin_popcountll((long long)x);
}
int hamming(int x) { return __builtin_popcount(x); }
int hamming(long x) { return __builtin_popcountl(x); }
int hamming(long long x) { return __builtin_popcountll(x); }
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);
}
template <typename T, typename... Args>
inline string arrStr(T arr, int n) {
stringstream s;
s << "[";
for (__typeof(n - 1) i = (0), __tmpvar__end89 = (n - 1); i < __tmpvar__end89;
i++)
s << arr[i] << ",";
s << arr[n - 1] << "]";
return s.str();
}
template <class T>
inline string TOSTR(const T &x) {
stringstream ss;
ss << x;
return ss.str();
}
inline void DIER(char *res, char *dbg = NULL) {
fprintf(stderr, "[!] die reason %s\n", dbg);
puts(res);
exit(0);
}
inline void PR(void) {}
inline void PR(int x) { printf("%d", x); }
inline void PR(long long x) { printf("%lld", x); }
inline void PR(size_t x) { printf("%llu", (unsigned long long)x); }
inline void PR(const char *s) { printf("%s", s); }
inline void PR(double f) { printf("%.10f", f); }
inline void PR(long double f) { printf("%.10f", (double)f); }
template <typename T>
inline void PR(vector<T> &vec) {
auto sz = vec.size();
for (auto x : vec) {
PR(x);
(--sz) ? putc(0x20, stdout) : 0;
}
}
template <typename T>
inline void PRS(T x) {
PR(x);
putc(0x20, stdout);
}
template <typename T>
inline void PRN(T x) {
PR(x);
putc(0x0a, stdout);
}
void PRN(void) { putc(0x0a, stdout); }
struct pairhash {
template <typename T, typename U>
std::size_t operator()(const std::pair<T, U> &x) const {
return std::hash<T>()(x.first) ^ std::hash<U>()(x.second);
}
};
const int MOD = 1000 * 1000 * 1000 + 7;
const double PI = 3.1415926535897932384626433832795l;
template <typename T>
inline T gcd(T a, T b) {
return a ? gcd(b % a, a) : b;
}
inline void addto(int &a, int b) {
a += b;
if (a >= MOD) a -= MOD;
}
inline int add(int a, int b) {
a += b;
if (a >= MOD) a -= MOD;
return a;
}
inline void subto(int &a, int b) {
a -= b;
if (a < 0) a += MOD;
if (a >= MOD) a -= MOD;
}
inline int sub(int a, int b) {
a -= b;
if (a < 0) a += MOD;
if (a >= MOD) a -= MOD;
return a;
}
inline void multo(int &a, int b) { a = (long long)a * b % MOD; }
inline int mul(int a, int b) { return (long long)a * b % MOD; }
inline int mulmod(int a, int b, int mod) { return (long long)a * b % mod; }
inline int powmod(int a, int e, int mod) {
int x;
for (x = 1; e > 0; e >>= 1) {
if (e & 1) x = mulmod(x, a, mod);
a = mulmod(a, a, mod);
}
return x;
}
inline int invmod_prime(int a, int mod) { return powmod(a, mod - 2, mod); }
inline long long invmod_LL(long long p) {
long long q = p;
for (long long a = p * p; a != 1; a *= a) q *= a;
return q;
}
template <typename F, typename T>
T binary_search_first_good(T l, T r, F good) {
T res = -1;
while (r >= l) {
T mid = (l + r) >> 1;
if (good(mid)) {
res = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
return res;
}
int N, M, K, L, E, Q, S, T;
pair<int, int> cars[200123];
vector<int> dists;
bool isgood(long long vol) {
long long tot = 0;
for (auto &d : dists) {
if (d > vol) return false;
long long num1 = max(0ll, 2 * d - vol);
num1 = min(num1, (long long)d);
long long num2 = d - num1;
tot += 2 * num1 + num2;
}
1;
return (tot <= T);
}
int main() {
ios_base::sync_with_stdio(0);
scanf("%d%d", &N, &K);
scanf("%d%d", &S, &T);
for (__typeof(N) i = (0), __tmpvar__end252 = (N); i < __tmpvar__end252; i++) {
scanf("%d%d", &cars[i].first, &cars[i].second);
}
vector<int> stops;
for (__typeof(K) i = (0), __tmpvar__end254 = (K); i < __tmpvar__end254; i++) {
int x;
scanf("%d", &x);
stops.push_back(x);
}
sort((stops).begin(), (stops).end());
int cur = 0;
for (auto &x : stops) {
dists.push_back(x - cur);
cur = x;
}
dists.push_back(S - stops.back());
long long minv =
binary_search_first_good((long long)1, (long long)2e9, isgood);
1;
if (minv == -1) {
printf("-1");
exit(0);
};
int ans = -1;
for (__typeof(N) i = (0), __tmpvar__end271 = (N); i < __tmpvar__end271; i++) {
if (cars[i].second >= minv) {
if (ans == -1)
ans = cars[i].first;
else
ans = min(ans, cars[i].first);
}
}
PRN(ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 1e15;
const long long int mod = 1000000007;
const int infInt = 1e9;
const double PI = acos(-1.00);
const double eps = 1e-6;
long long int nCars, nGas, len, Time;
pair<long long int, long long int> cars[200010];
long long int stations[200010];
long long int bb(long long int ini, long long int fin, long long int fuel) {
long long int ans = -1;
long long int dist = fin;
while (ini <= fin) {
long long int mid = (ini + fin) / 2;
if (2LL * mid + (dist - mid) <= fuel) {
ans = mid;
ini = mid + 1;
} else {
fin = mid - 1;
}
}
return ans;
}
bool can(long long int fuel) {
long long int timeSpend = 0;
long long int ant = 0;
for (int i = 0; i < nGas; i++) {
long long int dist = stations[i] - ant;
ant = stations[i];
if (2LL * dist <= fuel) {
timeSpend += dist;
continue;
}
if (dist > fuel) return false;
long long int bestAcc = bb(0, dist, fuel);
timeSpend += bestAcc + 2 * (dist - bestAcc);
}
return (timeSpend <= Time);
}
int main() {
cin.sync_with_stdio(false);
cin.tie(NULL);
long long int maxi = -inf;
cin >> nCars >> nGas >> len >> Time;
for (int i = 0; i < nCars; i++) {
cin >> cars[i].first >> cars[i].second;
maxi = max(maxi, cars[i].second);
}
for (int i = 0; i < nGas; i++) {
cin >> stations[i];
}
sort(stations, stations + nGas);
stations[nGas++] = len;
long long int ini = 0, fin = maxi;
long long int bestFuel = -1;
while (ini <= fin) {
long long int mid = (ini + fin) / 2;
if (can(mid)) {
bestFuel = mid;
fin = mid - 1;
} else {
ini = mid + 1;
}
}
if (bestFuel == -1)
cout << -1 << "\n";
else {
long long int best = inf;
for (int i = 0; i < nCars; i++) {
if (cars[i].second >= bestFuel) {
best = min(best, cars[i].first);
}
}
cout << best << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, s, T;
vector<pair<long long, long long>> cars;
vector<long long> v1;
bool check2(long long x, long long fuelcapacity, long long dist) {
return x + ((dist - x) * 2) <= fuelcapacity;
}
bool check3(long long mid, long long i, long long x) {
return (2 * (v1[mid] - v1[i])) <= x;
}
bool check(long long x) {
long long t = 0;
for (long long i = 1; i <= k + 1; i++) {
long long dist = v1[i] - v1[i - 1];
if (2 * dist <= x) {
long long l = i;
long long r = k + 1;
long long ans = i;
while (l <= r) {
long long mid = (l + r) / 2;
if (check3(mid, i - 1, x)) {
ans = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
long long newdist = v1[ans] - v1[i - 1];
t += newdist;
i = ans;
continue;
}
long long l = 0;
long long r = dist;
long long ans = -1;
while (l <= r) {
long long mid = (l + r) / 2;
if (check2(mid, x, dist)) {
ans = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
if (ans == -1) {
return false;
}
t += (2 * ans) + (dist - ans);
}
return t <= T;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k >> s >> T;
v1.push_back(0);
for (long long i = 1; i <= n; i++) {
long long x, y;
cin >> x >> y;
cars.push_back(make_pair(x, y));
}
for (long long i = 1; i <= k; i++) {
long long x;
cin >> x;
v1.push_back(x);
}
v1.push_back(s);
sort(v1.begin(), v1.end());
long long l = 0;
long long r = 2e9;
long long ans = 3e9;
while (l <= r) {
long long mid = (l + r) / 2;
if (check(mid)) {
ans = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
sort(cars.begin(), cars.end());
for (auto x : cars) {
if (x.second >= ans) {
cout << x.first;
return 0;
}
}
cout << -1;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> ar[200010];
long long br[200010];
long long n, k;
bool chk(long long cap, long long x) {
long long tmp;
for (int i = k; i >= 0; i--) {
if (br[i] > cap) return false;
tmp = 2 * br[i] - cap;
if (tmp > 0) {
x -= tmp;
if (x < 0) {
return false;
}
} else
break;
}
return true;
}
int bin(int l, int r, long long x) {
if (l == r) return l;
int mid = (l + r) / 2;
if (chk(ar[mid].first, x))
return bin(l, mid, x);
else
return bin(mid + 1, r, x);
}
void solve() {
long long s, t;
cin >> n >> k >> s >> t;
for (int i = 0; i < n; i++) {
scanf("%d", &ar[i].second);
;
scanf("%d", &ar[i].first);
;
}
sort(ar, ar + n);
for (int i = n - 2; i >= 0; i--) {
ar[i].second = min(ar[i].second, ar[i + 1].second);
}
for (int i = 0; i < k; i++) {
scanf("%d", &br[i]);
;
}
sort(br, br + k);
br[k] = s - br[k - 1];
for (int i = k - 1; i > 0; i--) {
br[i] -= br[i - 1];
}
sort(br, br + k + 1);
long long x = t - s;
if (x < 0) {
printf("-1\n");
return;
}
if (!chk(ar[n - 1].first, x)) {
printf("-1\n");
return;
}
long long ans = bin(0, n - 1, x);
printf("%d\n", ar[ans].second);
}
int main() {
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int INF = 2e9 + 1, t, k;
int b[200020];
int cal(int dis, int cap) {
if (dis > cap) return INF;
if (dis == cap) return 2 * cap;
if (dis * 2 <= cap) return dis;
return dis * 2 - (cap - dis);
}
bool ch(int x) {
long long int ans = 0;
for (int i = 1; i < k; i++) {
ans += cal(b[i + 1] - b[i], x);
}
if (ans <= t) return true;
return false;
}
pair<int, int> a[200010];
int main() {
int n, s, imin = INF;
scanf("%d %d %d %d", &n, &k, &s, &t);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &a[i].second, &a[i].first);
}
for (int i = 1; i <= k; i++) {
scanf("%d", &b[i]);
}
k += 2;
b[k - 1] = 0;
b[k] = s;
sort(b + 1, b + 1 + k);
int l = 1, r = 1e9 + 20;
while (l < r) {
int mid = (l + r) / 2;
if (ch(mid))
r = mid;
else
l = mid + 1;
}
for (int i = 1; i <= n; i++) {
if (l <= a[i].first) imin = min(imin, a[i].second);
}
cout << (imin == INF ? -1 : imin);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200010;
int n, k, s, t;
int gas[MAXN];
struct Node {
int c, v;
friend bool operator<(const Node &p, const Node &q) { return p.c < q.c; }
} P[MAXN];
int pre[MAXN];
int check(int o) {
int tt = 0;
for (int i = 1; i <= k; i++) {
int x = gas[i] - gas[i - 1];
if (o < x) return 2147483647;
tt += max(x, 2 * x - (o - x));
}
return tt;
}
int main() {
scanf("%d%d%d%d", &n, &k, &s, &t);
for (int i = 1; i <= n; i++) scanf("%d%d", &P[i].c, &P[i].v);
for (int i = 1; i <= k; i++) scanf("%d", &gas[i]);
sort(gas + 1, gas + k + 1);
gas[++k] = s;
int l = 1, r = n;
sort(P + 1, P + n + 1);
for (int i = 1; i <= n; i++) pre[i] = max(pre[i - 1], P[i].v);
while (l < r) {
int mid = (l + r) >> 1;
int o = pre[mid];
int tt = check(o);
if (tt <= t)
r = mid;
else
l = mid + 1;
}
if (check(pre[l]) > t)
puts("-1");
else
printf("%d\n", P[l].c);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXNK = 2e5 + 10;
const long long INF = 1e18;
struct dian {
int c, v;
};
dian node[MAXNK];
int g[MAXNK];
int n, k, s;
long long T;
long long fi = INF;
bool cmp1(dian a, dian b) { return a.v < b.v; }
bool judge(int sum) {
long long t = 0;
for (int i = 2; i <= k; i++) {
int dis = g[i] - g[i - 1];
if (dis * 2 <= sum)
t += g[i] - g[i - 1];
else {
if (sum >= dis) {
t += 3 * dis - sum;
} else {
return false;
}
}
if (t > T) return false;
}
return true;
}
int main() {
cin >> n >> k >> s >> T;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &node[i].c, &node[i].v);
}
for (int i = 1; i <= k; i++) {
scanf("%d", &g[i]);
}
g[++k] = 0;
g[++k] = s;
sort(g + 1, g + 1 + k);
sort(node + 1, node + 1 + n, cmp1);
int l = 1, r = n, ans = -1;
while (l <= r) {
int m = (l + r) >> 1;
if (judge(node[m].v)) {
ans = m;
r = m - 1;
} else
l = m + 1;
}
if (ans == -1) {
puts("-1");
return 0;
}
for (int i = 1; i <= n; i++) {
if (node[i].v >= node[ans].v && node[i].c < fi) fi = node[i].c;
}
cout << fi << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mod = 1e9 + 7;
long long powmod(long long a, long long b) {
long long res = 1;
if (a >= mod) a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a;
if (res >= mod) res %= mod;
a = a * a;
if (a >= mod) a %= mod;
}
return res;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
static struct IO {
char tmp[1 << 10];
char cur;
inline char nextChar() { return cur = getc(stdin); }
inline char peekChar() { return cur; }
inline operator bool() { return peekChar(); }
inline static bool isBlank(char c) { return (c < '-' && c); }
inline bool skipBlanks() {
while (isBlank(nextChar()))
;
return peekChar() != 0;
}
inline IO& operator>>(char& c) {
c = nextChar();
return *this;
}
inline IO& operator>>(char* buf) {
if (skipBlanks()) {
if (peekChar()) {
*(buf++) = peekChar();
while (!isBlank(nextChar())) *(buf++) = peekChar();
}
*(buf++) = 0;
}
return *this;
}
inline IO& operator>>(string& s) {
if (skipBlanks()) {
s.clear();
s += peekChar();
while (!isBlank(nextChar())) s += peekChar();
}
return *this;
}
inline IO& operator>>(double& d) {
if ((*this) >> tmp) sscanf(tmp, "%lf", &d);
return *this;
}
inline IO& operator>>(int& n) {
if (skipBlanks()) {
int sign = +1;
if (peekChar() == '-') {
sign = -1;
n = nextChar() - '0';
} else
n = peekChar() - '0';
while (!isBlank(nextChar())) {
n += n + (n << 3) + peekChar() - 48;
}
n *= sign;
}
return *this;
}
inline IO& operator>>(unsigned int& n) {
if (skipBlanks()) {
int sign = +1;
if (peekChar() == '-') {
sign = -1;
n = nextChar() - '0';
} else
n = peekChar() - '0';
while (!isBlank(nextChar())) {
n += n + (n << 3) + peekChar() - 48;
}
n *= sign;
}
return *this;
}
inline IO& operator>>(long long& n) {
if (skipBlanks()) {
int sign = +1;
if (peekChar() == '-') {
sign = -1;
n = nextChar() - '0';
} else
n = peekChar() - '0';
while (!isBlank(nextChar())) {
n += n + (n << 3) + peekChar() - 48;
}
n *= sign;
}
return *this;
}
inline void putChar(char c) { putc(c, stdout); }
inline IO& operator<<(char c) {
putChar(c);
return *this;
}
inline IO& operator<<(const char* s) {
while (*s) putChar(*s++);
return *this;
}
inline IO& operator<<(const string& s) {
for (int i = 0; i < (int)s.size(); ++i) putChar(s[i]);
return *this;
}
char* toString(double d) {
sprintf(tmp, "%lf%c", d, '\0');
return tmp;
}
inline IO& operator<<(double d) { return (*this) << toString(d); }
inline char* toString(int n) {
char* p = (tmp + 30);
if (n) {
bool isNeg = 0;
if (n < 0) isNeg = 1, n = -n;
while (n) *--p = (n % 10) + '0', n /= 10;
if (isNeg) *--p = '-';
} else
*--p = '0';
return p;
}
inline IO& operator<<(int n) { return (*this) << toString(n); }
inline char* toString(long long n) {
char* p = (tmp + 30);
if (n) {
bool isNeg = 0;
if (n < 0) isNeg = 1, n = -n;
while (n) *--p = (n % 10) + '0', n /= 10;
if (isNeg) *--p = '-';
} else
*--p = '0';
return p;
}
inline IO& operator<<(long long n) { return (*this) << toString(n); }
} __io__;
const int N = 200000 + 5;
long long n, k, s, t, len[N], c[N], v[N], g[N], sum[N];
int ans = mod;
long long maxlen;
bool ok(long long cap) {
long long tim = 0;
int idx = upper_bound(len, len + k, cap / 2) - len;
if (idx) tim += sum[idx - 1];
if (idx != k) {
tim -= cap * 1LL * (k - idx);
tim += 3 * sum[k - 1];
if (idx) tim -= 3 * sum[idx - 1];
}
return tim <= t;
}
int main() {
int i, j;
__io__ >> n >> k >> s >> t;
for (i = 0; i < n; i++) {
__io__ >> c[i] >> v[i];
}
for (i = 0; i < k; i++) {
__io__ >> g[i];
}
sort(g, g + k);
g[k] = s;
int last = 0;
for (i = 0; i <= k; i++) {
len[i] = g[i] - last;
last = g[i];
maxlen = max(maxlen, len[i]);
}
k++;
sort(len, len + k);
sum[0] = len[0];
for (i = 1; i < k; i++) sum[i] = len[i] + sum[i - 1];
for (i = 0; i < n; i++) {
if (v[i] >= maxlen && ans > c[i] && ok(v[i])) ans = c[i];
}
if (ans == mod) ans = -1;
__io__ << ans << ('\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7, INF = 0x3f3f3f3f;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long qpow(long long a, long long n) {
long long r = 1 % P;
for (a %= P; n; a = a * a % P, n >>= 1)
if (n & 1) r = r * a % P;
return r;
}
long long inv(long long first) {
return first <= 1 ? 1 : inv(P % first) * (P - P / first) % P;
}
const int N = 1e6 + 10;
int n, k, s, t;
int c[N], v[N], a[N], g[N];
int chk(int first) {
if (g[k] > first) return 0;
long long sum = 0;
for (int i = 1; i <= k; ++i) {
int p = min(g[i], first - g[i]);
sum += (long long)2 * g[i] - p;
}
return sum <= t;
}
int main() {
scanf("%d%d%d%d", &n, &k, &s, &t);
if (s > t) return puts("-1"), 0;
for (int i = 1; i <= n; ++i) scanf("%d%d", c + i, v + i);
for (int i = 1; i <= k; ++i) scanf("%d", a + i);
a[++k] = 0, a[++k] = s;
sort(a + 1, a + 1 + k);
for (int i = 2; i <= k; ++i) g[i - 1] = a[i] - a[i - 1];
--k;
sort(g + 1, g + 1 + k);
int l = 1, r = 1e9, ans = INF;
while (l <= r) {
if (chk(((l + r) >> 1)))
ans = ((l + r) >> 1), r = ((l + r) >> 1) - 1;
else
l = ((l + r) >> 1) + 1;
}
int mi = INF;
for (int i = 1; i <= n; ++i)
if (v[i] >= ans) mi = min(mi, c[i]);
printf("%d\n", mi == INF ? -1 : mi);
}
|
#include <bits/stdc++.h>
using namespace std;
bool less_vectors(const vector<int>& a, const vector<int>& b) {
return a.size() > b.size();
}
long long gcd(long long a, long long b) {
if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
class compr {
public:
bool operator()(pair<pair<int, long long>, int> p1,
pair<pair<int, long long>, int> p2) {
if (p1.first.second != p2.first.second)
return p1.first.second > p2.first.second;
else if (p1.second != p2.second)
return p1.second > p2.second;
else
return p1.first < p2.first;
}
};
long long fastexpo(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b % 2 == 1)
res = (((res) % 1000000007) * ((a) % 1000000007)) % 1000000007;
a = (((a) % 1000000007) * ((a) % 1000000007)) % 1000000007;
b /= 2;
}
return res;
}
long long fastexpom(long long a, long long b, long long m) {
long long res = 1;
while (b > 0) {
if (b % 2 == 1) res = (((res) % m) * ((a) % m)) % m;
a = (((a) % m) * ((a) % m)) % m;
b /= 2;
}
return res;
}
long long modinv(long long a, long long m = 1000000007) {
return fastexpom(a, m - 2, m);
}
vector<long long> pos;
int k;
bool check(long long m, int time) {
int t = 0;
bool ch = 1;
int fuel = m;
for (int i = 0; i <= k; i++) {
long long t1 = 0;
long long d = pos[i + 1] - pos[i];
t1 = 2 * d;
m = fuel;
m -= d;
if (m < 0) {
ch = 0;
break;
}
t1 -= min(d, m);
t += t1;
}
if (t <= time)
;
else
ch = 0;
return ch;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, s, t;
cin >> n >> k >> s >> t;
long long hi = 0;
vector<pair<long long, long long> > v(n);
pos.resize(k + 2);
for (int i = 0; i < n; i++) {
cin >> v[i].first >> v[i].second;
hi = max(hi, v[i].second);
}
for (int i = 1; i <= k; i++) cin >> pos[i];
pos[0] = 0;
pos[k + 1] = s;
;
sort(pos.begin(), pos.end());
hi = hi + 1;
long long lo = 0;
while (lo < hi) {
int mid = (lo + hi) >> 1;
if (check(mid, t)) {
hi = mid;
} else
lo = mid + 1;
}
sort(v.begin(), v.end());
long long ans = INT_MAX;
for (int i = 0; i < n; i++) {
if (v[i].second >= lo) ans = min(ans, v[i].first);
}
if (ans != INT_MAX)
cout << ans;
else
cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, s, t, l, r, md, b;
pair<long long, long long> p[200005];
vector<long long> a;
bool check(long long fuel) {
long long sum = 0, x, dist;
for (int i = 1; i < a.size(); i++) {
dist = a[i] - a[i - 1];
if (dist > fuel) return 0;
x = min(fuel - dist, dist);
sum += 2 * dist - x;
}
if (sum <= t) return 1;
return 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k >> s >> t;
for (int i = 0; i < n; i++) cin >> p[i].first >> p[i].second;
sort(p, p + n);
for (int i = 1; i < n; i++) p[i].second = max(p[i].second, p[i - 1].second);
for (int i = 0; i < k; i++) {
cin >> b;
a.push_back(b);
}
a.push_back(0);
a.push_back(s);
sort(a.begin(), a.end());
l = 0, r = n;
while (l < r) {
md = (l + r) / 2;
if (check(p[md].second) == 1)
r = md;
else
l = md + 1;
}
if (l == n)
cout << -1;
else
cout << p[l].first;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
pair<int, int> car[MAXN];
int g[MAXN], pref[MAXN];
int n, k, s, t;
bool check(int v) {
int needTime = 0;
int dist;
for (int i = 1; i <= k + 1; i++) {
dist = g[i] - g[i - 1];
if (v >= 2 * dist) {
needTime += dist;
} else {
needTime += (2 * dist - v % dist);
}
}
return (needTime <= t) ? true : false;
}
int main() {
ios_base::sync_with_stdio(false);
int ans, mx, lg, rg, mid;
bool flag;
cin >> n >> k >> s >> t;
for (int i = 0; i < n; i++) {
cin >> car[i].first >> car[i].second;
}
sort(car, car + n);
memset(pref, 0, sizeof(pref));
pref[0] = car[0].second;
for (int i = 1; i < n; i++) {
pref[i] = max(pref[i - 1], car[i].second);
}
g[0] = 0;
for (int i = 1; i <= k; i++) cin >> g[i];
g[k + 1] = s;
sort(g, g + k + 1);
mx = 0;
for (int i = 1; i <= k + 1; i++) mx = max(mx, g[i] - g[i - 1]);
lg = 0;
rg = n;
while (rg - lg > 1) {
mid = (lg + rg) / 2;
if (pref[mid] < mx) {
lg = mid;
continue;
}
if (check(pref[mid]))
rg = mid;
else
lg = mid;
}
if (rg == n) {
if ((mx <= pref[lg]) && (check(pref[lg]))) {
cout << car[lg].first << endl;
} else {
cout << -1 << endl;
}
} else {
if ((mx <= pref[lg]) && (check(pref[lg]))) {
cout << car[lg].first << endl;
} else {
cout << car[rg].first << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
long long n, k, s, t, c[N], v[N], x[N];
bool check(long long V) {
int last = 0;
long double T = 0;
for (int i = 0; i < k; i++) {
long double d = x[i] - last;
if (V < d) return false;
long double big = min(V - d, d);
T += big;
T += 2 * (d - big);
last = x[i];
}
if (T <= t)
return true;
else
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k >> s >> t;
for (int i = 0; i < n; i++) cin >> c[i] >> v[i];
for (int i = 0; i < k; i++) cin >> x[i];
x[k++] = s;
sort(x, x + k);
int l = 0, r = 1e9 + 10;
while (r - l > 1) {
int mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
long long ans = 1e9 + 10;
for (int i = 0; i < n; i++)
if (v[i] >= r) ans = min(ans, c[i]);
if (ans == 1e9 + 10)
cout << "-1\n";
else
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 10;
int main() {
int n, k, s, t;
scanf("%d%d%d%d", &n, &k, &s, &t);
vector<pair<int, int> > car(n + 2);
car[0] = make_pair(0, 0);
car[n + 1] = make_pair(INF, INF);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &car[i].second, &car[i].first);
}
sort(car.begin(), car.end());
vector<int> oil(k + 2);
oil[0] = 0;
oil[k + 1] = s;
for (int i = 1; i <= k; ++i) scanf("%d", &oil[i]);
sort(oil.begin(), oil.end());
vector<int> d(k + 1);
for (int i = 0; i < k + 1; ++i) d[i] = oil[i + 1] - oil[i];
int l = 0, r = n + 1;
while (r - l > 1) {
int m = (r + l) / 2;
int b = car[m].first;
long long cur = 0;
bool f = true;
for (int i = 0; i < k + 1; ++i) {
if (d[i] > b)
f = false;
else {
int d1 = b - d[i];
if (d1 >= d[i])
cur += d[i];
else {
int d2 = d[i] - d1;
cur += d1 + 2 * d2;
}
}
}
if ((cur <= t) && (f)) {
r = m;
while (car[r - 1].first == car[r].first) r--;
} else {
l = m;
}
}
int ans = car[r].second;
for (int i = r; i <= n; ++i) ans = min(ans, car[i].second);
if (ans == INF)
cout << -1;
else
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int pos[200005];
struct lx {
int cost, val;
} num[200005];
vector<int> vec;
int n, k, s, t, temp[200005], last = 0, maxn = 0, m2 = 0;
int Bsearch(int L, int R) {
int mid, l = L, r = R, co;
while (l < r) {
co = 0;
mid = (l + r) / 2;
for (int i = 0; i < vec.size(); ++i) {
co += vec[i] * 2 - min(vec[i], mid - vec[i]);
}
if (co <= t) {
r = mid;
} else {
l = mid + 1;
}
}
return l;
}
int main() {
scanf("%d%d%d%d", &n, &k, &s, &t);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &num[i].cost, &num[i].val);
m2 = max(m2, num[i].val);
}
for (int i = 0; i < k; ++i) {
scanf("%d", &temp[i]);
}
sort(temp, temp + k);
for (int i = 0; i < k; ++i) {
vec.push_back(temp[i] - last);
maxn = max(maxn, temp[i] - last);
last = temp[i];
}
vec.push_back(s - last);
maxn = max(maxn, s - last);
if (s > t) {
printf("-1\n");
return 0;
}
int co = 0;
for (int i = 0; i < vec.size(); ++i) {
co += vec[i] * 2 - min(vec[i], m2 - vec[i]);
}
if (co > t) {
printf("-1\n");
return 0;
}
int minn = Bsearch(maxn, maxn * 2), ans = 0x3f3f3f3f;
for (int i = 0; i < n; ++i) {
if (num[i].val >= minn) {
ans = min(ans, num[i].cost);
}
}
if (ans == 0x3f3f3f3f)
printf("-1\n");
else
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, s, t;
scanf("%lld %lld %lld %lld", &n, &k, &s, &t);
vector<pair<long long, long long> > cars;
for (int i = 0; i < n; i++) {
long long a, b;
scanf("%lld %lld", &a, &b);
cars.push_back(make_pair(b, a));
}
sort(cars.begin(), cars.end());
long long sum = 0;
long long maxi = -1;
long long last = 0;
vector<long long> gas;
for (int i = 0; i < k; i++) {
long long a;
scanf("%lld", &a);
gas.push_back(a);
}
sort(gas.begin(), gas.end());
vector<long long> val;
for (int i = 0; i < gas.size(); i++) {
long long a = gas[i];
if (maxi < a - last) {
maxi = a - last;
}
val.push_back(a - last);
sum += a - last;
last = a;
}
sum += s - last;
val.push_back(s - last);
if (maxi < s - last) {
maxi = s - last;
}
if (t < s) {
printf("-1\n");
return 0;
}
long long add = 0;
if (t < 2 * s) {
add = 2 * s - t;
}
long long min2 = maxi, max2 = 1000000000000000007, med = maxi;
if (add)
while (min2 < max2) {
med = (min2 + max2) / 2;
long long sum2 = 0;
for (int i = 0; i < val.size(); i++) {
sum2 += min(val[i], med - val[i]);
}
if (sum2 >= add) {
max2 = med;
}
if (sum2 < add) {
min2 = med + 1;
}
}
long long ans = 1000000007;
for (int i = 0; i < n; i++) {
if (min2 <= cars[i].first) ans = min(ans, cars[i].second);
}
if (ans == 1000000007)
printf("-1\n");
else
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10, inf = 1e9;
const long double pi = 3.14159265;
long long n, k, s, t;
long long gas[maxn];
vector<pair<long long, long long> > a;
bool check(long long mid) {
vector<long long> distance;
distance.push_back(0);
distance.push_back(s);
for (int i = 0; i < k; i++) {
distance.push_back(gas[i]);
}
sort(distance.begin(), distance.end());
long long fuel = mid, time = 0;
for (int i = 1; i < distance.size(); i++) {
long long dis = distance[i] - distance[i - 1];
if (dis > fuel)
return 0;
else {
long long tmp = min(dis, fuel - dis);
time += tmp + (dis - tmp) * 2;
}
}
if (time > t) {
return 0;
}
return 1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> s >> t;
for (int i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
a.push_back(make_pair(y, x));
}
for (int i = 0; i < k; i++) {
cin >> gas[i];
}
sort(a.begin(), a.end());
long long l = 0, r = t * 2;
while (l < r - 1) {
long long mid = (l + r) / 2;
if (check(mid) == 1) {
r = mid;
} else {
l = mid;
}
}
long long ans = 9e9;
if (check(r) == 0) {
return cout << -1, 0;
}
for (int i = 0; i < a.size(); i++) {
if (a[i].first >= r) {
ans = min(ans, a[i].second);
}
}
if (ans == 9e9) {
return cout << -1, 0;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int OO = 2e9;
const int MOD = 1e9 + 7;
const double Pi = 3.141592653589793;
const int N = 3e5 + 5;
long long c[N], v[N], g[N], a[N], n, k, s, t, m = 0, mx = 0, mn = -1, res = OO;
bool check(long long cap) {
long long time = 0;
for (int i = (int)1; i <= (int)m; i++) {
if (a[i] > cap) return false;
long long y = max(0LL, min(a[i], cap - a[i])), x = a[i] - y;
time += 2LL * x + y;
}
return (time <= t);
}
int main() {
cin >> n >> k >> s >> t;
if (s > t) {
cout << -1;
return 0;
}
for (int i = (int)1; i <= (int)n; i++) scanf("%i%i", &v[i], &c[i]);
for (int i = (int)1; i <= (int)k; i++) scanf("%i", &g[i]);
g[++k] = s;
g[++k] = 0;
sort(g + 1, g + k + 1);
for (int i = (int)2; i <= (int)k; i++)
a[++m] = g[i] - g[i - 1], mx = max(mx, a[m]);
long long l = mx, r = s * 2, mid;
while (l <= r) {
mid = (l + r) >> 1;
if (check(mid))
mn = mid, r = mid - 1;
else
l = mid + 1;
}
for (int i = (int)1; i <= (int)n; i++)
if (c[i] >= mn) res = min(res, v[i]);
if (res == OO)
cout << -1;
else
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int cars_cnt, fs_cnt, distance, til_time;
cin >> cars_cnt >> fs_cnt >> distance >> til_time;
vector<pair<int, int>> cars;
cars.reserve(cars_cnt);
for (int i = 0; i < cars_cnt; i++) {
int ci, vi;
cin >> ci >> vi;
cars.push_back(make_pair(vi, ci));
}
vector<int> gas_stations;
gas_stations.reserve(fs_cnt);
for (int i = 0; i < fs_cnt; i++) {
int tmp;
cin >> tmp;
gas_stations.push_back(tmp);
}
gas_stations.push_back(distance);
sort(gas_stations.begin(), gas_stations.end());
sort(cars.begin(), cars.end());
int l = -1, r = cars_cnt, m;
while (r - l > 1) {
m = l + (r - l) / 2;
int t = 0;
int fuel_max = cars[m].first;
int p = 0;
int dist = 0;
bool ok = true;
while (p < gas_stations.size()) {
int travel = gas_stations[p] - dist;
if (travel > fuel_max) {
ok = false;
break;
}
t += 2 * travel - min(travel, fuel_max - travel);
dist = gas_stations[p];
p++;
}
if (t <= til_time && ok) {
r = m;
} else {
l = m;
}
}
int mm = 1000000001;
for (int i = r; i < cars_cnt; i++) {
if (cars[i].second < mm) {
mm = cars[i].second;
}
}
if (mm == 1000000001) {
cout << -1 << endl;
} else {
cout << mm << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> p[200001];
int x[200001];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n, k, s, t;
cin >> n >> k >> s >> t;
for (int i = 0; i < n; i++) {
cin >> p[i].first >> p[i].second;
}
vector<pair<int, int> > vt;
sort(p, p + n);
for (int i = 0; i < n; i++) {
if (vt.empty() || p[i].second > vt.back().second) {
vt.push_back(p[i]);
}
}
for (int i = 1; i <= k; i++) {
cin >> x[i];
}
sort(x + 1, x + k + 1);
x[k + 1] = s;
int l = -1;
int r = vt.size();
while (l < r - 1) {
int m = (l + r) / 2;
int ct = 0;
for (int j = 0; j <= k; j++) {
if (vt[m].second < x[j + 1] - x[j]) {
ct = t + 1;
break;
}
int dt = min(vt[m].second - (x[j + 1] - x[j]), (x[j + 1] - x[j]));
ct += 2 * (x[j + 1] - x[j]) - dt;
}
cerr << ct << "\n";
if (ct > t) {
l = m;
} else {
r = m;
}
}
if (r == vt.size())
cout << "-1";
else
cout << vt[r].first;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool ok(vector<int> &p, int v, int t) {
long long spent = 0;
for (int i = 0; i < (int)p.size() - 1; i++) {
int len = p[i + 1] - p[i];
if (v < len) return false;
int speedy = max(0.0, (2 * v - len) / 3.0);
speedy = min(speedy, len);
speedy = min(speedy, v - len);
speedy = max(speedy, 0);
spent += speedy;
spent += 2 * (len - speedy);
}
return spent <= t;
}
namespace InputReader {
char inputBuffer[5 * 1000 * 1000];
inline void getNextToken() {
int memoryPointer = 0;
while (true) {
char c = static_cast<char>(getchar());
if ((c < '0' || c > '9') && c != '.' && c != '-') break;
inputBuffer[memoryPointer++] = c;
}
inputBuffer[memoryPointer] = 0;
}
inline int nextInt() {
getNextToken();
int ret = 0;
int sign = 1;
for (int i = 0; inputBuffer[i]; i++) {
switch (inputBuffer[i]) {
case '-':
sign = -1;
continue;
default:
ret = 10 * ret + inputBuffer[i] - '0';
}
}
return ret * sign;
}
inline long long nextLong() {
getNextToken();
long long ret = 0;
int sign = 1;
for (int i = 0; inputBuffer[i]; i++) {
switch (inputBuffer[i]) {
case '-':
sign = -1;
continue;
default:
ret = 10 * ret + inputBuffer[i] - '0';
}
}
return ret * sign;
}
inline double nextDouble() {
getNextToken();
double integerPart = 0.0;
double fractionalPart = 0.0;
bool fractionalPartStarted = false;
double fractionalPartMultiplier = 0.1;
int sign = -1;
for (int i = 0; inputBuffer[i]; i++) {
switch (inputBuffer[i]) {
case '-':
sign = -1;
continue;
case '.':
fractionalPartStarted = true;
continue;
default:
if (fractionalPartStarted) {
fractionalPart += (inputBuffer[i] - '0') * fractionalPartMultiplier;
fractionalPartMultiplier *= 0.1;
} else {
integerPart = 10 * integerPart + inputBuffer[i] - '0';
}
}
}
}
}; // namespace InputReader
using namespace InputReader;
int main() {
int n, k, s, t;
n = nextInt();
k = nextInt();
s = nextInt();
t = nextInt();
vector<pair<int, int>> a(n);
for (int i = 0; i < n; i++) {
a[i].first = nextInt();
a[i].second = nextInt();
}
sort(a.begin(), a.end());
for (int i = 1; i < n; i++) {
if (a[i - 1].second > a[i].second) a[i] = a[i - 1];
}
vector<int> g;
g.push_back(0);
for (int i = 0; i < k; i++) {
int x;
cin >> x;
g.push_back(x);
}
g.push_back(s);
sort(g.begin(), g.end());
int low = 0, high = n - 1, opt = 2e9 + 5;
for (int it = 0; it < 20; it++) {
int mid = (low + high) / 2;
int v = a[mid].second;
if (ok(g, v, t)) {
opt = min(opt, a[mid].first);
high = mid;
} else {
low = mid + 1;
}
}
if (opt > 2e9) opt = -1;
cout << opt << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, s, t;
vector<int> g;
vector<pair<int, int> > cars;
bool CanReach(int capacity) {
int time_left = t;
for (int i = 0; i < k - 1; i++) {
int distance = g[i + 1] - g[i];
if (distance > capacity) return false;
int accel = capacity - distance;
if (accel > distance) accel = distance;
int time = distance * 2 - accel;
time_left -= time;
if (time_left < 0) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
scanf("%d%d%d%d", &n, &k, &s, &t);
g = vector<int>(k);
cars = vector<pair<int, int> >(n);
for (int i = 0; i < n; i++) scanf("%d%d", &cars[i].second, &cars[i].first);
for (int i = 0; i < k; i++) scanf("%d", &g[i]);
g.push_back(0);
g.push_back(s);
k += 2;
sort(g.begin(), g.end());
sort(cars.begin(), cars.end());
for (int i = cars.size() - 1 - 1; i >= 0; i--)
if (cars[i].second > cars[i + 1].second)
cars[i].second = cars[i + 1].second;
int l = 0, h = cars.size() - 1;
while (l <= h) {
int mid = (l + h) >> 1;
if (CanReach(cars[mid].first))
h = mid - 1;
else
l = mid + 1;
}
if (l == n)
cout << -1 << endl;
else
cout << cars[l].second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000 + 1;
int n, k, s, t;
vector<pair<int, int> > cars;
vector<int> pos;
int calc(int c) {
int ret = 0;
for (int i = 0; i < (int)pos.size(); ++i) {
if (c >= pos[i] * 2) {
ret += pos[i];
} else {
ret += pos[i] * 2 - c + pos[i];
}
}
return ret;
}
int main() {
scanf("%d%d%d%d", &n, &k, &s, &t);
for (int i = 0; i < n; ++i) {
int c, v;
scanf("%d%d", &c, &v);
cars.push_back(make_pair(v, c));
}
for (int i = 0; i < k; ++i) {
int g;
scanf("%d", &g);
pos.push_back(g);
}
pos.push_back(s);
sort(pos.begin(), pos.end());
for (int i = k; i > 0; --i) {
pos[i] -= pos[i - 1];
}
sort(pos.begin(), pos.end());
int l = *pos.rbegin(), maxc = 2 * l + 1, r = maxc;
while (l < r) {
int m = ((r - l) >> 1) + l;
if (calc(m) <= t) {
r = m;
} else {
l = m + 1;
}
}
int minc = l;
if (minc == maxc) {
printf("-1\n");
} else {
int minv = INF;
for (int i = 0; i < n; ++i) {
if (cars[i].first >= minc) {
minv = min(minv, cars[i].second);
}
}
if (minv == INF) {
printf("-1\n");
} else {
printf("%d\n", minv);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, k, s, t;
cin >> n >> k >> s >> t;
vector<long long> c(n);
vector<long long> v(n);
for (int i = 0; i < n; ++i) cin >> c[i] >> v[i];
vector<long long> g(k);
for (int i = 0; i < k; ++i) cin >> g[i];
g.push_back(0);
sort(g.begin(), g.end());
for (int i = 0; i < g.size() - 1; ++i) g[i] = g[i + 1] - g[i];
g[g.size() - 1] = s - g[g.size() - 1];
long long l = 1, r = INT_MAX;
while (l <= r) {
long long mid = (l + r) / 2;
bool flag = true;
long long min_time = 0;
for (int i = 0; i < g.size(); ++i) {
if (g[i] > mid) {
flag = false;
break;
}
if (g[i] * 2 <= mid)
min_time += g[i];
else {
min_time += g[i] * 2 - (mid - g[i]);
}
}
if (!flag || min_time > t)
l = mid + 1;
else
r = mid - 1;
}
int ans = -1;
for (int i = 0; i < n; ++i) {
if (v[i] >= l && (ans == -1 || c[i] < ans)) ans = c[i];
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
template <typename T>
bool _max(T& a, T b) {
return (a < b) ? a = b, true : false;
}
template <typename T>
bool _min(T& a, T b) {
return (b < a) ? a = b, true : false;
}
unsigned S[200005];
std::pair<unsigned, unsigned> P[200005];
int main() {
unsigned n, k, s, l = 0, ans = -1;
unsigned long long t, wil, lazy = 0;
scanf("%u%u%u%llu", &n, &k, &s, &t), S[0] = 0, S[k + 1] = s;
for (unsigned i = 0; i < n; i++) scanf("%u%u", &P[i].second, &P[i].first);
std::sort(P, P + n);
for (unsigned i = 1; i <= k; i++) scanf("%u", S + i);
std::sort(S + 1, S + k + 1);
for (unsigned i = 0; i <= k; i++) S[i] = S[i + 1] - S[i];
std::sort(S, S + k + 1);
for (unsigned i = 0; i < n; i++) {
if (S[k] > P[i].first || P[i].second >= ans) continue;
while (l <= k && P[i].first >= 2 * S[l]) lazy += S[l++];
wil = lazy;
for (unsigned j = l; j <= k; j++) wil += 3 * S[j] - P[i].first;
if (wil <= t) _min(ans, P[i].second);
}
printf("%d\n", (~ans) ? (int)ans : -1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> a[200 * 1000 + 7];
long long b[200 * 1000 + 7];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, k, s, T, t, i, j, L, M, R, ans = INT_MAX;
cin >> n >> k >> s >> T;
for (i = 1; i <= n; i++) cin >> a[i].first >> a[i].second;
for (i = 1; i <= k; i++) cin >> b[i];
sort(b + 1, b + k + 1);
b[k + 1] = s;
L = 0;
R = 1000 * 1000 * 1000;
t = 0;
for (i = 1; i <= k + 1; i++) {
t +=
2 * (b[i] - b[i - 1]) - min(R - (b[i] - b[i - 1]), b[i] - b[i - 1]) * 1;
}
if (t > T) {
cout << -1;
return 0;
}
while (R - L > 1) {
M = (L + R) / 2;
t = 0;
for (i = 1; i <= k + 1; i++) {
if (b[i] - b[i - 1] > M) {
L = M;
goto m1;
}
t += 2 * (b[i] - b[i - 1]) -
min(M - (b[i] - b[i - 1]), b[i] - b[i - 1]) * 1;
}
if (t <= T)
R = M;
else
L = M;
m1:;
}
for (i = 1; i <= n; i++)
if (a[i].second >= R && a[i].first < ans) ans = a[i].first;
if (ans == INT_MAX)
cout << -1;
else
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long s, t;
pair<long long, long long> u[200007];
long long a[200007];
bool f(long long val) {
int i;
long long cur = 0;
for (i = 0; i <= k; i++) {
long long dist = a[i + 1] - a[i];
if (val < dist) {
return false;
}
long long h = (val - dist);
if (h >= dist) {
cur += dist;
} else {
cur += h;
cur += 2 * (dist - h);
}
if (cur > t) {
return false;
}
}
return true;
}
void input() {
scanf("%d%d", &n, &k);
scanf("%I64d%I64d", &s, &t);
int i;
for (i = 1; i <= n; i++) {
scanf("%I64d%I64d", &u[i].first, &u[i].second);
}
for (i = 1; i <= k; i++) {
scanf("%I64d", &a[i]);
}
sort(a + 1, a + k + 1);
a[0] = 0;
a[k + 1] = s;
}
void solve() {
if (t < s) {
printf("-1\n");
return;
}
long long l, r, mid;
l = r = 1;
int i;
for (i = 1; i <= 12; i++) {
r *= 10;
}
while ((r - l) > 3) {
mid = (l + r) / 2;
if (f(mid) == true) {
r = mid;
} else {
l = mid;
}
}
while (f(l) == false) {
l++;
}
long long ans = -1;
for (i = 1; i <= n; i++) {
if (u[i].second < l) {
continue;
}
if (ans == -1 || ans > u[i].first) {
ans = u[i].first;
}
}
printf("%I64d\n", ans);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long i, j, k, l, m, n, s, a[311111], b[322222], c[222222], d, e, t, nn, mm,
x, ll;
string p, q, r, w, ww;
multiset<long long> ms;
pair<long long, long long> y[311111];
vector<long long> u[111], uu, o;
int main() {
cin >> n >> k >> l >> t;
for (i = 0; i < n; i++) {
scanf("%I64d %I64d", &a[i], &b[i]);
}
c[0] = 0;
for (i = 1; i <= k; i++) scanf("%I64d", &c[i]);
c[k + 1] = l;
k += 2;
sort(c, c + k);
for (i = 0; i < k - 1; i++) c[i] = c[i + 1] - c[i];
k--;
sort(c, c + k);
d = c[k - 1];
e = 111111111111111;
while (e > d) {
s = 0;
m = (d + e) / 2;
for (i = 0; i < k; i++) {
if (m >= 2 * c[i])
s += c[i];
else {
s += 3 * c[i] - m;
}
}
if (s <= t)
e = m;
else
d = m + 1;
}
m = d;
s = 111111111111;
d = 0;
for (i = 0; i < n; i++) {
if (b[i] >= m) {
d = 1;
s = min(s, a[i]);
}
}
if (d == 0)
cout << -1;
else
cout << s;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long inf = mod * mod;
pair<int, int> p[210000];
int f[210000];
int g[210000];
int main() {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
int ret = mod;
for (int i = 0; i < a; i++) {
int x, y;
scanf("%d%d", &x, &y);
p[i] = make_pair(y, x);
}
std::sort(p, p + a);
for (int i = 0; i < b; i++) scanf("%d", f + i);
f[b] = c;
std::sort(f, f + b + 2);
for (int i = 0; i < b + 1; i++) {
g[i] = f[i + 1] - f[i];
}
std::sort(g, g + b + 1);
b++;
int at = 0;
long long tn = 0;
long long al = 0;
for (int i = 0; i < b; i++) tn += g[i];
tn *= 3;
for (int i = 0; i < a; i++) {
if (g[b - 1] > p[i].first) continue;
while (at < b && g[at] * 2 <= p[i].first) {
tn -= 3LL * g[at];
al += g[at];
at++;
}
long long cost = al + tn - (long long)(b - at) * p[i].first;
if (cost <= d) ret = min(ret, p[i].second);
}
if (ret == mod) ret = -1;
printf("%d\n", ret);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, s, t;
int g[200005], c[200005], v[200005], l[200005];
int suml[200005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> k >> s >> t;
for (int i = 1; i <= n; i++) {
cin >> c[i] >> v[i];
}
for (int i = 1; i <= k; i++) {
cin >> g[i];
}
k++;
sort(g + 1, g + k);
g[k] = s;
for (int i = 1; i <= k; i++) {
l[i] = g[i] - g[i - 1];
}
sort(l + 1, l + k + 1);
for (int i = 1; i <= k; i++) {
suml[i] = suml[i - 1] + l[i];
}
int mc = 1999999999;
for (int i = 1; i <= n; i++) {
int c = ::c[i];
int v = ::v[i];
if (v < l[k]) {
continue;
}
int split = upper_bound(l + 1, l + k + 1, v / 2) - l;
int t_fast = suml[split - 1];
long long t_eco =
3ll * (suml[k] - suml[split - 1]) - v * 1ll * (k - split + 1);
if (t_fast + t_eco <= t) {
mc = min(mc, c);
}
}
if (mc == 1999999999) {
mc = -1;
}
cout << mc;
}
|
#include <bits/stdc++.h>
using namespace std;
struct car {
long long v, c;
};
bool comp(const car &a, const car &b) { return a.v > b.v; }
long long g[202020];
car m[202020];
int n, k;
long long s, t;
bool gtime(int val) {
long long cur(0), res(0);
for (int i(0); i < k; ++i) {
if (g[i] - cur > m[val].v) return false;
long long dist(g[i] - cur);
res += max(dist, 3 * dist - m[val].v);
cur = g[i];
}
return res <= t;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k >> s >> t;
for (int i(0); i < n; ++i) cin >> m[i].c >> m[i].v;
sort(m, m + n, comp);
for (int i(0); i < k; ++i) cin >> g[i];
g[k++] = s;
sort(g, g + k);
int l(0), r(n);
while (l + 1 < r) {
if (gtime((l + r) / 2)) {
l = (l + r) / 2;
} else
r = (l + r) / 2;
}
if (!gtime(l)) {
cout << -1;
return 0;
}
long long ans(1e9 + 1);
for (int i(0); i <= l; ++i) ans = min(ans, m[i].c);
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 2100000000;
int s, t, ans, i, j, k, n, m, a[310001], mid, b[310001], g[310001], l, r;
bool check(int x) {
int i, j, k = 0;
for (i = 1; i <= m + 1; i++) {
if (g[i] - g[i - 1] > x) return 0;
k += min(x - g[i] + g[i - 1], g[i] - g[i - 1]);
}
return k >= 2LL * (long long)s - t;
}
int main() {
scanf("%d%d%d%d", &n, &m, &s, &t);
for (k = 0, i = 1; i <= n; i++) scanf("%d%d", &a[i], &b[i]), k = max(k, b[i]);
for (i = 1; i <= m; i++) scanf("%d", &g[i]);
sort(g + 1, g + 1 + m);
g[0] = 0;
g[m + 1] = s;
if (!check(k)) {
puts("-1");
return 0;
}
for (l = 0, r = k; l < r - 1;) {
mid = ((long long)l + (long long)r) / 2LL;
if (check(mid))
r = mid;
else
l = mid + 1;
}
k = (check(l)) ? l : r;
for (i = 1, ans = inf; i <= n; i++)
if (b[i] >= k) ans = min(ans, a[i]);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
template <typename T>
inline T max(T a, T b) {
return a > b ? a : b;
}
template <typename T>
inline T min(T a, T b) {
return a < b ? a : b;
}
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <typename T>
inline void repr(T &a, T b) {
if (a < b) a = b;
}
template <typename T>
inline void repl(T &a, T b) {
if (a > b) a = b;
}
template <typename T>
T gcd(T a, T b) {
if (b) return gcd(b, a % b);
return a;
}
int n, k, s, t, g[200002];
struct hh {
int c, v;
bool operator<(hh x) const { return c < x.c; }
} u[200000];
int main() {
scanf("%d%d%d%d", &n, &k, &s, &t);
for (int i = 0; i < n; i++) scanf("%d%d", &u[i].c, &u[i].v);
std::sort(u, u + n);
for (int i = 0; i < k; i++) scanf("%d", g + i);
g[k] = 0, g[k + 1] = s;
std::sort(g, g + k + 2);
int l = 0, r = 2000000000;
while (r - l > 1) {
int p = (l + r) / 2;
long long tm = 0;
for (int i = 0; i <= k; i++) {
if (p < g[i + 1] - g[i]) {
tm = 0x7fffffffffffffff;
break;
}
tm += max((long long)(g[i + 1] - g[i]) * 3 - p,
(long long)(g[i + 1] - g[i]));
}
if (tm > t)
l = p;
else
r = p;
}
for (int i = 0; i < n; i++)
if (u[i].v >= r) {
printf("%d", u[i].c);
return 0;
}
puts("-1");
}
|
#include <bits/stdc++.h>
using namespace std;
int g[200009], n, k, s, t;
long long ans = 1e10;
long long time(long long c) {
long long sum = 0;
for (int i = 1; i <= k + 1; i++) {
long long d = g[i] - g[i - 1];
if (c < d) return 0;
long long d1 = min(c - d, d);
long long d2 = d - d1;
sum += d1 + 2 * d2;
}
return sum <= t;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k >> s >> t;
pair<int, int> arr[n + 9];
g[0] = 0, g[k + 1] = s;
for (int i = 0; i < n; i++) cin >> arr[i].first >> arr[i].second;
for (int i = 1; i <= k; i++) cin >> g[i];
sort(g, g + k + 2);
long long low = 1, high = 1e10, m, cc;
while (low <= high) {
m = (low + high) / 2;
if (time(m))
high = m - 1, cc = m;
else
low = m + 1;
}
for (int i = 0; i < n; i++) {
if (arr[i].second >= cc && arr[i].first < ans) ans = arr[i].first;
}
cout << (ans != 1e10 ? ans : -1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 200002, INF = 2000000001;
pair<int, int> cars[maxN];
int k, gas[maxN];
int min_time(int cap) {
int t = 0;
for (int i = 0; i <= k; i++) {
int d = gas[i + 1] - gas[i];
if (cap < d) return INF;
t += (cap >= d * 2 ? d : d * 2 - (cap % d));
}
return t;
}
int main() {
int n, s, t;
scanf("%d%d%d%d", &n, &k, &s, &t);
for (int i = 0; i < n; i++) scanf("%d%d", &cars[i].first, &cars[i].second);
for (int i = 1; i <= k; i++) scanf("%d", gas + i);
sort(gas, gas + k + 1);
gas[k + 1] = s;
int begin = 0, end = s * 2 + 1;
while (end - begin > 1) {
int middle = (begin + end) / 2;
min_time(middle) <= t ? end = middle : begin = middle;
}
if (end == s * 2 + 1) {
printf("-1\n");
return 0;
}
int res = INF;
for (int i = 0; i < n; i++) {
if (cars[i].second >= end) res = min(res, cars[i].first);
}
printf("%d\n", (res == INF ? -1 : res));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
int n, k, s, t, c[200010], v[200010], g[200010], sum[200010];
vector<int> l;
bool check(int V) {
if (V < l.back()) return false;
auto it = upper_bound(l.begin(), l.end(), V / 2);
int cost = 0;
if (it != l.end()) {
int pos = it - l.begin();
int len = s - sum[pos];
cost += 3 * len - V * (int((l).size()) - pos);
cost += sum[pos];
} else {
cost = s;
}
return cost <= t;
}
int solve() {
sort((l).begin(), (l).end());
for (int i = 1; i < int((l).size()); i++) sum[i] = sum[i - 1] + l[i - 1];
int ans = -1;
for (int i = 0; i < n; i++) {
if (check(v[i])) ans = ans == -1 ? c[i] : min(ans, c[i]);
}
return ans;
}
int main() {
scanf("%d%d%d%d", &n, &k, &s, &t);
for (int i = 0; i < n; i++) scanf("%d%d", &c[i], &v[i]);
for (int i = 1; i <= k; i++) scanf("%d", &g[i]);
sort(g + 1, g + 1 + k);
for (int i = 1; i <= k; i++) l.push_back(g[i] - g[i - 1]);
l.push_back(s - g[k]);
printf("%d\n", solve());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mod = 1e9 + 7;
long long powmod(long long a, long long b) {
long long res = 1;
if (a >= mod) a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a;
if (res >= mod) res %= mod;
a = a * a;
if (a >= mod) a %= mod;
}
return res;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int N = 200000 + 5;
long long n, k, s, t, len[N], c[N], v[N], g[N], sum[N];
int ans = mod;
long long maxlen;
bool ok(long long cap) {
long long tim = 0;
int idx = upper_bound(len, len + k, cap / 2) - len;
if (idx) tim += sum[idx - 1];
if (idx != k) {
tim -= cap * 1LL * (k - idx);
tim += 3 * sum[k - 1];
if (idx) tim -= 3 * sum[idx - 1];
}
return tim <= t;
}
int main() {
ios_base::sync_with_stdio(false);
;
cin.tie(0);
int i, j;
cin >> n >> k >> s >> t;
for (i = 0; i < n; i++) {
cin >> c[i] >> v[i];
}
for (i = 0; i < k; i++) {
cin >> g[i];
}
sort(g, g + k);
g[k] = s;
int last = 0;
for (i = 0; i <= k; i++) {
len[i] = g[i] - last;
last = g[i];
maxlen = max(maxlen, len[i]);
}
k++;
sort(len, len + k);
sum[0] = len[0];
for (i = 1; i < k; i++) sum[i] = len[i] + sum[i - 1];
for (i = 0; i < n; i++) {
if (v[i] >= maxlen && ans > c[i] && ok(v[i])) ans = c[i];
}
if (ans == mod) ans = -1;
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g;
int n, k, s, t;
bool check(long long v) {
int cur = 0;
long long res = 0;
for (auto go : g) {
int dist = go - cur;
int l = 0, r = dist + 1;
while (l < r - 1) {
long long m = (l + r) / 2;
if (2 * m + (dist - m) <= v) {
l = m;
} else {
r = m;
}
}
if (2 * l + (dist - l) > v) {
return 0;
}
res += l + 2 * (dist - l);
cur = go;
}
return res <= t;
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> k >> s >> t;
vector<pair<int, int> > cv;
for (int i = 0; i < n; i++) {
int c, v;
cin >> c >> v;
cv.push_back({c, v});
}
for (int i = 0; i < k; i++) {
int x;
cin >> x;
g.push_back(x);
}
g.push_back(s);
sort(g.begin(), g.end());
long long l = -1, r = 2e9 + 7;
while (l < r - 1) {
long long m = (l + r) / 2;
if (check(m)) {
r = m;
} else {
l = m;
}
}
int res = 2e9;
for (int i = 0; i < n; i++) {
if (cv[i].second >= r) {
res = min(res, cv[i].first);
}
}
cout << (res == 2e9 ? -1 : res) << '\n';
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.