problem_id stringlengths 6 6 | buggy_code stringlengths 8 526k ⌀ | fixed_code stringlengths 12 526k ⌀ | labels listlengths 0 15 ⌀ | buggy_submission_id int64 1 1.54M ⌀ | fixed_submission_id int64 2 1.54M ⌀ | user_id stringlengths 10 10 ⌀ | language stringclasses 9 values |
|---|---|---|---|---|---|---|---|
p02949 | #include <bits/stdc++.h>
using namespace std;
typedef tuple<int, int, int> tiii;
constexpr int INF = 1e9;
int main() {
int N, M, P;
cin >> N >> M >> P;
vector<vector<int>> G(N + 1);
vector<vector<int>> invG(N + 1);
vector<tiii> edge(M);
for (int i = 0; i < M; i++) {
int A, B, C;
cin >> A >> B >> C;
G[A].push_back(B);
invG[B].push_back(A);
edge[i] = tiii(A, B, C - P);
}
vector<bool> visited(N + 1, false);
visited[1] = true;
queue<int> q;
q.push(1);
while (!q.empty()) {
int t = q.front();
q.pop();
for (int x : G[t]) {
if (!visited[x]) {
visited[x] = true;
q.push(x);
}
}
}
vector<bool> invvisited(N + 1, false);
visited[N] = true;
q.push(N);
while (!q.empty()) {
int t = q.front();
q.pop();
for (int x : G[t]) {
if (!invvisited[x]) {
invvisited[x] = true;
q.push(x);
}
}
}
vector<bool> ok(N + 1);
for (int i = 1; i <= N; i++) {
ok[i] = visited[i] && invvisited[i];
}
vector<int> cost(N + 1, -INF);
cost[1] = 0;
bool changed;
for (int i = 0; i <= N; i++) {
changed = false;
for (int j = 0; j < M; j++) {
int a, b, c;
tie(a, b, c) = edge[j];
if (cost[a] != -INF && cost[b] < cost[a] + c) {
if (ok[b])
changed = true;
cost[b] = cost[a] + c;
}
}
}
if (changed)
cout << -1 << endl;
else
cout << max(0, cost[N]) << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef tuple<int, int, int> tiii;
constexpr int INF = 1e9;
int main() {
int N, M, P;
cin >> N >> M >> P;
vector<vector<int>> G(N + 1);
vector<vector<int>> invG(N + 1);
vector<tiii> edge(M);
for (int i = 0; i < M; i++) {
int A, B, C;
cin >> A >> B >> C;
G[A].push_back(B);
invG[B].push_back(A);
edge[i] = tiii(A, B, C - P);
}
vector<bool> visited(N + 1, false);
visited[1] = true;
queue<int> q;
q.push(1);
while (!q.empty()) {
int t = q.front();
q.pop();
for (int x : G[t]) {
if (!visited[x]) {
visited[x] = true;
q.push(x);
}
}
}
vector<bool> invvisited(N + 1, false);
invvisited[N] = true;
q.push(N);
while (!q.empty()) {
int t = q.front();
q.pop();
for (int x : invG[t]) {
if (!invvisited[x]) {
invvisited[x] = true;
q.push(x);
}
}
}
vector<bool> ok(N + 1);
for (int i = 1; i <= N; i++) {
ok[i] = visited[i] && invvisited[i];
}
vector<int> cost(N + 1, -INF);
cost[1] = 0;
bool changed;
for (int i = 0; i <= N; i++) {
changed = false;
for (int j = 0; j < M; j++) {
int a, b, c;
tie(a, b, c) = edge[j];
if (cost[a] != -INF && cost[b] < cost[a] + c) {
if (ok[b])
changed = true;
cost[b] = cost[a] + c;
}
}
}
// for (int i = 1; i <= N; i++) cout << ok[i] << ' ';
// cout << endl;
if (changed)
cout << -1 << endl;
else
cout << max(0, cost[N]) << endl;
} | [
"assignment.variable.change",
"identifier.change"
] | 750,738 | 750,739 | u858575800 | cpp |
p02949 | #include <algorithm>
#include <cstdio>
#include <queue>
using namespace std;
int N, M, P, A[5050], B[5050], C[5050];
bool visit[2555], rvisit[2555];
long long dist[2555];
bool nvisit[2555];
long long ndist[2555];
int main() {
scanf("%d %d %d", &N, &M, &P);
for (int i = 0; i < M; i++)
scanf("%d %d %d", &A[i], &B[i], &C[i]), C[i] -= P;
for (int i = 1; i <= N; i++)
ndist[i] = -1e18;
visit[1] = 1;
ndist[1] = 0;
rvisit[N] = 1;
for (int k = 0; k < N; k++) {
for (int i = 1; i <= N; i++) {
nvisit[i] = 0;
ndist[i] = -1e18;
}
for (int i = 0; i < M; i++) {
if (visit[A[i]]) {
if (ndist[B[i]] < dist[A[i]] + C[i]) {
ndist[B[i]] = dist[A[i]] + C[i];
nvisit[B[i]] = 1;
}
}
if (rvisit[B[i]])
rvisit[A[i]] = 1;
}
for (int i = 1; i <= N; i++)
if (nvisit[i]) {
visit[i] = 1;
dist[i] = max(dist[i], ndist[i]);
}
}
for (int i = 0; i < M; i++)
if (visit[A[i]] && rvisit[A[i]] && visit[B[i]] && rvisit[B[i]]) {
if (dist[B[i]] < dist[A[i]] + C[i]) {
puts("-1");
return 0;
}
}
printf("%lld\n", max(0ll, dist[N]));
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <queue>
using namespace std;
int N, M, P, A[5050], B[5050], C[5050];
bool visit[2555], rvisit[2555];
long long dist[2555];
bool nvisit[2555];
long long ndist[2555];
int main() {
scanf("%d %d %d", &N, &M, &P);
for (int i = 0; i < M; i++)
scanf("%d %d %d", &A[i], &B[i], &C[i]), C[i] -= P;
for (int i = 1; i <= N; i++)
dist[i] = -1e18;
visit[1] = 1;
dist[1] = 0;
rvisit[N] = 1;
for (int k = 0; k < N; k++) {
for (int i = 1; i <= N; i++) {
nvisit[i] = 0;
ndist[i] = -1e18;
}
for (int i = 0; i < M; i++) {
if (visit[A[i]]) {
if (ndist[B[i]] < dist[A[i]] + C[i]) {
ndist[B[i]] = dist[A[i]] + C[i];
nvisit[B[i]] = 1;
}
}
if (rvisit[B[i]])
rvisit[A[i]] = 1;
}
for (int i = 1; i <= N; i++)
if (nvisit[i]) {
visit[i] = 1;
dist[i] = max(dist[i], ndist[i]);
}
}
for (int i = 0; i < M; i++)
if (visit[A[i]] && rvisit[A[i]] && visit[B[i]] && rvisit[B[i]]) {
if (dist[B[i]] < dist[A[i]] + C[i]) {
puts("-1");
return 0;
}
}
printf("%lld\n", max(0ll, dist[N]));
return 0;
}
| [
"assignment.variable.change",
"identifier.change"
] | 750,740 | 750,741 | u233632872 | cpp |
p02949 | #include <algorithm>
#include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define REP(i, n) for (int i = 1; i < (int)(n); ++i)
using namespace std;
constexpr long long INF = 1e18;
struct edge {
int from;
int to;
int cost;
};
vector<int> go_0; // 0からいける？
vector<int> go_N; // N-1からいける？
void dfs_0(vector<vector<edge>> &G, int n) {
for (auto e : G[n]) {
if (!go_0[e.to]) {
go_0[e.to] = 1;
dfs_0(G, e.to);
}
}
}
void dfs_N(vector<vector<edge>> &G, int n) {
for (auto e : G[n]) {
if (!go_N[e.to]) {
go_N[e.to] = 1;
dfs_N(G, e.to);
}
}
}
int main() {
int N, M, P;
cin >> N >> M >> P;
vector<edge> edges(M);
rep(i, M) {
int A, B, C;
cin >> A >> B >> C;
edges[i] = {A - 1, B - 1, C};
}
go_0 = vector<int>(N, 0);
go_0[0] = 1;
vector<vector<edge>> graph_0(N);
for (auto e : edges) {
graph_0[e.from].push_back(e);
}
dfs_0(graph_0, 0);
go_N = vector<int>(N, 0);
go_N[N - 1] = 1;
vector<vector<edge>> graph_N(N);
for (auto e : edges) {
graph_N[e.from].push_back({e.to, e.from, e.cost});
}
dfs_N(graph_N, N - 1);
vector<edge> use;
for (auto e : edges) {
if (go_0[e.from] && go_N[e.to]) {
use.push_back({e.from, e.to, -(e.cost - P)});
}
}
vector<long long> dist(N, INF);
dist[0] = 0;
rep(i, N) for (auto e : use) {
if (dist[e.from] + e.cost < dist[e.to]) {
dist[e.to] = dist[e.from] + e.cost;
if (i == N - 1) {
cout << -1 << endl;
return 0;
}
}
}
cout << max(-dist[N - 1], 0LL) << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define REP(i, n) for (int i = 1; i < (int)(n); ++i)
using namespace std;
constexpr long long INF = 1e18;
struct edge {
int from;
int to;
int cost;
};
vector<int> go_0; // 0からいける？
vector<int> go_N; // N-1からいける？
void dfs_0(vector<vector<edge>> &G, int n) {
for (auto e : G[n]) {
if (!go_0[e.to]) {
go_0[e.to] = 1;
dfs_0(G, e.to);
}
}
}
void dfs_N(vector<vector<edge>> &G, int n) {
for (auto e : G[n]) {
if (!go_N[e.to]) {
go_N[e.to] = 1;
dfs_N(G, e.to);
}
}
}
int main() {
int N, M, P;
cin >> N >> M >> P;
vector<edge> edges(M);
rep(i, M) {
int A, B, C;
cin >> A >> B >> C;
edges[i] = {A - 1, B - 1, C};
}
go_0 = vector<int>(N, 0);
go_0[0] = 1;
vector<vector<edge>> graph_0(N);
for (auto e : edges) {
graph_0[e.from].push_back(e);
}
dfs_0(graph_0, 0);
go_N = vector<int>(N, 0);
go_N[N - 1] = 1;
vector<vector<edge>> graph_N(N);
for (auto e : edges) {
graph_N[e.to].push_back({e.to, e.from, e.cost});
}
dfs_N(graph_N, N - 1);
vector<edge> use;
for (auto e : edges) {
if (go_0[e.from] && go_N[e.to]) {
use.push_back({e.from, e.to, -(e.cost - P)});
}
}
vector<long long> dist(N, INF);
dist[0] = 0;
rep(i, N) for (auto e : use) {
if (dist[e.from] + e.cost < dist[e.to]) {
dist[e.to] = dist[e.from] + e.cost;
if (i == N - 1) {
cout << -1 << endl;
return 0;
}
}
}
cout << max(-dist[N - 1], 0LL) << endl;
return 0;
}
| [
"variable_access.subscript.index.change"
] | 750,752 | 750,753 | u826189900 | cpp |
p02949 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
vector<pair<int, long long>> edges[2500];
vector<int> reverse_edges[2500];
long long d[2500];
bool reachable[2500];
// returns false when exists a negative loop
void dfs(int cur) {
reachable[cur] = true;
for (int i = 0; i < reverse_edges[cur].size(); i++) {
int next = reverse_edges[cur][i];
if (!reachable[next]) {
dfs(next);
}
}
}
bool bellman_ford(int s, int N) {
for (int i = 0; i < N; i++) {
d[i] = LLONG_MAX;
}
dfs(N - 1);
d[s] = 0;
for (int i = 0; i < N - 1; i++) {
for (int j = 0; j < N; j++) {
for (int k = 0; k < edges[j].size(); k++) {
int to = edges[j][k].first;
long long cost = edges[j][k].second;
if (d[j] != LLONG_MAX && d[to] > d[j] + cost) {
d[to] = d[j] + cost;
}
}
}
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < edges[i].size(); j++) {
int to = edges[i][j].first;
long long cost = edges[i][j].second;
if (d[i] != LLONG_MAX && d[to] != LLONG_MAX && d[i] + cost < d[to] &&
reachable[to]) {
return false;
}
}
}
return true;
}
int main() {
int N;
int M;
long long P;
cin >> N >> M >> P;
for (int i = 0; i < M; i++) {
int A;
int B;
int C;
cin >> A >> B >> C;
edges[A - 1].push_back(make_pair(B - 1, P - (long long)C));
reverse_edges[B - 1].push_back(B - 1);
}
if (bellman_ford(0, N)) {
cout << max(-d[N - 1], (long long)0) << endl;
} else {
cout << -1 << endl;
}
return 0;
}
| #define _USE_MATH_DEFINES
#include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
vector<pair<int, long long>> edges[2500];
vector<int> reverse_edges[2500];
long long d[2500];
bool reachable[2500];
// returns false when exists a negative loop
void dfs(int cur) {
reachable[cur] = true;
for (int i = 0; i < reverse_edges[cur].size(); i++) {
int next = reverse_edges[cur][i];
if (!reachable[next]) {
dfs(next);
}
}
}
bool bellman_ford(int s, int N) {
for (int i = 0; i < N; i++) {
d[i] = LLONG_MAX;
}
dfs(N - 1);
d[s] = 0;
for (int i = 0; i < N - 1; i++) {
for (int j = 0; j < N; j++) {
for (int k = 0; k < edges[j].size(); k++) {
int to = edges[j][k].first;
long long cost = edges[j][k].second;
if (d[j] != LLONG_MAX && d[to] > d[j] + cost) {
d[to] = d[j] + cost;
}
}
}
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < edges[i].size(); j++) {
int to = edges[i][j].first;
long long cost = edges[i][j].second;
if (d[i] != LLONG_MAX && d[to] != LLONG_MAX && d[i] + cost < d[to] &&
reachable[to]) {
return false;
}
}
}
return true;
}
int main() {
int N;
int M;
long long P;
cin >> N >> M >> P;
for (int i = 0; i < M; i++) {
int A;
int B;
int C;
cin >> A >> B >> C;
edges[A - 1].push_back(make_pair(B - 1, P - (long long)C));
reverse_edges[B - 1].push_back(A - 1);
}
if (bellman_ford(0, N)) {
cout << max(-d[N - 1], (long long)0) << endl;
} else {
cout << -1 << endl;
}
return 0;
} | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 750,758 | 750,759 | u623349537 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
int main() {
ll n, m, p;
cin >> n >> m >> p;
vector<ll> a(m), b(m), c(m), dp(n, 1e11);
vector<bool> reach(n, false);
bool flag = false;
for (int i = 0; i < m; i++) {
cin >> a[i] >> b[i] >> c[i];
a[i]--;
b[i]--;
c[i] = p - c[i]; // -(c[i] - p)
}
dp[0] = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (dp[a[j]] != 1e11 && dp[b[j]] > dp[a[j]] + c[j]) {
dp[b[j]] = dp[a[j]] + c[j];
if (i == n - 1) {
flag = true;
reach[a[j]] = reach[b[j]] = true;
}
}
}
}
if (flag) {
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < m; j++) {
reach[b[j]] = reach[a[j]] | reach[b[j]];
}
}
}
if (reach[n - 1])
cout << -1 << endl;
else
cout << max(0LL, -dp[n - 1]) << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
int main() {
ll n, m, p;
cin >> n >> m >> p;
vector<ll> a(m), b(m), c(m), dp(n, 1e11);
vector<bool> reach(n, false);
bool flag = false;
for (int i = 0; i < m; i++) {
cin >> a[i] >> b[i] >> c[i];
a[i]--;
b[i]--;
c[i] = p - c[i]; // -(c[i] - p)
}
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (dp[a[j]] != 1e11 && dp[b[j]] > dp[a[j]] + c[j]) {
dp[b[j]] = dp[a[j]] + c[j];
if (i == n - 1) {
flag = true;
reach[a[j]] = reach[b[j]] = true;
}
}
}
}
if (flag) {
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < m; j++) {
reach[b[j]] = reach[a[j]] | reach[b[j]];
}
}
}
if (reach[n - 1])
cout << -1 << endl;
else
cout << max(0LL, -dp[n - 1]) << endl;
} | [
"literal.number.change",
"assignment.value.change"
] | 750,775 | 750,776 | u246401216 | cpp |
p02949 | #include "bits/stdc++.h"
using namespace std;
#define Rep(i, n) for (int i = 0; i < (int)(n); i++)
#define For(i, n1, n2) for (int i = (int)(n1); i < (int)(n2); i++)
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define RREP(i, n) for (ll i = ((ll)(n)-1); i >= 0; i--)
#define FOR(i, n1, n2) for (ll i = (ll)(n1); i < (ll)(n2); i++)
#define RFOR(i, n1, n2) for (ll i = ((ll)(n1)-1); i >= (ll)(n2); i--)
#define all(a) (a).begin(), (a).end()
#define SORT(a) sort((a).begin(), (a).end())
#define oorret 0
#define oor(x) \
[&]() { \
try { \
x; \
} catch (const out_of_range &oor) { \
return oorret; \
} \
return x; \
}()
#define IOS cin.tie(0), ios::sync_with_stdio(false)
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class Type> struct is_vector : std::false_type {};
template <class ValueType, class Alloc>
struct is_vector<std::vector<ValueType, Alloc>> : std::true_type {};
template <typename T>
inline ostream &operator<<(ostream &out, const vector<T> &v) {
if (v.empty())
return out;
constexpr bool is_vector_v = is_vector<T>::value;
if (is_vector_v)
for (auto itr = v.begin(); itr != v.end();)
out << (*itr), out << ((++itr != v.end()) ? "\n" : "");
else
for (auto itr = v.begin(); itr != v.end();)
out << (*itr), out << ((++itr != v.end()) ? " " : "");
return out;
}
inline void put() {}
template <class T> inline void put(const T &first) {
std::cout << first << "\n";
}
template <class T, class... N>
inline void put(const T &first, const N &...rest) {
std::cout << first << " ";
put(rest...);
}
inline void putn() {}
template <class T, class... N>
inline void putn(const T &first, const N &...rest) {
std::cout << first << "\n";
putn(rest...);
}
struct edge {
ll to, cost, index;
edge(ll to, ll cost, ll index) : to(to), cost(cost), index(index) {}
};
void dfs(vector<vector<edge>> &path, vector<int> &st, int now) {
REP(i, path[now].size()) {
if (st[path[now][i].index] == 0) {
st[path[now][i].index] = 1;
dfs(path, st, path[now][i].to);
}
}
}
int main() {
IOS;
int n, m, p;
cin >> n >> m >> p;
vector<ll> a(m), b(m), c(m);
vector<vector<edge>> path(n);
vector<vector<edge>> path2(n);
vector<vector<edge>> path3(n);
vector<int> st(m, 0), dt(m, 0);
REP(i, m) {
cin >> a[i] >> b[i] >> c[i];
a[i]--;
b[i]--;
path[a[i]].push_back(edge(b[i], c[i] - p, i));
path2[b[i]].push_back(edge(a[i], c[i] - p, i));
}
vector<ll> dist(n, -1e15);
int src = 0, dest = n - 1;
dfs(path, st, src);
dfs(path2, dt, dest);
dist[src] = 0;
REP(i, m) {
if (st[i] && dt[i]) {
path3[a[i]].push_back(edge(b[i], c[i] - p, i));
}
}
REP(i, n * 2) {
REP(j, n) {
REP(k, path[j].size()) {
if (chmax(dist[path3[j][k].to], dist[j] + path3[j][k].cost)) {
}
}
}
}
REP(i, n) {
REP(j, path3[i].size()) {
if (dist[i] + path3[i][j].cost > dist[path3[i][j].to]) {
put(-1);
return 0;
}
}
}
put(max(dist[dest], 0ll));
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
#define Rep(i, n) for (int i = 0; i < (int)(n); i++)
#define For(i, n1, n2) for (int i = (int)(n1); i < (int)(n2); i++)
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define RREP(i, n) for (ll i = ((ll)(n)-1); i >= 0; i--)
#define FOR(i, n1, n2) for (ll i = (ll)(n1); i < (ll)(n2); i++)
#define RFOR(i, n1, n2) for (ll i = ((ll)(n1)-1); i >= (ll)(n2); i--)
#define all(a) (a).begin(), (a).end()
#define SORT(a) sort((a).begin(), (a).end())
#define oorret 0
#define oor(x) \
[&]() { \
try { \
x; \
} catch (const out_of_range &oor) { \
return oorret; \
} \
return x; \
}()
#define IOS cin.tie(0), ios::sync_with_stdio(false)
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class Type> struct is_vector : std::false_type {};
template <class ValueType, class Alloc>
struct is_vector<std::vector<ValueType, Alloc>> : std::true_type {};
template <typename T>
inline ostream &operator<<(ostream &out, const vector<T> &v) {
if (v.empty())
return out;
constexpr bool is_vector_v = is_vector<T>::value;
if (is_vector_v)
for (auto itr = v.begin(); itr != v.end();)
out << (*itr), out << ((++itr != v.end()) ? "\n" : "");
else
for (auto itr = v.begin(); itr != v.end();)
out << (*itr), out << ((++itr != v.end()) ? " " : "");
return out;
}
inline void put() {}
template <class T> inline void put(const T &first) {
std::cout << first << "\n";
}
template <class T, class... N>
inline void put(const T &first, const N &...rest) {
std::cout << first << " ";
put(rest...);
}
inline void putn() {}
template <class T, class... N>
inline void putn(const T &first, const N &...rest) {
std::cout << first << "\n";
putn(rest...);
}
struct edge {
ll to, cost, index;
edge(ll to, ll cost, ll index) : to(to), cost(cost), index(index) {}
};
void dfs(vector<vector<edge>> &path, vector<int> &st, int now) {
REP(i, path[now].size()) {
if (st[path[now][i].index] == 0) {
st[path[now][i].index] = 1;
dfs(path, st, path[now][i].to);
}
}
}
int main() {
IOS;
int n, m, p;
cin >> n >> m >> p;
vector<ll> a(m), b(m), c(m);
vector<vector<edge>> path(n);
vector<vector<edge>> path2(n);
vector<vector<edge>> path3(n);
vector<int> st(m, 0), dt(m, 0);
REP(i, m) {
cin >> a[i] >> b[i] >> c[i];
a[i]--;
b[i]--;
path[a[i]].push_back(edge(b[i], c[i] - p, i));
path2[b[i]].push_back(edge(a[i], c[i] - p, i));
}
vector<ll> dist(n, -1e15);
int src = 0, dest = n - 1;
dfs(path, st, src);
dfs(path2, dt, dest);
dist[src] = 0;
REP(i, m) {
if (st[i] && dt[i]) {
path3[a[i]].push_back(edge(b[i], c[i] - p, i));
}
}
REP(i, n * 2) {
REP(j, n) {
REP(k, path3[j].size()) {
if (chmax(dist[path3[j][k].to], dist[j] + path3[j][k].cost)) {
}
}
}
}
REP(i, n) {
REP(j, path3[i].size()) {
if (dist[i] + path3[i][j].cost > dist[path3[i][j].to]) {
put(-1);
return 0;
}
}
}
put(max(dist[dest], 0ll));
return 0;
}
| [
"identifier.change",
"call.arguments.change"
] | 750,779 | 750,780 | u030685402 | cpp |
p02949 | #include "bits/stdc++.h"
using namespace std;
#define Rep(i, n) for (int i = 0; i < (int)(n); i++)
#define For(i, n1, n2) for (int i = (int)(n1); i < (int)(n2); i++)
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define RREP(i, n) for (ll i = ((ll)(n)-1); i >= 0; i--)
#define FOR(i, n1, n2) for (ll i = (ll)(n1); i < (ll)(n2); i++)
#define RFOR(i, n1, n2) for (ll i = ((ll)(n1)-1); i >= (ll)(n2); i--)
#define all(a) (a).begin(), (a).end()
#define SORT(a) sort((a).begin(), (a).end())
#define oorret 0
#define oor(x) \
[&]() { \
try { \
x; \
} catch (const out_of_range &oor) { \
return oorret; \
} \
return x; \
}()
#define IOS cin.tie(0), ios::sync_with_stdio(false)
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class Type> struct is_vector : std::false_type {};
template <class ValueType, class Alloc>
struct is_vector<std::vector<ValueType, Alloc>> : std::true_type {};
template <typename T>
inline ostream &operator<<(ostream &out, const vector<T> &v) {
if (v.empty())
return out;
constexpr bool is_vector_v = is_vector<T>::value;
if (is_vector_v)
for (auto itr = v.begin(); itr != v.end();)
out << (*itr), out << ((++itr != v.end()) ? "\n" : "");
else
for (auto itr = v.begin(); itr != v.end();)
out << (*itr), out << ((++itr != v.end()) ? " " : "");
return out;
}
inline void put() {}
template <class T> inline void put(const T &first) {
std::cout << first << "\n";
}
template <class T, class... N>
inline void put(const T &first, const N &...rest) {
std::cout << first << " ";
put(rest...);
}
inline void putn() {}
template <class T, class... N>
inline void putn(const T &first, const N &...rest) {
std::cout << first << "\n";
putn(rest...);
}
struct edge {
ll to, cost, index;
edge(ll to, ll cost, ll index) : to(to), cost(cost), index(index) {}
};
void dfs(vector<vector<edge>> &path, vector<int> &st, int now) {
REP(i, path[now].size()) {
if (st[path[now][i].index] == 0) {
st[path[now][i].index] = 1;
dfs(path, st, path[now][i].to);
}
}
}
int main() {
IOS;
int n, m, p;
cin >> n >> m >> p;
vector<ll> a(m), b(m), c(m);
vector<vector<edge>> path(n);
vector<vector<edge>> path2(n);
vector<vector<edge>> path3(n);
// vector<vector<int>> visited(n * 2 + 1, vector<int>(n, -1));
vector<int> st(m, 0), dt(m, 0);
REP(i, m) {
cin >> a[i] >> b[i] >> c[i];
a[i]--;
b[i]--;
path[a[i]].push_back(edge(b[i], c[i] - p, i));
path2[b[i]].push_back(edge(a[i], c[i] - p, i));
}
vector<ll> dist(n, -1e15);
int src = 0, dest = n - 1;
dfs(path, st, src);
dfs(path2, dt, dest);
dist[src] = 0;
REP(i, m) {
if (st[i] && dt[i]) {
path3[a[i]].push_back(edge(b[i], c[i] - p, i));
}
}
REP(i, n * 2) {
REP(j, n) {
REP(k, path[j].size()) {
if (chmax(dist[path[j][k].to], dist[j] + path[j][k].cost)) {
}
}
}
}
REP(i, n) {
REP(j, path3[i].size()) {
if (dist[i] + path3[i][j].cost > dist[path[i][j].to]) {
put(-1);
return 0;
}
}
}
put(max(dist[dest], 0ll));
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
#define Rep(i, n) for (int i = 0; i < (int)(n); i++)
#define For(i, n1, n2) for (int i = (int)(n1); i < (int)(n2); i++)
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define RREP(i, n) for (ll i = ((ll)(n)-1); i >= 0; i--)
#define FOR(i, n1, n2) for (ll i = (ll)(n1); i < (ll)(n2); i++)
#define RFOR(i, n1, n2) for (ll i = ((ll)(n1)-1); i >= (ll)(n2); i--)
#define all(a) (a).begin(), (a).end()
#define SORT(a) sort((a).begin(), (a).end())
#define oorret 0
#define oor(x) \
[&]() { \
try { \
x; \
} catch (const out_of_range &oor) { \
return oorret; \
} \
return x; \
}()
#define IOS cin.tie(0), ios::sync_with_stdio(false)
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class Type> struct is_vector : std::false_type {};
template <class ValueType, class Alloc>
struct is_vector<std::vector<ValueType, Alloc>> : std::true_type {};
template <typename T>
inline ostream &operator<<(ostream &out, const vector<T> &v) {
if (v.empty())
return out;
constexpr bool is_vector_v = is_vector<T>::value;
if (is_vector_v)
for (auto itr = v.begin(); itr != v.end();)
out << (*itr), out << ((++itr != v.end()) ? "\n" : "");
else
for (auto itr = v.begin(); itr != v.end();)
out << (*itr), out << ((++itr != v.end()) ? " " : "");
return out;
}
inline void put() {}
template <class T> inline void put(const T &first) {
std::cout << first << "\n";
}
template <class T, class... N>
inline void put(const T &first, const N &...rest) {
std::cout << first << " ";
put(rest...);
}
inline void putn() {}
template <class T, class... N>
inline void putn(const T &first, const N &...rest) {
std::cout << first << "\n";
putn(rest...);
}
struct edge {
ll to, cost, index;
edge(ll to, ll cost, ll index) : to(to), cost(cost), index(index) {}
};
void dfs(vector<vector<edge>> &path, vector<int> &st, int now) {
REP(i, path[now].size()) {
if (st[path[now][i].index] == 0) {
st[path[now][i].index] = 1;
dfs(path, st, path[now][i].to);
}
}
}
int main() {
IOS;
int n, m, p;
cin >> n >> m >> p;
vector<ll> a(m), b(m), c(m);
vector<vector<edge>> path(n);
vector<vector<edge>> path2(n);
vector<vector<edge>> path3(n);
vector<int> st(m, 0), dt(m, 0);
REP(i, m) {
cin >> a[i] >> b[i] >> c[i];
a[i]--;
b[i]--;
path[a[i]].push_back(edge(b[i], c[i] - p, i));
path2[b[i]].push_back(edge(a[i], c[i] - p, i));
}
vector<ll> dist(n, -1e15);
int src = 0, dest = n - 1;
dfs(path, st, src);
dfs(path2, dt, dest);
dist[src] = 0;
REP(i, m) {
if (st[i] && dt[i]) {
path3[a[i]].push_back(edge(b[i], c[i] - p, i));
}
}
REP(i, n * 2) {
REP(j, n) {
REP(k, path3[j].size()) {
if (chmax(dist[path3[j][k].to], dist[j] + path3[j][k].cost)) {
}
}
}
}
REP(i, n) {
REP(j, path3[i].size()) {
if (dist[i] + path3[i][j].cost > dist[path3[i][j].to]) {
put(-1);
return 0;
}
}
}
put(max(dist[dest], 0ll));
return 0;
}
| [
"identifier.change",
"call.arguments.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 750,781 | 750,780 | u030685402 | cpp |
p02949 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
using namespace std;
typedef long long ll;
const int INF = 1001001001;
vector<int> to[2505];
vector<int> rto[2505];
bool reachableFrom1[2505];
bool reachableToN[2505];
bool ok[2505];
void dfs(int v) {
if (reachableFrom1[v])
return;
reachableFrom1[v] = true;
for (int u : to[v]) {
dfs(u);
}
}
void rdfs(int v) {
if (reachableToN[v])
return;
reachableToN[v] = true;
for (int u : rto[v]) {
rdfs(u);
}
}
int main() {
int n, m, p;
cin >> n >> m >> p;
vector<tuple<int, int, int>> edges;
rep(i, m) {
int a, b, c;
cin >> a >> b >> c;
--a;
--b;
c -= p;
c = -c;
edges.emplace_back(a, b, c);
to[a].push_back(b);
rto[b].push_back(a);
}
dfs(0);
rdfs(0);
rep(i, n) ok[i] = reachableFrom1[i] & reachableToN[i];
{ // bellman-ford
vector<int> d(n, INF);
d[0] = 0;
bool upd = true;
int step = 0;
while (upd) {
upd = false;
rep(i, n) {
int a, b, c;
tie(a, b, c) = edges[i];
if (!ok[a])
continue;
if (!ok[b])
continue;
int newD = d[a] + c;
if (newD < d[b]) {
upd = true;
d[b] = newD;
}
}
step++;
if (step > n) {
puts("-1");
return 0;
}
}
int ans = -d[n - 1];
ans = max(ans, 0);
cout << ans << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
using namespace std;
typedef long long ll;
const int INF = 1001001001;
vector<int> to[2505];
vector<int> rto[2505];
bool reachableFrom1[2505];
bool reachableToN[2505];
bool ok[2505];
void dfs(int v) {
if (reachableFrom1[v])
return;
reachableFrom1[v] = true;
for (int u : to[v]) {
dfs(u);
}
}
void rdfs(int v) {
if (reachableToN[v])
return;
reachableToN[v] = true;
for (int u : rto[v]) {
rdfs(u);
}
}
int main() {
int n, m, p;
cin >> n >> m >> p;
vector<tuple<int, int, int>> edges;
rep(i, m) {
int a, b, c;
cin >> a >> b >> c;
--a;
--b;
c -= p;
c = -c;
edges.emplace_back(a, b, c);
to[a].push_back(b);
rto[b].push_back(a);
}
dfs(0);
rdfs(n - 1);
rep(i, n) ok[i] = reachableFrom1[i] & reachableToN[i];
{ // bellman-ford
vector<int> d(n, INF);
d[0] = 0;
bool upd = true;
int step = 0;
while (upd) {
upd = false;
rep(i, m) {
int a, b, c;
tie(a, b, c) = edges[i];
if (!ok[a])
continue;
if (!ok[b])
continue;
int newD = d[a] + c;
if (newD < d[b]) {
upd = true;
d[b] = newD;
}
}
step++;
if (step > n) {
puts("-1");
return 0;
}
}
int ans = -d[n - 1];
ans = max(ans, 0);
cout << ans << endl;
}
return 0;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change"
] | 750,785 | 750,783 | u506858457 | cpp |
p02949 | #include <bits/stdc++.h>
#define int long long
using namespace std;
struct edge {
int a, b, c;
};
vector<vector<pair<int, int>>> adj1, adj2;
edge s[5005];
int dp[2505];
int n, m, p;
int ans = 0;
int vis1[2505], vis2[2505];
int mm[2505];
void solve() {
for (int i = 0; i < n - 1; ++i) {
for (int j = 0; j < m; ++j) {
if (dp[s[j].a] != 1e17) {
dp[s[j].b] = min(dp[s[j].b], dp[s[j].a] + s[j].c);
}
}
}
bool flag = true;
for (int j = 0; j < m; ++j) {
if (dp[s[j].a] != 1e17) {
if (dp[s[j].b] > dp[s[j].a] + s[j].c) {
if (mm[s[j].b] == 2) {
flag = false;
break;
}
dp[s[j].b] = dp[s[j].a] + s[j].c;
}
}
}
if (!flag) {
ans = -1e17;
} else {
ans = -dp[n - 1];
}
}
void dfs1(int i) {
vis1[i] = 1;
mm[i]++;
for (auto j : adj1[i]) {
if (vis1[j.first] == 0) {
dfs1(j.first);
}
}
}
void dfs2(int i) {
vis2[i] = 1;
mm[i]++;
for (auto j : adj2[i]) {
if (vis2[j.first] == 0) {
dfs1(j.first);
}
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> p;
fill_n(dp, 2505, 1e17);
dp[0] = 0;
int x, y, z;
adj1.resize(n);
adj2.resize(n);
for (int i = 0; i < m; ++i) {
cin >> x >> y >> z;
x--;
y--;
z = p - z;
adj1[x].push_back({y, z});
adj2[y].push_back({x, z});
s[i].a = x;
s[i].b = y;
s[i].c = z;
}
dfs1(0);
dfs2(n - 1);
solve();
if (ans == -1e17)
cout << -1;
else
cout << max(0LL, ans);
} | #include <bits/stdc++.h>
#define int long long
using namespace std;
struct edge {
int a, b, c;
};
vector<vector<pair<int, int>>> adj1, adj2;
edge s[5005];
int dp[2505];
int n, m, p;
int ans = 0;
int vis1[2505], vis2[2505];
int mm[2505];
void solve() {
for (int i = 0; i < n - 1; ++i) {
for (int j = 0; j < m; ++j) {
if (dp[s[j].a] != 1e17) {
dp[s[j].b] = min(dp[s[j].b], dp[s[j].a] + s[j].c);
}
}
}
bool flag = true;
for (int j = 0; j < m; ++j) {
if (dp[s[j].a] != 1e17) {
if (dp[s[j].b] > dp[s[j].a] + s[j].c) {
if (mm[s[j].b] == 2) {
flag = false;
break;
}
dp[s[j].b] = dp[s[j].a] + s[j].c;
}
}
}
if (!flag) {
ans = -1e17;
} else {
ans = -dp[n - 1];
}
}
void dfs1(int i) {
vis1[i] = 1;
mm[i]++;
for (auto j : adj1[i]) {
if (vis1[j.first] == 0) {
dfs1(j.first);
}
}
}
void dfs2(int i) {
vis2[i] = 1;
mm[i]++;
for (auto j : adj2[i]) {
if (vis2[j.first] == 0) {
dfs2(j.first);
}
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> p;
fill_n(dp, 2505, 1e17);
dp[0] = 0;
int x, y, z;
adj1.resize(n);
adj2.resize(n);
for (int i = 0; i < m; ++i) {
cin >> x >> y >> z;
x--;
y--;
z = p - z;
adj1[x].push_back({y, z});
adj2[y].push_back({x, z});
s[i].a = x;
s[i].b = y;
s[i].c = z;
}
dfs1(0);
dfs2(n - 1);
solve();
if (ans == -1e17)
cout << -1;
else
cout << max(0LL, ans);
} | [
"identifier.change",
"call.function.change"
] | 750,786 | 750,787 | u193815565 | cpp |
p02949 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
const int INF = 1001001001;
vector<int> to[2505];
vector<int> rto[2505];
int reachableFrom1[2505];
int reachableFromN[2505];
int ok[2505];
void dfs(int v) {
if (reachableFrom1[v])
return;
reachableFrom1[v] = true;
for (int u : to[v]) {
dfs(u);
}
}
void r_dfs(int v) {
if (reachableFromN[v])
return;
reachableFromN[v] = true;
for (int u : to[v]) {
r_dfs(u);
}
}
int main(void) {
int n, m, p;
cin >> n >> m >> p;
vector<tuple<int, int, int>> edges;
rep(i, m) {
int a, b, c;
cin >> a >> b >> c;
--a;
--b;
c -= p;
c = -c;
edges.emplace_back(a, b, c);
to[a].push_back(b);
rto[b].push_back(a);
}
dfs(0);
r_dfs(n - 1);
rep(i, n) ok[i] = reachableFrom1[i] & reachableFromN[i];
{ // bellman-ford
vector<int> d(n, INF);
d[0] = 0;
bool upd = true;
int step = 0;
while (upd) {
upd = false;
rep(i, m) {
int a, b, c;
tie(a, b, c) = edges[i];
if (!ok[a])
continue;
if (!ok[b])
continue;
int newD = d[a] + c;
if (newD < d[b]) {
upd = true;
d[b] = newD;
}
}
step++;
if (step > n) {
puts("-1");
return 0;
}
}
int ans = -d[n - 1];
ans = max(ans, 0);
cout << ans << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
const int INF = 1001001001;
vector<int> to[2505];
vector<int> rto[2505];
int reachableFrom1[2505];
int reachableFromN[2505];
int ok[2505];
void dfs(int v) {
if (reachableFrom1[v])
return;
reachableFrom1[v] = true;
for (int u : to[v]) {
dfs(u);
}
}
void r_dfs(int v) {
if (reachableFromN[v])
return;
reachableFromN[v] = true;
for (int u : rto[v]) {
r_dfs(u);
}
}
int main(void) {
int n, m, p;
cin >> n >> m >> p;
vector<tuple<int, int, int>> edges;
rep(i, m) {
int a, b, c;
cin >> a >> b >> c;
--a;
--b;
c -= p;
c = -c;
edges.emplace_back(a, b, c);
to[a].push_back(b);
rto[b].push_back(a);
}
dfs(0);
r_dfs(n - 1);
rep(i, n) ok[i] = reachableFrom1[i] & reachableFromN[i];
{ // bellman-ford
vector<int> d(n, INF);
d[0] = 0;
bool upd = true;
int step = 0;
while (upd) {
upd = false;
rep(i, m) {
int a, b, c;
tie(a, b, c) = edges[i];
if (!ok[a])
continue;
if (!ok[b])
continue;
int newD = d[a] + c;
if (newD < d[b]) {
upd = true;
d[b] = newD;
}
}
step++;
if (step > n) {
puts("-1");
return 0;
}
}
int ans = -d[n - 1];
ans = max(ans, 0);
cout << ans << endl;
}
return 0;
} | [
"identifier.change"
] | 750,788 | 750,789 | u976045502 | cpp |
p02949 | #include <algorithm>
#include <iostream>
using namespace std;
long long N, M, P, A[1 << 18], B[1 << 18], C[1 << 18];
long long dist[1 << 18], predist[1 << 18];
bool used1[1 << 18], used2[1 << 18];
int main() {
cin >> N >> M >> P;
for (int i = 1; i <= M; i++) {
cin >> A[i] >> B[i] >> C[i];
C[i] -= P;
}
used1[1] = true;
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
if (used1[A[j]] == true)
used1[B[j]] = true;
}
}
used2[N] = true;
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
if (used2[B[j]] == true)
used2[A[j]] = true;
}
}
for (int i = 1; i <= N; i++)
dist[i] = -(1LL << 60);
dist[1] = 0;
for (int i = 1; i <= N * 2; i++) {
for (int j = 1; j <= M; j++)
predist[j] = dist[j];
for (int j = 1; j <= M; j++) {
dist[B[j]] = max(dist[B[j]], dist[A[j]] + C[j]);
}
bool flag = false;
for (int j = 1; j <= N; j++) {
if (used1[j] == true && used2[j] == true && dist[j] != predist[j])
flag = true;
}
if (flag == false)
break;
if (i == N * 2) {
cout << "-1" << endl;
return 0;
}
}
cout << max(0LL, dist[N]) << endl;
return 0;
} | #include <algorithm>
#include <iostream>
using namespace std;
long long N, M, P, A[1 << 18], B[1 << 18], C[1 << 18];
long long dist[1 << 18], predist[1 << 18];
bool used1[1 << 18], used2[1 << 18];
int main() {
cin >> N >> M >> P;
for (int i = 1; i <= M; i++) {
cin >> A[i] >> B[i] >> C[i];
C[i] -= P;
}
used1[1] = true;
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
if (used1[A[j]] == true)
used1[B[j]] = true;
}
}
used2[N] = true;
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
if (used2[B[j]] == true)
used2[A[j]] = true;
}
}
for (int i = 1; i <= N; i++)
dist[i] = -(1LL << 60);
dist[1] = 0;
for (int i = 1; i <= N * 2; i++) {
for (int j = 1; j <= N; j++)
predist[j] = dist[j];
for (int j = 1; j <= M; j++) {
dist[B[j]] = max(dist[B[j]], dist[A[j]] + C[j]);
}
bool flag = false;
for (int j = 1; j <= N; j++) {
if (used1[j] == true && used2[j] == true && dist[j] != predist[j])
flag = true;
}
if (flag == false)
break;
if (i == N * 2) {
cout << "-1" << endl;
return 0;
}
}
cout << max(0LL, dist[N]) << endl;
return 0;
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 750,790 | 750,791 | u504103417 | cpp |
p02949 | #include <algorithm>
#include <iostream>
using namespace std;
long long N, M, P, A[1 << 18], B[1 << 18], C[1 << 18];
long long dist[1 << 18], predist[1 << 18];
bool used1[1 << 18], used2[1 << 18];
int main() {
cin >> N >> M >> P;
for (int i = 1; i <= M; i++) {
cin >> A[i] >> B[i] >> C[i];
C[i] -= P;
}
used1[1] = true;
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
if (used1[A[j]] == true)
used1[B[j]] = true;
}
}
used2[N] = true;
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
if (used2[B[j]] == true)
used2[A[j]] = true;
}
}
for (int i = 1; i <= N; i++)
dist[i] = -(1LL << 60);
dist[1] = 0;
for (int i = 1; i <= N * 5; i++) {
for (int j = 1; j <= M; j++)
predist[j] = dist[j];
for (int j = 1; j <= M; j++) {
dist[B[j]] = max(dist[B[j]], dist[A[j]] + C[j]);
}
bool flag = false;
for (int j = 1; j <= N; j++) {
if (used1[j] == true && used2[j] == true && dist[j] != predist[j])
flag = true;
}
if (flag == false)
break;
if (i == N * 5) {
cout << "-1" << endl;
return 0;
}
}
cout << max(0LL, dist[N]) << endl;
return 0;
} | #include <algorithm>
#include <iostream>
using namespace std;
long long N, M, P, A[1 << 18], B[1 << 18], C[1 << 18];
long long dist[1 << 18], predist[1 << 18];
bool used1[1 << 18], used2[1 << 18];
int main() {
cin >> N >> M >> P;
for (int i = 1; i <= M; i++) {
cin >> A[i] >> B[i] >> C[i];
C[i] -= P;
}
used1[1] = true;
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
if (used1[A[j]] == true)
used1[B[j]] = true;
}
}
used2[N] = true;
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
if (used2[B[j]] == true)
used2[A[j]] = true;
}
}
for (int i = 1; i <= N; i++)
dist[i] = -(1LL << 60);
dist[1] = 0;
for (int i = 1; i <= N * 2; i++) {
for (int j = 1; j <= N; j++)
predist[j] = dist[j];
for (int j = 1; j <= M; j++) {
dist[B[j]] = max(dist[B[j]], dist[A[j]] + C[j]);
}
bool flag = false;
for (int j = 1; j <= N; j++) {
if (used1[j] == true && used2[j] == true && dist[j] != predist[j])
flag = true;
}
if (flag == false)
break;
if (i == N * 2) {
cout << "-1" << endl;
return 0;
}
}
cout << max(0LL, dist[N]) << endl;
return 0;
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"identifier.change",
"control_flow.branch.if.condition.change"
] | 750,792 | 750,791 | u504103417 | cpp |
p02949 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define ll long long int
#define MAX 1000000000000
using namespace std;
int main(void) {
ll n, m, p;
cin >> n >> m >> p;
vector<vector<pair<ll, ll>>> list(n + 1);
rep(i, m) {
ll a, b, c;
cin >> a >> b >> c;
list[a].emplace_back(b, c - p);
}
vector<ll> cur(n + 1, -MAX), tmp(n + 1, 0);
vector<bool> reach(n + 1, false);
cur[1] = 0;
reach[1] = true;
ll ans;
bool flag;
rep(i, 3 * n) {
rep(j, n) {
if (!reach[j + 1])
break;
rep(k, list[j + 1].size()) {
reach[list[j + 1][k].first] = true;
if (cur[list[j + 1][k].first] < cur[j + 1] + list[j + 1][k].second) {
cur[list[j + 1][k].first] = cur[j + 1] + list[j + 1][k].second;
}
}
}
// rep(j,n) cout << cur[j+1] << " ";
// cout << endl;
if (i == n - 2) {
ans = cur[n];
tmp = cur;
}
if (i == n - 1) {
rep(j, n) {
if (tmp[j + 1] < cur[j + 1])
cur[j + 1] = MAX;
}
}
}
if (ans < cur[n])
cout << -1 << endl;
else
cout << max(ans, 0LL) << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define ll long long int
#define MAX 1000000000000
using namespace std;
int main(void) {
ll n, m, p;
cin >> n >> m >> p;
vector<vector<pair<ll, ll>>> list(n + 1);
rep(i, m) {
ll a, b, c;
cin >> a >> b >> c;
list[a].emplace_back(b, c - p);
}
vector<ll> cur(n + 1, -MAX), tmp(n + 1, 0);
vector<bool> reach(n + 1, false);
cur[1] = 0;
reach[1] = true;
ll ans;
bool flag;
rep(i, 3 * n) {
rep(j, n) {
if (!reach[j + 1])
continue;
rep(k, list[j + 1].size()) {
reach[list[j + 1][k].first] = true;
if (cur[list[j + 1][k].first] < cur[j + 1] + list[j + 1][k].second) {
cur[list[j + 1][k].first] = cur[j + 1] + list[j + 1][k].second;
}
}
}
// rep(j,n) cout << cur[j+1] << " ";
// cout << endl;
if (i == n - 2) {
ans = cur[n];
tmp = cur;
}
if (i == n - 1) {
rep(j, n) {
if (tmp[j + 1] < cur[j + 1])
cur[j + 1] = MAX;
}
}
}
if (ans < cur[n])
cout << -1 << endl;
else
cout << max(ans, 0LL) << endl;
return 0;
}
| [
"control_flow.break.remove",
"control_flow.continue.add"
] | 750,795 | 750,796 | u582848517 | cpp |
p02949 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
const int MOD = 1000000007;
using namespace std;
using lint = long long;
template <class T> ostream &operator<<(ostream &os, const vector<T> &vec) {
for (int i = 0; i < (int)vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : " ");
}
return os;
}
#ifdef _DEBUG
template <class Head> void dump(const char *str, Head &&h) {
cerr << str << " = " << h << "\n";
};
template <class Head, class... Tail>
void dump(const char *str, Head &&h, Tail &&...t) {
while (*str != ',')
cerr << *str++;
cerr << " = " << h << "\n";
dump(str + 1, t...);
}
#define DMP(...) dump(#__VA_ARGS__, __VA_ARGS__)
#else
#define DMP(...) ((void)0)
#endif
template <class T = lint> struct Edge {
int from, to;
T cost;
Edge() {}
Edge(int from, int to, T cost) : from(from), to(to), cost(cost) {}
};
template <class T>
vector<T> Bellman_Ford(vector<Edge<T>> &edges, int V, int st) {
const T inf = numeric_limits<T>::max() / 2; // different from INF!!!
vector<T> dist(V, inf);
dist[st] = 0;
for (int i = 0; i < V - 1; i++) {
for (const auto &e : edges) {
if (dist[e.from] == inf)
continue;
dist[e.to] = min(dist[e.to], dist[e.from] + e.cost);
}
}
for (int i = 0; i < V - 1; i++) {
for (const auto &e : edges) { // finding negative loop
if (dist[e.from] == inf)
continue;
if (dist[e.from] == -inf)
dist[e.to] = -inf; // src is nloop -> dst is nloop
else if (dist[e.to] > dist[e.from] + e.cost)
dist[e.to] = -inf; // chmin is possible -> nloop
}
}
return dist;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int N, M, P;
cin >> N >> M >> P;
int a, b, c;
vector<Edge<int>> edges(M);
for (int i = 0; i < M; i++) {
cin >> a >> b >> c;
a--, b--;
edges[i] = {a, b, P - c};
}
auto dist = Bellman_Ford(edges, N, 0);
DMP(dist);
lint ans = -dist.back();
DMP(ans);
if (ans == numeric_limits<int>::max())
cout << "-1\n";
else if (ans < 0)
cout << "0\n";
else
cout << ans << "\n";
return 0;
}
| #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
const int MOD = 1000000007;
using namespace std;
using lint = long long;
template <class T> ostream &operator<<(ostream &os, const vector<T> &vec) {
for (int i = 0; i < (int)vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : " ");
}
return os;
}
#ifdef _DEBUG
template <class Head> void dump(const char *str, Head &&h) {
cerr << str << " = " << h << "\n";
};
template <class Head, class... Tail>
void dump(const char *str, Head &&h, Tail &&...t) {
while (*str != ',')
cerr << *str++;
cerr << " = " << h << "\n";
dump(str + 1, t...);
}
#define DMP(...) dump(#__VA_ARGS__, __VA_ARGS__)
#else
#define DMP(...) ((void)0)
#endif
template <class T = lint> struct Edge {
int from, to;
T cost;
Edge() {}
Edge(int from, int to, T cost) : from(from), to(to), cost(cost) {}
};
template <class T>
vector<T> Bellman_Ford(vector<Edge<T>> &edges, int V, int st) {
const T inf = numeric_limits<T>::max(); // different from INF!!!
vector<T> dist(V, inf);
dist[st] = 0;
for (int i = 0; i < V - 1; i++) {
for (const auto &e : edges) {
if (dist[e.from] == inf)
continue;
dist[e.to] = min(dist[e.to], dist[e.from] + e.cost);
}
}
for (int i = 0; i < V - 1; i++) {
for (const auto &e : edges) { // finding negative loop
if (dist[e.from] == inf)
continue;
if (dist[e.from] == -inf)
dist[e.to] = -inf; // src is nloop -> dst is nloop
else if (dist[e.to] > dist[e.from] + e.cost)
dist[e.to] = -inf; // chmin is possible -> nloop
}
}
return dist;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int N, M, P;
cin >> N >> M >> P;
int a, b, c;
vector<Edge<int>> edges(M);
for (int i = 0; i < M; i++) {
cin >> a >> b >> c;
a--, b--;
edges[i] = {a, b, P - c};
}
auto dist = Bellman_Ford(edges, N, 0);
DMP(dist);
lint ans = -dist.back();
DMP(ans);
if (ans == numeric_limits<int>::max())
cout << "-1\n";
else if (ans < 0)
cout << "0\n";
else
cout << ans << "\n";
return 0;
}
| [
"expression.operation.binary.remove"
] | 750,797 | 750,798 | u532573979 | cpp |
p02949 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
const int MOD = 1000000007, INF = 1111111111;
using namespace std;
using lint = long long;
template <class T> ostream &operator<<(ostream &os, const vector<T> &vec) {
for (int i = 0; i < (int)vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : " ");
}
return os;
}
#ifdef _DEBUG
template <class Head> void dump(const char *str, Head &&h) {
cerr << str << " = " << h << "\n";
};
template <class Head, class... Tail>
void dump(const char *str, Head &&h, Tail &&...t) {
while (*str != ',')
cerr << *str++;
cerr << " = " << h << "\n";
dump(str + 1, t...);
}
#define DMP(...) dump(#__VA_ARGS__, __VA_ARGS__)
#else
#define DMP(...) ((void)0)
#endif
template <class T = lint> struct Edge {
int from, to;
T cost;
Edge() {}
Edge(int from, int to, T cost) : from(from), to(to), cost(cost) {}
};
template <class T>
vector<T> Bellman_Ford(vector<Edge<T>> &edges, int V, int st) {
vector<T> dist(V, INF);
dist[st] = 0;
for (int i = 0; i < V - 1; i++) {
for (const auto &ele : edges) {
if (dist[ele.from] == INF)
continue;
dist[ele.to] = min(dist[ele.to], dist[ele.from] + ele.cost);
}
}
for (int i = 0; i < V - 2; i++) {
for (const auto &ele : edges) { // finding negative loop
if (dist[ele.from] == INF)
continue;
if (dist[ele.from] == -INF)
dist[ele.to] = -INF; // src is nloop -> dst is nloop
if (dist[ele.to] > dist[ele.from] + ele.cost)
dist[ele.to] = -INF; // chmin is possible -> nloop
}
}
return dist;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int N, M, P;
cin >> N >> M >> P;
int a, b, c;
vector<Edge<int>> edges(M);
for (int i = 0; i < M; i++) {
cin >> a >> b >> c;
a--, b--;
edges[i] = {a, b, P - c};
}
auto dist = Bellman_Ford(edges, N, 0);
DMP(dist);
int ans = -dist.back();
if (ans == INF)
cout << "-1\n";
else if (ans < 0)
cout << "0\n";
else
cout << ans << "\n";
return 0;
}
| #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
const int MOD = 1000000007, INF = 1111111111;
using namespace std;
using lint = long long;
template <class T> ostream &operator<<(ostream &os, const vector<T> &vec) {
for (int i = 0; i < (int)vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : " ");
}
return os;
}
#ifdef _DEBUG
template <class Head> void dump(const char *str, Head &&h) {
cerr << str << " = " << h << "\n";
};
template <class Head, class... Tail>
void dump(const char *str, Head &&h, Tail &&...t) {
while (*str != ',')
cerr << *str++;
cerr << " = " << h << "\n";
dump(str + 1, t...);
}
#define DMP(...) dump(#__VA_ARGS__, __VA_ARGS__)
#else
#define DMP(...) ((void)0)
#endif
template <class T = lint> struct Edge {
int from, to;
T cost;
Edge() {}
Edge(int from, int to, T cost) : from(from), to(to), cost(cost) {}
};
template <class T>
vector<T> Bellman_Ford(vector<Edge<T>> &edges, int V, int st) {
vector<T> dist(V, INF);
dist[st] = 0;
for (int i = 0; i < V - 1; i++) {
for (const auto &ele : edges) {
if (dist[ele.from] == INF)
continue;
dist[ele.to] = min(dist[ele.to], dist[ele.from] + ele.cost);
}
}
for (int i = 0; i < 2 * V; i++) {
for (const auto &ele : edges) { // finding negative loop
if (dist[ele.from] == INF)
continue;
if (dist[ele.from] == -INF)
dist[ele.to] = -INF; // src is nloop -> dst is nloop
if (dist[ele.to] > dist[ele.from] + ele.cost)
dist[ele.to] = -INF; // chmin is possible -> nloop
}
}
return dist;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int N, M, P;
cin >> N >> M >> P;
int a, b, c;
vector<Edge<int>> edges(M);
for (int i = 0; i < M; i++) {
cin >> a >> b >> c;
a--, b--;
edges[i] = {a, b, P - c};
}
auto dist = Bellman_Ford(edges, N, 0);
DMP(dist);
int ans = -dist.back();
if (ans == INF)
cout << "-1\n";
else if (ans < 0)
cout << "0\n";
else
cout << ans << "\n";
return 0;
}
| [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 750,800 | 750,801 | u532573979 | cpp |
p02949 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
const int MOD = 1000000007;
using namespace std;
using lint = long long;
template <class T> ostream &operator<<(ostream &os, const vector<T> &vec) {
for (int i = 0; i < (int)vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : " ");
}
return os;
}
#ifdef _DEBUG
template <class Head> void dump(const char *str, Head &&h) {
cerr << str << " = " << h << "\n";
};
template <class Head, class... Tail>
void dump(const char *str, Head &&h, Tail &&...t) {
while (*str != ',')
cerr << *str++;
cerr << " = " << h << "\n";
dump(str + 1, t...);
}
#define DMP(...) dump(#__VA_ARGS__, __VA_ARGS__)
#else
#define DMP(...) ((void)0)
#endif
template <class T = lint> struct Edge {
int from, to;
T cost;
Edge() {}
Edge(int from, int to, T cost) : from(from), to(to), cost(cost) {}
};
template <class T>
vector<T> Bellman_Ford(vector<Edge<T>> &edges, int V, int st) {
const T INF = numeric_limits<lint>::max();
vector<T> dist(V, INF);
dist[st] = 0;
for (int i = 0; i <= 2 * V; i++) {
for (const auto &ele : edges) {
if (dist[ele.from] == INF)
continue;
if (dist[ele.to] > dist[ele.from] + ele.cost) {
dist[ele.to] = dist[ele.from] + ele.cost;
if (ele.from == V - 1 && i == 2 * V)
return vector<T>(1);
}
}
}
return dist;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int N, M, P;
cin >> N >> M >> P;
int a, b, c;
vector<Edge<lint>> edges(M);
for (int i = 0; i < M; i++) {
cin >> a >> b >> c;
a--, b--;
edges[i] = {a, b, P - c};
}
auto dist = Bellman_Ford(edges, N, 0);
DMP(dist);
lint ans = -dist.back();
if (dist.size() == 1)
cout << "-1\n";
else if (ans < 0)
cout << "0\n";
else
cout << ans << "\n";
return 0;
} | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
const int MOD = 1000000007;
using namespace std;
using lint = long long;
template <class T> ostream &operator<<(ostream &os, const vector<T> &vec) {
for (int i = 0; i < (int)vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : " ");
}
return os;
}
#ifdef _DEBUG
template <class Head> void dump(const char *str, Head &&h) {
cerr << str << " = " << h << "\n";
};
template <class Head, class... Tail>
void dump(const char *str, Head &&h, Tail &&...t) {
while (*str != ',')
cerr << *str++;
cerr << " = " << h << "\n";
dump(str + 1, t...);
}
#define DMP(...) dump(#__VA_ARGS__, __VA_ARGS__)
#else
#define DMP(...) ((void)0)
#endif
template <class T = lint> struct Edge {
int from, to;
T cost;
Edge() {}
Edge(int from, int to, T cost) : from(from), to(to), cost(cost) {}
};
template <class T>
vector<T> Bellman_Ford(vector<Edge<T>> &edges, int V, int st) {
const T INF = numeric_limits<lint>::max();
vector<T> dist(V, INF);
dist[st] = 0;
for (int i = 0; i <= 2 * V; i++) {
for (const auto &ele : edges) {
if (dist[ele.from] == INF)
continue;
if (dist[ele.to] > dist[ele.from] + ele.cost) {
dist[ele.to] = dist[ele.from] + ele.cost;
if (ele.to == V - 1 && i >= V)
return vector<T>(1);
}
}
}
return dist;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int N, M, P;
cin >> N >> M >> P;
int a, b, c;
vector<Edge<lint>> edges(M);
for (int i = 0; i < M; i++) {
cin >> a >> b >> c;
a--, b--;
edges[i] = {a, b, P - c};
}
auto dist = Bellman_Ford(edges, N, 0);
DMP(dist);
lint ans = -dist.back();
if (dist.size() == 1)
cout << "-1\n";
else if (ans < 0)
cout << "0\n";
else
cout << ans << "\n";
return 0;
} | [
"control_flow.branch.if.condition.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 750,805 | 750,804 | u532573979 | cpp |
p02949 | // #define DEBUGGING
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define ALL(V) (V).begin(), (V).end()
#define ALLR(V) (V).rbegin(), (V).rend()
template <typename T> using V = vector<T>;
template <typename T> using VV = V<V<T>>;
using ll = int64_t;
using ull = uint64_t;
using PLL = pair<ll, ll>;
template <typename T> const T &var_min(const T &t) { return t; }
template <typename T> const T &var_max(const T &t) { return t; }
template <typename T, typename... Tail>
const T &var_min(const T &t, const Tail &...tail) {
return min(t, var_min(tail...));
}
template <typename T, typename... Tail>
const T &var_max(const T &t, const Tail &...tail) {
return max(t, var_max(tail...));
}
template <typename T, typename... Tail> void chmin(T &t, const Tail &...tail) {
t = var_min(t, tail...);
}
template <typename T, typename... Tail> void chmax(T &t, const Tail &...tail) {
t = var_max(t, tail...);
}
template <typename T> const T &clamp(const T &t, const T &low, const T &high) {
return max(low, min(high, t));
}
template <typename T> void chclamp(T &t, const T &low, const T &high) {
t = clamp(t, low, high);
}
namespace init__ {
struct InitIO {
InitIO() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(30);
}
} init_io;
} // namespace init__
#ifdef DEBUGGING
// #include "../debug/debug.cpp"
#include "../../debug/debug.cpp"
#else
#define DEBUG(...) 0
#define DEBUG_SEPARATOR_LINE 0
#endif
template <typename T> T make_v(T init) { return init; }
template <typename T, typename... Tail>
auto make_v(T init, size_t s, Tail... tail) {
#define rec make_v(init, tail...)
return V<decltype(rec)>(s, rec);
#undef rec
}
const ll inf = 5e15;
bool vel(V<ll> &dists, const VV<PLL> &edges) {
ll N = dists.size();
for (ll i__ = 0; i__ <= 2 * N; i__++) {
bool update = false;
for (ll i = 0; i < N; i++) {
for (auto &&edge : edges[i]) {
ll nxt, cost;
tie(nxt, cost) = edge;
ll cur_d = dists[nxt];
ll update_d = dists[i] + cost;
if (update_d < cur_d) {
if (i == N - 1)
update = true;
dists[nxt] = update_d;
}
}
}
if (i__ >= N && update)
return false;
}
return true;
}
int main() {
ll N, M, P;
cin >> N >> M >> P;
VV<PLL> edges(N);
for (ll i = 0; i < M; i++) {
ll a, b, c;
cin >> a >> b >> c;
a--;
b--;
edges[a].emplace_back(b, P - c);
}
V<ll> dists(N, inf);
dists[0] = 0;
bool ok = vel(dists, edges);
DEBUG(dists);
if (ok)
cout << max<ll>(0, -dists[N - 1]) << endl;
else
cout << -1 << endl;
return 0;
}
| // #define DEBUGGING
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define ALL(V) (V).begin(), (V).end()
#define ALLR(V) (V).rbegin(), (V).rend()
template <typename T> using V = vector<T>;
template <typename T> using VV = V<V<T>>;
using ll = int64_t;
using ull = uint64_t;
using PLL = pair<ll, ll>;
template <typename T> const T &var_min(const T &t) { return t; }
template <typename T> const T &var_max(const T &t) { return t; }
template <typename T, typename... Tail>
const T &var_min(const T &t, const Tail &...tail) {
return min(t, var_min(tail...));
}
template <typename T, typename... Tail>
const T &var_max(const T &t, const Tail &...tail) {
return max(t, var_max(tail...));
}
template <typename T, typename... Tail> void chmin(T &t, const Tail &...tail) {
t = var_min(t, tail...);
}
template <typename T, typename... Tail> void chmax(T &t, const Tail &...tail) {
t = var_max(t, tail...);
}
template <typename T> const T &clamp(const T &t, const T &low, const T &high) {
return max(low, min(high, t));
}
template <typename T> void chclamp(T &t, const T &low, const T &high) {
t = clamp(t, low, high);
}
namespace init__ {
struct InitIO {
InitIO() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(30);
}
} init_io;
} // namespace init__
#ifdef DEBUGGING
// #include "../debug/debug.cpp"
#include "../../debug/debug.cpp"
#else
#define DEBUG(...) 0
#define DEBUG_SEPARATOR_LINE 0
#endif
template <typename T> T make_v(T init) { return init; }
template <typename T, typename... Tail>
auto make_v(T init, size_t s, Tail... tail) {
#define rec make_v(init, tail...)
return V<decltype(rec)>(s, rec);
#undef rec
}
const ll inf = 5e15;
bool vel(V<ll> &dists, const VV<PLL> &edges) {
ll N = dists.size();
for (ll i__ = 0; i__ <= 2 * N; i__++) {
bool update = false;
for (ll i = 0; i < N; i++) {
for (auto &&edge : edges[i]) {
ll nxt, cost;
tie(nxt, cost) = edge;
ll cur_d = dists[nxt];
ll update_d = dists[i] + cost;
if (update_d < cur_d) {
if (nxt == N - 1)
update = true;
dists[nxt] = update_d;
}
}
}
if (i__ >= N && update)
return false;
}
return true;
}
int main() {
ll N, M, P;
cin >> N >> M >> P;
VV<PLL> edges(N);
for (ll i = 0; i < M; i++) {
ll a, b, c;
cin >> a >> b >> c;
a--;
b--;
edges[a].emplace_back(b, P - c);
}
V<ll> dists(N, inf);
dists[0] = 0;
bool ok = vel(dists, edges);
DEBUG(dists);
if (ok)
cout << max<ll>(0, -dists[N - 1]) << endl;
else
cout << -1 << endl;
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 750,818 | 750,819 | u216962796 | cpp |
p02949 | // #define DEBUGGING
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define ALL(V) (V).begin(), (V).end()
#define ALLR(V) (V).rbegin(), (V).rend()
template <typename T> using V = vector<T>;
template <typename T> using VV = V<V<T>>;
using ll = int64_t;
using ull = uint64_t;
using PLL = pair<ll, ll>;
template <typename T> const T &var_min(const T &t) { return t; }
template <typename T> const T &var_max(const T &t) { return t; }
template <typename T, typename... Tail>
const T &var_min(const T &t, const Tail &...tail) {
return min(t, var_min(tail...));
}
template <typename T, typename... Tail>
const T &var_max(const T &t, const Tail &...tail) {
return max(t, var_max(tail...));
}
template <typename T, typename... Tail> void chmin(T &t, const Tail &...tail) {
t = var_min(t, tail...);
}
template <typename T, typename... Tail> void chmax(T &t, const Tail &...tail) {
t = var_max(t, tail...);
}
template <typename T> const T &clamp(const T &t, const T &low, const T &high) {
return max(low, min(high, t));
}
template <typename T> void chclamp(T &t, const T &low, const T &high) {
t = clamp(t, low, high);
}
namespace init__ {
struct InitIO {
InitIO() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(30);
}
} init_io;
} // namespace init__
#ifdef DEBUGGING
// #include "../debug/debug.cpp"
#include "../../debug/debug.cpp"
#else
#define DEBUG(...) 0
#define DEBUG_SEPARATOR_LINE 0
#endif
template <typename T> T make_v(T init) { return init; }
template <typename T, typename... Tail>
auto make_v(T init, size_t s, Tail... tail) {
#define rec make_v(init, tail...)
return V<decltype(rec)>(s, rec);
#undef rec
}
const ll inf = 5e15;
bool vel(V<ll> &dists, const VV<PLL> &edges) {
ll N = dists.size();
for (ll i__ = 0; i__ <= 2 * N; i__++) {
bool update = false;
for (ll i = 0; i < N; i++) {
for (auto &&edge : edges[i]) {
ll nxt, cost;
tie(nxt, cost) = edge;
ll cur_d = dists[nxt];
ll update_d = dists[i] + cost;
if (update_d < cur_d) {
if (i == N - 1)
update = true;
dists[nxt] = update_d;
}
}
}
if (i__ == 2 * N && update)
return false;
}
return true;
}
int main() {
ll N, M, P;
cin >> N >> M >> P;
VV<PLL> edges(N);
for (ll i = 0; i < M; i++) {
ll a, b, c;
cin >> a >> b >> c;
a--;
b--;
edges[a].emplace_back(b, P - c);
}
V<ll> dists(N, inf);
dists[0] = 0;
bool ok = vel(dists, edges);
DEBUG(dists);
if (ok)
cout << max<ll>(0, -dists[N - 1]) << endl;
else
cout << -1 << endl;
return 0;
}
| // #define DEBUGGING
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define ALL(V) (V).begin(), (V).end()
#define ALLR(V) (V).rbegin(), (V).rend()
template <typename T> using V = vector<T>;
template <typename T> using VV = V<V<T>>;
using ll = int64_t;
using ull = uint64_t;
using PLL = pair<ll, ll>;
template <typename T> const T &var_min(const T &t) { return t; }
template <typename T> const T &var_max(const T &t) { return t; }
template <typename T, typename... Tail>
const T &var_min(const T &t, const Tail &...tail) {
return min(t, var_min(tail...));
}
template <typename T, typename... Tail>
const T &var_max(const T &t, const Tail &...tail) {
return max(t, var_max(tail...));
}
template <typename T, typename... Tail> void chmin(T &t, const Tail &...tail) {
t = var_min(t, tail...);
}
template <typename T, typename... Tail> void chmax(T &t, const Tail &...tail) {
t = var_max(t, tail...);
}
template <typename T> const T &clamp(const T &t, const T &low, const T &high) {
return max(low, min(high, t));
}
template <typename T> void chclamp(T &t, const T &low, const T &high) {
t = clamp(t, low, high);
}
namespace init__ {
struct InitIO {
InitIO() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(30);
}
} init_io;
} // namespace init__
#ifdef DEBUGGING
// #include "../debug/debug.cpp"
#include "../../debug/debug.cpp"
#else
#define DEBUG(...) 0
#define DEBUG_SEPARATOR_LINE 0
#endif
template <typename T> T make_v(T init) { return init; }
template <typename T, typename... Tail>
auto make_v(T init, size_t s, Tail... tail) {
#define rec make_v(init, tail...)
return V<decltype(rec)>(s, rec);
#undef rec
}
const ll inf = 5e15;
bool vel(V<ll> &dists, const VV<PLL> &edges) {
ll N = dists.size();
for (ll i__ = 0; i__ <= 2 * N; i__++) {
bool update = false;
for (ll i = 0; i < N; i++) {
for (auto &&edge : edges[i]) {
ll nxt, cost;
tie(nxt, cost) = edge;
ll cur_d = dists[nxt];
ll update_d = dists[i] + cost;
if (update_d < cur_d) {
if (nxt == N - 1)
update = true;
dists[nxt] = update_d;
}
}
}
if (i__ >= N && update)
return false;
}
return true;
}
int main() {
ll N, M, P;
cin >> N >> M >> P;
VV<PLL> edges(N);
for (ll i = 0; i < M; i++) {
ll a, b, c;
cin >> a >> b >> c;
a--;
b--;
edges[a].emplace_back(b, P - c);
}
V<ll> dists(N, inf);
dists[0] = 0;
bool ok = vel(dists, edges);
DEBUG(dists);
if (ok)
cout << max<ll>(0, -dists[N - 1]) << endl;
else
cout << -1 << endl;
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 750,820 | 750,819 | u216962796 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> P;
typedef pair<LL, LL> PL;
typedef pair<P, LL> PP;
typedef pair<P, LL> PP;
typedef long long LL;
#define xx first
#define yy second
vector<int> G1[110000], G2[110000];
vector<tuple<int, int, int>> vt;
int n, m, p;
int eg[110000], d[110000];
int vis[110000];
void dfs1(int p) {
if ((vis[p] & 2))
return;
vis[p] |= 2;
for (auto adj : G1[p]) {
dfs1(adj);
}
}
void dfs2(int p) {
if ((vis[p] & 1))
return;
vis[p] |= 1;
for (auto adj : G2[p]) {
dfs2(adj);
}
}
void bf() {
for (int i = 0; i < n + 10; i++)
d[i] = INT_MAX;
// cout<<-d[0]<<" "<<d[0]<<endl;
d[1] = 0;
int test;
int fl = 0;
for (int i = 0; i < n; i++) {
// cout<<"round"<<endl;
test = 0;
for (auto e : vt) {
int a, b, c;
tie(a, b, c) = e;
if (d[a] < INT_MAX && (d[b] > d[a] + c)) {
d[b] = d[a] + c, eg[b] = eg[a] + 1, test = (vis[b] == 3 ? 1 : test);
}
if (i >= n && test == 1)
fl = 1;
}
}
// cout<<d[n]<<endl;
if (fl) {
cout << -1 << endl;
} else
cout << max(0, -d[n]) << endl;
}
int main() {
// #ifndef ONLINE_JUDGE
// freopen("input", "r", stdin);
// freopen("output", "w", stdout);
std::ios::sync_with_stdio(false);
std::cin.tie(0);
cin >> n >> m >> p;
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
vt.push_back(make_tuple(a, b, p - c));
G1[a].push_back(b);
G2[b].push_back(a);
}
dfs1(1);
dfs2(n);
bf();
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> P;
typedef pair<LL, LL> PL;
typedef pair<P, LL> PP;
typedef pair<P, LL> PP;
typedef long long LL;
#define xx first
#define yy second
vector<int> G1[110000], G2[110000];
vector<tuple<int, int, int>> vt;
int n, m, p;
int eg[110000], d[110000];
int vis[110000];
void dfs1(int p) {
if ((vis[p] & 2))
return;
vis[p] |= 2;
for (auto adj : G1[p]) {
dfs1(adj);
}
}
void dfs2(int p) {
if ((vis[p] & 1))
return;
vis[p] |= 1;
for (auto adj : G2[p]) {
dfs2(adj);
}
}
void bf() {
for (int i = 0; i < n + 10; i++)
d[i] = INT_MAX;
// cout<<-d[0]<<" "<<d[0]<<endl;
d[1] = 0;
int test;
int fl = 0;
for (int i = 0; i < n; i++) {
// cout<<"round"<<endl;
test = 0;
for (auto e : vt) {
int a, b, c;
tie(a, b, c) = e;
if (d[a] < INT_MAX && (d[b] > d[a] + c)) {
d[b] = d[a] + c, eg[b] = eg[a] + 1, test = (vis[b] == 3 ? 1 : test);
}
if (i >= n - 1 && test == 1)
fl = 1;
}
}
// cout<<d[n]<<endl;
if (fl) {
cout << -1 << endl;
} else
cout << max(0, -d[n]) << endl;
}
int main() {
// #ifndef ONLINE_JUDGE
// freopen("input", "r", stdin);
// freopen("output", "w", stdout);
std::ios::sync_with_stdio(false);
std::cin.tie(0);
cin >> n >> m >> p;
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
vt.push_back(make_tuple(a, b, p - c));
G1[a].push_back(b);
G2[b].push_back(a);
}
dfs1(1);
dfs2(n);
bf();
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 750,840 | 750,841 | u032032867 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "../lib/dump.hpp"
#else
#define dump(...)
#define dumpv(...)
#endif
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef long long ll;
typedef pair<int, int> P;
const int MOD = 1e9 + 7;
const int INF = 1001001001;
const ll LINF = 1001002003004005006ll;
void solve() {
int N, M, P;
cin >> N >> M >> P;
vector<vector<int>> to(N), ot(N);
vector<tuple<int, int, int>> eg;
rep(i, M) {
int a, b, c;
cin >> a >> b >> c;
a--, b--;
c = -(c - P);
to[a].push_back(b);
ot[b].push_back(a);
eg.emplace_back(a, b, c);
}
vector<int> from1(N);
function<void(int)> dfs1 = [&](int u) {
if (from1[u])
return;
from1[u] = 1;
for (auto &v : to[u])
dfs1(v);
};
dfs1(0);
vector<int> fromN(N);
function<void(int)> dfsN = [&](int u) {
if (fromN[u])
return;
fromN[u] = 1;
for (auto &v : ot[u])
dfsN(v);
};
dfsN(N - 1);
dump(from1, fromN);
vector<int> dist(N, INF);
dist[0] = 0;
int updated = 1;
int step = 0;
while (updated) {
dump(dist);
updated = 0;
rep(i, M) {
int a, b, c;
tie(a, b, c) = eg[i];
if (!from1[a] || !fromN[a])
continue;
if (!from1[b] || !fromN[b])
continue;
if (dist[a] + c < dist[b]) {
updated = 1;
dist[b] = dist[a] + c;
}
}
step++;
if (M < step) {
cout << -1 << endl;
return;
}
}
cout << max(0, -dist[N - 1]) << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
// freopen("temp.1", "r", stdin);
solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "../lib/dump.hpp"
#else
#define dump(...)
#define dumpv(...)
#endif
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef long long ll;
typedef pair<int, int> P;
const int MOD = 1e9 + 7;
const int INF = 1001001001;
const ll LINF = 1001002003004005006ll;
void solve() {
int N, M, P;
cin >> N >> M >> P;
vector<vector<int>> to(N), ot(N);
vector<tuple<int, int, int>> eg;
rep(i, M) {
int a, b, c;
cin >> a >> b >> c;
a--, b--;
c = -(c - P);
to[a].push_back(b);
ot[b].push_back(a);
eg.emplace_back(a, b, c);
}
vector<int> from1(N);
function<void(int)> dfs1 = [&](int u) {
if (from1[u])
return;
from1[u] = 1;
for (auto &v : to[u])
dfs1(v);
};
dfs1(0);
vector<int> fromN(N);
function<void(int)> dfsN = [&](int u) {
if (fromN[u])
return;
fromN[u] = 1;
for (auto &v : ot[u])
dfsN(v);
};
dfsN(N - 1);
dump(from1, fromN);
vector<int> dist(N, INF);
dist[0] = 0;
int updated = 1;
int step = 0;
while (updated) {
dump(dist);
updated = 0;
rep(i, M) {
int a, b, c;
tie(a, b, c) = eg[i];
if (!from1[a] || !fromN[a])
continue;
if (!from1[b] || !fromN[b])
continue;
if (dist[a] + c < dist[b]) {
updated = 1;
dist[b] = dist[a] + c;
}
}
step++;
if (N < step) {
cout << -1 << endl;
return;
}
}
cout << max(0, -dist[N - 1]) << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
// freopen("temp.1", "r", stdin);
solve();
return 0;
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 750,845 | 750,846 | u147305315 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define int long long
// [a -> b-1]
#define reps(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
// [0 -> a-1]
#define rep(i, a) reps(i, 0, (a))
// [a-1 -> b]
#define rreps(i, a, b) for (int i = (int)((a)-1); i >= (int)(b); i--)
// [a-1 -> 0]
#define rrep(i, a) rreps(i, a, 0)
#define all(v) (v).begin(), (v).end()
// next_permutation(all(v))
#define PERM(v) next_permutation(all(v))
/*sort(all(v));
* (v).erase(unique(all(v)), v.end())*/
#define UNIQUE(v) \
sort(all(v)); \
(v).erase(unique(all(v)), v.end())
#define MINV(v) min_element(all(v))
#define MAXV(v) max_element(all(v))
#define MIN3(a, b, c) min(min(a, b), c)
#define MIN4(a, b, c, d) min(MIN3(a, b, c), d)
#define MIN5(a, b, c, d, e) min(MIN4(a, b, c, d), e)
#define MIN6(a, b, c, d, e, f) min(MIN5(a, b, c, d, e), f)
#define MAX3(a, b, c) max(max(a, b), c)
#define MAX4(a, b, c, d) max(MAX3(a, b, c), d)
#define MAX5(a, b, c, d, e) max(MAX4(a, b, c, d), e)
#define MAX6(a, b, c, d, e, f) max(MAX5(a, b, c, d, e), f)
// b is [a, c)
#define RANGE(a, b, c) ((a) <= (b) && (b) < (c))
// c is [a, e) && d is [b, f)
#define RANGE2D(a, b, c, d, e, f) (RANGE((a), (c), (e)) && RANGE((b), (d), (f)))
#define chmin(a, b) a = min(a, (b))
#define chmin3(a, b, c) a = MIN3(a, (b), (c))
#define chmin4(a, b, c, d) a = MIN4(a, (b), (c), (d))
#define chmin5(a, b, c, d, e) a = MIN5(a, (b), (c), (d), (e))
#define chmin6(a, b, c, d, e, f) a = MIN6(a, (b), (c), (d), (e), (f))
#define chmax(a, b) a = max(a, (b))
#define chmax3(a, b, c) a = MAX3(a, (b), (c))
#define chmax4(a, b, c, d) a = MAX4(a, (b), (c), (d))
#define chmax5(a, b, c, d, e) a = MAX5(a, (b), (c), (d), (e))
#define chmax6(a, b, c, d, e, f) a = MAX6(a, (b), (c), (d), (e), (f))
#define fcout cout << fixed << setprecision(15)
#define YES(f) cout << ((f) ? YES_STR : NO_STR) << endl;
using bellman_cost = int;
template <class V, class E> struct Graph {
int sz;
vector<V> v;
vector<vector<E>> e;
Graph(int n) : sz(n), v(n), e(n) {}
template <class... Args> inline void assign_vertex(int pos, Args... args) {
v[pos] = V(args...);
}
template <class... Args> inline void add_edge(int pos, Args... args) {
e[pos].emplace_back(args...);
}
inline int size() { return sz; }
};
template <class T> struct Vertex_Cost {
T cost;
bool valid = false;
Vertex_Cost(T v1) : cost(v1) {}
Vertex_Cost() {}
};
using vertex = Vertex_Cost<bellman_cost>;
template <class T> struct Edge_Cost {
int to;
T cost;
Edge_Cost(int t, T c) : to(t), cost(c) {}
Edge_Cost() {}
};
using edge = Edge_Cost<bellman_cost>;
using graph = Graph<vertex, edge>;
template <class T, class V, class E>
void Bellmanford(Graph<V, E> &G, int s, T INF_COST) {
auto &v = G.v;
auto &e = G.e;
for (auto &vv : v)
vv.cost = INF_COST;
v[s].cost = 0;
v[s].valid = true;
for (int i = 0; i + 1 < (int)v.size(); i++) {
for (int j = 0; j < (int)v.size(); j++) {
for (auto &x : e[j]) {
if (v[j].cost == INF_COST)
continue;
v[x.to].cost = min(v[x.to].cost, v[j].cost + x.cost);
v[x.to].valid = true;
}
}
}
vector<int> not_valid;
for (int i = 0; i < (int)v.size(); i++) {
for (auto &x : e[i]) {
if (v[i].cost == INF_COST)
continue;
if (v[x.to].cost > v[i].cost + x.cost) {
not_valid.emplace_back(x.to);
}
}
}
for (auto &x : not_valid) {
auto dfs = [&](auto f, int pos) {
if (!v[pos].valid)
return;
v[pos].valid = false;
for (auto &y : e[pos]) {
f(f, y.to);
}
};
dfs(dfs, x);
}
}
void solve(long long N, long long M, long long P, std::vector<long long> A,
std::vector<long long> B, std::vector<long long> C) {
graph g(N);
rep(i, M) { g.add_edge(A[i] - 1, B[i] - 1, -(C[i] - P)); }
Bellmanford(g, 0, LLONG_MAX);
if (!g.v[N - 1].valid)
cout << -1 << endl;
else
cout << max(g.v[N - 1].cost, 0LL) << endl;
}
signed main() {
long long N;
scanf("%lld", &N);
long long M;
scanf("%lld", &M);
long long P;
scanf("%lld", &P);
std::vector<long long> A(M);
std::vector<long long> B(M);
std::vector<long long> C(M);
for (int i = 0; i < M; i++) {
scanf("%lld", &A[i]);
scanf("%lld", &B[i]);
scanf("%lld", &C[i]);
}
solve(N, M, P, std::move(A), std::move(B), std::move(C));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define int long long
// [a -> b-1]
#define reps(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
// [0 -> a-1]
#define rep(i, a) reps(i, 0, (a))
// [a-1 -> b]
#define rreps(i, a, b) for (int i = (int)((a)-1); i >= (int)(b); i--)
// [a-1 -> 0]
#define rrep(i, a) rreps(i, a, 0)
#define all(v) (v).begin(), (v).end()
// next_permutation(all(v))
#define PERM(v) next_permutation(all(v))
/*sort(all(v));
* (v).erase(unique(all(v)), v.end())*/
#define UNIQUE(v) \
sort(all(v)); \
(v).erase(unique(all(v)), v.end())
#define MINV(v) min_element(all(v))
#define MAXV(v) max_element(all(v))
#define MIN3(a, b, c) min(min(a, b), c)
#define MIN4(a, b, c, d) min(MIN3(a, b, c), d)
#define MIN5(a, b, c, d, e) min(MIN4(a, b, c, d), e)
#define MIN6(a, b, c, d, e, f) min(MIN5(a, b, c, d, e), f)
#define MAX3(a, b, c) max(max(a, b), c)
#define MAX4(a, b, c, d) max(MAX3(a, b, c), d)
#define MAX5(a, b, c, d, e) max(MAX4(a, b, c, d), e)
#define MAX6(a, b, c, d, e, f) max(MAX5(a, b, c, d, e), f)
// b is [a, c)
#define RANGE(a, b, c) ((a) <= (b) && (b) < (c))
// c is [a, e) && d is [b, f)
#define RANGE2D(a, b, c, d, e, f) (RANGE((a), (c), (e)) && RANGE((b), (d), (f)))
#define chmin(a, b) a = min(a, (b))
#define chmin3(a, b, c) a = MIN3(a, (b), (c))
#define chmin4(a, b, c, d) a = MIN4(a, (b), (c), (d))
#define chmin5(a, b, c, d, e) a = MIN5(a, (b), (c), (d), (e))
#define chmin6(a, b, c, d, e, f) a = MIN6(a, (b), (c), (d), (e), (f))
#define chmax(a, b) a = max(a, (b))
#define chmax3(a, b, c) a = MAX3(a, (b), (c))
#define chmax4(a, b, c, d) a = MAX4(a, (b), (c), (d))
#define chmax5(a, b, c, d, e) a = MAX5(a, (b), (c), (d), (e))
#define chmax6(a, b, c, d, e, f) a = MAX6(a, (b), (c), (d), (e), (f))
#define fcout cout << fixed << setprecision(15)
#define YES(f) cout << ((f) ? YES_STR : NO_STR) << endl;
using bellman_cost = int;
template <class V, class E> struct Graph {
int sz;
vector<V> v;
vector<vector<E>> e;
Graph(int n) : sz(n), v(n), e(n) {}
template <class... Args> inline void assign_vertex(int pos, Args... args) {
v[pos] = V(args...);
}
template <class... Args> inline void add_edge(int pos, Args... args) {
e[pos].emplace_back(args...);
}
inline int size() { return sz; }
};
template <class T> struct Vertex_Cost {
T cost;
bool valid = false;
Vertex_Cost(T v1) : cost(v1) {}
Vertex_Cost() {}
};
using vertex = Vertex_Cost<bellman_cost>;
template <class T> struct Edge_Cost {
int to;
T cost;
Edge_Cost(int t, T c) : to(t), cost(c) {}
Edge_Cost() {}
};
using edge = Edge_Cost<bellman_cost>;
using graph = Graph<vertex, edge>;
template <class T, class V, class E>
void Bellmanford(Graph<V, E> &G, int s, T INF_COST) {
auto &v = G.v;
auto &e = G.e;
for (auto &vv : v)
vv.cost = INF_COST;
v[s].cost = 0;
v[s].valid = true;
for (int i = 0; i + 1 < (int)v.size(); i++) {
for (int j = 0; j < (int)v.size(); j++) {
for (auto &x : e[j]) {
if (v[j].cost == INF_COST)
continue;
v[x.to].cost = min(v[x.to].cost, v[j].cost + x.cost);
v[x.to].valid = true;
}
}
}
vector<int> not_valid;
for (int i = 0; i < (int)v.size(); i++) {
for (auto &x : e[i]) {
if (v[i].cost == INF_COST)
continue;
if (v[x.to].cost > v[i].cost + x.cost) {
not_valid.emplace_back(x.to);
}
}
}
for (auto &x : not_valid) {
auto dfs = [&](auto f, int pos) {
if (!v[pos].valid)
return;
v[pos].valid = false;
for (auto &y : e[pos]) {
f(f, y.to);
}
};
dfs(dfs, x);
}
}
void solve(long long N, long long M, long long P, std::vector<long long> A,
std::vector<long long> B, std::vector<long long> C) {
graph g(N);
rep(i, M) { g.add_edge(A[i] - 1, B[i] - 1, -(C[i] - P)); }
Bellmanford(g, 0, LLONG_MAX);
if (!g.v[N - 1].valid)
cout << -1 << endl;
else
cout << max(-g.v[N - 1].cost, 0LL) << endl;
}
signed main() {
long long N;
scanf("%lld", &N);
long long M;
scanf("%lld", &M);
long long P;
scanf("%lld", &P);
std::vector<long long> A(M);
std::vector<long long> B(M);
std::vector<long long> C(M);
for (int i = 0; i < M; i++) {
scanf("%lld", &A[i]);
scanf("%lld", &B[i]);
scanf("%lld", &C[i]);
}
solve(N, M, P, std::move(A), std::move(B), std::move(C));
return 0;
}
| [
"expression.operation.unary.add",
"call.arguments.change"
] | 750,847 | 750,848 | u946322619 | cpp |
p02949 | #include <algorithm>
#include <assert.h>
#include <climits> // LLONG_MAX, LLONG_MIN, INT_MIN, INT_MAX
#include <cmath>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility> // pair make_pair
#include <vector>
#define m0(x) memset(x, 0, sizeof(x))
#define m1(x) memset(x, 63, sizeof(x))
#define fill(x, y) memset(x, y, sizeof(x))
#define ll long long
#define int ll
#define INF LLONG_MAX / 100000
using namespace std;
using Pi = pair<int, int>;
using Graph = vector<vector<int>>;
using WeightGraph = vector<vector<Pi>>;
static const int MAX = 2500;
int d[MAX];
WeightGraph WG(MAX);
// true if negative loop, false if no negative loop
// O (|E| * |V|)
pair<bool, int> bellman_ford(const WeightGraph &WG, int (&d)[MAX], const int &n,
const int &s) {
// initialize to INF except the starting node
for (int i = 0; i < n; i++) {
d[i] = INF;
}
d[s] = 0;
int flag;
int ans = INF;
for (int i = 0; i < 2 * n; i++) {
if (i == n - 1) {
flag = d[s];
ans = d[0];
}
for (int v = 0; v < n; v++) {
for (auto adjacent : WG[v]) {
int nv = adjacent.first;
int nd = adjacent.second;
if (d[v] != INF && d[nv] > d[v] + nd) {
if (i == n - 1) {
// cout << "negative loop" << endl;
// return true;
d[nv] = d[v] + nd - INF;
} else {
d[nv] = d[v] + nd;
}
}
}
}
}
return Pi(flag == d[s], d[0]);
}
signed main() {
int N, M, P;
cin >> N >> M >> P;
Graph G(N);
for (int i = 0; i < M; i++) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
c -= P;
c = -1 * c;
G[b].push_back(a);
WG[b].push_back(Pi(a, c));
}
// DAG dg(G);
// dg.tsort();
// if (dg.is_acyclic == false) {
// cout << -1 << endl;
// return 0;
// }
Pi A = bellman_ford(WG, d, N, N - 1);
if (!A.first) {
cout << -1 << endl;
return 0;
} else {
if (A.second == INF) {
cout << -1 << endl;
} else if (A.second > 0) {
cout << 0 << endl;
} else {
cout << -1 * A.second << endl;
}
}
}
| #include <algorithm>
#include <assert.h>
#include <climits> // LLONG_MAX, LLONG_MIN, INT_MIN, INT_MAX
#include <cmath>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility> // pair make_pair
#include <vector>
#define m0(x) memset(x, 0, sizeof(x))
#define m1(x) memset(x, 63, sizeof(x))
#define fill(x, y) memset(x, y, sizeof(x))
#define ll long long
#define int ll
#define INF LLONG_MAX / 100000
using namespace std;
using Pi = pair<int, int>;
using Graph = vector<vector<int>>;
using WeightGraph = vector<vector<Pi>>;
static const int MAX = 2500;
int d[MAX];
WeightGraph WG(MAX);
// true if negative loop, false if no negative loop
// O (|E| * |V|)
pair<bool, int> bellman_ford(const WeightGraph &WG, int (&d)[MAX], const int &n,
const int &s) {
// initialize to INF except the starting node
for (int i = 0; i < n; i++) {
d[i] = INF;
}
d[s] = 0;
int flag;
int ans = INF;
for (int i = 0; i < 2 * n; i++) {
if (i == n - 1) {
flag = d[s];
ans = d[0];
}
for (int v = 0; v < n; v++) {
for (auto adjacent : WG[v]) {
int nv = adjacent.first;
int nd = adjacent.second;
if (d[v] != INF && d[nv] > d[v] + nd) {
if (i == n - 1) {
// cout << "negative loop" << endl;
// return true;
d[nv] = d[v] + nd - INF;
} else {
d[nv] = d[v] + nd;
}
}
}
}
}
return Pi(flag == d[s], d[0]);
}
signed main() {
int N, M, P;
cin >> N >> M >> P;
Graph G(N);
for (int i = 0; i < M; i++) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
c -= P;
c = -1 * c;
G[b].push_back(a);
WG[b].push_back(Pi(a, c));
}
// DAG dg(G);
// dg.tsort();
// if (dg.is_acyclic == false) {
// cout << -1 << endl;
// return 0;
// }
Pi A = bellman_ford(WG, d, N, N - 1);
if (!A.first) {
cout << -1 << endl;
return 0;
} else {
if (A.second <= -1 * INF / 100) {
cout << -1 << endl;
} else if (A.second > 0) {
cout << 0 << endl;
} else {
cout << -1 * A.second << endl;
}
}
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 750,858 | 750,859 | u703205079 | cpp |
p02949 |
#include <climits>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
class BellmanFord {
class Edge {
int from, to; // 2端点のインデックス
int weight; // コスト
public:
Edge(int n, int m, int w) {
from = n;
to = m;
weight = w;
}
int GetFrom() { return from; }
int GetTo() { return to; }
int GetWeight() { return weight; }
};
int node_num;
vector<Edge> edges;
int *distances;
int start;
int end;
public:
BellmanFord(int n, int s, int e) {
node_num = n;
start = s;
end = e;
distances = new int[n];
}
~BellmanFord() { delete[] distances; }
void AddEdge(int from, int to, int weight) {
Edge edge(from, to, weight);
edges.push_back(edge);
}
int ShortestPath(bool &has_roop) {
// initialise
for (int i = 0; i < node_num; i++) {
distances[i] = (i == start) ? 0 : INT_MAX;
}
has_roop = false;
// back traceしてゴールにたどり着き得る頂点を得る
vector<Edge>::iterator itr, itr_end = edges.end();
vector<int> reached(node_num, 0);
reached[end] = 1;
priority_queue<int> queue;
queue.push(end);
while (!queue.size()) {
int cur = queue.top();
queue.pop();
for (itr = edges.begin(); itr != itr_end; itr++) {
if (cur != itr->GetTo())
continue; // curを接続するedgeでない
if (reached[itr->GetFrom()] == 1)
continue; // 検索済み
reached[itr->GetFrom()] = 1;
queue.push(itr->GetFrom());
}
}
for (int i = 0; i < node_num; i++) {
for (itr = edges.begin(); itr != itr_end; itr++) {
int from_cost = distances[itr->GetFrom()];
int to_cost = distances[itr->GetTo()];
if (!reached[itr->GetTo()])
continue; // さし先が無関係
if (from_cost == INT_MAX)
continue; // 1度も訪れていない
int new_dist = from_cost + itr->GetWeight();
if (new_dist < to_cost) {
distances[itr->GetTo()] = new_dist;
if (i == node_num - 1) {
// ループがなければ、1回のコスト更新で1つの頂点の経路が確定
// つまり、node_num-1回ですべての頂点の経路の最小値が決まる
// node_num回目の更新ができるとすると、ループがある
has_roop = true;
break;
}
}
}
}
return distances[end];
}
};
int main() {
int n, m, p;
cin >> n >> m >> p;
BellmanFord bellman(n, 0, n - 1);
int a, b, c;
for (int i = 0; i < m; i++) {
cin >> a >> b >> c;
c = c - p;
a = a - 1;
b = b - 1;
// 最短経路を求めるアルゴリズムなので-1をかける
c *= -1;
bellman.AddEdge(a, b, c);
}
bool has_roop = false;
int dist = bellman.ShortestPath(has_roop);
if (has_roop)
cout << "-1" << endl;
else {
dist *= -1; // スコアの符号を戻す
if (dist < 0)
dist = 0;
cout << dist << endl;
}
return 0;
} | #include <climits>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
class BellmanFord {
class Edge {
int from, to; // 2端点のインデックス
int weight; // コスト
public:
Edge(int n, int m, int w) {
from = n;
to = m;
weight = w;
}
int GetFrom() { return from; }
int GetTo() { return to; }
int GetWeight() { return weight; }
};
int node_num;
vector<Edge> edges;
int *distances;
int start;
int end;
public:
BellmanFord(int n, int s, int e) {
node_num = n;
start = s;
end = e;
distances = new int[n];
}
~BellmanFord() { delete[] distances; }
void AddEdge(int from, int to, int weight) {
Edge edge(from, to, weight);
edges.push_back(edge);
}
int ShortestPath(bool &has_roop) {
// initialise
for (int i = 0; i < node_num; i++) {
distances[i] = (i == start) ? 0 : INT_MAX;
}
has_roop = false;
// back traceしてゴールにたどり着き得る頂点を得る
vector<Edge>::iterator itr, itr_end = edges.end();
vector<int> reached(node_num, 0);
reached[end] = 1;
priority_queue<int> queue;
queue.push(end);
while (queue.size()) {
int cur = queue.top();
queue.pop();
for (itr = edges.begin(); itr != itr_end; itr++) {
if (cur != itr->GetTo())
continue; // curを接続するedgeでない
if (reached[itr->GetFrom()] == 1)
continue; // 検索済み
reached[itr->GetFrom()] = 1;
queue.push(itr->GetFrom());
}
}
for (int i = 0; i < node_num; i++) {
for (itr = edges.begin(); itr != itr_end; itr++) {
int from_cost = distances[itr->GetFrom()];
int to_cost = distances[itr->GetTo()];
if (!reached[itr->GetTo()])
continue; // さし先が無関係
if (from_cost == INT_MAX)
continue; // 1度も訪れていない
int new_dist = from_cost + itr->GetWeight();
if (new_dist < to_cost) {
distances[itr->GetTo()] = new_dist;
if (i == node_num - 1) {
// ループがなければ、1回のコスト更新で1つの頂点の経路が確定
// つまり、node_num-1回ですべての頂点の経路の最小値が決まる
// node_num回目の更新ができるとすると、ループがある
has_roop = true;
break;
}
}
}
}
return distances[end];
}
};
int main() {
int n, m, p;
cin >> n >> m >> p;
BellmanFord bellman(n, 0, n - 1);
int a, b, c;
for (int i = 0; i < m; i++) {
cin >> a >> b >> c;
c = c - p;
a = a - 1;
b = b - 1;
// 最短経路を求めるアルゴリズムなので-1をかける
c *= -1;
bellman.AddEdge(a, b, c);
}
bool has_roop = false;
int dist = bellman.ShortestPath(has_roop);
if (has_roop)
cout << "-1" << endl;
else {
dist *= -1; // スコアの符号を戻す
if (dist < 0)
dist = 0;
cout << dist << endl;
}
return 0;
} | [
"expression.operation.unary.logical.remove",
"control_flow.loop.condition.change"
] | 750,862 | 750,863 | u924514474 | cpp |
p02949 | #pragma GCC optimize("O3")
#include "bits/stdc++.h"
using namespace std;
using ll = long long int;
#define debugos cout
#define debug(v) \
{ \
printf("L%d %s > ", __LINE__, #v); \
debugos << (v) << endl; \
}
#define debugv(v) \
{ \
printf("L%d %s > ", __LINE__, #v); \
for (auto e : (v)) { \
debugos << e << " "; \
} \
debugos << endl; \
}
#define debuga(m, w) \
{ \
printf("L%d %s > ", __LINE__, #m); \
for (int x = 0; x < (w); x++) { \
debugos << (m)[x] << " "; \
} \
debugos << endl; \
}
#define debugaa(m, h, w) \
{ \
printf("L%d %s >\n", __LINE__, #m); \
for (int y = 0; y < (h); y++) { \
for (int x = 0; x < (w); x++) { \
debugos << (m)[y][x] << " "; \
} \
debugos << endl; \
} \
}
#define all(v) (v).begin(), (v).end()
#define repeat(cnt, l) for (auto cnt = decltype(l)(); (cnt) < (l); ++(cnt))
#define rrepeat(cnt, l) for (auto cnt = (l)-1; 0 <= (cnt); --(cnt))
#define iterate(cnt, b, e) for (auto cnt = (b); (cnt) != (e); ++(cnt))
#define diterate(cnt, b, e) for (auto cnt = (b); (cnt) != (e); --(cnt))
const ll MD = 1000000007ll;
const long double PI = 3.1415926535897932384626433832795L;
inline void assert_call(bool assertion, function<void()> f) {
if (!assertion) {
cerr << "assertion fault:" << endl;
f();
abort();
}
}
template <typename T1, typename T2>
inline ostream &operator<<(ostream &o, const pair<T1, T2> p) {
o << '(' << p.first << ':' << p.second << ')';
return o;
}
template <typename Vec>
inline ostream &_ostream_vecprint(ostream &os, const Vec &a) {
os << '[';
for (const auto &e : a)
os << ' ' << e << ' ';
os << ']';
return os;
}
template <typename T>
inline ostream &operator<<(ostream &o, const vector<T> &v) {
return _ostream_vecprint(o, v);
}
template <typename T, size_t S>
inline ostream &operator<<(ostream &o, const array<T, S> &v) {
return _ostream_vecprint(o, v);
}
template <typename T> inline T &chmax(T &to, const T &val) {
return to = max(to, val);
}
template <typename T> inline T &chmin(T &to, const T &val) {
return to = min(to, val);
}
void bye(string s, int code = 0) {
cout << s << endl;
exit(code);
}
mt19937_64 randdev(8901016);
template <typename T, typename Random = decltype(randdev),
typename enable_if<is_integral<T>::value>::type * = nullptr>
inline T rand(T l, T h, Random &rand = randdev) {
return uniform_int_distribution<T>(l, h)(rand);
}
template <typename T, typename Random = decltype(randdev),
typename enable_if<is_floating_point<T>::value>::type * = nullptr>
inline T rand(T l, T h, Random &rand = randdev) {
return uniform_real_distribution<T>(l, h)(rand);
}
#if defined(_WIN32) || defined(_WIN64)
#define getc_x _getc_nolock
#define putc_x _putc_nolock
#elif defined(__GNUC__)
#define getc_x getc_unlocked
#define putc_x putc_unlocked
#else
#define getc_x getc
#define putc_x putc
#endif
#define isvisiblechar(c) (0x21 <= (c) && (c) <= 0x7E)
class MaiScanner {
FILE *fp_;
public:
inline MaiScanner(FILE *fp) : fp_(fp) {}
template <typename T> void input_integer(T &var) noexcept {
var = 0;
T sign = 1;
int cc = getc_x(fp_);
for (; cc < '0' || '9' < cc; cc = getc_x(fp_))
if (cc == '-')
sign = -1;
for (; '0' <= cc && cc <= '9'; cc = getc_x(fp_))
var = (var << 3) + (var << 1) + cc - '0';
var = var * sign;
}
inline int c() noexcept { return getc_x(fp_); }
inline MaiScanner &operator>>(int &var) noexcept {
input_integer<int>(var);
return *this;
}
inline MaiScanner &operator>>(long long &var) noexcept {
input_integer<long long>(var);
return *this;
}
inline MaiScanner &operator>>(string &var) {
int cc = getc_x(fp_);
for (; !isvisiblechar(cc); cc = getc_x(fp_))
;
for (; isvisiblechar(cc); cc = getc_x(fp_))
var.push_back(cc);
return *this;
}
template <typename IT> inline void in(IT begin, IT end) {
for (auto it = begin; it != end; ++it)
*this >> *it;
}
};
class MaiPrinter {
FILE *fp_;
public:
inline MaiPrinter(FILE *fp) : fp_(fp) {}
template <typename T> void output_integer(T var) noexcept {
if (var == 0) {
putc_x('0', fp_);
return;
}
if (var < 0)
putc_x('-', fp_), var = -var;
char stack[32];
int stack_p = 0;
while (var)
stack[stack_p++] = '0' + (var % 10), var /= 10;
while (stack_p)
putc_x(stack[--stack_p], fp_);
}
inline MaiPrinter &operator<<(char c) noexcept {
putc_x(c, fp_);
return *this;
}
inline MaiPrinter &operator<<(int var) noexcept {
output_integer<int>(var);
return *this;
}
inline MaiPrinter &operator<<(long long var) noexcept {
output_integer<long long>(var);
return *this;
}
inline MaiPrinter &operator<<(char *str_p) noexcept {
while (*str_p)
putc_x(*(str_p++), fp_);
return *this;
}
inline MaiPrinter &operator<<(const string &str) {
const char *p = str.c_str();
const char *l = p + str.size();
while (p < l)
putc_x(*p++, fp_);
return *this;
}
template <typename IT> void join(IT begin, IT end, char sep = ' ') {
for (bool b = 0; begin != end; ++begin, b = 1)
b ? *this << sep << *begin : *this << *begin;
}
};
MaiScanner scanner(stdin);
MaiPrinter printer(stdout);
class DGraphE {
public:
using W_T = ll;
struct Arc {
int from, to;
W_T value;
Arc(int f = 0, int t = 0, W_T value = 0) : from(f), to(t), value(value) {}
inline int pair(int _v) const { return _v == to ? from : to; }
};
size_t n;
vector<vector<int>> vertex_to;
vector<vector<int>> vertex_from;
vector<Arc> arcs;
DGraphE(int n = 1) : n(n), vertex_to(n), vertex_from(n) {}
inline size_t size() const { return n; }
void resize(size_t _n) {
n = _n;
vertex_to.resize(_n);
vertex_from.resize(_n);
}
void connect(int from, int to, W_T val = 0) {
vertex_to[(size_t)from].push_back((int)arcs.size());
vertex_from[(size_t)to].push_back((int)arcs.size());
arcs.emplace_back(from, to, val);
}
};
class DGraph {
public:
size_t n;
vector<vector<int>> vertex_to;
vector<vector<int>> vertex_from;
DGraph(size_t n = 1) : n(n), vertex_to(n), vertex_from(n) {}
inline size_t size() const { return n; }
void resize(size_t _n) {
n = _n;
vertex_to.resize(_n);
vertex_from.resize(_n);
}
void connect(int from, int to) {
vertex_to[(size_t)from].emplace_back(to);
vertex_from[(size_t)to].emplace_back(from);
}
};
vector<int> dijkstraD(const DGraph &graph, int startIndex) {
vector<int> dist(graph.size(), numeric_limits<int>::max());
queue<pair<int, int>> que; // <dist, idx>
que.emplace(0, startIndex);
dist[startIndex] = 0;
while (!que.empty()) {
int d = que.front().first;
int v = que.front().second;
que.pop();
if (dist[v] < d)
continue;
for (int u : graph.vertex_to[v])
if (d + 1 < dist[u])
que.emplace(dist[u] = d + 1, u);
}
return move(dist);
}
vector<DGraphE::W_T> bellmanFord(int n, const vector<DGraphE::Arc> &arcs,
int start = 0) {
using T = DGraphE::W_T;
vector<T> dist(n, numeric_limits<T>::min());
dist[start] = 0;
bool running = true;
while (running && --n >= 0) {
running = false;
for (auto &arc : arcs) {
if (dist[arc.to] < dist[arc.from] + arc.value) {
dist[arc.to] = dist[arc.from] + arc.value;
running = true;
if (n <= 0)
return vector<T>();
}
}
}
return dist;
}
//
int N, M;
ll P;
vector<array<int, 3>> edges;
//
int main() {
scanner >> N >> M >> P;
DGraph dg(N);
DGraph dgr(N);
repeat(i, M) {
int a, b, c;
scanner >> a >> b >> c;
--a;
--b;
edges.push_back({a, b, c - P});
dg.connect(a, b);
dgr.connect(b, a);
}
auto va = dijkstraD(dgr, N - 1);
auto vb = dijkstraD(dg, 0);
vector<DGraphE::Arc> arcs;
for (auto e : edges) {
if (va[e[0]] < N && va[e[1]] < N && vb[e[0]] < N && vb[e[1]] < N)
arcs.emplace_back(e[0], e[1], e[2]);
}
auto d = bellmanFord(N, arcs);
if (d.empty())
bye("-1");
cout << max(0ll, d[N - 1]) << endl;
return 0;
}
| #pragma GCC optimize("O3")
#include "bits/stdc++.h"
using namespace std;
using ll = long long int;
#define debugos cout
#define debug(v) \
{ \
printf("L%d %s > ", __LINE__, #v); \
debugos << (v) << endl; \
}
#define debugv(v) \
{ \
printf("L%d %s > ", __LINE__, #v); \
for (auto e : (v)) { \
debugos << e << " "; \
} \
debugos << endl; \
}
#define debuga(m, w) \
{ \
printf("L%d %s > ", __LINE__, #m); \
for (int x = 0; x < (w); x++) { \
debugos << (m)[x] << " "; \
} \
debugos << endl; \
}
#define debugaa(m, h, w) \
{ \
printf("L%d %s >\n", __LINE__, #m); \
for (int y = 0; y < (h); y++) { \
for (int x = 0; x < (w); x++) { \
debugos << (m)[y][x] << " "; \
} \
debugos << endl; \
} \
}
#define all(v) (v).begin(), (v).end()
#define repeat(cnt, l) for (auto cnt = decltype(l)(); (cnt) < (l); ++(cnt))
#define rrepeat(cnt, l) for (auto cnt = (l)-1; 0 <= (cnt); --(cnt))
#define iterate(cnt, b, e) for (auto cnt = (b); (cnt) != (e); ++(cnt))
#define diterate(cnt, b, e) for (auto cnt = (b); (cnt) != (e); --(cnt))
const ll MD = 1000000007ll;
const long double PI = 3.1415926535897932384626433832795L;
inline void assert_call(bool assertion, function<void()> f) {
if (!assertion) {
cerr << "assertion fault:" << endl;
f();
abort();
}
}
template <typename T1, typename T2>
inline ostream &operator<<(ostream &o, const pair<T1, T2> p) {
o << '(' << p.first << ':' << p.second << ')';
return o;
}
template <typename Vec>
inline ostream &_ostream_vecprint(ostream &os, const Vec &a) {
os << '[';
for (const auto &e : a)
os << ' ' << e << ' ';
os << ']';
return os;
}
template <typename T>
inline ostream &operator<<(ostream &o, const vector<T> &v) {
return _ostream_vecprint(o, v);
}
template <typename T, size_t S>
inline ostream &operator<<(ostream &o, const array<T, S> &v) {
return _ostream_vecprint(o, v);
}
template <typename T> inline T &chmax(T &to, const T &val) {
return to = max(to, val);
}
template <typename T> inline T &chmin(T &to, const T &val) {
return to = min(to, val);
}
void bye(string s, int code = 0) {
cout << s << endl;
exit(code);
}
mt19937_64 randdev(8901016);
template <typename T, typename Random = decltype(randdev),
typename enable_if<is_integral<T>::value>::type * = nullptr>
inline T rand(T l, T h, Random &rand = randdev) {
return uniform_int_distribution<T>(l, h)(rand);
}
template <typename T, typename Random = decltype(randdev),
typename enable_if<is_floating_point<T>::value>::type * = nullptr>
inline T rand(T l, T h, Random &rand = randdev) {
return uniform_real_distribution<T>(l, h)(rand);
}
#if defined(_WIN32) || defined(_WIN64)
#define getc_x _getc_nolock
#define putc_x _putc_nolock
#elif defined(__GNUC__)
#define getc_x getc_unlocked
#define putc_x putc_unlocked
#else
#define getc_x getc
#define putc_x putc
#endif
#define isvisiblechar(c) (0x21 <= (c) && (c) <= 0x7E)
class MaiScanner {
FILE *fp_;
public:
inline MaiScanner(FILE *fp) : fp_(fp) {}
template <typename T> void input_integer(T &var) noexcept {
var = 0;
T sign = 1;
int cc = getc_x(fp_);
for (; cc < '0' || '9' < cc; cc = getc_x(fp_))
if (cc == '-')
sign = -1;
for (; '0' <= cc && cc <= '9'; cc = getc_x(fp_))
var = (var << 3) + (var << 1) + cc - '0';
var = var * sign;
}
inline int c() noexcept { return getc_x(fp_); }
inline MaiScanner &operator>>(int &var) noexcept {
input_integer<int>(var);
return *this;
}
inline MaiScanner &operator>>(long long &var) noexcept {
input_integer<long long>(var);
return *this;
}
inline MaiScanner &operator>>(string &var) {
int cc = getc_x(fp_);
for (; !isvisiblechar(cc); cc = getc_x(fp_))
;
for (; isvisiblechar(cc); cc = getc_x(fp_))
var.push_back(cc);
return *this;
}
template <typename IT> inline void in(IT begin, IT end) {
for (auto it = begin; it != end; ++it)
*this >> *it;
}
};
class MaiPrinter {
FILE *fp_;
public:
inline MaiPrinter(FILE *fp) : fp_(fp) {}
template <typename T> void output_integer(T var) noexcept {
if (var == 0) {
putc_x('0', fp_);
return;
}
if (var < 0)
putc_x('-', fp_), var = -var;
char stack[32];
int stack_p = 0;
while (var)
stack[stack_p++] = '0' + (var % 10), var /= 10;
while (stack_p)
putc_x(stack[--stack_p], fp_);
}
inline MaiPrinter &operator<<(char c) noexcept {
putc_x(c, fp_);
return *this;
}
inline MaiPrinter &operator<<(int var) noexcept {
output_integer<int>(var);
return *this;
}
inline MaiPrinter &operator<<(long long var) noexcept {
output_integer<long long>(var);
return *this;
}
inline MaiPrinter &operator<<(char *str_p) noexcept {
while (*str_p)
putc_x(*(str_p++), fp_);
return *this;
}
inline MaiPrinter &operator<<(const string &str) {
const char *p = str.c_str();
const char *l = p + str.size();
while (p < l)
putc_x(*p++, fp_);
return *this;
}
template <typename IT> void join(IT begin, IT end, char sep = ' ') {
for (bool b = 0; begin != end; ++begin, b = 1)
b ? *this << sep << *begin : *this << *begin;
}
};
MaiScanner scanner(stdin);
MaiPrinter printer(stdout);
class DGraphE {
public:
using W_T = ll;
struct Arc {
int from, to;
W_T value;
Arc(int f = 0, int t = 0, W_T value = 0) : from(f), to(t), value(value) {}
inline int pair(int _v) const { return _v == to ? from : to; }
};
size_t n;
vector<vector<int>> vertex_to;
vector<vector<int>> vertex_from;
vector<Arc> arcs;
DGraphE(int n = 1) : n(n), vertex_to(n), vertex_from(n) {}
inline size_t size() const { return n; }
void resize(size_t _n) {
n = _n;
vertex_to.resize(_n);
vertex_from.resize(_n);
}
void connect(int from, int to, W_T val = 0) {
vertex_to[(size_t)from].push_back((int)arcs.size());
vertex_from[(size_t)to].push_back((int)arcs.size());
arcs.emplace_back(from, to, val);
}
};
class DGraph {
public:
size_t n;
vector<vector<int>> vertex_to;
vector<vector<int>> vertex_from;
DGraph(size_t n = 1) : n(n), vertex_to(n), vertex_from(n) {}
inline size_t size() const { return n; }
void resize(size_t _n) {
n = _n;
vertex_to.resize(_n);
vertex_from.resize(_n);
}
void connect(int from, int to) {
vertex_to[(size_t)from].emplace_back(to);
vertex_from[(size_t)to].emplace_back(from);
}
};
vector<int> dijkstraD(const DGraph &graph, int startIndex) {
vector<int> dist(graph.size(), numeric_limits<int>::max());
queue<pair<int, int>> que; // <dist, idx>
que.emplace(0, startIndex);
dist[startIndex] = 0;
while (!que.empty()) {
int d = que.front().first;
int v = que.front().second;
que.pop();
if (dist[v] < d)
continue;
for (int u : graph.vertex_to[v])
if (d + 1 < dist[u])
que.emplace(dist[u] = d + 1, u);
}
return move(dist);
}
vector<DGraphE::W_T> bellmanFord(int n, const vector<DGraphE::Arc> &arcs,
int start = 0) {
using T = DGraphE::W_T;
vector<T> dist(n, numeric_limits<T>::min() / 2);
dist[start] = 0;
bool running = true;
while (running && --n >= 0) {
running = false;
for (auto &arc : arcs) {
if (dist[arc.to] < dist[arc.from] + arc.value) {
dist[arc.to] = dist[arc.from] + arc.value;
running = true;
if (n <= 0)
return vector<T>();
}
}
}
return dist;
}
//
int N, M;
ll P;
vector<array<int, 3>> edges;
//
int main() {
scanner >> N >> M >> P;
DGraph dg(N);
DGraph dgr(N);
repeat(i, M) {
int a, b, c;
scanner >> a >> b >> c;
--a;
--b;
edges.push_back({a, b, c - P});
dg.connect(a, b);
dgr.connect(b, a);
}
auto va = dijkstraD(dgr, N - 1);
auto vb = dijkstraD(dg, 0);
vector<DGraphE::Arc> arcs;
for (auto e : edges) {
if (va[e[0]] < N && va[e[1]] < N && vb[e[0]] < N && vb[e[1]] < N)
arcs.emplace_back(e[0], e[1], e[2]);
}
auto d = bellmanFord(N, arcs);
if (d.empty())
bye("-1");
cout << max(0ll, d[N - 1]) << endl;
return 0;
}
| [
"assignment.change"
] | 750,870 | 750,871 | u079330987 | cpp |
p02949 | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
void *wmem;
template <class T> inline void walloc1d(T **arr, int x, void **mem = &wmem) {
static int skip[16] = {0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
(*mem) = (void *)(((char *)(*mem)) + skip[((unsigned long long)(*mem)) & 15]);
(*arr) = (T *)(*mem);
(*mem) = ((*arr) + x);
}
inline void rd(int &x) {
int k, m = 0;
x = 0;
for (;;) {
k = getchar_unlocked();
if (k == '-') {
m = 1;
break;
}
if ('0' <= k && k <= '9') {
x = k - '0';
break;
}
}
for (;;) {
k = getchar_unlocked();
if (k < '0' || k > '9') {
break;
}
x = x * 10 + k - '0';
}
if (m) {
x = -x;
}
}
inline void wt_L(char a) { putchar_unlocked(a); }
inline void wt_L(long long x) {
char f[20];
int m = 0, s = 0;
if (x < 0) {
m = 1;
x = -x;
}
while (x) {
f[s++] = x % 10;
x /= 10;
}
if (!s) {
f[s++] = 0;
}
if (m) {
putchar_unlocked('-');
}
while (s--) {
putchar_unlocked(f[s] + '0');
}
}
template <class T> struct DijkstraHeap {
T *val;
char *visited;
int *hp, *place, size;
void malloc(int N) {
hp = (int *)std::malloc(N * sizeof(int));
place = (int *)std::malloc(N * sizeof(int));
visited = (char *)std::malloc(N * sizeof(char));
val = (T *)std::malloc(N * sizeof(T));
}
void free() {
std::free(hp);
std::free(place);
std::free(visited);
std::free(val);
}
void walloc(int N, void **mem = &wmem) {
walloc1d(&hp, N, mem);
walloc1d(&place, N, mem);
walloc1d(&visited, N, mem);
walloc1d(&val, N, mem);
}
void init(int N) {
int i;
size = 0;
for (i = 0; i < (N); i++) {
place[i] = -1;
}
for (i = 0; i < (N); i++) {
visited[i] = 0;
}
}
void up(int n) {
int m;
while (n) {
m = (n - 1) / 2;
if (val[hp[m]] <= val[hp[n]]) {
break;
}
swap(hp[m], hp[n]);
swap(place[hp[m]], place[hp[n]]);
n = m;
}
}
void down(int n) {
int m;
for (;;) {
m = 2 * n + 1;
if (m >= size) {
break;
}
if (m + 1 < size && val[hp[m]] > val[hp[m + 1]]) {
m++;
}
if (val[hp[m]] >= val[hp[n]]) {
break;
}
swap(hp[m], hp[n]);
swap(place[hp[m]], place[hp[n]]);
n = m;
}
}
void change(int n, T v) {
if (visited[n] || (place[n] >= 0 && val[n] <= v)) {
return;
}
val[n] = v;
if (place[n] == -1) {
place[n] = size;
hp[size++] = n;
up(place[n]);
} else {
up(place[n]);
}
}
int pop(void) {
int res = hp[0];
place[res] = -1;
size--;
if (size) {
hp[0] = hp[size];
place[hp[0]] = 0;
down(0);
}
visited[res] = 1;
return res;
}
};
struct graph {
int N, **edge, *es;
void setEdge(int N__, int M, int A[], int B[], void **mem = &wmem) {
int i;
N = N__;
walloc1d(&es, N, mem);
walloc1d(&edge, N, mem);
for (i = 0; i < (N); i++) {
es[i] = 0;
}
for (i = 0; i < (M); i++) {
es[A[i]]++;
es[B[i]]++;
}
for (i = 0; i < (N); i++) {
walloc1d(&edge[i], es[i], mem);
}
for (i = 0; i < (N); i++) {
es[i] = 0;
}
for (i = 0; i < (M); i++) {
edge[A[i]][es[A[i]]++] = B[i];
edge[B[i]][es[B[i]]++] = A[i];
}
}
void setDirectEdge(int N__, int M, int A[], int B[], void **mem = &wmem) {
int i;
N = N__;
walloc1d(&es, N, mem);
walloc1d(&edge, N, mem);
walloc1d(&edge[0], M, mem);
for (i = 0; i < (N); i++) {
es[i] = 0;
}
for (i = 0; i < (M); i++) {
es[A[i]]++;
}
for (i = 0; i < (N); i++) {
walloc1d(&edge[i], es[i], mem);
}
for (i = 0; i < (N); i++) {
es[i] = 0;
}
for (i = 0; i < (M); i++) {
edge[A[i]][es[A[i]]++] = B[i];
}
}
graph reverse(void **mem = &wmem) {
graph g;
int i, j, k;
g.N = N;
walloc1d(&g.es, N, mem);
walloc1d(&g.edge, N, mem);
for (i = 0; i < (N); i++) {
g.es[i] = 0;
}
for (i = 0; i < (N); i++) {
for (j = 0; j < (es[i]); j++) {
g.es[edge[i][j]]++;
}
}
for (i = 0; i < (N); i++) {
walloc1d(&g.edge[i], g.es[i]);
}
for (i = 0; i < (N); i++) {
g.es[i] = 0;
}
for (i = 0; i < (N); i++) {
for (j = 0; j < (es[i]); j++) {
k = edge[i][j];
g.edge[k][g.es[k]++] = i;
}
}
return g;
}
graph reduce(int tn, int ind[], int self_e = 0, int dep_e = 0,
void **mem = &wmem) {
graph g;
int M = 0, i, j, k, x, y;
pair<int, int> *A;
for (i = 0; i < (N); i++) {
M += es[i];
}
A = (pair<int, int> *)((int *)((int **)(*mem) + tn) + tn + M);
M = 0;
for (i = 0; i < (N); i++) {
x = ind[i];
if (x < 0) {
continue;
}
for (j = 0; j < (es[i]); j++) {
y = ind[edge[i][j]];
if (y < 0) {
continue;
}
if (self_e == 0 && x == y) {
continue;
}
A[M++] = make_pair(x, y);
}
}
if (dep_e == 0) {
sort(A, A + M);
k = 0;
for (i = 0; i < (M); i++) {
if (k && A[k - 1] == A[i]) {
continue;
}
A[k++] = A[i];
}
M = k;
}
g.N = tn;
g.es = (int *)(*mem);
g.edge = (int **)(g.es + tn);
g.edge[0] = (int *)(g.edge + tn);
for (i = 0; i < (tn); i++) {
g.es[i] = 0;
}
for (i = 0; i < (M); i++) {
g.es[A[i].first]++;
}
for (i = (1); i < (tn); i++) {
g.edge[i] = g.edge[i - 1] + g.es[i - 1];
}
*mem = g.edge[tn - 1] + g.es[tn - 1];
for (i = 0; i < (tn); i++) {
g.es[i] = 0;
}
for (i = 0; i < (M); i++) {
j = A[i].first;
k = A[i].second;
g.edge[j][g.es[j]++] = k;
}
return g;
}
void getDist(int root, int res[], void *mem = wmem) {
int i, j, k, *q, s, z;
walloc1d(&q, N, &mem);
for (i = 0; i < (N); i++) {
res[i] = -1;
}
res[root] = 0;
s = 0;
z = 1;
q[0] = root;
while (z) {
i = q[s++];
z--;
for (j = 0; j < (es[i]); j++) {
k = edge[i][j];
if (res[k] >= 0) {
continue;
}
res[k] = res[i] + 1;
q[s + z++] = k;
}
}
}
inline int sccDFS(int num[], int st, int mx) {
int i, j;
num[st] = -2;
for (i = 0; i < (es[st]); i++) {
j = edge[st][i];
if (num[j] == -1) {
mx = sccDFS(num, j, mx);
}
}
num[st] = mx;
return mx + 1;
}
int scc(int res[], void *mem = wmem) {
graph r;
int i, j, k, *nrv, *num, ret = 0, *st, st_size;
r = reverse(&mem);
walloc1d(&st, N, &mem);
walloc1d(&num, N, &mem);
walloc1d(&nrv, N, &mem);
for (i = 0; i < (N); i++) {
res[i] = num[i] = -1;
}
k = 0;
for (i = 0; i < (N); i++) {
if (num[i] == -1) {
k = sccDFS(num, i, k);
}
}
for (i = 0; i < (N); i++) {
nrv[num[i]] = i;
}
for (k = N - 1; k >= 0; k--) {
i = nrv[k];
if (res[i] >= 0) {
continue;
}
res[i] = ret;
st_size = 0;
st[st_size++] = i;
while (st_size) {
i = st[--st_size];
for (j = 0; j < (r.es[i]); j++) {
if (res[r.edge[i][j]] == -1) {
res[r.edge[i][j]] = ret;
st[st_size++] = r.edge[i][j];
}
}
}
ret++;
}
return ret;
}
inline void bccDFS(int v, int u, int *res, int *rt, int &rts, int *S, int &Ss,
int *inS, int *num, int &tm) {
int i, k;
num[v] = ++tm;
S[Ss++] = v;
inS[v] = 1;
rt[rts++] = v;
for (i = 0; i < (es[v]); i++) {
int w = edge[v][i];
if (!num[w]) {
bccDFS(w, v, res, rt, rts, S, Ss, inS, num, tm);
} else if (u != w && inS[w]) {
while (num[rt[rts - 1]] > num[w]) {
rts--;
}
}
}
if (v == rt[rts - 1]) {
k = S[Ss - 1];
for (;;) {
int w = S[--Ss];
inS[w] = 0;
res[w] = k;
if (v == w) {
break;
}
}
rts--;
}
}
int bcc(int res[], void *mem = wmem) {
int *S, Ss = 0, i, *inS, k, *num, *rt, rts = 0, tm = 0;
pair<int, int> *arr;
walloc1d(&num, N, &mem);
walloc1d(&rt, N, &mem);
walloc1d(&S, N, &mem);
walloc1d(&inS, N, &mem);
memset(num, 0, sizeof(int) * N);
memset(inS, 0, sizeof(int) * N);
for (i = 0; i < (N); i++) {
if (!num[i]) {
bccDFS(i, N, res, rt, rts, S, Ss, inS, num, tm);
}
}
arr = (pair<int, int> *)mem;
for (i = 0; i < (N); i++) {
arr[i].first = res[i];
arr[i].second = i;
}
sort(arr, arr + N);
k = 0;
for (i = 0; i < (N); i++) {
if (i && arr[i].first != arr[i - 1].first) {
k++;
}
res[arr[i].second] = k;
}
return k + 1;
}
int shortestPath(const int s, const int t, int res[], void *mem = wmem) {
int *b, i, j, k, *q, qe = 0, qs = 0;
walloc1d(&b, N, &mem);
walloc1d(&q, N, &mem);
for (i = 0; i < (N); i++) {
b[i] = -1;
}
b[s] = -2;
q[qe++] = s;
while (qe > qs) {
i = q[qs++];
for (j = 0; j < (es[i]); j++) {
k = edge[i][j];
if (b[k] != -1) {
continue;
}
b[k] = i;
q[qe++] = k;
}
if (b[t] != -1) {
break;
}
}
if (b[t] == -1) {
return -1;
}
k = 0;
res[k] = i = t;
while (i != s) {
res[++k] = (i = b[i]);
}
std::reverse(res, res + k + 1);
return k;
}
int TopologicalSort(int res[], void *mem = wmem) {
int *deg, i, j, k, *q, qe = 0, qs = 0, rs;
walloc1d(°, N, &mem);
walloc1d(&q, N, &mem);
rs = 0;
for (i = 0; i < (N); i++) {
deg[i] = 0;
}
for (i = 0; i < (N); i++) {
for (j = 0; j < (es[i]); j++) {
deg[edge[i][j]]++;
}
}
for (i = 0; i < (N); i++) {
if (deg[i] == 0) {
q[qe++] = i;
}
}
while (qs < qe) {
i = q[qs++];
res[rs++] = i;
for (j = 0; j < (es[i]); j++) {
k = edge[i][j];
deg[k]--;
if (deg[k] == 0) {
q[qe++] = k;
}
}
}
if (rs == N) {
return 1;
}
return 0;
}
};
template <class T> struct wgraph {
T **cost;
graph g;
int N, **edge, *es;
void setEdge(int N__, int M, int A[], int B[], T C[], void **mem = &wmem) {
int i;
N = N__;
walloc1d(&es, N, mem);
for (i = 0; i < (N); i++) {
es[i] = 0;
}
for (i = 0; i < (M); i++) {
es[A[i]]++;
es[B[i]]++;
}
walloc1d(&edge, N, mem);
for (i = 0; i < (N); i++) {
walloc1d(&edge[i], es[i], mem);
}
walloc1d(&cost, N, mem);
for (i = 0; i < (N); i++) {
walloc1d(&cost[i], es[i], mem);
}
for (i = 0; i < (N); i++) {
es[i] = 0;
}
for (i = 0; i < (M); i++) {
edge[A[i]][es[A[i]]] = B[i];
edge[B[i]][es[B[i]]] = A[i];
cost[A[i]][es[A[i]]++] = C[i];
cost[B[i]][es[B[i]]++] = C[i];
}
g.N = N;
g.es = es;
g.edge = edge;
}
void setDirectEdge(int N__, int M, int A[], int B[], T C[],
void **mem = &wmem) {
int i;
N = N__;
walloc1d(&es, N, mem);
for (i = 0; i < (N); i++) {
es[i] = 0;
}
for (i = 0; i < (M); i++) {
es[A[i]]++;
}
walloc1d(&edge, N, mem);
for (i = 0; i < (N); i++) {
walloc1d(&edge[i], es[i], mem);
}
walloc1d(&cost, N, mem);
for (i = 0; i < (N); i++) {
walloc1d(&cost[i], es[i], mem);
}
for (i = 0; i < (N); i++) {
es[i] = 0;
}
for (i = 0; i < (M); i++) {
edge[A[i]][es[A[i]]] = B[i];
cost[A[i]][es[A[i]]++] = C[i];
}
g.N = N;
g.es = es;
g.edge = edge;
}
template <class S>
void getDist(int root, S res[], S unreachable = -1, void *mem = wmem) {
DijkstraHeap<S> hp;
int i, j;
hp.walloc(N, &mem);
hp.init(N);
hp.change(root, 0);
while (hp.size) {
i = hp.pop();
for (j = 0; j < (es[i]); j++) {
hp.change(edge[i][j], hp.val[i] + cost[i][j]);
}
}
for (i = 0; i < (N); i++) {
res[i] = (hp.visited[i] ? hp.val[i] : unreachable);
}
}
template <class S>
void getDistForest(int root, S res[], S unreachable = -1, void *mem = wmem) {
char *r;
int i, j, k, *q, s, z;
walloc1d(&q, N, &mem);
walloc1d(&r, N, &mem);
for (i = 0; i < (N); i++) {
r[i] = 0;
}
res[root] = 0;
r[root] = 1;
s = 0;
z = 1;
q[0] = root;
while (z) {
i = q[s++];
z--;
for (j = 0; j < (es[i]); j++) {
k = edge[i][j];
if (r[k]) {
continue;
}
res[k] = res[i] + cost[i][j];
r[k] = 1;
q[s + z++] = k;
}
}
for (i = 0; i < (N); i++) {
if (!r[i]) {
res[i] = unreachable;
}
}
}
template <class S>
void BellmanFord(int root, S res[], S unreachable = -1, S minusInf = -2,
int step = -1, void *mem = wmem) {
S *arr;
int KL2GvlyY, i, *inf, j, k, *nx, qe, qs, t, *vis;
walloc1d(&inf, N, &mem);
walloc1d(&vis, N, &mem);
walloc1d(&arr, N, &mem);
walloc1d(&nx, N, &mem);
for (i = 0; i < (N); i++) {
inf[i] = 0;
}
for (i = 0; i < (N); i++) {
vis[i] = 0;
}
for (i = 0; i < (N); i++) {
nx[i] = 0;
}
res[root] = arr[root] = 0;
vis[root] = nx[root] = 1;
t = step;
if (t == -1) {
t = N;
}
for (KL2GvlyY = 0; KL2GvlyY < (t); KL2GvlyY++) {
for (i = 0; i < (N); i++) {
if (vis[i]) {
for (j = 0; j < (es[i]); j++) {
k = edge[i][j];
if (nx[k] == 0 || arr[k] > res[i] + cost[i][j]) {
nx[k] = 1;
arr[k] = res[i] + cost[i][j];
}
}
}
}
for (i = 0; i < (N); i++) {
res[i] = arr[i];
}
for (i = 0; i < (N); i++) {
vis[i] = nx[i];
}
}
if (step == -1) {
for (i = 0; i < (N); i++) {
if (vis[i] == 0) {
res[i] = unreachable;
}
}
return;
}
for (i = 0; i < (N); i++) {
if (vis[i]) {
for (j = 0; j < (es[i]); j++) {
k = edge[i][j];
if (nx[k] == 0 || arr[k] > res[i] + cost[i][j]) {
inf[k] = 1;
}
}
}
}
qs = qe = 0;
for (i = 0; i < (N); i++) {
if (inf[i]) {
nx[qe++] = i;
}
}
while (qs < qe) {
i = nx[qs++];
for (j = 0; j < (es[i]); j++) {
k = edge[i][j];
if (inf[k] == 0) {
inf[k] = 1;
nx[qe++] = k;
}
}
}
for (i = 0; i < (N); i++) {
if (vis[i] == 0) {
res[i] = unreachable;
}
}
for (i = 0; i < (N); i++) {
if (inf[i] == 1) {
res[i] = minusInf;
}
}
}
T MST_Prim_cost(void *mem = wmem) {
DijkstraHeap<T> hp;
T res = 0;
int i, j;
hp.walloc(N, &mem);
hp.init(N);
hp.change(0, 0);
while (hp.size) {
i = hp.pop();
res += hp.val[i];
for (j = 0; j < (es[i]); j++) {
hp.change(edge[i][j], cost[i][j]);
}
}
return res;
}
int MST_Prim_cost(T &res, void *mem = wmem) {
DijkstraHeap<T> hp;
int cnt = 0, i, j;
res = 0;
hp.walloc(N, &mem);
hp.init(N);
hp.change(0, 0);
while (hp.size) {
i = hp.pop();
res += hp.val[i];
cnt++;
for (j = 0; j < (es[i]); j++) {
hp.change(edge[i][j], cost[i][j]);
}
}
if (cnt == N) {
return 1;
}
return 0;
}
};
char memarr[96000000];
int N;
int M;
int A[5000];
int B[5000];
int C[5000];
int P;
long long dist[2500];
int main() {
int i;
long long res;
wgraph<int> g;
wmem = memarr;
rd(N);
rd(M);
rd(P);
{
int Lj4PdHRW;
for (Lj4PdHRW = 0; Lj4PdHRW < (M); Lj4PdHRW++) {
rd(A[Lj4PdHRW]);
A[Lj4PdHRW] += (-1);
rd(B[Lj4PdHRW]);
B[Lj4PdHRW] += (-1);
rd(C[Lj4PdHRW]);
}
}
for (i = 0; i < (M); i++) {
C[i] = P - C[i];
}
g.setDirectEdge(N, M, A, B, C);
g.BellmanFord(0, dist, 0LL, -4611686016279904256LL);
res = dist[N - 1];
if (res == -4611686016279904256LL) {
res = -1;
} else if (res > 0) {
res = 0;
} else {
res = -res;
}
wt_L(res);
wt_L('\n');
return 0;
}
// cLay varsion 20190816-1 [beta]
// --- original code ---
// int N, M, A[5000], B[5000], C[5000], P;
// ll dist[2500];
// {
// int i;
// ll res;
// wgraph<int> g;
//
// rd(N,M,P,(A--,B--,C)(M));
// rep(i,M) C[i] = P - C[i];
// g.setDirectEdge(N,M,A,B,C);
// g.BellmanFord(0, dist, 0LL, -ll_inf);
//
// res = dist[N-1];
// res = if[res==-ll_inf, -1, res>0, 0, -res];
//
// wt(res);
// }
| #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
void *wmem;
template <class T> inline void walloc1d(T **arr, int x, void **mem = &wmem) {
static int skip[16] = {0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
(*mem) = (void *)(((char *)(*mem)) + skip[((unsigned long long)(*mem)) & 15]);
(*arr) = (T *)(*mem);
(*mem) = ((*arr) + x);
}
inline void rd(int &x) {
int k, m = 0;
x = 0;
for (;;) {
k = getchar_unlocked();
if (k == '-') {
m = 1;
break;
}
if ('0' <= k && k <= '9') {
x = k - '0';
break;
}
}
for (;;) {
k = getchar_unlocked();
if (k < '0' || k > '9') {
break;
}
x = x * 10 + k - '0';
}
if (m) {
x = -x;
}
}
inline void wt_L(char a) { putchar_unlocked(a); }
inline void wt_L(long long x) {
char f[20];
int m = 0, s = 0;
if (x < 0) {
m = 1;
x = -x;
}
while (x) {
f[s++] = x % 10;
x /= 10;
}
if (!s) {
f[s++] = 0;
}
if (m) {
putchar_unlocked('-');
}
while (s--) {
putchar_unlocked(f[s] + '0');
}
}
template <class T> struct DijkstraHeap {
T *val;
char *visited;
int *hp, *place, size;
void malloc(int N) {
hp = (int *)std::malloc(N * sizeof(int));
place = (int *)std::malloc(N * sizeof(int));
visited = (char *)std::malloc(N * sizeof(char));
val = (T *)std::malloc(N * sizeof(T));
}
void free() {
std::free(hp);
std::free(place);
std::free(visited);
std::free(val);
}
void walloc(int N, void **mem = &wmem) {
walloc1d(&hp, N, mem);
walloc1d(&place, N, mem);
walloc1d(&visited, N, mem);
walloc1d(&val, N, mem);
}
void init(int N) {
int i;
size = 0;
for (i = 0; i < (N); i++) {
place[i] = -1;
}
for (i = 0; i < (N); i++) {
visited[i] = 0;
}
}
void up(int n) {
int m;
while (n) {
m = (n - 1) / 2;
if (val[hp[m]] <= val[hp[n]]) {
break;
}
swap(hp[m], hp[n]);
swap(place[hp[m]], place[hp[n]]);
n = m;
}
}
void down(int n) {
int m;
for (;;) {
m = 2 * n + 1;
if (m >= size) {
break;
}
if (m + 1 < size && val[hp[m]] > val[hp[m + 1]]) {
m++;
}
if (val[hp[m]] >= val[hp[n]]) {
break;
}
swap(hp[m], hp[n]);
swap(place[hp[m]], place[hp[n]]);
n = m;
}
}
void change(int n, T v) {
if (visited[n] || (place[n] >= 0 && val[n] <= v)) {
return;
}
val[n] = v;
if (place[n] == -1) {
place[n] = size;
hp[size++] = n;
up(place[n]);
} else {
up(place[n]);
}
}
int pop(void) {
int res = hp[0];
place[res] = -1;
size--;
if (size) {
hp[0] = hp[size];
place[hp[0]] = 0;
down(0);
}
visited[res] = 1;
return res;
}
};
struct graph {
int N, **edge, *es;
void setEdge(int N__, int M, int A[], int B[], void **mem = &wmem) {
int i;
N = N__;
walloc1d(&es, N, mem);
walloc1d(&edge, N, mem);
for (i = 0; i < (N); i++) {
es[i] = 0;
}
for (i = 0; i < (M); i++) {
es[A[i]]++;
es[B[i]]++;
}
for (i = 0; i < (N); i++) {
walloc1d(&edge[i], es[i], mem);
}
for (i = 0; i < (N); i++) {
es[i] = 0;
}
for (i = 0; i < (M); i++) {
edge[A[i]][es[A[i]]++] = B[i];
edge[B[i]][es[B[i]]++] = A[i];
}
}
void setDirectEdge(int N__, int M, int A[], int B[], void **mem = &wmem) {
int i;
N = N__;
walloc1d(&es, N, mem);
walloc1d(&edge, N, mem);
walloc1d(&edge[0], M, mem);
for (i = 0; i < (N); i++) {
es[i] = 0;
}
for (i = 0; i < (M); i++) {
es[A[i]]++;
}
for (i = 0; i < (N); i++) {
walloc1d(&edge[i], es[i], mem);
}
for (i = 0; i < (N); i++) {
es[i] = 0;
}
for (i = 0; i < (M); i++) {
edge[A[i]][es[A[i]]++] = B[i];
}
}
graph reverse(void **mem = &wmem) {
graph g;
int i, j, k;
g.N = N;
walloc1d(&g.es, N, mem);
walloc1d(&g.edge, N, mem);
for (i = 0; i < (N); i++) {
g.es[i] = 0;
}
for (i = 0; i < (N); i++) {
for (j = 0; j < (es[i]); j++) {
g.es[edge[i][j]]++;
}
}
for (i = 0; i < (N); i++) {
walloc1d(&g.edge[i], g.es[i]);
}
for (i = 0; i < (N); i++) {
g.es[i] = 0;
}
for (i = 0; i < (N); i++) {
for (j = 0; j < (es[i]); j++) {
k = edge[i][j];
g.edge[k][g.es[k]++] = i;
}
}
return g;
}
graph reduce(int tn, int ind[], int self_e = 0, int dep_e = 0,
void **mem = &wmem) {
graph g;
int M = 0, i, j, k, x, y;
pair<int, int> *A;
for (i = 0; i < (N); i++) {
M += es[i];
}
A = (pair<int, int> *)((int *)((int **)(*mem) + tn) + tn + M);
M = 0;
for (i = 0; i < (N); i++) {
x = ind[i];
if (x < 0) {
continue;
}
for (j = 0; j < (es[i]); j++) {
y = ind[edge[i][j]];
if (y < 0) {
continue;
}
if (self_e == 0 && x == y) {
continue;
}
A[M++] = make_pair(x, y);
}
}
if (dep_e == 0) {
sort(A, A + M);
k = 0;
for (i = 0; i < (M); i++) {
if (k && A[k - 1] == A[i]) {
continue;
}
A[k++] = A[i];
}
M = k;
}
g.N = tn;
g.es = (int *)(*mem);
g.edge = (int **)(g.es + tn);
g.edge[0] = (int *)(g.edge + tn);
for (i = 0; i < (tn); i++) {
g.es[i] = 0;
}
for (i = 0; i < (M); i++) {
g.es[A[i].first]++;
}
for (i = (1); i < (tn); i++) {
g.edge[i] = g.edge[i - 1] + g.es[i - 1];
}
*mem = g.edge[tn - 1] + g.es[tn - 1];
for (i = 0; i < (tn); i++) {
g.es[i] = 0;
}
for (i = 0; i < (M); i++) {
j = A[i].first;
k = A[i].second;
g.edge[j][g.es[j]++] = k;
}
return g;
}
void getDist(int root, int res[], void *mem = wmem) {
int i, j, k, *q, s, z;
walloc1d(&q, N, &mem);
for (i = 0; i < (N); i++) {
res[i] = -1;
}
res[root] = 0;
s = 0;
z = 1;
q[0] = root;
while (z) {
i = q[s++];
z--;
for (j = 0; j < (es[i]); j++) {
k = edge[i][j];
if (res[k] >= 0) {
continue;
}
res[k] = res[i] + 1;
q[s + z++] = k;
}
}
}
inline int sccDFS(int num[], int st, int mx) {
int i, j;
num[st] = -2;
for (i = 0; i < (es[st]); i++) {
j = edge[st][i];
if (num[j] == -1) {
mx = sccDFS(num, j, mx);
}
}
num[st] = mx;
return mx + 1;
}
int scc(int res[], void *mem = wmem) {
graph r;
int i, j, k, *nrv, *num, ret = 0, *st, st_size;
r = reverse(&mem);
walloc1d(&st, N, &mem);
walloc1d(&num, N, &mem);
walloc1d(&nrv, N, &mem);
for (i = 0; i < (N); i++) {
res[i] = num[i] = -1;
}
k = 0;
for (i = 0; i < (N); i++) {
if (num[i] == -1) {
k = sccDFS(num, i, k);
}
}
for (i = 0; i < (N); i++) {
nrv[num[i]] = i;
}
for (k = N - 1; k >= 0; k--) {
i = nrv[k];
if (res[i] >= 0) {
continue;
}
res[i] = ret;
st_size = 0;
st[st_size++] = i;
while (st_size) {
i = st[--st_size];
for (j = 0; j < (r.es[i]); j++) {
if (res[r.edge[i][j]] == -1) {
res[r.edge[i][j]] = ret;
st[st_size++] = r.edge[i][j];
}
}
}
ret++;
}
return ret;
}
inline void bccDFS(int v, int u, int *res, int *rt, int &rts, int *S, int &Ss,
int *inS, int *num, int &tm) {
int i, k;
num[v] = ++tm;
S[Ss++] = v;
inS[v] = 1;
rt[rts++] = v;
for (i = 0; i < (es[v]); i++) {
int w = edge[v][i];
if (!num[w]) {
bccDFS(w, v, res, rt, rts, S, Ss, inS, num, tm);
} else if (u != w && inS[w]) {
while (num[rt[rts - 1]] > num[w]) {
rts--;
}
}
}
if (v == rt[rts - 1]) {
k = S[Ss - 1];
for (;;) {
int w = S[--Ss];
inS[w] = 0;
res[w] = k;
if (v == w) {
break;
}
}
rts--;
}
}
int bcc(int res[], void *mem = wmem) {
int *S, Ss = 0, i, *inS, k, *num, *rt, rts = 0, tm = 0;
pair<int, int> *arr;
walloc1d(&num, N, &mem);
walloc1d(&rt, N, &mem);
walloc1d(&S, N, &mem);
walloc1d(&inS, N, &mem);
memset(num, 0, sizeof(int) * N);
memset(inS, 0, sizeof(int) * N);
for (i = 0; i < (N); i++) {
if (!num[i]) {
bccDFS(i, N, res, rt, rts, S, Ss, inS, num, tm);
}
}
arr = (pair<int, int> *)mem;
for (i = 0; i < (N); i++) {
arr[i].first = res[i];
arr[i].second = i;
}
sort(arr, arr + N);
k = 0;
for (i = 0; i < (N); i++) {
if (i && arr[i].first != arr[i - 1].first) {
k++;
}
res[arr[i].second] = k;
}
return k + 1;
}
int shortestPath(const int s, const int t, int res[], void *mem = wmem) {
int *b, i, j, k, *q, qe = 0, qs = 0;
walloc1d(&b, N, &mem);
walloc1d(&q, N, &mem);
for (i = 0; i < (N); i++) {
b[i] = -1;
}
b[s] = -2;
q[qe++] = s;
while (qe > qs) {
i = q[qs++];
for (j = 0; j < (es[i]); j++) {
k = edge[i][j];
if (b[k] != -1) {
continue;
}
b[k] = i;
q[qe++] = k;
}
if (b[t] != -1) {
break;
}
}
if (b[t] == -1) {
return -1;
}
k = 0;
res[k] = i = t;
while (i != s) {
res[++k] = (i = b[i]);
}
std::reverse(res, res + k + 1);
return k;
}
int TopologicalSort(int res[], void *mem = wmem) {
int *deg, i, j, k, *q, qe = 0, qs = 0, rs;
walloc1d(°, N, &mem);
walloc1d(&q, N, &mem);
rs = 0;
for (i = 0; i < (N); i++) {
deg[i] = 0;
}
for (i = 0; i < (N); i++) {
for (j = 0; j < (es[i]); j++) {
deg[edge[i][j]]++;
}
}
for (i = 0; i < (N); i++) {
if (deg[i] == 0) {
q[qe++] = i;
}
}
while (qs < qe) {
i = q[qs++];
res[rs++] = i;
for (j = 0; j < (es[i]); j++) {
k = edge[i][j];
deg[k]--;
if (deg[k] == 0) {
q[qe++] = k;
}
}
}
if (rs == N) {
return 1;
}
return 0;
}
};
template <class T> struct wgraph {
T **cost;
graph g;
int N, **edge, *es;
void setEdge(int N__, int M, int A[], int B[], T C[], void **mem = &wmem) {
int i;
N = N__;
walloc1d(&es, N, mem);
for (i = 0; i < (N); i++) {
es[i] = 0;
}
for (i = 0; i < (M); i++) {
es[A[i]]++;
es[B[i]]++;
}
walloc1d(&edge, N, mem);
for (i = 0; i < (N); i++) {
walloc1d(&edge[i], es[i], mem);
}
walloc1d(&cost, N, mem);
for (i = 0; i < (N); i++) {
walloc1d(&cost[i], es[i], mem);
}
for (i = 0; i < (N); i++) {
es[i] = 0;
}
for (i = 0; i < (M); i++) {
edge[A[i]][es[A[i]]] = B[i];
edge[B[i]][es[B[i]]] = A[i];
cost[A[i]][es[A[i]]++] = C[i];
cost[B[i]][es[B[i]]++] = C[i];
}
g.N = N;
g.es = es;
g.edge = edge;
}
void setDirectEdge(int N__, int M, int A[], int B[], T C[],
void **mem = &wmem) {
int i;
N = N__;
walloc1d(&es, N, mem);
for (i = 0; i < (N); i++) {
es[i] = 0;
}
for (i = 0; i < (M); i++) {
es[A[i]]++;
}
walloc1d(&edge, N, mem);
for (i = 0; i < (N); i++) {
walloc1d(&edge[i], es[i], mem);
}
walloc1d(&cost, N, mem);
for (i = 0; i < (N); i++) {
walloc1d(&cost[i], es[i], mem);
}
for (i = 0; i < (N); i++) {
es[i] = 0;
}
for (i = 0; i < (M); i++) {
edge[A[i]][es[A[i]]] = B[i];
cost[A[i]][es[A[i]]++] = C[i];
}
g.N = N;
g.es = es;
g.edge = edge;
}
template <class S>
void getDist(int root, S res[], S unreachable = -1, void *mem = wmem) {
DijkstraHeap<S> hp;
int i, j;
hp.walloc(N, &mem);
hp.init(N);
hp.change(root, 0);
while (hp.size) {
i = hp.pop();
for (j = 0; j < (es[i]); j++) {
hp.change(edge[i][j], hp.val[i] + cost[i][j]);
}
}
for (i = 0; i < (N); i++) {
res[i] = (hp.visited[i] ? hp.val[i] : unreachable);
}
}
template <class S>
void getDistForest(int root, S res[], S unreachable = -1, void *mem = wmem) {
char *r;
int i, j, k, *q, s, z;
walloc1d(&q, N, &mem);
walloc1d(&r, N, &mem);
for (i = 0; i < (N); i++) {
r[i] = 0;
}
res[root] = 0;
r[root] = 1;
s = 0;
z = 1;
q[0] = root;
while (z) {
i = q[s++];
z--;
for (j = 0; j < (es[i]); j++) {
k = edge[i][j];
if (r[k]) {
continue;
}
res[k] = res[i] + cost[i][j];
r[k] = 1;
q[s + z++] = k;
}
}
for (i = 0; i < (N); i++) {
if (!r[i]) {
res[i] = unreachable;
}
}
}
template <class S>
void BellmanFord(int root, S res[], S unreachable = -1, S minusInf = -2,
int step = -1, void *mem = wmem) {
S *arr;
int KL2GvlyY, i, *inf, j, k, *nx, qe, qs, t, *vis;
walloc1d(&inf, N, &mem);
walloc1d(&vis, N, &mem);
walloc1d(&arr, N, &mem);
walloc1d(&nx, N, &mem);
for (i = 0; i < (N); i++) {
inf[i] = 0;
}
for (i = 0; i < (N); i++) {
vis[i] = 0;
}
for (i = 0; i < (N); i++) {
nx[i] = 0;
}
res[root] = arr[root] = 0;
vis[root] = nx[root] = 1;
t = step;
if (t == -1) {
t = N;
}
for (KL2GvlyY = 0; KL2GvlyY < (t); KL2GvlyY++) {
for (i = 0; i < (N); i++) {
if (vis[i]) {
for (j = 0; j < (es[i]); j++) {
k = edge[i][j];
if (nx[k] == 0 || arr[k] > res[i] + cost[i][j]) {
nx[k] = 1;
arr[k] = res[i] + cost[i][j];
}
}
}
}
for (i = 0; i < (N); i++) {
res[i] = arr[i];
}
for (i = 0; i < (N); i++) {
vis[i] = nx[i];
}
}
if (step != -1) {
for (i = 0; i < (N); i++) {
if (vis[i] == 0) {
res[i] = unreachable;
}
}
return;
}
for (i = 0; i < (N); i++) {
if (vis[i]) {
for (j = 0; j < (es[i]); j++) {
k = edge[i][j];
if (nx[k] == 0 || arr[k] > res[i] + cost[i][j]) {
inf[k] = 1;
}
}
}
}
qs = qe = 0;
for (i = 0; i < (N); i++) {
if (inf[i]) {
nx[qe++] = i;
}
}
while (qs < qe) {
i = nx[qs++];
for (j = 0; j < (es[i]); j++) {
k = edge[i][j];
if (inf[k] == 0) {
inf[k] = 1;
nx[qe++] = k;
}
}
}
for (i = 0; i < (N); i++) {
if (vis[i] == 0) {
res[i] = unreachable;
}
}
for (i = 0; i < (N); i++) {
if (inf[i] == 1) {
res[i] = minusInf;
}
}
}
T MST_Prim_cost(void *mem = wmem) {
DijkstraHeap<T> hp;
T res = 0;
int i, j;
hp.walloc(N, &mem);
hp.init(N);
hp.change(0, 0);
while (hp.size) {
i = hp.pop();
res += hp.val[i];
for (j = 0; j < (es[i]); j++) {
hp.change(edge[i][j], cost[i][j]);
}
}
return res;
}
int MST_Prim_cost(T &res, void *mem = wmem) {
DijkstraHeap<T> hp;
int cnt = 0, i, j;
res = 0;
hp.walloc(N, &mem);
hp.init(N);
hp.change(0, 0);
while (hp.size) {
i = hp.pop();
res += hp.val[i];
cnt++;
for (j = 0; j < (es[i]); j++) {
hp.change(edge[i][j], cost[i][j]);
}
}
if (cnt == N) {
return 1;
}
return 0;
}
};
char memarr[96000000];
int N;
int M;
int A[5000];
int B[5000];
int C[5000];
int P;
long long dist[2500];
int main() {
int i;
long long res;
wgraph<int> g;
wmem = memarr;
rd(N);
rd(M);
rd(P);
{
int Lj4PdHRW;
for (Lj4PdHRW = 0; Lj4PdHRW < (M); Lj4PdHRW++) {
rd(A[Lj4PdHRW]);
A[Lj4PdHRW] += (-1);
rd(B[Lj4PdHRW]);
B[Lj4PdHRW] += (-1);
rd(C[Lj4PdHRW]);
}
}
for (i = 0; i < (M); i++) {
C[i] = P - C[i];
}
g.setDirectEdge(N, M, A, B, C);
g.BellmanFord(0, dist, 0LL, -4611686016279904256LL);
res = dist[N - 1];
if (res == -4611686016279904256LL) {
res = -1;
} else if (res > 0) {
res = 0;
} else {
res = -res;
}
wt_L(res);
wt_L('\n');
return 0;
}
// cLay varsion 20190816-1 [beta]
// --- original code ---
// int N, M, A[5000], B[5000], C[5000], P;
// ll dist[2500];
// {
// int i;
// ll res;
// wgraph<int> g;
//
// rd(N,M,P,(A--,B--,C)(M));
// rep(i,M) C[i] = P - C[i];
// g.setDirectEdge(N,M,A,B,C);
// g.BellmanFord(0, dist, 0LL, -ll_inf);
//
// res = dist[N-1];
// res = if[res==-ll_inf, -1, res>0, 0, -res];
//
// wt(res);
// }
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 750,879 | 750,880 | u066369439 | cpp |
p02949 | /* ---------- STL Libraries ---------- */
// IO library
#include <cstdio>
#include <fstream>
#include <iomanip>
#include <ios>
#include <iostream>
// algorithm library
#include <algorithm>
#include <cmath>
#include <cstring>
#include <numeric>
#include <random>
// container library
#include <array>
#include <bitset>
#include <deque>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
/* ---------- Namespace ---------- */
using namespace std;
/* ---------- Type ---------- */
using ll = long long;
#define int ll
/* ---------- Constants */
const double PI = 3.141592653589793238462643383279;
const ll MOD = 1e9 + 7;
const int INF = 1LL << 55;
const int MAX_N = 2500;
vector<int> table[MAX_N];
vector<int> rev_table[MAX_N];
bool reachable[MAX_N];
bool reachable2[MAX_N];
bool valid[MAX_N];
void dfs(int node) {
if (reachable[node])
return;
reachable[node] = true;
for (int next : table[node])
dfs(next);
}
void dfs2(int node) {
if (reachable2[node])
return;
reachable2[node] = true;
for (int next : rev_table[node])
dfs2(next);
}
signed main() {
int N, M, P;
cin >> N >> M >> P;
vector<tuple<int, int, int>> edges(M);
for (int i = 0; i < M; i++) {
int from, to, cost;
cin >> from >> to >> cost;
from--;
to--;
edges[i] = make_tuple(from, to, -(cost - P));
table[from].push_back(to);
rev_table[to].push_back(from);
}
dfs(0);
dfs2(N - 1);
for (int i = 0; i < N; i++) {
valid[i] = reachable[i] & reachable2[i];
}
vector<int> d(N, INF);
d[0] = 0;
for (int i = 0; i < N; i++) {
bool update = false;
for (int j = 0; j < M; j++) {
int from, to, cost;
tie(from, to, cost) = edges[j];
if (!valid[from] || !valid[to])
continue;
if (d[to] > d[from] + cost) {
d[to] = d[from] + cost;
update = true;
}
}
if (update && i == N - 1) {
cout << -1 << endl;
return 0;
}
}
cout << min(0LL, -d[N - 1]) << endl;
return 0;
}
| /* ---------- STL Libraries ---------- */
// IO library
#include <cstdio>
#include <fstream>
#include <iomanip>
#include <ios>
#include <iostream>
// algorithm library
#include <algorithm>
#include <cmath>
#include <cstring>
#include <numeric>
#include <random>
// container library
#include <array>
#include <bitset>
#include <deque>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
/* ---------- Namespace ---------- */
using namespace std;
/* ---------- Type ---------- */
using ll = long long;
#define int ll
/* ---------- Constants */
const double PI = 3.141592653589793238462643383279;
const ll MOD = 1e9 + 7;
const int INF = 1LL << 55;
const int MAX_N = 2500;
vector<int> table[MAX_N];
vector<int> rev_table[MAX_N];
bool reachable[MAX_N];
bool reachable2[MAX_N];
bool valid[MAX_N];
void dfs(int node) {
if (reachable[node])
return;
reachable[node] = true;
for (int next : table[node])
dfs(next);
}
void dfs2(int node) {
if (reachable2[node])
return;
reachable2[node] = true;
for (int next : rev_table[node])
dfs2(next);
}
signed main() {
int N, M, P;
cin >> N >> M >> P;
vector<tuple<int, int, int>> edges(M);
for (int i = 0; i < M; i++) {
int from, to, cost;
cin >> from >> to >> cost;
from--;
to--;
edges[i] = make_tuple(from, to, -(cost - P));
table[from].push_back(to);
rev_table[to].push_back(from);
}
dfs(0);
dfs2(N - 1);
for (int i = 0; i < N; i++) {
valid[i] = reachable[i] & reachable2[i];
}
vector<int> d(N, INF);
d[0] = 0;
for (int i = 0; i < N; i++) {
bool update = false;
for (int j = 0; j < M; j++) {
int from, to, cost;
tie(from, to, cost) = edges[j];
if (!valid[from] || !valid[to])
continue;
if (d[to] > d[from] + cost) {
d[to] = d[from] + cost;
update = true;
}
}
if (update && i == N - 1) {
cout << -1 << endl;
return 0;
}
}
cout << max(0LL, -d[N - 1]) << endl;
return 0;
}
| [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 750,881 | 750,882 | u853132965 | cpp |
p02949 | #include <iostream>
#include <tuple>
#include <vector>
using namespace std;
const int INF = 1001001001;
vector<int> v[2505];
vector<int> rv[2505];
vector<tuple<int, int, int>> edge;
bool reachable1[2505];
bool reachable2[2505];
bool ok[2505];
void dfs(int n) {
if (reachable1[n]) {
return;
}
reachable1[n] = true;
for (int p : v[n]) {
dfs(p);
}
}
void rdfs(int n) {
if (reachable2[n]) {
return;
}
reachable2[n] = true;
for (int p : rv[n]) {
rdfs(p);
}
}
int main(int argc, char *argv[]) {
int N, M, P;
cin >> N >> M >> P;
for (int i = 0; i < M; i++) {
int A, B, C;
cin >> A >> B >> C;
A--;
B--;
C -= P;
C = -C;
v[A].push_back(B);
rv[B].push_back(A);
edge.emplace_back(A, B, C);
}
dfs(0);
rdfs(N - 1);
int w[2505];
for (int i = 0; i < N; i++) {
w[i] = INF;
}
for (int i = 0; i < N; i++) {
ok[i] = reachable1[i] & reachable2[i];
}
bool update = true;
int step = 0;
w[0] = 0;
while (update) {
update = false;
for (int i = 0; i < N; i++) {
int a, b, c;
tie(a, b, c) = edge[i];
if (!ok[a]) {
continue;
}
if (!ok[b]) {
continue;
}
int nw = w[a] + c;
if (nw < w[b]) {
update = true;
w[b] = nw;
}
}
step++;
if (step > N) {
cout << -1 << endl;
return 0;
}
}
int ans = -w[N - 1];
ans = max(ans, 0);
cout << ans << endl;
return 0;
} | #include <iostream>
#include <tuple>
#include <vector>
using namespace std;
const int INF = 1001001001;
vector<int> v[2505];
vector<int> rv[2505];
vector<tuple<int, int, int>> edge;
bool reachable1[2505];
bool reachable2[2505];
bool ok[2505];
void dfs(int n) {
if (reachable1[n]) {
return;
}
reachable1[n] = true;
for (int p : v[n]) {
dfs(p);
}
}
void rdfs(int n) {
if (reachable2[n]) {
return;
}
reachable2[n] = true;
for (int p : rv[n]) {
rdfs(p);
}
}
int main(int argc, char *argv[]) {
int N, M, P;
cin >> N >> M >> P;
for (int i = 0; i < M; i++) {
int A, B, C;
cin >> A >> B >> C;
A--;
B--;
C -= P;
C = -C;
v[A].push_back(B);
rv[B].push_back(A);
edge.emplace_back(A, B, C);
}
dfs(0);
rdfs(N - 1);
int w[2505];
for (int i = 0; i < N; i++) {
w[i] = INF;
}
for (int i = 0; i < N; i++) {
ok[i] = reachable1[i] & reachable2[i];
}
bool update = true;
int step = 0;
w[0] = 0;
while (update) {
update = false;
for (int i = 0; i < M; i++) {
int a, b, c;
tie(a, b, c) = edge[i];
if (!ok[a]) {
continue;
}
if (!ok[b]) {
continue;
}
int nw = w[a] + c;
if (nw < w[b]) {
update = true;
w[b] = nw;
}
}
step++;
if (step > N) {
cout << -1 << endl;
return 0;
}
}
int ans = -w[N - 1];
ans = max(ans, 0);
cout << ans << endl;
return 0;
} | [
"identifier.change",
"control_flow.loop.condition.change"
] | 750,885 | 750,886 | u993229809 | cpp |
p02949 | #include <iostream>
#include <tuple>
#include <vector>
using namespace std;
const int INF = 1e9;
vector<int> v[2505];
vector<int> rv[2505];
vector<tuple<int, int, int>> edge;
bool reachable1[2505];
bool reachable2[2505];
bool ok[2505];
void dfs(int n) {
if (reachable1[n]) {
return;
}
reachable1[n] = true;
for (int p : v[n]) {
dfs(p);
}
}
void rdfs(int n) {
if (reachable2[n]) {
return;
}
reachable2[n] = true;
for (int p : rv[n]) {
rdfs(p);
}
}
int main(int argc, char *argv[]) {
int N, M, P;
cin >> N >> M >> P;
for (int i = 0; i < M; i++) {
int A, B, C;
cin >> A >> B >> C;
A--;
B--;
C -= P;
C = -C;
v[A].push_back(B);
rv[B].push_back(A);
edge.emplace_back(A, B, C);
}
dfs(0);
rdfs(N - 1);
int w[2505];
for (int i = 0; i < N; i++) {
w[i] = INF;
}
for (int i = 0; i < N; i++) {
ok[i] = reachable1[i] & reachable2[i];
}
bool update = true;
int step = 0;
w[0] = 0;
while (update) {
update = false;
for (int i = 0; i < N; i++) {
int a, b, c;
tie(a, b, c) = edge[i];
if (!ok[a]) {
continue;
}
if (!ok[b]) {
continue;
}
int nw = w[a] + c;
if (nw < w[b]) {
update = true;
w[b] = nw;
}
}
step++;
if (step > N) {
cout << -1 << endl;
return 0;
}
}
int ans = -w[N - 1];
ans = max(ans, 0);
cout << ans << endl;
return 0;
}
| #include <iostream>
#include <tuple>
#include <vector>
using namespace std;
const int INF = 1001001001;
vector<int> v[2505];
vector<int> rv[2505];
vector<tuple<int, int, int>> edge;
bool reachable1[2505];
bool reachable2[2505];
bool ok[2505];
void dfs(int n) {
if (reachable1[n]) {
return;
}
reachable1[n] = true;
for (int p : v[n]) {
dfs(p);
}
}
void rdfs(int n) {
if (reachable2[n]) {
return;
}
reachable2[n] = true;
for (int p : rv[n]) {
rdfs(p);
}
}
int main(int argc, char *argv[]) {
int N, M, P;
cin >> N >> M >> P;
for (int i = 0; i < M; i++) {
int A, B, C;
cin >> A >> B >> C;
A--;
B--;
C -= P;
C = -C;
v[A].push_back(B);
rv[B].push_back(A);
edge.emplace_back(A, B, C);
}
dfs(0);
rdfs(N - 1);
int w[2505];
for (int i = 0; i < N; i++) {
w[i] = INF;
}
for (int i = 0; i < N; i++) {
ok[i] = reachable1[i] & reachable2[i];
}
bool update = true;
int step = 0;
w[0] = 0;
while (update) {
update = false;
for (int i = 0; i < M; i++) {
int a, b, c;
tie(a, b, c) = edge[i];
if (!ok[a]) {
continue;
}
if (!ok[b]) {
continue;
}
int nw = w[a] + c;
if (nw < w[b]) {
update = true;
w[b] = nw;
}
}
step++;
if (step > N) {
cout << -1 << endl;
return 0;
}
}
int ans = -w[N - 1];
ans = max(ans, 0);
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"identifier.change",
"control_flow.loop.condition.change"
] | 750,887 | 750,886 | u993229809 | cpp |
p02949 | #include <algorithm>
#include <bitset>
#include <cfloat>
#include <climits>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
struct Edge {
int from, to;
long long int cost;
};
int main() {
int n, m, p;
std::cin >> n >> m >> p;
std::vector<std::vector<Edge>> in_edge(n);
std::vector<Edge> edges(m);
for (auto &e : edges) {
std::cin >> e.from >> e.to >> e.cost;
e.from--;
e.to--;
in_edge[e.to].push_back(e);
}
std::vector<bool> can_reach_goal(n, false);
can_reach_goal[n - 1] = true;
std::queue<int> queue;
queue.push(n - 1);
while (!queue.empty()) {
auto top = queue.front();
queue.pop();
for (const auto &e : in_edge[top])
if (!can_reach_goal[e.to]) {
can_reach_goal[e.to] = true;
queue.emplace(e.to);
}
}
std::vector<long long int> max_gain(n, LLONG_MIN);
max_gain[0] = 0;
for (auto i = 0; i < n; ++i) {
for (const auto &e : edges) {
if (max_gain[e.from] != LLONG_MIN && can_reach_goal[e.to] &&
max_gain[e.to] < max_gain[e.from] + e.cost - p) {
max_gain[e.to] = max_gain[e.from] + e.cost - p;
}
}
}
if (std::any_of(edges.begin(), edges.end(),
[&can_reach_goal, &max_gain, p](const Edge &e) {
return max_gain[e.from] != LLONG_MIN &&
can_reach_goal[e.to] &&
max_gain[e.to] < max_gain[e.from] + e.cost - p;
})) {
std::cout << -1 << std::endl;
} else {
std::cout << std::max(0LL, max_gain.back()) << std::endl;
}
}
| #include <algorithm>
#include <bitset>
#include <cfloat>
#include <climits>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
struct Edge {
int from, to;
long long int cost;
};
int main() {
int n, m, p;
std::cin >> n >> m >> p;
std::vector<std::vector<Edge>> in_edge(n);
std::vector<Edge> edges(m);
for (auto &e : edges) {
std::cin >> e.from >> e.to >> e.cost;
e.from--;
e.to--;
in_edge[e.to].push_back(e);
}
std::vector<bool> can_reach_goal(n, false);
can_reach_goal[n - 1] = true;
std::queue<int> queue;
queue.push(n - 1);
while (!queue.empty()) {
auto top = queue.front();
queue.pop();
for (const auto &e : in_edge[top])
if (!can_reach_goal[e.from]) {
can_reach_goal[e.from] = true;
queue.emplace(e.from);
}
}
std::vector<long long int> max_gain(n, LLONG_MIN);
max_gain[0] = 0;
for (auto i = 0; i < n; ++i) {
for (const auto &e : edges) {
if (max_gain[e.from] != LLONG_MIN && can_reach_goal[e.to] &&
max_gain[e.to] < max_gain[e.from] + e.cost - p) {
max_gain[e.to] = max_gain[e.from] + e.cost - p;
}
}
}
if (std::any_of(edges.begin(), edges.end(),
[&can_reach_goal, &max_gain, p](const Edge &e) {
return max_gain[e.from] != LLONG_MIN &&
can_reach_goal[e.to] &&
max_gain[e.to] < max_gain[e.from] + e.cost - p;
})) {
std::cout << -1 << std::endl;
} else {
std::cout << std::max(0LL, max_gain.back()) << std::endl;
}
}
| [
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"assignment.variable.change",
"call.arguments.change"
] | 750,888 | 750,889 | u419330815 | cpp |
p02949 | #include <algorithm>
#include <assert.h>
#include <cstring>
#include <iterator>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#pragma warning(disable : 4996)
typedef long long ll;
#define MIN(a, b) ((a) > (b) ? (b) : (a))
#define MAX(a, b) ((a) < (b) ? (b) : (a))
#define LINF 9223300000000000000
#define INF 2140000000
const long long MOD = 1000000007;
using namespace std;
vector<vector<pair<int, int>>> g; // to, pt
void dfs0(int curr, const vector<vector<int>> &gg, vector<int> &vis) {
if (vis[curr])
return;
vis[curr] = 1;
int siz = gg[curr].size();
int i;
for (i = 0; i < siz; i++) {
int next = gg[curr][i];
if (vis[next])
continue;
dfs0(next, gg, vis);
}
return;
}
int main() {
int n, m, p;
scanf("%d%d%d", &n, &m, &p);
g.resize(n);
vector<vector<int>> g0(n); // to
vector<vector<int>> g1(n); // from
int i;
for (i = 0; i < m; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
a--;
b--;
c -= p;
g[a].push_back(make_pair(b, c));
g0[a].push_back(b);
g1[b].push_back(a);
}
vector<int> vis0(n), vis1(n);
dfs0(0, g0, vis0);
dfs0(n - 1, g1, vis1);
vector<ll> pt(n, -1);
pt[0] = 0;
int j;
int numloop = 0;
while (1) {
int cnt = 0;
for (i = 0; i < n; i++) {
if (vis0[i] && vis1[i] && pt[i] >= 0) {
for (j = 0; j < (int)g[i].size(); j++) {
int next = g[i][j].first;
int add = g[i][j].second;
if (pt[next] >= pt[i] + add) {
continue;
} else {
pt[next] = pt[i] + add;
cnt++;
}
}
}
}
if (cnt == 0)
break;
else
numloop++;
if (numloop > n) {
printf("-1\n");
return 0;
}
}
printf("%lld\n", MAX(0, pt[n - 1]));
return 0;
}
| #include <algorithm>
#include <assert.h>
#include <cstring>
#include <iterator>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#pragma warning(disable : 4996)
typedef long long ll;
#define MIN(a, b) ((a) > (b) ? (b) : (a))
#define MAX(a, b) ((a) < (b) ? (b) : (a))
#define LINF 9223300000000000000
#define INF 2140000000
const long long MOD = 1000000007;
using namespace std;
vector<vector<pair<int, int>>> g; // to, pt
void dfs0(int curr, const vector<vector<int>> &gg, vector<int> &vis) {
if (vis[curr])
return;
vis[curr] = 1;
int siz = gg[curr].size();
int i;
for (i = 0; i < siz; i++) {
int next = gg[curr][i];
if (vis[next])
continue;
dfs0(next, gg, vis);
}
return;
}
int main() {
int n, m, p;
scanf("%d%d%d", &n, &m, &p);
g.resize(n);
vector<vector<int>> g0(n); // to
vector<vector<int>> g1(n); // from
int i;
for (i = 0; i < m; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
a--;
b--;
c -= p;
g[a].push_back(make_pair(b, c));
g0[a].push_back(b);
g1[b].push_back(a);
}
vector<int> vis0(n), vis1(n);
dfs0(0, g0, vis0);
dfs0(n - 1, g1, vis1);
vector<ll> pt(n, -INF);
pt[0] = 0;
int j;
int numloop = 0;
while (1) {
int cnt = 0;
for (i = 0; i < n; i++) {
if (vis0[i] && vis1[i] && pt[i] > -INF) {
for (j = 0; j < (int)g[i].size(); j++) {
int next = g[i][j].first;
int add = g[i][j].second;
if (pt[next] >= pt[i] + add) {
continue;
} else {
pt[next] = pt[i] + add;
cnt++;
}
}
}
}
if (cnt == 0)
break;
else
numloop++;
if (numloop > n) {
printf("-1\n");
return 0;
}
}
printf("%lld\n", MAX(0, pt[n - 1]));
return 0;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change",
"control_flow.loop.for.condition.change",
"expression.operation.unary.add",
"control_flow.branch.if.condition.change"
] | 750,890 | 750,891 | u209713918 | cpp |
p02949 | #include <algorithm>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdlib.h>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// INT_MAX 2,147,483,647 = 2*1.0e9
vector<vector<int>> path;
vector<vector<int>> rpath;
vector<bool> canGo;
vector<bool> canCome;
void dfs(int v) {
if (canGo[v])
return;
else {
canGo[v] = true;
for (int i : path[v])
dfs(i);
}
}
void rdfs(int v) {
if (canCome[v])
return;
else {
canCome[v] = true;
for (int i : rpath[v])
rdfs(i);
}
}
const int INF = 1000000000;
int main() {
int N, M, P;
cin >> N >> M >> P;
path.resize(N);
rpath.resize(N);
canGo.assign(N, false);
canCome.assign(N, false);
vector<tuple<int, int, int>> ABC;
for (int i = 0; i < M; i++) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
c -= P;
path[a].push_back(b);
rpath[b].push_back(a);
ABC.push_back(make_tuple(a, b, -c));
}
dfs(0);
rdfs(N - 1);
vector<bool> OK(N);
for (int i = 0; i < N; i++)
OK[i] = canGo[i] & canCome[i];
vector<int> dist(N, INF);
dist[0] = 0;
bool upd = true;
int cnt = 0;
while (upd) {
upd = false;
for (int i = 0; i < M; i++) {
int a, b, c;
tie(a, b, c) = ABC[i];
if (!OK[a])
continue;
if (!OK[b])
continue;
if (dist[b] > dist[a] + c) {
dist[b] = dist[a] + c;
upd = true;
}
}
cnt++;
if (cnt == N) {
cout << "-1" << endl;
return 0;
}
}
int ans = max(0, -dist[N - 1]);
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdlib.h>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// INT_MAX 2,147,483,647 = 2*1.0e9
vector<vector<int>> path;
vector<vector<int>> rpath;
vector<bool> canGo;
vector<bool> canCome;
void dfs(int v) {
if (canGo[v])
return;
else {
canGo[v] = true;
for (int i : path[v])
dfs(i);
}
}
void rdfs(int v) {
if (canCome[v])
return;
else {
canCome[v] = true;
for (int i : rpath[v])
rdfs(i);
}
}
const int INF = 1000000000;
int main() {
int N, M, P;
cin >> N >> M >> P;
path.resize(N);
rpath.resize(N);
canGo.assign(N, false);
canCome.assign(N, false);
vector<tuple<int, int, int>> ABC;
for (int i = 0; i < M; i++) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
c -= P;
path[a].push_back(b);
rpath[b].push_back(a);
ABC.push_back(make_tuple(a, b, -c));
}
dfs(0);
rdfs(N - 1);
vector<bool> OK(N);
for (int i = 0; i < N; i++)
OK[i] = canGo[i] & canCome[i];
vector<int> dist(N, INF);
dist[0] = 0;
bool upd = true;
int cnt = 0;
while (upd) {
upd = false;
for (int i = 0; i < M; i++) {
int a, b, c;
tie(a, b, c) = ABC[i];
if (!OK[a])
continue;
if (!OK[b])
continue;
if (dist[b] > dist[a] + c) {
dist[b] = dist[a] + c;
upd = true;
}
}
cnt++;
if (cnt > N) {
cout << "-1" << endl;
return 0;
}
}
int ans = max(0, -dist[N - 1]);
cout << ans << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 750,892 | 750,893 | u561443723 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
typedef long long int lli;
int n, m, p;
vector<vector<pair<int, int>>> edge(2501, vector<pair<int, int>>()),
redge(2501, vector<pair<int, int>>());
vector<int> score(2501, -2000000000), used(2501, 0), pass(2501, 0);
void dfs(int crnt, int t) {
used[crnt] = 1;
for (auto x : edge[crnt]) {
int bb = x.first, cc = x.second;
if (used[bb]) {
if (score[crnt] + cc - t * p > score[bb] && pass[bb]) {
score[n] = 2000000000;
// cout << "## " << crnt << " " << bb << endl;
}
continue;
}
if (score[crnt] + cc - t * p > score[bb]) {
score[bb] = score[crnt] + cc - t * p;
dfs(bb, t + 1);
}
}
used[crnt] = 0;
return;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m >> p;
int a, b, c;
for (int i = 0; i < m; i++) {
cin >> a >> b >> c;
edge[a].push_back(make_pair(b, c));
redge[b].push_back(make_pair(a, c));
}
queue<int> qu;
qu.push(n);
while (!qu.empty()) {
int x = qu.front();
qu.pop();
used[x] = 1;
pass[x] = 1;
for (auto e : redge[x]) {
if (used[e.first])
continue;
qu.push(e.first);
}
}
used = vector<int>(2501, 0);
score[1] = 0;
dfs(1, 1);
/*
for (int i=1; i<=n; i++) cout << score[i] << " ";
cout << endl;
*/
cout << ((score[n] == 2000000000) ? -1 : max(0, score[n])) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long int lli;
int n, m, p;
vector<vector<pair<int, int>>> edge(2501, vector<pair<int, int>>()),
redge(2501, vector<pair<int, int>>());
vector<int> score(2501, -2000000000), used(2501, 0), pass(2501, 0);
void dfs(int crnt, int t) {
used[crnt] = 1;
for (auto x : edge[crnt]) {
int bb = x.first, cc = x.second;
if (used[bb]) {
if (score[crnt] + cc - p > score[bb] && pass[bb]) {
score[n] = 2000000000;
// cout << "## " << crnt << " " << bb << endl;
}
continue;
}
if (score[crnt] + cc - p > score[bb]) {
score[bb] = score[crnt] + cc - p;
dfs(bb, t + 1);
}
}
used[crnt] = 0;
return;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m >> p;
int a, b, c;
for (int i = 0; i < m; i++) {
cin >> a >> b >> c;
edge[a].push_back(make_pair(b, c));
redge[b].push_back(make_pair(a, c));
}
queue<int> qu;
qu.push(n);
while (!qu.empty()) {
int x = qu.front();
qu.pop();
used[x] = 1;
pass[x] = 1;
for (auto e : redge[x]) {
if (used[e.first])
continue;
qu.push(e.first);
}
}
used = vector<int>(2501, 0);
score[1] = 0;
dfs(1, 1);
/*
for (int i=1; i<=n; i++) cout << score[i] << " ";
cout << endl;
*/
cout << ((score[n] == 2000000000) ? -1 : max(0, score[n])) << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 750,896 | 750,895 | u905270643 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
struct edge {
int from, to, cost;
};
edge es[5001];
int d[2501], V, E, INF = 1e9;
int shortest_path() {
rep(i, V) d[i + 1] = INF;
d[1] = 0;
while (true) {
int x = 0;
rep(i, E) {
edge e = es[i];
if (d[e.from] != INF && d[e.to] > d[e.from] + e.cost)
d[e.to] = d[e.from] + e.cost, x = 1;
}
if (!x)
break;
}
return d[V];
}
int r[200001][2] = {0};
vector<int> A[200001], B[200001];
int search(int x, int y) {
if (r[x][y])
return 0;
r[x][y] = 1;
if (y == 0)
for (auto i : A[x])
search(i, y);
else
for (auto i : B[x])
search(i, y);
}
int find_negative_loop() {
search(V, 0);
search(1, 1);
rep(i, V) d[i + 1] = 1;
d[1] = 0;
rep(i, 2 * V) rep(j, E) {
edge e = es[j];
if (d[e.from] != 1 && d[e.to] > d[e.from] + e.cost) {
d[e.to] = d[e.from] + e.cost;
if (i >= V - 1 && r[e.to][0] && r[e.to][1])
return 1;
}
}
return 0;
}
int main() {
int P, a, b, c;
cin >> V >> E >> P;
rep(i, E) cin >> a >> b >> c, es[i] = {a, b, -(c - P)}, A[b].push_back(a),
B[a].push_back(b);
if (find_negative_loop())
cout << -1;
else if (shortest_path() > 0)
cout << 0;
else
cout << -shortest_path();
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
struct edge {
int from, to, cost;
};
edge es[5001];
int d[2501], V, E, INF = 1e9;
int shortest_path() {
rep(i, V) d[i + 1] = INF;
d[1] = 0;
while (true) {
int x = 0;
rep(i, E) {
edge e = es[i];
if (d[e.from] != INF && d[e.to] > d[e.from] + e.cost)
d[e.to] = d[e.from] + e.cost, x = 1;
}
if (!x)
break;
}
return d[V];
}
int r[200001][2] = {0};
vector<int> A[200001], B[200001];
int search(int x, int y) {
if (r[x][y])
return 0;
r[x][y] = 1;
if (y == 0)
for (auto i : A[x])
search(i, y);
else
for (auto i : B[x])
search(i, y);
}
int find_negative_loop() {
search(V, 0);
search(1, 1);
rep(i, V) d[i + 1] = INF;
d[1] = 0;
rep(i, 2 * V) rep(j, E) {
edge e = es[j];
if (d[e.from] != INF && d[e.to] > d[e.from] + e.cost) {
d[e.to] = d[e.from] + e.cost;
if (i >= V - 1 && r[e.to][0] && r[e.to][1])
return 1;
}
}
return 0;
}
int main() {
int P, a, b, c;
cin >> V >> E >> P;
rep(i, E) cin >> a >> b >> c, es[i] = {a, b, -(c - P)}, A[b].push_back(a),
B[a].push_back(b);
if (find_negative_loop())
cout << -1;
else if (shortest_path() > 0)
cout << 0;
else
cout << -shortest_path();
} | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.branch.if.condition.change"
] | 750,900 | 750,901 | u441296840 | cpp |
p02949 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <unordered_map>
#include <vector>
using namespace std;
struct edge {
int to;
int cost;
};
int main() {
int n, m, p;
cin >> n >> m >> p;
vector<vector<edge>> edges(n + 1);
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
edges[a].push_back({b, p - c}); // 支払いを辺の重みとして、最小値を求める
}
//ベルマンフォード法で探す
bool is_minus = false;
int init_value = pow(10, 9); // ありえない最大値
vector<int> d(n + 1, init_value);
d[1] = 0; // 始点は0
for (int count = 1; count <= n; count++) {
for (int from = 1; from <= n; from++) {
for (const auto &e : edges[from]) {
int to = e.to;
int old = d[to];
d[to] = min(d[to], d[from] + e.cost);
if (to == n && count >= n && old != d[to]) {
is_minus = true; // 負の経路あり
}
}
}
}
if (is_minus) {
cout << -1 << endl;
} else if (d[n] > 0) {
// 支払のほうが多い
cout << 0 << endl;
} else {
cout << -d[n] << endl;
}
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <unordered_map>
#include <vector>
using namespace std;
struct edge {
int to;
int cost;
};
int main() {
int n, m, p;
cin >> n >> m >> p;
vector<vector<edge>> edges(n + 1);
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
edges[a].push_back({b, p - c}); // 支払いを辺の重みとして、最小値を求める
}
//ベルマンフォード法で探す
bool is_minus = false;
int init_value = pow(10, 9); // ありえない最大値
vector<int> d(n + 1, init_value);
d[1] = 0; // 始点は0
for (int count = 1; count <= n + m; count++) {
for (int from = 1; from <= n; from++) {
for (const auto &e : edges[from]) {
int to = e.to;
int old = d[to];
d[to] = min(d[to], d[from] + e.cost);
if (to == n && count >= n && old != d[to]) {
is_minus = true; // 負の経路あり
}
}
}
}
if (is_minus) {
cout << -1 << endl;
} else if (d[n] > 0) {
// 支払のほうが多い
cout << 0 << endl;
} else {
cout << -d[n] << endl;
}
return 0;
}
| [
"control_flow.loop.for.condition.change"
] | 750,904 | 750,905 | u538188080 | cpp |
p02949 | #include <cstdio>
int n, m, i, j, k, k2, t, x, y, z, a[2505], v[2505], st[5005], en[5005],
len[5005], last[2505], nxt[5005], st2[5005], en2[5005], last2[2505],
nxt2[5005], find[10000005];
bool b[2505], f[2505];
void build(int x, int y, int z) {
k++, st[k] = x, en[k] = y, len[k] = z, nxt[k] = last[x], last[x] = k;
}
void build2(int x, int y) {
k2++, st2[k2] = x, en2[k2] = y, nxt2[k2] = last2[x], last2[x] = k2;
}
void go(int x) {
for (i = last2[x]; i; i = nxt2[i])
if (!f[en2[i]]) {
f[en2[i]] = true;
go(en2[i]);
}
}
int main() {
scanf("%d%d%d", &n, &m, &t);
for (i = 1; i <= m; i++) {
scanf("%d%d%d", &x, &y, &z);
build(x, y, z);
build2(y, x);
}
f[n] = true;
go(n);
for (i = 1; i <= n; i++)
a[i] = -2e9;
a[1] = 0, x = y = find[1] = 1, b[1] = true;
while (x <= y) {
b[find[x]] = false;
for (i = last[find[x]]; i; i = nxt[i])
if (a[en[i]] < a[st[i]] + len[i] - t && f[en[i]]) {
a[en[i]] = a[st[i]] + len[i] - t;
if (!b[en[i]])
b[en[i]] = true, y++, find[y] = en[i], v[en[i]]++;
if (v[n] == n)
return printf("-1\n") && 0;
}
x++;
}
printf("%d\n", a[n] > 0 ? a[n] : 0);
return 0;
} | #include <cstdio>
int n, m, i, j, k, k2, t, x, y, z, a[2505], v[2505], st[5005], en[5005],
len[5005], last[2505], nxt[5005], st2[5005], en2[5005], last2[2505],
nxt2[5005], find[10000005];
bool b[2505], f[2505];
void build(int x, int y, int z) {
k++, st[k] = x, en[k] = y, len[k] = z, nxt[k] = last[x], last[x] = k;
}
void build2(int x, int y) {
k2++, st2[k2] = x, en2[k2] = y, nxt2[k2] = last2[x], last2[x] = k2;
}
void go(int x) {
for (int i = last2[x]; i; i = nxt2[i])
if (!f[en2[i]]) {
f[en2[i]] = true;
go(en2[i]);
}
}
int main() {
scanf("%d%d%d", &n, &m, &t);
for (i = 1; i <= m; i++) {
scanf("%d%d%d", &x, &y, &z);
build(x, y, z);
build2(y, x);
}
f[n] = true;
go(n);
for (i = 1; i <= n; i++)
a[i] = -2e9;
a[1] = 0, x = y = find[1] = 1, b[1] = true;
while (x <= y) {
b[find[x]] = false;
for (i = last[find[x]]; i; i = nxt[i])
if (a[en[i]] < a[st[i]] + len[i] - t && f[en[i]]) {
a[en[i]] = a[st[i]] + len[i] - t;
if (!b[en[i]])
b[en[i]] = true, y++, find[y] = en[i], v[en[i]]++;
if (v[en[i]] == n)
return printf("-1\n") && 0;
}
x++;
}
printf("%d\n", a[n] > 0 ? a[n] : 0);
return 0;
} | [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 750,908 | 750,907 | u764483026 | cpp |
p02949 | #include <cstdio>
int n, m, i, j, k, k2, t, x, y, z, a[2505], v[2505], st[5005], en[5005],
len[5005], last[2505], nxt[5005], st2[5005], en2[5005], last2[2505],
nxt2[5005], find[10000005];
bool b[2505], f[2505];
void build(int x, int y, int z) {
k++, st[k] = x, en[k] = y, len[k] = z, nxt[k] = last[x], last[x] = k;
}
void build2(int x, int y) {
k2++, st2[k2] = x, en2[k2] = y, nxt2[k2] = last2[x], last2[x] = k2;
}
void go(int x) {
for (i = last2[x]; i; i = nxt2[i])
if (!f[en2[i]]) {
f[en2[i]] = true;
go(en2[i]);
}
}
int main() {
scanf("%d%d%d", &n, &m, &t);
for (i = 1; i <= m; i++) {
scanf("%d%d%d", &x, &y, &z);
build(x, y, z);
build2(y, x);
}
f[n] = true;
go(n);
for (i = 1; i <= n; i++)
a[i] = -2e9;
a[1] = 0, x = y = find[1] = 1, b[1] = true;
while (x <= y) {
b[find[x]] = false;
for (i = last[find[x]]; i; i = nxt[i])
if (a[en[i]] < a[st[i]] + len[i] - t && f[en[i]]) {
a[en[i]] = a[st[i]] + len[i] - t;
if (!b[en[i]])
b[en[i]] = true, y++, find[y] = en[i], v[en[i]]++;
if (v[n] == n)
return printf("-1\n") && 0;
}
x++;
}
printf("%d\n", a[n] > 0 ? a[n] : 0);
return 0;
} | #include <cstdio>
int n, m, i, j, k, k2, t, x, y, z, a[2505], v[2505], st[5005], en[5005],
len[5005], last[2505], nxt[5005], st2[5005], en2[5005], last2[2505],
nxt2[5005], find[10000005];
bool b[2505], f[2505];
void build(int x, int y, int z) {
k++, st[k] = x, en[k] = y, len[k] = z, nxt[k] = last[x], last[x] = k;
}
void build2(int x, int y) {
k2++, st2[k2] = x, en2[k2] = y, nxt2[k2] = last2[x], last2[x] = k2;
}
void go(int x) {
for (int i = last2[x]; i; i = nxt2[i])
if (!f[en2[i]]) {
f[en2[i]] = true;
go(en2[i]);
}
}
int main() {
scanf("%d%d%d", &n, &m, &t);
for (i = 1; i <= m; i++) {
scanf("%d%d%d", &x, &y, &z);
build(x, y, z);
build2(y, x);
}
f[n] = true;
go(n);
for (i = 1; i <= n; i++)
a[i] = -2e9;
a[1] = 0, x = y = find[1] = 1, b[1] = true;
while (x <= y) {
b[find[x]] = false;
for (i = last[find[x]]; i; i = nxt[i])
if (a[en[i]] < a[st[i]] + len[i] - t && f[en[i]]) {
a[en[i]] = a[st[i]] + len[i] - t;
if (!b[en[i]])
b[en[i]] = true, y++, find[y] = en[i], v[en[i]]++;
if (v[en[i]] > n)
return printf("-1\n") && 0;
}
x++;
}
printf("%d\n", a[n] > 0 ? a[n] : 0);
return 0;
} | [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 750,908 | 750,909 | u764483026 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, j, n) for (long long i = j; i <= n; i++)
const ll N = 123456;
vector<pair<ll, pair<ll, ll>>> a;
ll dist[N];
ll len[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, m;
cin >> n >> m;
ll p;
cin >> p;
rep(i, 1, m) {
ll x, y, z;
cin >> x >> y >> z;
a.push_back({x, {y, -z + p}});
}
rep(i, 1, n) dist[i] = INT_MAX;
;
dist[1] = 0;
rep(i, 1, 2 * n) {
rep(j, 0, m - 1) {
ll u = a[j].first;
ll v = a[j].second.first;
ll w = a[j].second.second;
if (dist[u] != INT_MAX && dist[u] + w < dist[v]) {
dist[v] = w + dist[u];
if (i >= n + 1) {
dist[u] = INT_MIN;
}
}
}
}
int ans = 0;
if (dist[n] == INT_MIN) {
ans = -1;
} else if (dist[n] > 0) {
ans = 0;
} else {
ans = -dist[n];
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, j, n) for (long long i = j; i <= n; i++)
const ll N = 123456;
vector<pair<ll, pair<ll, ll>>> a;
ll dist[N];
ll len[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, m;
cin >> n >> m;
ll p;
cin >> p;
rep(i, 1, m) {
ll x, y, z;
cin >> x >> y >> z;
a.push_back({x, {y, -z + p}});
}
rep(i, 1, n) dist[i] = INT_MAX;
;
dist[1] = 0;
rep(i, 1, 2 * n) {
rep(j, 0, m - 1) {
ll u = a[j].first;
ll v = a[j].second.first;
ll w = a[j].second.second;
if (dist[u] != INT_MAX && dist[u] + w < dist[v]) {
dist[v] = w + dist[u];
if (i >= n + 1) {
dist[v] = INT_MIN;
}
}
}
}
int ans = 0;
if (dist[n] == INT_MIN) {
ans = -1;
} else if (dist[n] > 0) {
ans = 0;
} else {
ans = -dist[n];
}
cout << ans << endl;
return 0;
}
| [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 750,910 | 750,911 | u095029955 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define debug(n) cerr << #n << ' ' << n << endl;
inline bool ChangeMin(int &a, int b) {
if (a > b) {
a = b;
return true;
}
return false;
}
void CheckReachableNode(const vector<unordered_set<int>> &movable_list, int pos,
bitset<2500> &nodes) {
if (nodes[pos] == 1) {
return;
} else {
nodes[pos] = 1;
for (auto &&node : movable_list[pos]) {
CheckReachableNode(movable_list, node, nodes);
}
}
}
int main() {
int v, e, p;
cin >> v >> e >> p;
vector<tuple<int, int, int>> edges;
vector<unordered_set<int>> in_list(e);
vector<unordered_set<int>> out_list(e);
bitset<2500> reachable_from_start = 0;
bitset<2500> reachable_in_goal = 0;
for (int i = 0; i < e; ++i) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
edges.emplace_back(a, b, -(c - p));
out_list[a].insert(b);
in_list[b].insert(a);
}
CheckReachableNode(out_list, 0, reachable_from_start);
CheckReachableNode(in_list, v - 1, reachable_in_goal);
bitset<2500> on_path;
for (int i = 0; i < 2500; ++i) {
on_path[i] = reachable_from_start[i] & reachable_in_goal[i];
}
vector<int> costs(v, 1111111111);
int loop_count = 0;
bool loop_fin = false;
costs[0] = 0;
while (!loop_fin) {
loop_fin = true;
for (auto &&edge : edges) {
int a, b, c;
tie(a, b, c) = edge;
if (out_list[a].count(b) != 0 && on_path[a] & on_path[b]) {
if (ChangeMin(costs[b], costs[a] + c)) {
loop_fin = false;
}
}
}
if (loop_count++ > v) {
cout << -1 << endl;
return 0;
}
}
cout << max(-costs[v - 1], 0) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define debug(n) cerr << #n << ' ' << n << endl;
inline bool ChangeMin(int &a, int b) {
if (a > b) {
a = b;
return true;
}
return false;
}
void CheckReachableNode(const vector<unordered_set<int>> &movable_list, int pos,
bitset<2500> &nodes) {
if (nodes[pos] == 1) {
return;
} else {
nodes[pos] = 1;
for (auto &&node : movable_list[pos]) {
CheckReachableNode(movable_list, node, nodes);
}
}
}
int main() {
int v, e, p;
cin >> v >> e >> p;
vector<tuple<int, int, int>> edges;
vector<unordered_set<int>> in_list(v);
vector<unordered_set<int>> out_list(v);
bitset<2500> reachable_from_start = 0;
bitset<2500> reachable_in_goal = 0;
for (int i = 0; i < e; ++i) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
edges.emplace_back(a, b, -(c - p));
out_list[a].insert(b);
in_list[b].insert(a);
}
CheckReachableNode(out_list, 0, reachable_from_start);
CheckReachableNode(in_list, v - 1, reachable_in_goal);
bitset<2500> on_path;
for (int i = 0; i < 2500; ++i) {
on_path[i] = reachable_from_start[i] & reachable_in_goal[i];
}
vector<int> costs(v, 1e+9);
int loop_count = 0;
bool loop_fin = false;
costs[0] = 0;
while (!loop_fin) {
loop_fin = true;
for (auto &&edge : edges) {
int a, b, c;
tie(a, b, c) = edge;
if (out_list[a].count(b) != 0 && on_path[a] & on_path[b]) {
if (ChangeMin(costs[b], costs[a] + c)) {
loop_fin = false;
}
}
}
if (loop_count++ > v) {
cout << -1 << endl;
return 0;
}
}
cout << max(-costs[v - 1], 0) << endl;
return 0;
}
| [
"literal.number.change",
"call.arguments.change"
] | 750,912 | 750,913 | u691380397 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define debug(n) cerr << #n << ' ' << n << endl;
inline bool ChangeMin(int &a, int b) {
if (a > b) {
a = b;
return true;
}
return false;
}
void CheckReachableNode(const vector<unordered_set<int>> &movable_list, int pos,
bitset<2500> &nodes) {
if (nodes[pos] == 1) {
return;
} else {
nodes[pos] = 1;
for (auto &&node : movable_list[pos]) {
CheckReachableNode(movable_list, node, nodes);
}
}
}
int main() {
int v, e, p;
cin >> v >> e >> p;
vector<tuple<int, int, int>> edges;
vector<unordered_set<int>> in_list(e);
vector<unordered_set<int>> out_list(e);
bitset<2500> reachable_from_start = 0;
bitset<2500> reachable_in_goal = 0;
for (int i = 0; i < e; ++i) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
edges.emplace_back(a, b, -(c - p));
out_list[a].insert(b);
in_list[b].insert(a);
}
CheckReachableNode(out_list, 0, reachable_from_start);
CheckReachableNode(in_list, v - 1, reachable_in_goal);
bitset<2500> on_path;
for (int i = 0; i < 2500; ++i) {
on_path[i] = reachable_from_start[i] & reachable_in_goal[i];
}
vector<int> costs(v, 1e+9);
int loop_count = 0;
bool loop_fin = false;
costs[0] = 0;
while (!loop_fin) {
loop_fin = true;
for (auto &&edge : edges) {
int a, b, c;
tie(a, b, c) = edge;
if (out_list[a].count(b) != 0 && on_path[a] & on_path[b]) {
if (ChangeMin(costs[b], costs[a] + c)) {
loop_fin = false;
}
}
}
if (loop_count++ > v) {
cout << -1 << endl;
return 0;
}
}
cout << max(-costs[v - 1], 0) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define debug(n) cerr << #n << ' ' << n << endl;
inline bool ChangeMin(int &a, int b) {
if (a > b) {
a = b;
return true;
}
return false;
}
void CheckReachableNode(const vector<unordered_set<int>> &movable_list, int pos,
bitset<2500> &nodes) {
if (nodes[pos] == 1) {
return;
} else {
nodes[pos] = 1;
for (auto &&node : movable_list[pos]) {
CheckReachableNode(movable_list, node, nodes);
}
}
}
int main() {
int v, e, p;
cin >> v >> e >> p;
vector<tuple<int, int, int>> edges;
vector<unordered_set<int>> in_list(v);
vector<unordered_set<int>> out_list(v);
bitset<2500> reachable_from_start = 0;
bitset<2500> reachable_in_goal = 0;
for (int i = 0; i < e; ++i) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
edges.emplace_back(a, b, -(c - p));
out_list[a].insert(b);
in_list[b].insert(a);
}
CheckReachableNode(out_list, 0, reachable_from_start);
CheckReachableNode(in_list, v - 1, reachable_in_goal);
bitset<2500> on_path;
for (int i = 0; i < 2500; ++i) {
on_path[i] = reachable_from_start[i] & reachable_in_goal[i];
}
vector<int> costs(v, 1e+9);
int loop_count = 0;
bool loop_fin = false;
costs[0] = 0;
while (!loop_fin) {
loop_fin = true;
for (auto &&edge : edges) {
int a, b, c;
tie(a, b, c) = edge;
if (out_list[a].count(b) != 0 && on_path[a] & on_path[b]) {
if (ChangeMin(costs[b], costs[a] + c)) {
loop_fin = false;
}
}
}
if (loop_count++ > v) {
cout << -1 << endl;
return 0;
}
}
cout << max(-costs[v - 1], 0) << endl;
return 0;
}
| [] | 750,914 | 750,913 | u691380397 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const int MAXN = 5555;
vector<pair<int, int>> adj[MAXN];
vector<int> radj[MAXN];
int n, m, p;
int dis[MAXN];
int vis[MAXN];
int rel[MAXN], rel2[MAXN];
void dfs(int u) {
vis[u] = rel[u] = 1;
for (auto p : adj[u]) {
int v = p.first;
if (!vis[v])
dfs(v);
}
}
void rdfs(int u) {
vis[u] = rel2[u] = 1;
for (auto v : radj[u]) {
if (!vis[v])
dfs(v);
}
}
int cntv[MAXN];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> n >> m >> p;
for (int i = 0; i < m; i++) {
int u, v, c;
cin >> u >> v >> c;
adj[u].emplace_back(v, p - c);
radj[v].push_back(u);
}
dfs(1);
memset(vis, 0, sizeof vis);
rdfs(n);
memset(dis, 0x3f, sizeof dis);
memset(vis, 0, sizeof vis);
dis[1] = 0;
vis[1] = 1;
queue<int> q;
q.push(1);
bool pos = true;
while (!q.empty()) {
int u = q.front();
vis[u] = 0;
cntv[u]++;
if (cntv[u] >= n) {
pos = false;
break;
}
q.pop();
for (auto p : adj[u]) {
int v = p.first;
if (!rel[v] || !rel2[v])
continue;
int dd = p.second;
if (dis[v] > dd + dis[u]) {
dis[v] = dd + dis[u];
if (!vis[v]) {
vis[v] = 1;
q.push(v);
}
}
}
}
if (pos)
cout << max(0, -dis[n]) << endl;
else
cout << -1 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const int MAXN = 5555;
vector<pair<int, int>> adj[MAXN];
vector<int> radj[MAXN];
int n, m, p;
int dis[MAXN];
int vis[MAXN];
int rel[MAXN], rel2[MAXN];
void dfs(int u) {
vis[u] = rel[u] = 1;
for (auto p : adj[u]) {
int v = p.first;
if (!vis[v])
dfs(v);
}
}
void rdfs(int u) {
vis[u] = rel2[u] = 1;
for (auto v : radj[u]) {
if (!vis[v])
rdfs(v);
}
}
int cntv[MAXN];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> n >> m >> p;
for (int i = 0; i < m; i++) {
int u, v, c;
cin >> u >> v >> c;
adj[u].emplace_back(v, p - c);
radj[v].push_back(u);
}
dfs(1);
memset(vis, 0, sizeof vis);
rdfs(n);
memset(dis, 0x3f, sizeof dis);
memset(vis, 0, sizeof vis);
dis[1] = 0;
vis[1] = 1;
queue<int> q;
q.push(1);
bool pos = true;
while (!q.empty()) {
int u = q.front();
vis[u] = 0;
cntv[u]++;
if (cntv[u] >= n) {
pos = false;
break;
}
q.pop();
for (auto p : adj[u]) {
int v = p.first;
if (!rel[v] || !rel2[v])
continue;
int dd = p.second;
if (dis[v] > dd + dis[u]) {
dis[v] = dd + dis[u];
if (!vis[v]) {
vis[v] = 1;
q.push(v);
}
}
}
}
if (pos)
cout << max(0, -dis[n]) << endl;
else
cout << -1 << endl;
}
| [
"identifier.change",
"call.function.change"
] | 750,928 | 750,929 | u161130215 | cpp |
p02949 | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll LINF = 1e18;
inline ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
inline ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
template <class S, class T>
ostream &operator<<(ostream &out, const pair<S, T> &o) {
out << "(" << o.first << "," << o.second << ")";
return out;
}
template <class T> ostream &operator<<(ostream &out, const vector<T> &V) {
for (int i = 0; i < V.size(); i++) {
out << V[i];
if (i != V.size() - 1)
out << " ";
}
return out;
}
template <class T>
ostream &operator<<(ostream &out, const vector<vector<T>> &Mat) {
for (int i = 0; i < Mat.size(); i++) {
if (i != 0)
out << endl;
out << Mat[i];
}
return out;
}
template <class S, class T>
ostream &operator<<(ostream &out, const map<S, T> &mp) {
out << "{ ";
for (auto it = mp.begin(); it != mp.end(); it++) {
out << it->first << ":" << it->second;
if (mp.size() - 1 != distance(mp.begin(), it))
out << ", ";
}
out << " }";
return out;
}
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
/*
<url:https://atcoder.jp/contests/abc137/tasks/abc137_e>
問題文============================================================
=================================================================
解説=============================================================
================================================================
*/
template <class Type> Type solve(Type res = Type()) {
int N, M;
cin >> N >> M;
vector<vector<pll>> G(N);
vector<vector<ll>> rG(N);
ll P;
cin >> P;
for (int i = 0; i < M; i++) {
int A, B;
cin >> A >> B;
ll C;
cin >> C;
A--;
B--;
G[A].emplace_back(B, -(C - P));
rG[B].emplace_back(B);
}
vector<bool> can_visit_to_N(N);
function<void(int)> rec = [&](int n) {
if (can_visit_to_N[n])
return;
can_visit_to_N[n] = true;
for (auto next : rG[n])
rec((int)next);
};
rec(N - 1);
// bellman ford
vector<ll> dist(N, LINF);
dist[0] = 0;
auto ok = [&]() {
for (int i = 0; i < N; i++) {
bool update = true;
for (int v = 0; v < N; v++) {
if (dist[v] == LINF)
continue;
for (int j = 0; j < (int)G[v].size(); j++) {
ll next, cost;
tie(next, cost) = G[v][j];
if (can_visit_to_N[next] && dist[next] > dist[v] + cost) {
dist[next] = dist[v] + cost;
update = false;
if (i == N - 1)
return true;
}
}
}
if (update)
return false;
}
return false;
}();
if (ok)
res = -1;
else
res = max(0LL, -dist[N - 1]);
return res;
}
int main(void) {
cin.tie(0);
ios_base::sync_with_stdio(false);
// solve(0);
cout << fixed << setprecision(15) << solve<ll>() << endl;
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll LINF = 1e18;
inline ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
inline ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
template <class S, class T>
ostream &operator<<(ostream &out, const pair<S, T> &o) {
out << "(" << o.first << "," << o.second << ")";
return out;
}
template <class T> ostream &operator<<(ostream &out, const vector<T> &V) {
for (int i = 0; i < V.size(); i++) {
out << V[i];
if (i != V.size() - 1)
out << " ";
}
return out;
}
template <class T>
ostream &operator<<(ostream &out, const vector<vector<T>> &Mat) {
for (int i = 0; i < Mat.size(); i++) {
if (i != 0)
out << endl;
out << Mat[i];
}
return out;
}
template <class S, class T>
ostream &operator<<(ostream &out, const map<S, T> &mp) {
out << "{ ";
for (auto it = mp.begin(); it != mp.end(); it++) {
out << it->first << ":" << it->second;
if (mp.size() - 1 != distance(mp.begin(), it))
out << ", ";
}
out << " }";
return out;
}
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
/*
<url:https://atcoder.jp/contests/abc137/tasks/abc137_e>
問題文============================================================
=================================================================
解説=============================================================
T分経過してゴールした時T*P枚のコインを支払うのではなく、一回の移動毎にP枚のコインを
支払うと考える。
そうするとこの問題は各辺に対してC-Pコスト支払う最長経路問題となる。
よって、コストを負値として最短経路問題に落とし込んでベルマンフォードを行うことで求まる。
注意事項としてNに到達できない点で生じる閉路を検出してしまう場合があるので検出しないように場合分けを行う。
================================================================
*/
template <class Type> Type solve(Type res = Type()) {
int N, M;
cin >> N >> M;
vector<vector<pll>> G(N);
vector<vector<ll>> rG(N);
ll P;
cin >> P;
for (int i = 0; i < M; i++) {
int A, B;
cin >> A >> B;
ll C;
cin >> C;
A--;
B--;
G[A].emplace_back(B, -(C - P));
rG[B].emplace_back(A);
}
vector<bool> can_visit_to_N(N);
function<void(int)> rec = [&](int n) {
if (can_visit_to_N[n])
return;
can_visit_to_N[n] = true;
for (auto next : rG[n])
rec((int)next);
};
rec(N - 1);
// bellman ford
vector<ll> dist(N, LINF);
dist[0] = 0;
auto ok = [&]() {
for (int i = 0; i < N; i++) {
bool update = true;
for (int v = 0; v < N; v++) {
if (dist[v] == LINF)
continue;
for (int j = 0; j < (int)G[v].size(); j++) {
ll next, cost;
tie(next, cost) = G[v][j];
if (can_visit_to_N[next] && dist[next] > dist[v] + cost) {
dist[next] = dist[v] + cost;
update = false;
if (i == N - 1)
return true;
}
}
}
if (update)
return false;
}
return false;
}();
if (ok)
res = -1;
else
res = max(0LL, -dist[N - 1]);
return res;
}
int main(void) {
cin.tie(0);
ios_base::sync_with_stdio(false);
// solve(0);
cout << fixed << setprecision(15) << solve<ll>() << endl;
return 0;
}
| [
"identifier.change",
"call.arguments.change"
] | 750,930 | 750,931 | u728732647 | cpp |
p02949 | #include <cstdio>
const int N = 5e3 + 5;
struct Edge {
int u, v, c;
};
Edge e[N];
int start[N];
int end[N];
int d[N];
int max(int a, int b) { return a > b ? a : b; }
int main() {
int n, m, p;
scanf("%d%d%d", &n, &m, &p);
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].c);
e[i].c -= p;
}
d[1] = 0;
start[1] = 1, end[n] = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (end[e[j].v])
end[e[j].u] = 1;
if (start[e[j].u]) {
if (!start[e[j].v]) {
start[e[j].v] = 1;
d[e[j].v] = d[e[j].u] + e[j].c;
} else
d[e[j].v] = max(d[e[j].v], d[e[j].u] + e[j].c);
}
}
}
int ok = 1;
for (int i = 0; i < m; i++) {
//存在可达终点的正环才行
if (d[e[i].v] < d[e[i].u] + e[i].c && end[e[i].v] && start[e[i].u]) {
ok = 0;
break;
}
}
if (ok && start[n])
printf("%d\n", d[n]);
else
printf("-1\n");
return 0;
} | #include <cstdio>
const int N = 5e3 + 5;
struct Edge {
int u, v, c;
};
Edge e[N];
int start[N];
int end[N];
int d[N];
int max(int a, int b) { return a > b ? a : b; }
int main() {
int n, m, p;
scanf("%d%d%d", &n, &m, &p);
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].c);
e[i].c -= p;
}
d[1] = 0;
start[1] = 1, end[n] = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (end[e[j].v])
end[e[j].u] = 1;
if (start[e[j].u]) {
if (!start[e[j].v]) {
start[e[j].v] = 1;
d[e[j].v] = d[e[j].u] + e[j].c;
} else
d[e[j].v] = max(d[e[j].v], d[e[j].u] + e[j].c);
}
}
}
int ok = 1;
for (int i = 0; i < m; i++) {
//存在可达终点的正环才行
if (d[e[i].v] < d[e[i].u] + e[i].c && end[e[i].v] && start[e[i].u]) {
ok = 0;
break;
}
}
if (ok && start[n])
printf("%d\n", max(0, d[n]));
else
printf("-1\n");
return 0;
} | [
"call.add",
"call.arguments.change"
] | 750,935 | 750,936 | u602509796 | cpp |
p02949 | #include <algorithm>
#include <cstdio>
#include <queue>
#include <vector>
const int MAXN = 1e5 + 5;
int n, m, p, u, v, k;
int dist[MAXN], num[MAXN];
bool flag[MAXN], inQueue[MAXN];
struct graph {
int vertex, val;
graph(int vv = 0, int vval = 0) {
vertex = vv;
val = vval;
}
};
std::vector<graph> con[MAXN], reverse[MAXN];
std::queue<int> q;
void ins(int start, int end, int key, std::vector<graph> a[]) {
a[start].push_back(graph(end, key));
}
void init(int key) {
flag[key] = true;
for (int i = 0; i < reverse[key].size(); ++i) {
int nxt = reverse[key][i].vertex;
if (flag[nxt] == false)
init(flag[nxt]);
}
}
int spfa() {
for (int i = 2; i <= n; ++i) {
dist[i] = -(1e9 + 7);
}
dist[1] = 0;
q.push(1);
inQueue[1] = true;
while (!q.empty()) {
int cur = q.front();
q.pop();
inQueue[cur] = false;
for (int i = 0; i < con[cur].size(); ++i) {
int nxt = con[cur][i].vertex, cost = con[cur][i].val;
if (flag[nxt] && dist[nxt] < dist[cur] + cost) {
dist[nxt] = dist[cur] + cost;
if (!inQueue[nxt]) {
q.push(nxt);
inQueue[nxt] = true;
++num[nxt];
if (num[nxt] > n)
return -1;
}
}
}
}
return std::max(dist[n], 0);
}
int main() {
scanf("%d%d%d", &n, &m, &p);
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d", &u, &v, &k);
ins(u, v, k - p, con);
ins(v, u, 1, reverse);
}
init(n);
printf("%d", spfa());
return 0;
} | #include <algorithm>
#include <cstdio>
#include <queue>
#include <vector>
const int MAXN = 1e5 + 5;
int n, m, p, u, v, k;
int dist[MAXN], num[MAXN];
bool flag[MAXN], inQueue[MAXN];
struct graph {
int vertex, val;
graph(int vv = 0, int vval = 0) {
vertex = vv;
val = vval;
}
};
std::vector<graph> con[MAXN], reverse[MAXN];
std::queue<int> q;
void ins(int start, int end, int key, std::vector<graph> a[]) {
a[start].push_back(graph(end, key));
}
void init(int key) {
flag[key] = true;
for (int i = 0; i < reverse[key].size(); ++i) {
int nxt = reverse[key][i].vertex;
if (flag[nxt] == false)
init(nxt);
}
}
int spfa() {
for (int i = 2; i <= n; ++i) {
dist[i] = -(1e9 + 7);
}
dist[1] = 0;
q.push(1);
inQueue[1] = true;
while (!q.empty()) {
int cur = q.front();
q.pop();
inQueue[cur] = false;
for (int i = 0; i < con[cur].size(); ++i) {
int nxt = con[cur][i].vertex, cost = con[cur][i].val;
if (flag[nxt] && dist[nxt] < dist[cur] + cost) {
dist[nxt] = dist[cur] + cost;
if (!inQueue[nxt]) {
q.push(nxt);
inQueue[nxt] = true;
++num[nxt];
if (num[nxt] > n)
return -1;
}
}
}
}
return std::max(dist[n], 0);
}
int main() {
scanf("%d%d%d", &n, &m, &p);
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d", &u, &v, &k);
ins(u, v, k - p, con);
ins(v, u, 1, reverse);
}
init(n);
printf("%d", spfa());
return 0;
} | [
"call.arguments.change"
] | 750,951 | 750,952 | u645561303 | cpp |
p02949 | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfenv>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <time.h>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
//#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
long long MOD = 1000000000 + 7;
constexpr long long INF = numeric_limits<LL>::max() / 2;
const double PI = acos(-1);
#define fir first
#define sec second
#define thi third
#define debug(x) cerr << #x << ": " << x << '\n'
typedef pair<LL, LL> Pll;
typedef pair<LL, pair<LL, LL>> Ppll;
typedef pair<LL, pair<LL, bitset<100001>>> Pbll;
typedef pair<LL, pair<LL, vector<LL>>> Pvll;
typedef pair<LL, LL> Vec2;
struct Tll {
LL first, second, third;
};
struct Fll {
LL first, second, third, fourd;
};
typedef pair<LL, Tll> Ptll;
#define rep(i, rept) for (LL i = 0; i < rept; i++)
#define Mfor(i, mf) for (LL i = mf - 1; i >= 0; i--)
void YN(bool f) {
if (f)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
void yn(bool f) {
if (f)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
struct Edge {
LL to, cost;
};
struct edge {
LL from, to, cost;
};
vector<vector<Edge>> g;
vector<edge> edges;
vector<Pll> v;
map<string, LL> ma;
multiset<LL> st;
LL h, w, n, m, k, t, s, p, q, last, cnt, sum, ans, a[210000], b[210000],
d[10000];
string str, ss;
bool f[110000];
char c;
int di[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
int main() {
cin >> n >> m >> p;
rep(i, m) {
LL x, y, z;
cin >> x >> y >> z;
x--, y--;
edges.push_back(edge{x, y, -(z - p)});
}
rep(i, 10000) d[i] = INF;
d[0] = 0;
for (int i = 0; i < 40000; i++) {
for (int j = 0; j < (int)edges.size(); j++) {
struct edge e = edges[j];
if (d[e.from] != INF)
if (d[e.to] >
d[e.from] +
e.cost) { //移動した後のコストが小さいと、頂点のコストを更新
d[e.to] = d[e.from] + e.cost;
if (i == 40000 - 1 &&
e.to ==
n - 1) { //頂点の数と同じ回数ループすると、負の閉路があるのでループをぬける
cout << -1 << endl;
return 0;
}
}
}
}
cout << max(0LL, -d[n - 1]) << endl;
return 0;
}
| #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfenv>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <time.h>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
//#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
long long MOD = 1000000000 + 7;
constexpr long long INF = numeric_limits<LL>::max() / 2;
const double PI = acos(-1);
#define fir first
#define sec second
#define thi third
#define debug(x) cerr << #x << ": " << x << '\n'
typedef pair<LL, LL> Pll;
typedef pair<LL, pair<LL, LL>> Ppll;
typedef pair<LL, pair<LL, bitset<100001>>> Pbll;
typedef pair<LL, pair<LL, vector<LL>>> Pvll;
typedef pair<LL, LL> Vec2;
struct Tll {
LL first, second, third;
};
struct Fll {
LL first, second, third, fourd;
};
typedef pair<LL, Tll> Ptll;
#define rep(i, rept) for (LL i = 0; i < rept; i++)
#define Mfor(i, mf) for (LL i = mf - 1; i >= 0; i--)
void YN(bool f) {
if (f)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
void yn(bool f) {
if (f)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
struct Edge {
LL to, cost;
};
struct edge {
LL from, to, cost;
};
vector<vector<Edge>> g;
vector<edge> edges;
vector<Pll> v;
map<string, LL> ma;
multiset<LL> st;
LL h, w, n, m, k, t, s, p, q, last, cnt, sum, ans, a[210000], b[210000],
d[10000];
string str, ss;
bool f[110000];
char c;
int di[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
int main() {
cin >> n >> m >> p;
rep(i, m) {
LL x, y, z;
cin >> x >> y >> z;
x--, y--;
edges.push_back(edge{x, y, -(z - p)});
}
rep(i, 10000) d[i] = INF;
d[0] = 0;
for (int i = 0; i < 40000; i++) {
for (int j = 0; j < (int)edges.size(); j++) {
struct edge e = edges[j];
if (d[e.from] != INF)
if (d[e.to] >
d[e.from] +
e.cost) { //移動した後のコストが小さいと、頂点のコストを更新
d[e.to] = d[e.from] + e.cost;
if (i > 20000 &&
e.to ==
n - 1) { //頂点の数と同じ回数ループすると、負の閉路があるのでループをぬける
cout << -1 << endl;
return 0;
}
}
}
}
cout << max(0LL, -d[n - 1]) << endl;
return 0;
}
| [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 750,955 | 750,956 | u202928696 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "debug.h"
#else
#define dump(...)
#endif
#define endl "\n"
#define ll long long
#define int ll
#define BUF 1e5
#define INF 1 << 30
#define vi vector<int>
#define vvi vector<vector<int>>
#define all(a) (a).begin(), (a).end()
#define bit(n) (1LL << (n))
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
constexpr ll mod = 1e9 + 7;
ll A, B, C, D, G, H, N, M, L, K, P, Q, R, W, X, Y, Z;
string S, T;
ll ans = 0;
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
struct edge {
int from, to, cost;
};
edge es[5001];
int d[2501];
int V, E;
bool shortest_path(int s) {
for (int i = 0; i < V; i++) {
d[i] = INF;
}
d[s] = 0;
for (int i = 0; i < 2 * V; i++) {
for (int j = 0; j < E; j++) {
edge e = es[j];
if (d[e.from] != INF && d[e.to] > d[e.from] + e.cost) {
d[e.to] = d[e.from] + e.cost;
if (i == 2 * V - 1 && e.to == V - 1) {
return false;
}
}
}
}
return true;
}
signed main() {
cin >> V >> E >> P;
for (int i = 0; i < E; i++) {
cin >> es[i].from >> es[i].to >> es[i].cost;
es[i].from--, es[i].to--;
es[i].cost -= P;
es[i].cost *= -1;
}
vector<int> v;
if (shortest_path(0)) {
cout << max(-d[V - 1], 0LL) << endl;
} else {
cout << -1 << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "debug.h"
#else
#define dump(...)
#endif
#define endl "\n"
#define ll long long
#define int ll
#define BUF 1e5
#define INF 1 << 30
#define vi vector<int>
#define vvi vector<vector<int>>
#define all(a) (a).begin(), (a).end()
#define bit(n) (1LL << (n))
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
constexpr ll mod = 1e9 + 7;
ll A, B, C, D, G, H, N, M, L, K, P, Q, R, W, X, Y, Z;
string S, T;
ll ans = 0;
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
struct edge {
int from, to, cost;
};
edge es[5001];
int d[2501];
int V, E;
bool shortest_path(int s) {
for (int i = 0; i < V; i++) {
d[i] = INF;
}
d[s] = 0;
for (int i = 0; i < 2 * V; i++) {
for (int j = 0; j < E; j++) {
edge e = es[j];
if (d[e.from] != INF && d[e.to] > d[e.from] + e.cost) {
d[e.to] = d[e.from] + e.cost;
if (i >= V && e.to == V - 1) {
return false;
}
}
}
}
return true;
}
signed main() {
cin >> V >> E >> P;
for (int i = 0; i < E; i++) {
cin >> es[i].from >> es[i].to >> es[i].cost;
es[i].from--, es[i].to--;
es[i].cost -= P;
es[i].cost *= -1;
}
vector<int> v;
if (shortest_path(0)) {
cout << max(-d[V - 1], 0LL) << endl;
} else {
cout << -1 << endl;
}
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 750,960 | 750,961 | u030090262 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "debug.h"
#else
#define dump(...)
#endif
#define endl "\n"
#define ll long long
#define int ll
#define BUF 1e5
#define INF 1 << 30
#define vi vector<int>
#define vvi vector<vector<int>>
#define all(a) (a).begin(), (a).end()
#define bit(n) (1LL << (n))
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
constexpr ll mod = 1e9 + 7;
ll A, B, C, D, G, H, N, M, L, K, P, Q, R, W, X, Y, Z;
string S, T;
ll ans = 0;
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
struct edge {
int from, to, cost;
};
edge es[5001];
int d[2501];
int V, E;
bool shortest_path(int s) {
for (int i = 0; i < V; i++) {
d[i] = INF;
}
d[s] = 0;
for (int i = 0; i < V; i++) {
for (int j = 0; j < E; j++) {
edge e = es[j];
if (d[e.from] != INF && d[e.to] > d[e.from] + e.cost) {
d[e.to] = d[e.from] + e.cost;
if (i == V - 1 && e.to == V - 1) {
return false;
}
}
}
}
return true;
}
signed main() {
cin >> V >> E >> P;
for (int i = 0; i < E; i++) {
cin >> es[i].from >> es[i].to >> es[i].cost;
es[i].from--, es[i].to--;
es[i].cost -= P;
es[i].cost *= -1;
}
vector<int> v;
if (shortest_path(0)) {
cout << max(-d[V - 1], 0LL) << endl;
} else {
cout << -1 << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "debug.h"
#else
#define dump(...)
#endif
#define endl "\n"
#define ll long long
#define int ll
#define BUF 1e5
#define INF 1 << 30
#define vi vector<int>
#define vvi vector<vector<int>>
#define all(a) (a).begin(), (a).end()
#define bit(n) (1LL << (n))
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
constexpr ll mod = 1e9 + 7;
ll A, B, C, D, G, H, N, M, L, K, P, Q, R, W, X, Y, Z;
string S, T;
ll ans = 0;
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
struct edge {
int from, to, cost;
};
edge es[5001];
int d[2501];
int V, E;
bool shortest_path(int s) {
for (int i = 0; i < V; i++) {
d[i] = INF;
}
d[s] = 0;
for (int i = 0; i < 2 * V; i++) {
for (int j = 0; j < E; j++) {
edge e = es[j];
if (d[e.from] != INF && d[e.to] > d[e.from] + e.cost) {
d[e.to] = d[e.from] + e.cost;
if (i >= V && e.to == V - 1) {
return false;
}
}
}
}
return true;
}
signed main() {
cin >> V >> E >> P;
for (int i = 0; i < E; i++) {
cin >> es[i].from >> es[i].to >> es[i].cost;
es[i].from--, es[i].to--;
es[i].cost -= P;
es[i].cost *= -1;
}
vector<int> v;
if (shortest_path(0)) {
cout << max(-d[V - 1], 0LL) << endl;
} else {
cout << -1 << endl;
}
} | [
"control_flow.loop.for.condition.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 750,963 | 750,961 | u030090262 | cpp |
p02949 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
#define all(x) x.begin(), x.end()
const ll mod = 1e9 + 7;
const ll INF = 1e9;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
vector<vector<P>> g;
bool has_positive_cycle(int target, int pos, vector<int> flag, int cost) {
flag[pos]++;
for (int i = 0; i < g[pos].size(); i++) {
int x = g[pos][i].first;
if (x == target) {
return cost + g[pos][i].second > 0;
}
if (flag[x] < 0) {
return has_positive_cycle(target, x, flag, cost + g[pos][i].second);
}
}
return false;
}
bool go_target(int target, int pos, vector<int> flag) {
flag[pos]++;
for (int i = 0; i < g[pos].size(); i++) {
int x = g[pos][i].first;
if (x == target) {
return true;
}
if (flag[x] < 0) {
return go_target(target, x, flag);
}
}
return false;
}
int main() {
int n, m, p;
cin >> n >> m >> p;
g.resize(n);
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
c = max(0, c - p);
g[a].push_back(P(b, c));
}
// for (int i = 1; i < n-1; i++){
// vector<int> flag1(n,-1),flag2(n,-1);
// if(!go_target(i,0,flag1) || !go_target(i,n-1,flag2)){
// for (int j = 0; j < g[i].size(); j++){
// g[i][j].second= 0;
// }
// }
// }
// for (int i = 0; i < n; i++){
// vector<int> flag(n,-1);
// if(has_positive_cycle(i,i,flag,0)){
// cout<<-1<<endl;
// return 0;
// }
// }
for (int i = 0; i < n; i++) {
for (int j = 0; j < g[i].size(); j++) {
g[i][j].second *= -1;
}
}
int ret = 1e9;
vector<int> dist(n, 1e9);
dist[0] = 0;
for (int k = 0; k < n * 2; k++) {
bool update = false;
for (int i = 0; i < n; i++) {
for (int j = 0; j < g[i].size(); j++) {
int to = g[i][j].first;
int cost = g[i][j].second;
if (dist[i] != 1e9 && dist[to] > dist[i] + cost) {
dist[to] = dist[i] + cost;
update = true;
}
}
if (update) {
// cout<<dist[n-1]<<endl;
if (k >= n && dist[n - 1] < ret) {
cout << -1 << endl;
return 0;
}
ret = dist[n - 1];
// break;
}
}
}
cout << max(0, -1 * dist[n - 1]) << endl;
return 0;
} | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
#define all(x) x.begin(), x.end()
const ll mod = 1e9 + 7;
const ll INF = 1e9;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
vector<vector<P>> g;
bool has_positive_cycle(int target, int pos, vector<int> flag, int cost) {
flag[pos]++;
for (int i = 0; i < g[pos].size(); i++) {
int x = g[pos][i].first;
if (x == target) {
return cost + g[pos][i].second > 0;
}
if (flag[x] < 0) {
return has_positive_cycle(target, x, flag, cost + g[pos][i].second);
}
}
return false;
}
bool go_target(int target, int pos, vector<int> flag) {
flag[pos]++;
for (int i = 0; i < g[pos].size(); i++) {
int x = g[pos][i].first;
if (x == target) {
return true;
}
if (flag[x] < 0) {
return go_target(target, x, flag);
}
}
return false;
}
int main() {
int n, m, p;
cin >> n >> m >> p;
g.resize(n);
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
c = c - p;
g[a].push_back(P(b, c));
}
// for (int i = 1; i < n-1; i++){
// vector<int> flag1(n,-1),flag2(n,-1);
// if(!go_target(i,0,flag1) || !go_target(i,n-1,flag2)){
// for (int j = 0; j < g[i].size(); j++){
// g[i][j].second= 0;
// }
// }
// }
// for (int i = 0; i < n; i++){
// vector<int> flag(n,-1);
// if(has_positive_cycle(i,i,flag,0)){
// cout<<-1<<endl;
// return 0;
// }
// }
for (int i = 0; i < n; i++) {
for (int j = 0; j < g[i].size(); j++) {
g[i][j].second *= -1;
}
}
int ret = 1e9;
vector<int> dist(n, 1e9);
dist[0] = 0;
for (int k = 0; k < n * 2; k++) {
bool update = false;
for (int i = 0; i < n; i++) {
for (int j = 0; j < g[i].size(); j++) {
int to = g[i][j].first;
int cost = g[i][j].second;
if (dist[i] != 1e9 && dist[to] > dist[i] + cost) {
dist[to] = dist[i] + cost;
update = true;
}
}
if (update) {
// cout<<dist[n-1]<<endl;
if (k >= n && dist[n - 1] < ret) {
cout << -1 << endl;
return 0;
}
ret = dist[n - 1];
// break;
}
}
}
cout << max(0, -1 * dist[n - 1]) << endl;
return 0;
} | [
"call.remove",
"call.arguments.change"
] | 750,966 | 750,967 | u700986952 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
struct edge {
int from;
int to;
ll cost;
};
typedef pair<ll, ll> P;
vector<edge> es;
ll dist[2505];
ll inf = pow(1, 50);
std::vector<int> rev_g[2505];
int ok[2505];
ll n, m, p;
void bfs(int v) {
ok[v] = 1;
for (auto u : rev_g[v]) {
if (ok[u])
continue;
bfs(u);
}
}
bool solve_bf() {
dist[0] = 0;
for (int i = 0; i < n; i++) {
bool update = 0;
for (auto e : es) {
if (ok[e.from] && ok[e.to] && dist[e.from] != inf &&
dist[e.to] > dist[e.from] + e.cost) {
dist[e.to] = dist[e.from] + e.cost;
update = 1;
}
}
if (!update)
break;
if (i == n - 1) {
cout << -1 << endl;
exit(0);
}
}
return true;
}
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
for (int i = 0; i < 2505; i++)
dist[i] = inf;
cin >> n >> m >> p;
for (int i = 0; i < m; i++) {
int a, b;
ll c;
cin >> a >> b >> c;
a--;
b--;
es.push_back({a, b, -c + p});
rev_g[b].push_back(a);
}
bfs(n - 1);
solve_bf();
cout << max(dist[n - 1] * -1, 0ll) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
struct edge {
int from;
int to;
ll cost;
};
typedef pair<ll, ll> P;
vector<edge> es;
ll dist[2505];
ll inf = 1ll << 50;
std::vector<int> rev_g[2505];
int ok[2505];
ll n, m, p;
void bfs(int v) {
ok[v] = 1;
for (auto u : rev_g[v]) {
if (ok[u])
continue;
bfs(u);
}
}
bool solve_bf() {
dist[0] = 0;
for (int i = 0; i < n; i++) {
bool update = 0;
for (auto e : es) {
if (ok[e.from] && ok[e.to] && dist[e.from] != inf &&
dist[e.to] > dist[e.from] + e.cost) {
dist[e.to] = dist[e.from] + e.cost;
update = 1;
}
}
if (!update)
break;
if (i == n - 1) {
cout << -1 << endl;
exit(0);
}
}
return true;
}
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
for (int i = 0; i < 2505; i++)
dist[i] = inf;
cin >> n >> m >> p;
for (int i = 0; i < m; i++) {
int a, b;
ll c;
cin >> a >> b >> c;
a--;
b--;
es.push_back({a, b, -c + p});
rev_g[b].push_back(a);
}
bfs(n - 1);
solve_bf();
cout << max(dist[n - 1] * -1, 0ll) << endl;
return 0;
}
| [
"call.remove",
"call.arguments.change"
] | 750,968 | 750,969 | u440032761 | cpp |
p02949 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define INF 1000000000;
typedef long long ll;
ll n, m, P, d[2500], d1[2500], d2[2500];
struct edge {
ll a;
ll b;
ll c;
};
vector<edge> v;
queue<ll> q;
vector<ll> ch1[2500], ch2[2500];
int main(void) {
cin >> n >> m >> P;
for (int i = 1; i < n; i++)
d[i] = INF;
for (int i = 0; i < m; i++) {
struct edge add;
cin >> add.a >> add.b >> add.c;
add.a--, add.b--, add.c = P - add.c;
ch1[add.a].push_back(add.b);
ch2[add.b].push_back(add.a);
v.push_back(add);
}
d1[0] = 1;
for (auto x : ch1[0]) {
q.push(x);
}
while (!q.empty()) {
ll p = q.front();
q.pop();
if (d1[p] == 0) {
for (auto x : ch1[0])
q.push(x);
d1[p] = 1;
}
}
d2[n - 1] = 1;
for (auto x : ch2[n - 1]) {
q.push(x);
}
while (!q.empty()) {
ll p = q.front();
q.pop();
if (d2[p] == 0 && d1[p] == 1) {
for (auto x : ch2[0])
q.push(x);
d2[p] = 1;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
struct edge e = v[j];
if (d2[e.a] == 1 && d2[e.b] == 1 && d[e.a] + e.c < d[e.b]) {
d[e.b] = d[e.a] + e.c;
if (i == n - 1) {
cout << -1 << endl;
return 0;
}
}
}
}
cout << max(0LL, -d[n - 1]) << endl;
}
| #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define INF 1000000000;
typedef long long ll;
ll n, m, P, d[2500], d1[2500], d2[2500];
struct edge {
ll a;
ll b;
ll c;
};
vector<edge> v;
queue<ll> q;
vector<ll> ch1[2500], ch2[2500];
int main(void) {
cin >> n >> m >> P;
for (int i = 1; i < n; i++)
d[i] = INF;
for (int i = 0; i < m; i++) {
struct edge add;
cin >> add.a >> add.b >> add.c;
add.a--, add.b--, add.c = P - add.c;
ch1[add.a].push_back(add.b);
ch2[add.b].push_back(add.a);
v.push_back(add);
}
d1[0] = 1;
for (auto x : ch1[0]) {
q.push(x);
}
while (!q.empty()) {
ll p = q.front();
q.pop();
if (d1[p] == 0) {
for (auto x : ch1[p])
q.push(x);
d1[p] = 1;
}
}
d2[n - 1] = 1;
for (auto x : ch2[n - 1]) {
q.push(x);
}
while (!q.empty()) {
ll p = q.front();
q.pop();
if (d2[p] == 0 && d1[p] == 1) {
for (auto x : ch2[p])
q.push(x);
d2[p] = 1;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
struct edge e = v[j];
if (d2[e.a] == 1 && d2[e.b] == 1 && d[e.a] + e.c < d[e.b]) {
d[e.b] = d[e.a] + e.c;
if (i == n - 1) {
cout << -1 << endl;
return 0;
}
}
}
}
cout << max(0LL, -d[n - 1]) << endl;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change"
] | 750,975 | 750,976 | u050428930 | cpp |
p02949 | #include <bits/stdc++.h>
#define repd(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) repd(i, 0, n)
#define int long long
typedef long long ll;
const int MOD = 1000000007;
const int INF = 1010000000;
const double EPS = 1e-10;
using namespace std;
signed main() {
int n, m, p;
cin >> n >> m >> p;
pair<pair<int, int>, int> g[5100];
int d[2600];
rep(i, m) {
cin >> g[i].first.first >> g[i].first.second >> g[i].second;
g[i].second -= p;
g[i].second *= -1;
}
rep(i, 2600) d[i] = INF;
d[1] = 0;
int dd;
rep(i, 2 * n) {
bool updated = false;
rep(j, m) {
pair<int, int> e = g[j].first;
int cost = g[j].second;
if (d[e.first] != INF && d[e.second] > d[e.first] + cost) {
if (i < n - 1)
d[e.second] = d[e.first] + cost;
else
d[e.second] = LLONG_MIN;
updated = true;
}
}
if (i < n - 1) {
dd = d[n];
}
if (!updated)
break;
}
if (dd == d[n])
cout << max((ll)0, d[n] * -1) << endl;
else
cout << -1 << endl;
}
| #include <bits/stdc++.h>
#define repd(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) repd(i, 0, n)
#define int long long
typedef long long ll;
const int MOD = 1000000007;
const int INF = 1010000000;
const double EPS = 1e-10;
using namespace std;
signed main() {
int n, m, p;
cin >> n >> m >> p;
pair<pair<int, int>, int> g[5100];
int d[2600];
rep(i, m) {
cin >> g[i].first.first >> g[i].first.second >> g[i].second;
g[i].second -= p;
g[i].second *= -1;
}
rep(i, 2600) d[i] = INF;
d[1] = 0;
int dd;
rep(i, 2 * n) {
bool updated = false;
rep(j, m) {
pair<int, int> e = g[j].first;
int cost = g[j].second;
if (d[e.first] != INF && d[e.second] > d[e.first] + cost) {
if (i < n - 1)
d[e.second] = d[e.first] + cost;
else
d[e.second] = -922337203685;
updated = true;
}
}
if (i < n - 1) {
dd = d[n];
}
if (!updated)
break;
}
if (dd == d[n])
cout << max((ll)0, d[n] * -1) << endl;
else
cout << -1 << endl;
}
| [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 750,994 | 750,995 | u317754719 | cpp |
p02949 | #include <functional>
#include <iostream>
#include <limits>
#include <queue>
#include <vector>
using namespace std;
//===
template <class T> struct Edge {
int src, to;
T cost;
Edge(int to, T cost) : src(-1), to(to), cost(cost){};
Edge(int src, int to, T cost) : src(src), to(to), cost(cost){};
operator int() const { return to; };
};
template <class T> using WeightedGraph = vector<vector<Edge<T>>>;
using UnWeightedGraph = vector<vector<int>>;
//===
//===
// require graph/basic.cpp
// #inlcude <limits>
// when g has negative cycle, it returns empty vector<>
// time: O(|E||V|)
template <class T, class Compare = less<T>>
vector<T> bellman_ford(WeightedGraph<T> &g, int from,
const T INF = numeric_limits<T>::max(),
const Compare &cmp = Compare()) {
const int V = g.size();
vector<T> min_cost(g.size(), INF);
min_cost[from] = 0;
for (int k = 0; k < V; k++) {
for (int i = 0; i < V; i++) {
for (auto &e : g[i]) {
if (min_cost[i] == INF)
break;
if (cmp(min_cost[i] + e.cost, min_cost[e.to])) {
min_cost[e.to] = min_cost[i] + e.cost;
if (k == V - 1)
return vector<T>();
}
}
}
}
return min_cost;
};
// when some negative cycles is into from->to path has, it returns empty
// vector<T>
template <class T, class Compare = less<T>>
vector<T> bellman_ford(WeightedGraph<T> &g, int from, int to,
const T INF = numeric_limits<T>::max(),
const Compare &cmp = Compare()) {
const int V = g.size();
vector<T> min_cost(g.size(), INF);
vector<bool> used(g.size(), 0);
vector<bool> reach(g.size(), 0);
/*
auto dfs = [&rec = [&](auto f, int u) -> bool {
if (used[u]) return reach[u];
used[u] = true;
for (int v:g[u]) reach[u] = reach[u] | f(f, v);
return reach[u];
}] (int u) -> bool {return rec(rec, u);};
*/
function<bool(int)> dfs = [&dfs, &g, &min_cost, &used,
&reach](int u) -> bool {
if (used[u])
return reach[u];
used[u] = true;
for (int v : g[u])
reach[u] = reach[u] | dfs(v);
return reach[u];
};
reach[to] = true;
for (int i = 0; i < V; i++)
dfs(i);
min_cost[from] = 0;
for (int k = 0; k < V; k++) {
for (int i = 0; i < V; i++) {
for (auto &e : g[i]) {
if (min_cost[i] == INF)
break;
if (cmp(min_cost[i] + e.cost, min_cost[e.to])) {
min_cost[e.to] = min_cost[i] + e.cost;
if (k == V - 1 && reach[i])
return vector<T>();
}
}
}
}
return min_cost;
};
//===
int AOJ_GRL_1_B() {
int V, E, R;
int s, t, d;
cin >> V >> E >> R;
WeightedGraph<int> G(V);
for (int i = 0; i < E; i++) {
cin >> s >> t >> d;
G[s].emplace_back(t, d);
}
auto dist = bellman_ford(G, R);
if (dist.empty())
cout << "NEGATIVE CYCLE" << endl;
for (auto &e : dist) {
if (e == numeric_limits<int>::max())
cout << "INF" << endl;
else
cout << e << endl;
}
return 0;
};
int ABC137_E() {
using llong = long long;
llong n, m, p;
llong a, b, c;
WeightedGraph<llong> G(2505);
cin >> n >> m >> p;
for (int i = 0; i < m; i++) {
cin >> a >> b >> c;
G[a].emplace_back(b, c - p);
}
auto dist =
bellman_ford(G, 1, n, numeric_limits<llong>::min(), greater<llong>());
if (dist.empty())
cout << -1 << endl;
else
cout << max(0ll, -dist[n]) << endl;
return 0;
};
int main() {
return ABC137_E();
// return AOJ_GRL_1_B();
};
| #include <functional>
#include <iostream>
#include <limits>
#include <queue>
#include <vector>
using namespace std;
//===
template <class T> struct Edge {
int src, to;
T cost;
Edge(int to, T cost) : src(-1), to(to), cost(cost){};
Edge(int src, int to, T cost) : src(src), to(to), cost(cost){};
operator int() const { return to; };
};
template <class T> using WeightedGraph = vector<vector<Edge<T>>>;
using UnWeightedGraph = vector<vector<int>>;
//===
//===
// require graph/basic.cpp
// #inlcude <limits>
// when g has negative cycle, it returns empty vector<>
// time: O(|E||V|)
template <class T, class Compare = less<T>>
vector<T> bellman_ford(WeightedGraph<T> &g, int from,
const T INF = numeric_limits<T>::max(),
const Compare &cmp = Compare()) {
const int V = g.size();
vector<T> min_cost(g.size(), INF);
min_cost[from] = 0;
for (int k = 0; k < V; k++) {
for (int i = 0; i < V; i++) {
for (auto &e : g[i]) {
if (min_cost[i] == INF)
break;
if (cmp(min_cost[i] + e.cost, min_cost[e.to])) {
min_cost[e.to] = min_cost[i] + e.cost;
if (k == V - 1)
return vector<T>();
}
}
}
}
return min_cost;
};
// when some negative cycles is into from->to path has, it returns empty
// vector<T>
template <class T, class Compare = less<T>>
vector<T> bellman_ford(WeightedGraph<T> &g, int from, int to,
const T INF = numeric_limits<T>::max(),
const Compare &cmp = Compare()) {
const int V = g.size();
vector<T> min_cost(g.size(), INF);
vector<bool> used(g.size(), 0);
vector<bool> reach(g.size(), 0);
/*
auto dfs = [&rec = [&](auto f, int u) -> bool {
if (used[u]) return reach[u];
used[u] = true;
for (int v:g[u]) reach[u] = reach[u] | f(f, v);
return reach[u];
}] (int u) -> bool {return rec(rec, u);};
*/
function<bool(int)> dfs = [&dfs, &g, &min_cost, &used,
&reach](int u) -> bool {
if (used[u])
return reach[u];
used[u] = true;
for (int v : g[u])
reach[u] = reach[u] | dfs(v);
return reach[u];
};
reach[to] = true;
for (int i = 0; i < V; i++)
dfs(i);
min_cost[from] = 0;
for (int k = 0; k < V; k++) {
for (int i = 0; i < V; i++) {
for (auto &e : g[i]) {
if (min_cost[i] == INF)
break;
if (cmp(min_cost[i] + e.cost, min_cost[e.to])) {
min_cost[e.to] = min_cost[i] + e.cost;
if (k == V - 1 && reach[i])
return vector<T>();
}
}
}
}
return min_cost;
};
//===
int AOJ_GRL_1_B() {
int V, E, R;
int s, t, d;
cin >> V >> E >> R;
WeightedGraph<int> G(V);
for (int i = 0; i < E; i++) {
cin >> s >> t >> d;
G[s].emplace_back(t, d);
}
auto dist = bellman_ford(G, R);
if (dist.empty())
cout << "NEGATIVE CYCLE" << endl;
for (auto &e : dist) {
if (e == numeric_limits<int>::max())
cout << "INF" << endl;
else
cout << e << endl;
}
return 0;
};
int ABC137_E() {
using llong = long long;
llong n, m, p;
llong a, b, c;
WeightedGraph<llong> G(2505);
cin >> n >> m >> p;
for (int i = 0; i < m; i++) {
cin >> a >> b >> c;
G[a].emplace_back(b, c - p);
}
auto dist =
bellman_ford(G, 1, n, numeric_limits<llong>::min(), greater<llong>());
if (dist.empty())
cout << -1 << endl;
else
cout << max(0ll, dist[n]) << endl;
return 0;
};
int main() {
return ABC137_E();
// return AOJ_GRL_1_B();
};
| [
"expression.operation.unary.arithmetic.remove",
"call.arguments.change"
] | 750,999 | 751,000 | u683588090 | cpp |
p02949 | #ifdef _MSC_VER
#pragma warning(disable : 4996)
#include <intrin.h>
#define __builtin_popcount __popcnt
#endif
#include <limits.h>
#include <math.h>
#include <time.h>
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; ++i)
#define REPR(i, n) for (int i = n - 1; i >= 0; --i)
#define FOR(i, m, n) for (int i = m; i < n; ++i)
#define FORR(i, m, n) for (int i = m - 1; i >= n; --i)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define REVERSE(v, n) reverse(v, v + n);
#define VREVERSE(v) reverse(v.begin(), v.end())
#define ll long long
#define print(x) cout << (x) << '\n'
#define pe(x) cout << (x) << " "
#define DEBUG(x) cout << #x << ": " << x << endl
#define lb(v, n) lower_bound(v.begin(), v.end(), (n))
#define ub(v, n) upper_bound(v.begin(), v.end(), (n))
#define int long long
//#define double long double
#define all(x) (x).begin(), (x).end()
#define print_space(v) \
REP(i, v.size()) cout << v[i] << ((i == v.size() - 1) ? "\n" : " ")
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
typedef pair<int, int> pii;
typedef array<int, 3> arr3;
std::random_device rd;
std::mt19937 mt(rd());
constexpr ll MOD = 1e9 + 7;
constexpr int MAX = 200020;
const double pi = acos(-1);
constexpr double EPS = 1e-8;
constexpr ll INF = 1e16;
using Point = complex<double>;
typedef int Weight;
struct Edge {
int src, dst;
Weight weight;
Edge(int src, int dst, Weight weight) : src(src), dst(dst), weight(weight) {}
};
bool operator<(const Edge &e, const Edge &f) {
return e.weight != f.weight ? e.weight > f.weight : // !!INVERSE!!
e.src != f.src ? e.src < f.src
: e.dst < f.dst;
}
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
typedef vector<Weight> Array;
typedef vector<Array> Matrix;
bool vis[10010];
bool canreach[10010];
void dfs(int n, int pre, Graph &g) {
vis[n] = true;
canreach[n] = true;
for (auto e : g[n]) {
int nxt = e.dst;
if (vis[nxt])
continue;
dfs(nxt, n, g);
}
}
bool shortestPath(const Graph g, int s, vector<Weight> &dist,
vector<int> &prev) {
int n = g.size();
dist.assign(n, INF + INF);
dist[s] = 0;
prev.assign(n, -2);
bool negative_cycle = false;
REP(k, n) REP(i, n) for (auto e : g[i]) {
if (!canreach[e.src])
continue;
if (dist[e.dst] > dist[e.src] + e.weight) {
dist[e.dst] = dist[e.src] + e.weight;
prev[e.dst] = e.src;
if (k == n - 1) {
dist[e.dst] = -INF;
negative_cycle = true;
}
}
}
return !negative_cycle;
}
vector<int> buildPath(const vector<int> &prev, int t) {
vector<int> path;
for (int u = t; u >= 0; u = prev[u])
path.push_back(u);
reverse(path.begin(), path.end());
return path;
}
void solve() {
int N, M, P;
cin >> N >> M >> P;
Graph g;
g.resize(N);
REP(i, M) {
int u, v, c;
cin >> u >> v >> c;
c -= P;
c = -c;
u--, v--;
g[u].push_back({u, v, c});
}
dfs(0, 0, g);
vector<int> dist, prev;
bool ret = shortestPath(g, 0, dist, prev);
if (dist[N - 1] == -INF) {
cout << -1 << endl;
} else
cout << max(0LL, -dist[N - 1]) << endl;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
// int q; cin >> q;
// while (q--)
solve();
}
| #ifdef _MSC_VER
#pragma warning(disable : 4996)
#include <intrin.h>
#define __builtin_popcount __popcnt
#endif
#include <limits.h>
#include <math.h>
#include <time.h>
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; ++i)
#define REPR(i, n) for (int i = n - 1; i >= 0; --i)
#define FOR(i, m, n) for (int i = m; i < n; ++i)
#define FORR(i, m, n) for (int i = m - 1; i >= n; --i)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define REVERSE(v, n) reverse(v, v + n);
#define VREVERSE(v) reverse(v.begin(), v.end())
#define ll long long
#define print(x) cout << (x) << '\n'
#define pe(x) cout << (x) << " "
#define DEBUG(x) cout << #x << ": " << x << endl
#define lb(v, n) lower_bound(v.begin(), v.end(), (n))
#define ub(v, n) upper_bound(v.begin(), v.end(), (n))
#define int long long
//#define double long double
#define all(x) (x).begin(), (x).end()
#define print_space(v) \
REP(i, v.size()) cout << v[i] << ((i == v.size() - 1) ? "\n" : " ")
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
typedef pair<int, int> pii;
typedef array<int, 3> arr3;
std::random_device rd;
std::mt19937 mt(rd());
constexpr ll MOD = 1e9 + 7;
constexpr int MAX = 200020;
const double pi = acos(-1);
constexpr double EPS = 1e-8;
constexpr ll INF = 1e16;
using Point = complex<double>;
typedef int Weight;
struct Edge {
int src, dst;
Weight weight;
Edge(int src, int dst, Weight weight) : src(src), dst(dst), weight(weight) {}
};
bool operator<(const Edge &e, const Edge &f) {
return e.weight != f.weight ? e.weight > f.weight : // !!INVERSE!!
e.src != f.src ? e.src < f.src
: e.dst < f.dst;
}
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
typedef vector<Weight> Array;
typedef vector<Array> Matrix;
bool vis[10010];
bool canreach[10010];
void dfs(int n, int pre, Graph &g) {
vis[n] = true;
canreach[n] = true;
for (auto e : g[n]) {
int nxt = e.dst;
if (vis[nxt])
continue;
dfs(nxt, n, g);
}
}
bool shortestPath(const Graph g, int s, vector<Weight> &dist,
vector<int> &prev) {
int n = g.size();
dist.assign(n, INF + INF);
dist[s] = 0;
prev.assign(n, -2);
bool negative_cycle = false;
REP(k, 10 * n) REP(i, n) for (auto e : g[i]) {
if (!canreach[e.src])
continue;
if (dist[e.dst] > dist[e.src] + e.weight) {
dist[e.dst] = dist[e.src] + e.weight;
prev[e.dst] = e.src;
if (k >= n - 1) {
dist[e.dst] = -INF;
negative_cycle = true;
}
}
}
return !negative_cycle;
}
vector<int> buildPath(const vector<int> &prev, int t) {
vector<int> path;
for (int u = t; u >= 0; u = prev[u])
path.push_back(u);
reverse(path.begin(), path.end());
return path;
}
void solve() {
int N, M, P;
cin >> N >> M >> P;
Graph g;
g.resize(N);
REP(i, M) {
int u, v, c;
cin >> u >> v >> c;
c -= P;
c = -c;
u--, v--;
g[u].push_back({u, v, c});
}
dfs(0, 0, g);
vector<int> dist, prev;
bool ret = shortestPath(g, 0, dist, prev);
if (dist[N - 1] == -INF) {
cout << -1 << endl;
} else
cout << max(0LL, -dist[N - 1]) << endl;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
// int q; cin >> q;
// while (q--)
solve();
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 751,001 | 751,002 | u859396346 | cpp |
p02949 | #ifdef _MSC_VER
#pragma warning(disable : 4996)
#include <intrin.h>
#define __builtin_popcount __popcnt
#endif
#include <limits.h>
#include <math.h>
#include <time.h>
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; ++i)
#define REPR(i, n) for (int i = n - 1; i >= 0; --i)
#define FOR(i, m, n) for (int i = m; i < n; ++i)
#define FORR(i, m, n) for (int i = m - 1; i >= n; --i)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define REVERSE(v, n) reverse(v, v + n);
#define VREVERSE(v) reverse(v.begin(), v.end())
#define ll long long
#define print(x) cout << (x) << '\n'
#define pe(x) cout << (x) << " "
#define DEBUG(x) cout << #x << ": " << x << endl
#define lb(v, n) lower_bound(v.begin(), v.end(), (n))
#define ub(v, n) upper_bound(v.begin(), v.end(), (n))
#define int long long
//#define double long double
#define all(x) (x).begin(), (x).end()
#define print_space(v) \
REP(i, v.size()) cout << v[i] << ((i == v.size() - 1) ? "\n" : " ")
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
typedef pair<int, int> pii;
typedef array<int, 3> arr3;
std::random_device rd;
std::mt19937 mt(rd());
constexpr ll MOD = 1e9 + 7;
constexpr int MAX = 200020;
const double pi = acos(-1);
constexpr double EPS = 1e-8;
constexpr ll INF = 1e16;
using Point = complex<double>;
typedef int Weight;
struct Edge {
int src, dst;
Weight weight;
Edge(int src, int dst, Weight weight) : src(src), dst(dst), weight(weight) {}
};
bool operator<(const Edge &e, const Edge &f) {
return e.weight != f.weight ? e.weight > f.weight : // !!INVERSE!!
e.src != f.src ? e.src < f.src
: e.dst < f.dst;
}
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
typedef vector<Weight> Array;
typedef vector<Array> Matrix;
bool vis[10010];
bool canreach[10010];
void dfs(int n, int pre, Graph &g) {
vis[n] = true;
canreach[n] = true;
for (auto e : g[n]) {
int nxt = e.dst;
if (vis[nxt])
continue;
dfs(nxt, n, g);
}
}
bool shortestPath(const Graph g, int s, vector<Weight> &dist,
vector<int> &prev) {
int n = g.size();
dist.assign(n, INF + INF);
dist[s] = 0;
prev.assign(n, -2);
bool negative_cycle = false;
REP(k, n) REP(i, n) for (auto e : g[i]) {
if (!canreach[e.src])
continue;
if (dist[e.dst] > dist[e.src] + e.weight) {
dist[e.dst] = dist[e.src] + e.weight;
prev[e.dst] = e.src;
if (k = n - 1) {
dist[e.dst] = -INF;
negative_cycle = true;
}
}
}
return !negative_cycle;
}
vector<int> buildPath(const vector<int> &prev, int t) {
vector<int> path;
for (int u = t; u >= 0; u = prev[u])
path.push_back(u);
reverse(path.begin(), path.end());
return path;
}
void solve() {
int N, M, P;
cin >> N >> M >> P;
Graph g;
g.resize(N);
REP(i, M) {
int u, v, c;
cin >> u >> v >> c;
c -= P;
c = -c;
u--, v--;
g[u].push_back({u, v, c});
}
dfs(0, 0, g);
vector<int> dist, prev;
bool ret = shortestPath(g, 0, dist, prev);
if (dist[N - 1] == -INF) {
cout << -1 << endl;
} else
cout << max(0LL, -dist[N - 1]) << endl;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
// int q; cin >> q;
// while (q--)
solve();
}
| #ifdef _MSC_VER
#pragma warning(disable : 4996)
#include <intrin.h>
#define __builtin_popcount __popcnt
#endif
#include <limits.h>
#include <math.h>
#include <time.h>
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; ++i)
#define REPR(i, n) for (int i = n - 1; i >= 0; --i)
#define FOR(i, m, n) for (int i = m; i < n; ++i)
#define FORR(i, m, n) for (int i = m - 1; i >= n; --i)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define REVERSE(v, n) reverse(v, v + n);
#define VREVERSE(v) reverse(v.begin(), v.end())
#define ll long long
#define print(x) cout << (x) << '\n'
#define pe(x) cout << (x) << " "
#define DEBUG(x) cout << #x << ": " << x << endl
#define lb(v, n) lower_bound(v.begin(), v.end(), (n))
#define ub(v, n) upper_bound(v.begin(), v.end(), (n))
#define int long long
//#define double long double
#define all(x) (x).begin(), (x).end()
#define print_space(v) \
REP(i, v.size()) cout << v[i] << ((i == v.size() - 1) ? "\n" : " ")
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
typedef pair<int, int> pii;
typedef array<int, 3> arr3;
std::random_device rd;
std::mt19937 mt(rd());
constexpr ll MOD = 1e9 + 7;
constexpr int MAX = 200020;
const double pi = acos(-1);
constexpr double EPS = 1e-8;
constexpr ll INF = 1e16;
using Point = complex<double>;
typedef int Weight;
struct Edge {
int src, dst;
Weight weight;
Edge(int src, int dst, Weight weight) : src(src), dst(dst), weight(weight) {}
};
bool operator<(const Edge &e, const Edge &f) {
return e.weight != f.weight ? e.weight > f.weight : // !!INVERSE!!
e.src != f.src ? e.src < f.src
: e.dst < f.dst;
}
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
typedef vector<Weight> Array;
typedef vector<Array> Matrix;
bool vis[10010];
bool canreach[10010];
void dfs(int n, int pre, Graph &g) {
vis[n] = true;
canreach[n] = true;
for (auto e : g[n]) {
int nxt = e.dst;
if (vis[nxt])
continue;
dfs(nxt, n, g);
}
}
bool shortestPath(const Graph g, int s, vector<Weight> &dist,
vector<int> &prev) {
int n = g.size();
dist.assign(n, INF + INF);
dist[s] = 0;
prev.assign(n, -2);
bool negative_cycle = false;
REP(k, 10 * n) REP(i, n) for (auto e : g[i]) {
if (!canreach[e.src])
continue;
if (dist[e.dst] > dist[e.src] + e.weight) {
dist[e.dst] = dist[e.src] + e.weight;
prev[e.dst] = e.src;
if (k >= n - 1) {
dist[e.dst] = -INF;
negative_cycle = true;
}
}
}
return !negative_cycle;
}
vector<int> buildPath(const vector<int> &prev, int t) {
vector<int> path;
for (int u = t; u >= 0; u = prev[u])
path.push_back(u);
reverse(path.begin(), path.end());
return path;
}
void solve() {
int N, M, P;
cin >> N >> M >> P;
Graph g;
g.resize(N);
REP(i, M) {
int u, v, c;
cin >> u >> v >> c;
c -= P;
c = -c;
u--, v--;
g[u].push_back({u, v, c});
}
dfs(0, 0, g);
vector<int> dist, prev;
bool ret = shortestPath(g, 0, dist, prev);
if (dist[N - 1] == -INF) {
cout << -1 << endl;
} else
cout << max(0LL, -dist[N - 1]) << endl;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
// int q; cin >> q;
// while (q--)
solve();
}
| [
"control_flow.branch.if.condition.change"
] | 751,003 | 751,002 | u859396346 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
struct edge {
ll from;
ll to;
ll cost;
};
int main(void) {
ll n, m, p;
ll d[2500];
vector<edge> edges;
cin >> n >> m >> p;
for (int i = 0; i < m; i++) {
struct edge add;
cin >> add.from >> add.to >> add.cost;
add.from--, add.to--;
add.cost -= p;
edges.push_back(add);
}
fill(d, d + n, -INF);
d[0] = 0;
for (int i = 0; i < n; i++) {
for (auto e : edges) {
if (d[e.from] != -INF && d[e.to] < d[e.from] + e.cost) {
d[e.to] = min(d[e.from] + e.cost, INF);
if (i == n - 1) {
d[e.to] = INF;
}
}
}
}
for (auto e : edges) {
if (d[e.from] != -INF && d[e.to] < d[e.from] + e.cost) {
d[e.to] = min(d[e.from] + e.cost, INF);
}
}
if (d[n - 1] == INF)
cout << -1 << endl;
else
cout << max(ll(0), d[n - 1]) << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
struct edge {
ll from;
ll to;
ll cost;
};
int main(void) {
ll n, m, p;
ll d[2500];
vector<edge> edges;
cin >> n >> m >> p;
for (int i = 0; i < m; i++) {
struct edge add;
cin >> add.from >> add.to >> add.cost;
add.from--, add.to--;
add.cost -= p;
edges.push_back(add);
}
fill(d, d + n, -INF);
d[0] = 0;
for (int i = 0; i < 2 * n; i++) {
for (auto e : edges) {
if (d[e.from] != -INF && d[e.to] < d[e.from] + e.cost) {
d[e.to] = min(d[e.from] + e.cost, INF);
if (i >= n - 1) {
d[e.to] = INF;
}
}
}
}
for (auto e : edges) {
if (d[e.from] != -INF && d[e.to] < d[e.from] + e.cost) {
d[e.to] = min(d[e.from] + e.cost, INF);
}
}
if (d[n - 1] == INF)
cout << -1 << endl;
else
cout << max(ll(0), d[n - 1]) << endl;
}
| [
"control_flow.loop.for.condition.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 751,006 | 751,007 | u675509234 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define db double
#define pii pair<int, int>
#define pli pair<ll, int>
#define pil pair<int, ll>
#define pll pair<ll, ll>
#define mat vector<vector<int>>
const int inf = 1 << 30;
const ll linf = 1e18;
const db EPS = 1e-7;
template <class T> void chmin(T &x, T y) {
if (x > y)
x = y;
}
template <class T> void chmax(T &x, T y) {
if (x < y)
x = y;
}
struct edge {
int from, to, cost;
};
edge es[5010];
int N, M, P;
int d[2510];
bool shortest_path(int s) {
for (int i = 1; i <= N; i++)
d[i] = inf;
d[s] = 0;
int cnt = 0;
bool update = true;
while (update && cnt <= N) {
update = false;
cnt++;
for (int i = 0; i < M; i++) {
edge e = es[i];
if (d[e.from] != inf && d[e.from] + e.cost < d[e.to]) {
d[e.to] = d[e.from] + e.cost;
update = true;
}
}
}
int res = d[N];
cnt = 0;
update = true;
while (update && cnt <= N) {
update = false;
cnt++;
for (int i = 0; i < M; i++) {
edge e = es[i];
if (d[e.from] != inf && d[e.from] + e.cost < d[e.to]) {
d[e.to] = d[e.from] + e.cost;
d[e.to] = 1 << 31;
update = true;
}
}
}
return d[N] != res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> N >> M >> P;
for (int i = 0; i < M; i++) {
int A, B, C;
cin >> A >> B >> C;
es[i] = {A, B, P - C};
}
cout << (shortest_path(1) ? -1 : max(-d[N], 0)) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define db double
#define pii pair<int, int>
#define pli pair<ll, int>
#define pil pair<int, ll>
#define pll pair<ll, ll>
#define mat vector<vector<int>>
const int inf = 1 << 30;
const ll linf = 1e18;
const db EPS = 1e-7;
template <class T> void chmin(T &x, T y) {
if (x > y)
x = y;
}
template <class T> void chmax(T &x, T y) {
if (x < y)
x = y;
}
struct edge {
int from, to, cost;
};
edge es[5010];
int N, M, P;
int d[2510];
bool shortest_path(int s) {
for (int i = 1; i <= N; i++)
d[i] = inf;
d[s] = 0;
int cnt = 0;
bool update = true;
while (update && cnt <= N) {
update = false;
cnt++;
for (int i = 0; i < M; i++) {
edge e = es[i];
if (d[e.from] != inf && d[e.from] + e.cost < d[e.to]) {
d[e.to] = d[e.from] + e.cost;
update = true;
}
}
}
int res = d[N];
cnt = 0;
update = true;
while (update && cnt <= N) {
update = false;
cnt++;
for (int i = 0; i < M; i++) {
edge e = es[i];
if (d[e.from] != inf && d[e.from] + e.cost < d[e.to]) {
d[e.to] = d[e.from] + e.cost;
d[e.to] = -(2e9);
update = true;
}
}
}
return d[N] != res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> N >> M >> P;
for (int i = 0; i < M; i++) {
int A, B, C;
cin >> A >> B >> C;
es[i] = {A, B, P - C};
}
cout << (shortest_path(1) ? -1 : max(-d[N], 0)) << endl;
return 0;
}
| [] | 751,010 | 751,011 | u554116180 | cpp |
p02949 |
#include <time.h>
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdint>
#include <deque>
#include <fstream> // ifstream, ofstream
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <omp.h>
#include <queue>
#include <set>
#include <stdlib.h>
#include <string>
#include <vector>
typedef int64_t ll;
using namespace std;
const ll INF = 1e16;
const double EPS = 1e-8;
const ll mod = 1000000007;
#include <limits>
#include <queue>
#include <vector>
class Vertex;
class Edge {
public:
friend class Vertex;
friend class Graph;
Vertex *from;
Vertex *to;
int64_t cost;
public:
Edge(Vertex *from, Vertex *to, int64_t cost = 0) {
this->from = from;
this->to = to;
this->cost = cost;
}
};
struct Dijkstra {
int64_t d;
Vertex *parent;
bool searched;
};
class Vertex {
friend class Graph;
public:
Dijkstra dijk_data;
std::vector<Edge *> departure;
std::vector<Edge *> arrival;
int32_t id;
bool forward_reachable = false;
bool backward_reachable = false;
bool count_finish = false;
void add_edge(Edge *d) {
departure.push_back(d);
d->to->arrival.push_back(d);
}
void initialize_Dijkstra() {
dijk_data.d = INF;
dijk_data.parent = NULL;
dijk_data.searched = false;
}
int32_t count_union(Edge *e1, Edge *e2) {
int32_t retval = 1;
count_finish = true;
for (auto i1 = departure.begin(); i1 != departure.end(); i1++) {
Edge *temp = (*i1);
if (temp == e1 || temp == e2 || temp->to->count_finish) {
continue;
}
retval += temp->to->count_union(e1, e2);
}
return retval;
}
};
class dijkstra_calc {
public:
int64_t current_cost;
Vertex *from;
Vertex *to;
dijkstra_calc(const int64_t cost, Vertex *c1, Vertex *c2)
: current_cost(cost), from(c1), to(c2) {}
};
bool operator<(const dijkstra_calc &a, const dijkstra_calc &b) {
return a.current_cost < b.current_cost;
}
bool operator>(const dijkstra_calc &a, const dijkstra_calc &b) {
return a.current_cost > b.current_cost;
}
class Graph {
private:
std::vector<Vertex *> v;
std::vector<Edge *> e;
int64_t **WF;
void initialize_Dijkstra() {
for (auto i = v.begin(); i != v.end(); i++) {
Vertex *temp = (*i);
temp->initialize_Dijkstra();
}
}
static void dijkstra(Vertex *source, Vertex *goal = NULL) {
std::priority_queue<dijkstra_calc, std::vector<dijkstra_calc>,
std::greater<dijkstra_calc>>
queue;
queue.push(dijkstra_calc(0, NULL, source));
while (true) {
const dijkstra_calc temp = queue.top();
queue.pop();
if (!(temp.to->dijk_data.searched)) {
temp.to->dijk_data.searched = true;
temp.to->dijk_data.parent = temp.from;
temp.to->dijk_data.d = temp.current_cost;
for (auto i = temp.to->departure.begin(); i != temp.to->departure.end();
i++) {
const Edge *j = (*i);
if (!j->to->dijk_data.searched) {
dijkstra_calc a(temp.current_cost + (j->cost), j->from, j->to);
queue.push(a);
}
}
if (temp.to == goal) {
return;
}
}
if (queue.empty()) {
return;
}
}
}
bool Bellman_Ford(Vertex *source) { // use after initialize_Dijkstra
source->dijk_data.d = 0;
ll repeat = v.size() - 1;
bool updated = false;
for (ll i1 = 0; i1 < repeat; i1++) {
updated = false;
for (auto i2 = e.begin(); i2 != e.end(); i2++) {
Edge *edge_temp = (*i2);
if ((edge_temp->from->forward_reachable) &&
(edge_temp->to->backward_reachable) &&
((edge_temp->from->dijk_data.d + edge_temp->cost) <
(edge_temp->to->dijk_data.d))) {
updated = true;
edge_temp->to->dijk_data.d =
edge_temp->from->dijk_data.d + edge_temp->cost;
}
}
}
return updated;
}
public:
static const int64_t INF = 1000000000000000;
Graph(int32_t num_v) {
v.reserve(num_v);
for (int32_t i1 = 0; i1 < num_v; i1++) {
Vertex *temp = new Vertex();
temp->id = i1;
v.push_back(temp);
}
WF = new int64_t *[num_v];
for (int64_t i1 = 0; i1 < num_v; i1++) {
WF[i1] = new int64_t[num_v];
}
}
void add_edge(int32_t from, int32_t to, ll cost = 0) {
Edge *temp = new Edge(v[from], v[to], cost);
e.push_back(temp);
v[from]->add_edge(temp);
}
void dijkstra(int32_t start) {
initialize_Dijkstra();
dijkstra(v[start]);
}
void dijkstra(int32_t start, int32_t goal) {
initialize_Dijkstra();
dijkstra(v[start], v[goal]);
}
bool Bellman_Ford(int32_t start) {
initialize_Dijkstra();
return Bellman_Ford(v[start]);
}
int64_t **WarshallFloid() {
for (int64_t i1 = 0; i1 < v.size(); i1++) {
for (int64_t i2 = 0; i2 < v.size(); i2++) {
WF[i1][i2] = INF;
}
}
for (int64_t i1 = 0; i1 < v.size(); i1++) {
for (auto i2 = v[i1]->departure.begin(); i2 != v[i1]->departure.end();
i2++) {
Edge *temp = (*i2);
if (WF[i1][temp->to->id] > temp->cost) {
WF[i1][temp->to->id] = temp->cost;
}
}
WF[i1][i1] = 0;
}
for (int64_t i1 = 0; i1 < v.size(); i1++) {
for (int64_t i2 = 0; i2 < v.size(); i2++) {
for (int64_t i3 = 0; i3 < v.size(); i3++) {
WF[i2][i3] = min(WF[i2][i3], WF[i2][i1] + WF[i1][i3]);
}
}
}
return WF;
}
Vertex *getVertex(int place) const { return v[place]; }
bool isBridge(Edge *e1, Edge *e2) {
for (auto i1 = v.begin(); i1 != v.end(); i1++) {
Vertex *temp = (*i1);
temp->count_finish = false;
}
int32_t r = v[0]->count_union(e1, e2);
return v.size() != r;
}
vector<Edge *> getEdge() { return e; }
virtual ~Graph() {
for (auto i = v.begin(); i != v.end(); i++) {
delete *i;
}
for (auto i = e.begin(); i != e.end(); i++) {
delete *i;
}
for (int64_t i1 = 0; i1 < v.size(); i1++) {
delete[] WF[i1];
}
delete[] WF;
}
};
void forward_reachable(Vertex *ve) {
ve->forward_reachable = true;
vector<Edge *> edges = ve->departure;
for (auto i1 = edges.begin(); i1 != edges.end(); i1++) {
Edge *temp = *i1;
if (!(temp->to->forward_reachable)) {
forward_reachable(temp->to);
}
}
}
void backward_reachable(Vertex *ve) {
ve->backward_reachable = true;
vector<Edge *> edges = ve->arrival;
for (auto i1 = edges.begin(); i1 != edges.end(); i1++) {
Edge *temp = *i1;
if (!(temp->from->backward_reachable)) {
backward_reachable(temp->from);
}
}
}
int main() {
ll n, m, p;
cin >> n >> m >> p;
Graph gr(n);
for (ll i1 = 0; i1 < m; i1++) {
ll a, b, c;
cin >> a >> b >> c;
gr.add_edge(a - 1, b - 1, -(c - p));
}
forward_reachable(gr.getVertex(0));
backward_reachable(gr.getVertex(n - 1));
bool impossible = gr.Bellman_Ford(0);
if (impossible) {
cout << -1 << endl;
} else {
cout << max<ll>(0, -1 * (gr.getVertex(n - 1)->dijk_data.d)) << endl;
}
}
|
#include <time.h>
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdint>
#include <deque>
#include <fstream> // ifstream, ofstream
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <omp.h>
#include <queue>
#include <set>
#include <stdlib.h>
#include <string>
#include <vector>
typedef int64_t ll;
using namespace std;
const ll INF = 1e16;
const double EPS = 1e-8;
const ll mod = 1000000007;
#include <limits>
#include <queue>
#include <vector>
class Vertex;
class Edge {
public:
friend class Vertex;
friend class Graph;
Vertex *from;
Vertex *to;
int64_t cost;
public:
Edge(Vertex *from, Vertex *to, int64_t cost = 0) {
this->from = from;
this->to = to;
this->cost = cost;
}
};
struct Dijkstra {
int64_t d;
Vertex *parent;
bool searched;
};
class Vertex {
friend class Graph;
public:
Dijkstra dijk_data;
std::vector<Edge *> departure;
std::vector<Edge *> arrival;
int32_t id;
bool forward_reachable = false;
bool backward_reachable = false;
bool count_finish = false;
void add_edge(Edge *d) {
departure.push_back(d);
d->to->arrival.push_back(d);
}
void initialize_Dijkstra() {
dijk_data.d = INF;
dijk_data.parent = NULL;
dijk_data.searched = false;
}
int32_t count_union(Edge *e1, Edge *e2) {
int32_t retval = 1;
count_finish = true;
for (auto i1 = departure.begin(); i1 != departure.end(); i1++) {
Edge *temp = (*i1);
if (temp == e1 || temp == e2 || temp->to->count_finish) {
continue;
}
retval += temp->to->count_union(e1, e2);
}
return retval;
}
};
class dijkstra_calc {
public:
int64_t current_cost;
Vertex *from;
Vertex *to;
dijkstra_calc(const int64_t cost, Vertex *c1, Vertex *c2)
: current_cost(cost), from(c1), to(c2) {}
};
bool operator<(const dijkstra_calc &a, const dijkstra_calc &b) {
return a.current_cost < b.current_cost;
}
bool operator>(const dijkstra_calc &a, const dijkstra_calc &b) {
return a.current_cost > b.current_cost;
}
class Graph {
private:
std::vector<Vertex *> v;
std::vector<Edge *> e;
int64_t **WF;
void initialize_Dijkstra() {
for (auto i = v.begin(); i != v.end(); i++) {
Vertex *temp = (*i);
temp->initialize_Dijkstra();
}
}
static void dijkstra(Vertex *source, Vertex *goal = NULL) {
std::priority_queue<dijkstra_calc, std::vector<dijkstra_calc>,
std::greater<dijkstra_calc>>
queue;
queue.push(dijkstra_calc(0, NULL, source));
while (true) {
const dijkstra_calc temp = queue.top();
queue.pop();
if (!(temp.to->dijk_data.searched)) {
temp.to->dijk_data.searched = true;
temp.to->dijk_data.parent = temp.from;
temp.to->dijk_data.d = temp.current_cost;
for (auto i = temp.to->departure.begin(); i != temp.to->departure.end();
i++) {
const Edge *j = (*i);
if (!j->to->dijk_data.searched) {
dijkstra_calc a(temp.current_cost + (j->cost), j->from, j->to);
queue.push(a);
}
}
if (temp.to == goal) {
return;
}
}
if (queue.empty()) {
return;
}
}
}
bool Bellman_Ford(Vertex *source) { // use after initialize_Dijkstra
source->dijk_data.d = 0;
ll repeat = v.size();
bool updated = false;
for (ll i1 = 0; i1 < repeat; i1++) {
updated = false;
for (auto i2 = e.begin(); i2 != e.end(); i2++) {
Edge *edge_temp = (*i2);
if ((edge_temp->from->forward_reachable) &&
(edge_temp->to->backward_reachable) &&
((edge_temp->from->dijk_data.d + edge_temp->cost) <
(edge_temp->to->dijk_data.d))) {
updated = true;
edge_temp->to->dijk_data.d =
edge_temp->from->dijk_data.d + edge_temp->cost;
}
}
}
return updated;
}
public:
static const int64_t INF = 1000000000000000;
Graph(int32_t num_v) {
v.reserve(num_v);
for (int32_t i1 = 0; i1 < num_v; i1++) {
Vertex *temp = new Vertex();
temp->id = i1;
v.push_back(temp);
}
WF = new int64_t *[num_v];
for (int64_t i1 = 0; i1 < num_v; i1++) {
WF[i1] = new int64_t[num_v];
}
}
void add_edge(int32_t from, int32_t to, ll cost = 0) {
Edge *temp = new Edge(v[from], v[to], cost);
e.push_back(temp);
v[from]->add_edge(temp);
}
void dijkstra(int32_t start) {
initialize_Dijkstra();
dijkstra(v[start]);
}
void dijkstra(int32_t start, int32_t goal) {
initialize_Dijkstra();
dijkstra(v[start], v[goal]);
}
bool Bellman_Ford(int32_t start) {
initialize_Dijkstra();
return Bellman_Ford(v[start]);
}
int64_t **WarshallFloid() {
for (int64_t i1 = 0; i1 < v.size(); i1++) {
for (int64_t i2 = 0; i2 < v.size(); i2++) {
WF[i1][i2] = INF;
}
}
for (int64_t i1 = 0; i1 < v.size(); i1++) {
for (auto i2 = v[i1]->departure.begin(); i2 != v[i1]->departure.end();
i2++) {
Edge *temp = (*i2);
if (WF[i1][temp->to->id] > temp->cost) {
WF[i1][temp->to->id] = temp->cost;
}
}
WF[i1][i1] = 0;
}
for (int64_t i1 = 0; i1 < v.size(); i1++) {
for (int64_t i2 = 0; i2 < v.size(); i2++) {
for (int64_t i3 = 0; i3 < v.size(); i3++) {
WF[i2][i3] = min(WF[i2][i3], WF[i2][i1] + WF[i1][i3]);
}
}
}
return WF;
}
Vertex *getVertex(int place) const { return v[place]; }
bool isBridge(Edge *e1, Edge *e2) {
for (auto i1 = v.begin(); i1 != v.end(); i1++) {
Vertex *temp = (*i1);
temp->count_finish = false;
}
int32_t r = v[0]->count_union(e1, e2);
return v.size() != r;
}
vector<Edge *> getEdge() { return e; }
virtual ~Graph() {
for (auto i = v.begin(); i != v.end(); i++) {
delete *i;
}
for (auto i = e.begin(); i != e.end(); i++) {
delete *i;
}
for (int64_t i1 = 0; i1 < v.size(); i1++) {
delete[] WF[i1];
}
delete[] WF;
}
};
void forward_reachable(Vertex *ve) {
ve->forward_reachable = true;
vector<Edge *> edges = ve->departure;
for (auto i1 = edges.begin(); i1 != edges.end(); i1++) {
Edge *temp = *i1;
if (!(temp->to->forward_reachable)) {
forward_reachable(temp->to);
}
}
}
void backward_reachable(Vertex *ve) {
ve->backward_reachable = true;
vector<Edge *> edges = ve->arrival;
for (auto i1 = edges.begin(); i1 != edges.end(); i1++) {
Edge *temp = *i1;
if (!(temp->from->backward_reachable)) {
backward_reachable(temp->from);
}
}
}
int main() {
ll n, m, p;
cin >> n >> m >> p;
Graph gr(n);
for (ll i1 = 0; i1 < m; i1++) {
ll a, b, c;
cin >> a >> b >> c;
gr.add_edge(a - 1, b - 1, -(c - p));
}
forward_reachable(gr.getVertex(0));
backward_reachable(gr.getVertex(n - 1));
bool impossible = gr.Bellman_Ford(0);
if (impossible) {
cout << -1 << endl;
} else {
cout << max<ll>(0, -1 * (gr.getVertex(n - 1)->dijk_data.d)) << endl;
}
}
| [
"expression.operation.binary.remove"
] | 751,015 | 751,016 | u279976468 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) begin(v), end(v)
#define fi first
#define se second
template <typename A, typename B> inline bool chmax(A &a, B b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename A, typename B> inline bool chmin(A &a, B b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
using ll = long long;
using pii = pair<int, int>;
constexpr ll INF = 1ll << 30;
constexpr ll longINF = 1ll << 60;
constexpr ll MOD = 1000000007;
constexpr bool debug = 0;
//---------------------------------//
void dfs(int u, const vector<vector<pii>> &g, vector<int> &done) {
if (done[u])
return;
done[u] = true;
for (pii e : g[u]) {
int v = e.fi;
if (!done[v])
dfs(v, g, done);
}
}
int main() {
int N, M, P;
cin >> N >> M >> P;
vector<vector<pii>> g(N), rg(N);
REP(i, M) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
--a;
--b;
g[a].emplace_back(b, c - P);
rg[b].emplace_back(a, c - P);
}
vector<ll> d(N, -longINF);
d[0] = 0;
vector<int> loop(N);
REP(i, 2 * M) {
REP(j, N) {
if (d[j] == -longINF)
continue;
for (pii e : g[j]) {
int v = e.fi;
int c = e.se;
if (chmax(d[v], d[j] + c)) {
if (i + 1 == M)
loop[v] = true;
}
}
}
}
vector<int> done[2];
REP(i, 2) done[i].resize(N);
dfs(0, g, done[0]);
dfs(N - 1, rg, done[1]);
bool upl = false;
REP(i, N) upl |= done[0][i] && done[1][i] && loop[i];
if (upl)
puts("-1");
else
cout << max(d[N - 1], 0ll) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) begin(v), end(v)
#define fi first
#define se second
template <typename A, typename B> inline bool chmax(A &a, B b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename A, typename B> inline bool chmin(A &a, B b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
using ll = long long;
using pii = pair<int, int>;
constexpr ll INF = 1ll << 30;
constexpr ll longINF = 1ll << 60;
constexpr ll MOD = 1000000007;
constexpr bool debug = 0;
//---------------------------------//
void dfs(int u, const vector<vector<pii>> &g, vector<int> &done) {
if (done[u])
return;
done[u] = true;
for (pii e : g[u]) {
int v = e.fi;
if (!done[v])
dfs(v, g, done);
}
}
int main() {
int N, M, P;
cin >> N >> M >> P;
vector<vector<pii>> g(N), rg(N);
REP(i, M) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
--a;
--b;
g[a].emplace_back(b, c - P);
rg[b].emplace_back(a, c - P);
}
vector<ll> d(N, -longINF);
d[0] = 0;
vector<int> loop(N);
REP(i, M + 1) {
REP(j, N) {
if (d[j] == -longINF)
continue;
for (pii e : g[j]) {
int v = e.fi;
int c = e.se;
if (chmax(d[v], d[j] + c)) {
if (i == M)
loop[v] = true;
}
}
}
}
vector<int> done[2];
REP(i, 2) done[i].resize(N);
dfs(0, g, done[0]);
dfs(N - 1, rg, done[1]);
bool upl = false;
REP(i, N) upl |= done[0][i] && done[1][i] && loop[i];
if (upl)
puts("-1");
else
cout << max(d[N - 1], 0ll) << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 751,021 | 751,022 | u105791541 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) begin(v), end(v)
#define fi first
#define se second
template <typename A, typename B> inline bool chmax(A &a, B b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename A, typename B> inline bool chmin(A &a, B b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
using ll = long long;
using pii = pair<int, int>;
constexpr ll INF = 1ll << 30;
constexpr ll longINF = 1ll << 60;
constexpr ll MOD = 1000000007;
constexpr bool debug = 0;
//---------------------------------//
void dfs(int u, const vector<vector<pii>> &g, vector<int> &done) {
if (done[u])
return;
done[u] = true;
for (pii e : g[u]) {
int v = e.fi;
if (!done[v])
dfs(v, g, done);
}
}
int main() {
int N, M, P;
cin >> N >> M >> P;
vector<vector<pii>> g(N), rg(N);
REP(i, M) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
--a;
--b;
g[a].emplace_back(b, c - P);
rg[b].emplace_back(a, c - P);
}
vector<ll> d(N, -longINF);
d[0] = 0;
vector<int> loop(N);
REP(i, M) {
REP(j, N) {
if (d[j] == -longINF)
continue;
for (pii e : g[j]) {
int v = e.fi;
int c = e.se;
if (chmax(d[v], d[j] + c)) {
if (i + 1 == M)
loop[v] = true;
}
}
}
}
vector<int> done[2];
REP(i, 2) done[i].resize(N);
dfs(0, g, done[0]);
dfs(N - 1, rg, done[1]);
bool upl = false;
REP(i, N) upl |= done[0][i] && done[1][i] && loop[i];
if (upl)
puts("-1");
else
cout << max(d[N - 1], 0ll) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) begin(v), end(v)
#define fi first
#define se second
template <typename A, typename B> inline bool chmax(A &a, B b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename A, typename B> inline bool chmin(A &a, B b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
using ll = long long;
using pii = pair<int, int>;
constexpr ll INF = 1ll << 30;
constexpr ll longINF = 1ll << 60;
constexpr ll MOD = 1000000007;
constexpr bool debug = 0;
//---------------------------------//
void dfs(int u, const vector<vector<pii>> &g, vector<int> &done) {
if (done[u])
return;
done[u] = true;
for (pii e : g[u]) {
int v = e.fi;
if (!done[v])
dfs(v, g, done);
}
}
int main() {
int N, M, P;
cin >> N >> M >> P;
vector<vector<pii>> g(N), rg(N);
REP(i, M) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
--a;
--b;
g[a].emplace_back(b, c - P);
rg[b].emplace_back(a, c - P);
}
vector<ll> d(N, -longINF);
d[0] = 0;
vector<int> loop(N);
REP(i, M + 1) {
REP(j, N) {
if (d[j] == -longINF)
continue;
for (pii e : g[j]) {
int v = e.fi;
int c = e.se;
if (chmax(d[v], d[j] + c)) {
if (i == M)
loop[v] = true;
}
}
}
}
vector<int> done[2];
REP(i, 2) done[i].resize(N);
dfs(0, g, done[0]);
dfs(N - 1, rg, done[1]);
bool upl = false;
REP(i, N) upl |= done[0][i] && done[1][i] && loop[i];
if (upl)
puts("-1");
else
cout << max(d[N - 1], 0ll) << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 751,023 | 751,022 | u105791541 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) begin(v), end(v)
#define fi first
#define se second
template <typename A, typename B> inline bool chmax(A &a, B b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename A, typename B> inline bool chmin(A &a, B b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
using ll = long long;
using pii = pair<int, int>;
constexpr ll INF = 1ll << 30;
constexpr ll longINF = 1ll << 60;
constexpr ll MOD = 1000000007;
constexpr bool debug = 0;
//---------------------------------//
void dfs(int u, const vector<vector<pii>> &g, vector<int> &done) {
if (done[u])
return;
done[u] = true;
for (pii e : g[u]) {
int v = e.fi;
if (!done[v])
dfs(v, g, done);
}
}
int main() {
int N, M, P;
cin >> N >> M >> P;
vector<vector<pii>> g(N), rg(N);
REP(i, M) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
--a;
--b;
g[a].emplace_back(b, c - P);
rg[b].emplace_back(a, c - P);
}
vector<ll> d(N, -longINF);
d[0] = 0;
vector<int> loop(N);
REP(i, 2 * M) {
REP(j, N) {
if (d[j] == -longINF)
continue;
for (pii e : g[j]) {
int v = e.fi;
int c = e.se;
if (chmax(d[v], d[j] + c)) {
if (i + 1 == M)
loop[v] = true;
}
}
}
}
vector<int> done[2];
REP(i, 2) done[i].resize(N);
dfs(0, g, done[0]);
dfs(N - 1, rg, done[1]);
bool upl = false;
REP(i, N) upl |= done[0][i] && done[1][i] && loop[i];
if (upl)
puts("-1");
else
cout << max(d[N - 1], 0ll) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) begin(v), end(v)
#define fi first
#define se second
template <typename A, typename B> inline bool chmax(A &a, B b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename A, typename B> inline bool chmin(A &a, B b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
using ll = long long;
using pii = pair<int, int>;
constexpr ll INF = 1ll << 30;
constexpr ll longINF = 1ll << 60;
constexpr ll MOD = 1000000007;
constexpr bool debug = 0;
//---------------------------------//
void dfs(int u, const vector<vector<pii>> &g, vector<int> &done) {
if (done[u])
return;
done[u] = true;
for (pii e : g[u]) {
int v = e.fi;
if (!done[v])
dfs(v, g, done);
}
}
int main() {
int N, M, P;
cin >> N >> M >> P;
vector<vector<pii>> g(N), rg(N);
REP(i, M) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
--a;
--b;
g[a].emplace_back(b, c - P);
rg[b].emplace_back(a, c - P);
}
vector<ll> d(N, -longINF);
d[0] = 0;
vector<int> loop(N);
REP(i, 3 * M) {
REP(j, N) {
if (d[j] == -longINF)
continue;
for (pii e : g[j]) {
int v = e.fi;
int c = e.se;
if (chmax(d[v], d[j] + c)) {
if (i >= M)
loop[v] = true;
}
}
}
}
vector<int> done[2];
REP(i, 2) done[i].resize(N);
dfs(0, g, done[0]);
dfs(N - 1, rg, done[1]);
bool upl = false;
REP(i, N) upl |= done[0][i] && done[1][i] && loop[i];
if (upl)
puts("-1");
else
cout << max(d[N - 1], 0ll) << endl;
return 0;
}
| [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 751,021 | 751,024 | u105791541 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) begin(v), end(v)
#define fi first
#define se second
template <typename A, typename B> inline bool chmax(A &a, B b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename A, typename B> inline bool chmin(A &a, B b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
using ll = long long;
using pii = pair<int, int>;
constexpr ll INF = 1ll << 30;
constexpr ll longINF = 1ll << 60;
constexpr ll MOD = 1000000007;
constexpr bool debug = 0;
//---------------------------------//
void dfs(int u, const vector<vector<pii>> &g, vector<int> &done) {
if (done[u])
return;
done[u] = true;
for (pii e : g[u]) {
int v = e.fi;
if (!done[v])
dfs(v, g, done);
}
}
int main() {
int N, M, P;
cin >> N >> M >> P;
vector<vector<pii>> g(N), rg(N);
REP(i, M) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
--a;
--b;
g[a].emplace_back(b, c - P);
rg[b].emplace_back(a, c - P);
}
vector<ll> d(N, -longINF);
d[0] = 0;
vector<int> loop(N);
REP(i, M) {
REP(j, N) {
if (d[j] == -longINF)
continue;
for (pii e : g[j]) {
int v = e.fi;
int c = e.se;
if (chmax(d[v], d[j] + c)) {
if (i + 1 == M)
loop[v] = true;
}
}
}
}
vector<int> done[2];
REP(i, 2) done[i].resize(N);
dfs(0, g, done[0]);
dfs(N - 1, rg, done[1]);
bool upl = false;
REP(i, N) upl |= done[0][i] && done[1][i] && loop[i];
if (upl)
puts("-1");
else
cout << max(d[N - 1], 0ll) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) begin(v), end(v)
#define fi first
#define se second
template <typename A, typename B> inline bool chmax(A &a, B b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename A, typename B> inline bool chmin(A &a, B b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
using ll = long long;
using pii = pair<int, int>;
constexpr ll INF = 1ll << 30;
constexpr ll longINF = 1ll << 60;
constexpr ll MOD = 1000000007;
constexpr bool debug = 0;
//---------------------------------//
void dfs(int u, const vector<vector<pii>> &g, vector<int> &done) {
if (done[u])
return;
done[u] = true;
for (pii e : g[u]) {
int v = e.fi;
if (!done[v])
dfs(v, g, done);
}
}
int main() {
int N, M, P;
cin >> N >> M >> P;
vector<vector<pii>> g(N), rg(N);
REP(i, M) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
--a;
--b;
g[a].emplace_back(b, c - P);
rg[b].emplace_back(a, c - P);
}
vector<ll> d(N, -longINF);
d[0] = 0;
vector<int> loop(N);
REP(i, 3 * M) {
REP(j, N) {
if (d[j] == -longINF)
continue;
for (pii e : g[j]) {
int v = e.fi;
int c = e.se;
if (chmax(d[v], d[j] + c)) {
if (i >= M)
loop[v] = true;
}
}
}
}
vector<int> done[2];
REP(i, 2) done[i].resize(N);
dfs(0, g, done[0]);
dfs(N - 1, rg, done[1]);
bool upl = false;
REP(i, N) upl |= done[0][i] && done[1][i] && loop[i];
if (upl)
puts("-1");
else
cout << max(d[N - 1], 0ll) << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 751,023 | 751,024 | u105791541 | cpp |
p02949 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
#define REP(i, n) for (ll i = 0; i < n; i++)
template <typename T> class Bellmanford {
private:
struct edge {
int to;
T cost;
};
int n;
vector<vector<edge>> g;
vector<T> dist;
public:
Bellmanford(int n) : n(n), g(n), dist(n, INF) {}
void add_edge(int v1, int v2, T cost) { g[v1].push_back({v2, cost}); }
// 負の閉路があるときfalseを返す
bool run(int s) {
dist[s] = 0; //開始点の距離は0
for (int i = 0; i < n; i++) {
for (int v = 0; v < n; v++) {
for (auto &e : g[v]) {
if (dist[v] != INF && dist[e.to] > dist[v] + e.cost) {
dist[e.to] = dist[v] + e.cost;
if (i == n - 1) {
// return false;
dist[e.to] = -INF;
}
}
}
}
}
return true;
}
T get_distance(int v) { return dist[v]; }
};
int main() {
ll n, m, p;
cin >> n >> m >> p;
Bellmanford<ll> bell(n);
REP(i, m) {
ll a, b, c;
cin >> a >> b >> c;
a--;
b--;
bell.add_edge(a, b, -(c - p));
}
bell.run(0);
ll ans = -bell.get_distance(n - 1);
cout << ((ans < INF) ? max(ans, 0LL) : -1) << endl;
} | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
#define REP(i, n) for (ll i = 0; i < n; i++)
template <typename T> class Bellmanford {
private:
struct edge {
int to;
T cost;
};
int n;
vector<vector<edge>> g;
vector<T> dist;
public:
Bellmanford(int n) : n(n), g(n), dist(n, INF) {}
void add_edge(int v1, int v2, T cost) { g[v1].push_back({v2, cost}); }
// 負の閉路があるときfalseを返す
bool run(int s) {
dist[s] = 0; //開始点の距離は0
for (int i = 0; i < 2 * n; i++) {
for (int v = 0; v < n; v++) {
for (auto &e : g[v]) {
if (dist[v] != INF && dist[e.to] > dist[v] + e.cost) {
dist[e.to] = dist[v] + e.cost;
if (i >= n - 1) {
// return false;
dist[e.to] = -INF;
}
}
}
}
}
return true;
}
T get_distance(int v) { return dist[v]; }
};
int main() {
ll n, m, p;
cin >> n >> m >> p;
Bellmanford<ll> bell(n);
REP(i, m) {
ll a, b, c;
cin >> a >> b >> c;
a--;
b--;
bell.add_edge(a, b, -(c - p));
}
bell.run(0);
ll ans = -bell.get_distance(n - 1);
cout << ((ans < INF) ? max(ans, 0LL) : -1) << endl;
} | [
"control_flow.loop.for.condition.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 751,034 | 751,035 | u711985352 | cpp |
p02949 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
#define REP(i, n) for (ll i = 0; i < n; i++)
template <typename T> class bellmanford {
private:
struct edge {
int to;
T cost;
};
int n;
vector<vector<edge>> g;
vector<T> dist;
public:
bellmanford(int n) : n(n), g(n) {}
void add_edge(int v1, int v2, T cost) { g[v1].push_back({v2, cost}); }
// 負の閉路があるときfalseを返す
bool run(int s) {
dist = vector<T>(n, INF);
dist[s] = 0; //開始点の距離は0
for (int i = 0; i < 2 * n; i++) {
for (int v = 0; v < n; v++) {
for (auto &e : g[v]) {
if (dist[v] != INF && dist[e.to] > dist[v] + e.cost) {
dist[e.to] = dist[v] + e.cost;
if (i == n - 1) {
// return false;
dist[e.to] = -INF;
}
}
}
}
}
return true;
}
T get_distance(int v) { return dist[v]; }
};
int main() {
ll n, m, p;
cin >> n >> m >> p;
bellmanford<ll> bell(n);
REP(i, m) {
ll a, b, c;
cin >> a >> b >> c;
a--;
b--;
bell.add_edge(a, b, -(c - p));
}
bell.run(0);
ll ans = -bell.get_distance(n - 1);
cout << ((ans >= INF) ? max(ans, 0LL) : -1) << endl;
}
| #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
#define REP(i, n) for (ll i = 0; i < n; i++)
template <typename T> class bellmanford {
private:
struct edge {
int to;
T cost;
};
int n;
vector<vector<edge>> g;
vector<T> dist;
public:
bellmanford(int n) : n(n), g(n) {}
void add_edge(int v1, int v2, T cost) { g[v1].push_back({v2, cost}); }
// 負の閉路があるときfalseを返す
bool run(int s) {
dist = vector<T>(n, INF);
dist[s] = 0; //開始点の距離は0
for (int i = 0; i < 2 * n; i++) {
for (int v = 0; v < n; v++) {
for (auto &e : g[v]) {
if (dist[v] != INF && dist[e.to] > dist[v] + e.cost) {
dist[e.to] = dist[v] + e.cost;
if (i >= n - 1) {
// return false;
dist[e.to] = -INF;
}
}
}
}
}
return true;
}
T get_distance(int v) { return dist[v]; }
};
int main() {
ll n, m, p;
cin >> n >> m >> p;
bellmanford<ll> bell(n);
REP(i, m) {
ll a, b, c;
cin >> a >> b >> c;
a--;
b--;
bell.add_edge(a, b, -(c - p));
}
bell.run(0);
ll ans = -bell.get_distance(n - 1);
cout << ((ans < INF) ? max(ans, 0LL) : -1) << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"io.output.change"
] | 751,038 | 751,037 | u711985352 | cpp |
p02949 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
#define REP(i, n) for (ll i = 0; i < n; i++)
template <typename T> class bellmanford {
private:
struct edge {
int to;
T cost;
};
int n;
vector<vector<edge>> g;
vector<T> dist;
public:
bellmanford(int n) : n(n), g(n) {}
void add_edge(int v1, int v2, T cost) { g[v1].push_back({v2, cost}); }
// 負の閉路があるときfalseを返す
bool run(int s) {
dist = vector<T>(n, INF);
dist[s] = 0; //開始点の距離は0
for (int i = 0; i < 3 * n; i++) {
for (int v = 0; v < n; v++) {
for (auto &e : g[v]) {
if (dist[v] != INF && dist[e.to] > dist[v] + e.cost) {
dist[e.to] = dist[v] + e.cost;
if (i == 3 * n - 1) {
// return false;
dist[e.to] = -INF;
}
}
}
}
}
return true;
}
T get_distance(int v) { return dist[v]; }
};
int main() {
ll n, m, p;
cin >> n >> m >> p;
bellmanford<ll> bell(n);
REP(i, m) {
ll a, b, c;
cin >> a >> b >> c;
a--;
b--;
bell.add_edge(a, b, -(c - p));
}
bell.run(0);
ll ans = -bell.get_distance(n - 1);
cout << ((ans != INF) ? max(ans, 0LL) : -1) << endl;
}
| #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
#define REP(i, n) for (ll i = 0; i < n; i++)
template <typename T> class bellmanford {
private:
struct edge {
int to;
T cost;
};
int n;
vector<vector<edge>> g;
vector<T> dist;
public:
bellmanford(int n) : n(n), g(n) {}
void add_edge(int v1, int v2, T cost) { g[v1].push_back({v2, cost}); }
// 負の閉路があるときfalseを返す
bool run(int s) {
dist = vector<T>(n, INF);
dist[s] = 0; //開始点の距離は0
for (int i = 0; i < 2 * n; i++) {
for (int v = 0; v < n; v++) {
for (auto &e : g[v]) {
if (dist[v] != INF && dist[e.to] > dist[v] + e.cost) {
dist[e.to] = dist[v] + e.cost;
if (i >= n - 1) {
// return false;
dist[e.to] = -INF;
}
}
}
}
}
return true;
}
T get_distance(int v) { return dist[v]; }
};
int main() {
ll n, m, p;
cin >> n >> m >> p;
bellmanford<ll> bell(n);
REP(i, m) {
ll a, b, c;
cin >> a >> b >> c;
a--;
b--;
bell.add_edge(a, b, -(c - p));
}
bell.run(0);
ll ans = -bell.get_distance(n - 1);
cout << ((ans < INF) ? max(ans, 0LL) : -1) << endl;
}
| [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove",
"io.output.change"
] | 751,039 | 751,037 | u711985352 | cpp |
p02949 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
#define REP(i, n) for (ll i = 0; i < n; i++)
template <typename T> class bellmanford {
private:
struct edge {
int to;
T cost;
};
int n;
vector<vector<edge>> g;
vector<T> dist;
public:
bellmanford(int n) : n(n), g(n) {}
void add_edge(int v1, int v2, T cost) { g[v1].push_back({v2, cost}); }
// 負の閉路があるときfalseを返す
bool run(int s) {
dist = vector<T>(n, INF);
dist[s] = 0; //開始点の距離は0
for (int i = 0; i < 2 * n; i++) {
for (int v = 0; v < n; v++) {
for (auto &e : g[v]) {
if (dist[v] != INF && dist[e.to] > dist[v] + e.cost) {
dist[e.to] = dist[v] + e.cost;
if (i == 2 * n - 1) {
// return false;
dist[e.to] = -INF;
}
}
}
}
}
return true;
}
T get_distance(int v) { return dist[v]; }
};
int main() {
ll n, m, p;
cin >> n >> m >> p;
bellmanford<ll> bell(n);
REP(i, m) {
ll a, b, c;
cin >> a >> b >> c;
a--;
b--;
bell.add_edge(a, b, -(c - p));
}
bell.run(0);
ll ans = -bell.get_distance(n - 1);
cout << ((ans != INF) ? max(ans, 0LL) : -1) << endl;
}
| #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
#define REP(i, n) for (ll i = 0; i < n; i++)
template <typename T> class bellmanford {
private:
struct edge {
int to;
T cost;
};
int n;
vector<vector<edge>> g;
vector<T> dist;
public:
bellmanford(int n) : n(n), g(n) {}
void add_edge(int v1, int v2, T cost) { g[v1].push_back({v2, cost}); }
// 負の閉路があるときfalseを返す
bool run(int s) {
dist = vector<T>(n, INF);
dist[s] = 0; //開始点の距離は0
for (int i = 0; i < 2 * n; i++) {
for (int v = 0; v < n; v++) {
for (auto &e : g[v]) {
if (dist[v] != INF && dist[e.to] > dist[v] + e.cost) {
dist[e.to] = dist[v] + e.cost;
if (i >= n - 1) {
// return false;
dist[e.to] = -INF;
}
}
}
}
}
return true;
}
T get_distance(int v) { return dist[v]; }
};
int main() {
ll n, m, p;
cin >> n >> m >> p;
bellmanford<ll> bell(n);
REP(i, m) {
ll a, b, c;
cin >> a >> b >> c;
a--;
b--;
bell.add_edge(a, b, -(c - p));
}
bell.run(0);
ll ans = -bell.get_distance(n - 1);
cout << ((ans < INF) ? max(ans, 0LL) : -1) << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"io.output.change"
] | 751,040 | 751,037 | u711985352 | cpp |
p02949 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
#define REP(i, n) for (ll i = 0; i < n; i++)
template <typename T> class bellmanford {
private:
struct edge {
int to;
T cost;
};
int n;
vector<vector<edge>> g;
vector<T> dist;
public:
bellmanford(int n) : n(n), g(n) {}
void add_edge(int v1, int v2, T cost) { g[v1].push_back({v2, cost}); }
// 負の閉路があるときfalseを返す
bool run(int s) {
dist = vector<T>(n, INF);
dist[s] = 0; //開始点の距離は0
for (int i = 0; i < 2 * n; i++) {
for (int v = 0; v < n; v++) {
for (auto &e : g[v]) {
if (dist[v] != INF && dist[e.to] > dist[v] + e.cost) {
dist[e.to] = dist[v] + e.cost;
if (i == n - 1) {
// return false;
dist[e.to] = -INF;
}
}
}
}
}
return true;
}
T get_distance(int v) { return dist[v]; }
};
int main() {
ll n, m, p;
cin >> n >> m >> p;
bellmanford<ll> bell(n);
REP(i, m) {
ll a, b, c;
cin >> a >> b >> c;
a--;
b--;
bell.add_edge(a, b, -(c - p));
}
bell.run(0);
ll ans = -bell.get_distance(n - 1);
cout << ((ans != INF) ? max(ans, 0LL) : -1) << endl;
}
| #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
#define REP(i, n) for (ll i = 0; i < n; i++)
template <typename T> class bellmanford {
private:
struct edge {
int to;
T cost;
};
int n;
vector<vector<edge>> g;
vector<T> dist;
public:
bellmanford(int n) : n(n), g(n) {}
void add_edge(int v1, int v2, T cost) { g[v1].push_back({v2, cost}); }
// 負の閉路があるときfalseを返す
bool run(int s) {
dist = vector<T>(n, INF);
dist[s] = 0; //開始点の距離は0
for (int i = 0; i < 2 * n; i++) {
for (int v = 0; v < n; v++) {
for (auto &e : g[v]) {
if (dist[v] != INF && dist[e.to] > dist[v] + e.cost) {
dist[e.to] = dist[v] + e.cost;
if (i >= n - 1) {
// return false;
dist[e.to] = -INF;
}
}
}
}
}
return true;
}
T get_distance(int v) { return dist[v]; }
};
int main() {
ll n, m, p;
cin >> n >> m >> p;
bellmanford<ll> bell(n);
REP(i, m) {
ll a, b, c;
cin >> a >> b >> c;
a--;
b--;
bell.add_edge(a, b, -(c - p));
}
bell.run(0);
ll ans = -bell.get_distance(n - 1);
cout << ((ans < INF) ? max(ans, 0LL) : -1) << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"io.output.change"
] | 751,041 | 751,037 | u711985352 | cpp |
p02949 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
#define REP(i, n) for (ll i = 0; i < n; i++)
template <typename T> class bellmanford {
private:
struct edge {
int to;
T cost;
};
int n;
vector<vector<edge>> g;
vector<T> dist;
public:
bellmanford(int n) : n(n), g(n) {}
void add_edge(int v1, int v2, T cost) { g[v1].push_back({v2, cost}); }
// 負の閉路があるときfalseを返す
bool run(int s) {
dist = vector<T>(n, INF);
dist[s] = 0; //開始点の距離は0
for (int i = 0; i < n; i++) {
for (int v = 0; v < n; v++) {
for (auto &e : g[v]) {
if (dist[v] != INF && dist[e.to] > dist[v] + e.cost) {
dist[e.to] = dist[v] + e.cost;
if (i == n - 1) {
// return false;
dist[e.to] = -INF;
}
}
}
}
}
return true;
}
T get_distance(int v) { return dist[v]; }
};
int main() {
ll n, m, p;
cin >> n >> m >> p;
bellmanford<ll> bell(n);
REP(i, m) {
ll a, b, c;
cin >> a >> b >> c;
a--;
b--;
bell.add_edge(a, b, -(c - p));
}
bell.run(0);
ll ans = -bell.get_distance(n - 1);
cout << ((ans != INF) ? max(ans, 0LL) : -1) << endl;
}
| #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
#define REP(i, n) for (ll i = 0; i < n; i++)
template <typename T> class bellmanford {
private:
struct edge {
int to;
T cost;
};
int n;
vector<vector<edge>> g;
vector<T> dist;
public:
bellmanford(int n) : n(n), g(n) {}
void add_edge(int v1, int v2, T cost) { g[v1].push_back({v2, cost}); }
// 負の閉路があるときfalseを返す
bool run(int s) {
dist = vector<T>(n, INF);
dist[s] = 0; //開始点の距離は0
for (int i = 0; i < 2 * n; i++) {
for (int v = 0; v < n; v++) {
for (auto &e : g[v]) {
if (dist[v] != INF && dist[e.to] > dist[v] + e.cost) {
dist[e.to] = dist[v] + e.cost;
if (i >= n - 1) {
// return false;
dist[e.to] = -INF;
}
}
}
}
}
return true;
}
T get_distance(int v) { return dist[v]; }
};
int main() {
ll n, m, p;
cin >> n >> m >> p;
bellmanford<ll> bell(n);
REP(i, m) {
ll a, b, c;
cin >> a >> b >> c;
a--;
b--;
bell.add_edge(a, b, -(c - p));
}
bell.run(0);
ll ans = -bell.get_distance(n - 1);
cout << ((ans < INF) ? max(ans, 0LL) : -1) << endl;
}
| [
"control_flow.loop.for.condition.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"io.output.change"
] | 751,042 | 751,037 | u711985352 | cpp |
p02949 | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <assert.h>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <vector>
#define int long long
//#define ll long long
#define double long double
#define mod 1000000007
#define MAXN (int)1e+5 * 2 + 1
#define LL_MAX 9223372036854775807 //ない環境用
#define LL_HALFMAX 9223372036854775807 / 2 //ない環境用
#define MIN -(9223372036854775807 / 2)
#define INF 9223372036854775807 / 2
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define FOR(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define ALLOF(c) (c).begin(), (c).end()
#define REPS(i, x) for (int i = 1; i <= (int)(x); i++)
#define RREP(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define RREPS(i, x) for (int i = ((int)(x)); i > 0; i--)
#define repl(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define mp make_pair
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
using namespace std;
std::mt19937 mt((int)time(0));
int dx[4] = {0, 1, 0, -1}; // x軸方向への変位
int dy[4] = {1, 0, -1, 0}; // y軸方向への変位
using Weight = int;
using Flow = int;
struct Edge {
int src, dst;
Weight weight;
Flow cap;
Edge() : src(0), dst(0), weight(0) {}
Edge(int s, int d, Weight w) : src(s), dst(d), weight(w) {}
};
using Edges = std::vector<Edge>;
using Graph = std::vector<Edges>;
using Array = std::vector<Weight>;
using Matrix = std::vector<Array>;
void add_edge(Graph &g, int a, int b, Weight w = 1) {
g[a].emplace_back(a, b, w);
g[b].emplace_back(b, a, w);
}
void add_arc(Graph &g, int a, int b, Weight w = 1) {
g[a].emplace_back(a, b, w);
}
struct uf_tree {
std::vector<int> parent;
int __size;
uf_tree(int size_) : parent(size_, -1), __size(size_) {}
void unite(int x, int y) {
if ((x = find(x)) != (y = find(y))) {
if (parent[y] < parent[x])
std::swap(x, y);
parent[x] += parent[y];
parent[y] = x;
__size--;
}
}
bool is_same(int x, int y) { return find(x) == find(y); }
int find(int x) { return parent[x] < 0 ? x : parent[x] = find(parent[x]); }
int size(int x) { return -parent[find(x)]; }
int size() { return __size; }
};
//!!!問題をちゃんと読む!!!
//!!!問題をちゃんと読め!!!
//!!!問題は読みましたか？!!!
template <signed M, unsigned T> struct mod_int {
constexpr static signed MODULO = M;
constexpr static unsigned TABLE_SIZE = T;
signed x;
mod_int() : x(0) {}
mod_int(long long y)
: x(static_cast<signed>(y >= 0 ? y % MODULO : MODULO - (-y) % MODULO)) {}
mod_int(signed y) : x(y >= 0 ? y % MODULO : MODULO - (-y) % MODULO) {}
mod_int &operator+=(const mod_int &rhs) {
if ((x += rhs.x) >= MODULO)
x -= MODULO;
return *this;
}
mod_int &operator-=(const mod_int &rhs) {
if ((x += MODULO - rhs.x) >= MODULO)
x -= MODULO;
return *this;
}
mod_int &operator*=(const mod_int &rhs) {
x = static_cast<signed>(1LL * x * rhs.x % MODULO);
return *this;
}
mod_int &operator/=(const mod_int &rhs) {
x = static_cast<signed>((1LL * x * rhs.inv().x) % MODULO);
return *this;
}
mod_int operator-() const { return mod_int(-x); }
mod_int operator+(const mod_int &rhs) const { return mod_int(*this) += rhs; }
mod_int operator-(const mod_int &rhs) const { return mod_int(*this) -= rhs; }
mod_int operator*(const mod_int &rhs) const { return mod_int(*this) *= rhs; }
mod_int operator/(const mod_int &rhs) const { return mod_int(*this) /= rhs; }
bool operator<(const mod_int &rhs) const { return x < rhs.x; }
mod_int inv() const {
assert(x != 0);
if (x <= static_cast<signed>(TABLE_SIZE)) {
if (_inv[1].x == 0)
prepare();
return _inv[x];
} else {
signed a = x, b = MODULO, u = 1, v = 0, t;
while (b) {
t = a / b;
a -= t * b;
std::swap(a, b);
u -= t * v;
std::swap(u, v);
}
return mod_int(u);
}
}
mod_int pow(long long t) const {
assert(!(x == 0 && t == 0));
mod_int e = *this, res = mod_int(1);
for (; t; e *= e, t >>= 1)
if (t & 1)
res *= e;
return res;
}
mod_int fact() {
if (_fact[0].x == 0)
prepare();
return _fact[x];
}
mod_int inv_fact() {
if (_fact[0].x == 0)
prepare();
return _inv_fact[x];
}
mod_int choose(mod_int y) {
assert(y.x <= x);
return this->fact() * y.inv_fact() * mod_int(x - y.x).inv_fact();
}
static mod_int _inv[TABLE_SIZE + 1];
static mod_int _fact[TABLE_SIZE + 1];
static mod_int _inv_fact[TABLE_SIZE + 1];
static void prepare() {
_inv[1] = 1;
for (int i = 2; i <= (int)TABLE_SIZE; ++i) {
_inv[i] = 1LL * _inv[MODULO % i].x * (MODULO - MODULO / i) % MODULO;
}
_fact[0] = 1;
for (unsigned i = 1; i <= TABLE_SIZE; ++i) {
_fact[i] = _fact[i - 1] * signed(i);
}
_inv_fact[TABLE_SIZE] = _fact[TABLE_SIZE].inv();
for (int i = (int)TABLE_SIZE - 1; i >= 0; --i) {
_inv_fact[i] = _inv_fact[i + 1] * (i + 1);
}
}
};
template <signed M, unsigned F>
std::ostream &operator<<(std::ostream &os, const mod_int<M, F> &rhs) {
return os << rhs.x;
}
template <signed M, unsigned F>
std::istream &operator>>(std::istream &is, mod_int<M, F> &rhs) {
long long s;
is >> s;
rhs = mod_int<M, F>(s);
return is;
}
template <signed M, unsigned F>
mod_int<M, F> mod_int<M, F>::_inv[TABLE_SIZE + 1];
template <signed M, unsigned F>
mod_int<M, F> mod_int<M, F>::_fact[TABLE_SIZE + 1];
template <signed M, unsigned F>
mod_int<M, F> mod_int<M, F>::_inv_fact[TABLE_SIZE + 1];
template <signed M, unsigned F>
bool operator==(const mod_int<M, F> &lhs, const mod_int<M, F> &rhs) {
return lhs.x == rhs.x;
}
template <int M, unsigned F>
bool operator!=(const mod_int<M, F> &lhs, const mod_int<M, F> &rhs) {
return !(lhs == rhs);
}
const signed MF = 1000010;
const signed MOD = 1000000007;
using mint = mod_int<MOD, MF>;
mint binom(int n, int r) {
return (r < 0 || r > n || n < 0) ? 0 : mint(n).choose(r);
}
mint fact(int n) { return mint(n).fact(); }
mint inv_fact(int n) { return mint(n).inv_fact(); }
//出典 http://beet-aizu.hatenablog.com/entry/2017/12/01/225955
/*
コンストラクタ引数説明
int n_
要素数。
f
2つの要素Tをマージするための関数。
区間MAX区間更新の時: max
区間Sum区間Addの時: +
g
1つの要素Tに作用素Eを適用するための関数。
区間MAX区間更新の時: =
区間Sum区間Addの時: +
h
2つの作用素Eをマージするための関数。
区間MAX区間更新の時: =
区間Sum区間Addの時: +
T d1
演算fの単位元。
区間MAX区間更新の時: -INF
区間Sum区間Addの時: 0
E d0,
g, hの単位元。
区間MAX区間更新の時: 定義域外のどこか
区間Sum区間Addの時: 0
vector<T> v = vector<T>()
セグ木を構成するときのvector
P p = [](E a, int b) {return a; }
区間の長さbを引数に取り、区間の長さによって変化する作用素E'を返す関数。
例えば、区間MAX区間Addの時なんかは区間長によって足すべき数が変化するので必要
区間Sum区間Addの時: *
//具体例
//区間chmin, 区間min
auto myMin = [](int a, int b) {return min(a, b); };
SegmentTree<int, int> seg(n, myMin, myMin, myMin, LL_HALFMAX, LL_HALFMAX);
//区間update、区間min
SegmentTree<int, int> seg(n, myMin, myMin, myMin, LL_HALFMAX, LL_HALFMAX);
*/
template <typename T, typename E> struct SegmentTree {
typedef function<T(T, T)> F;
typedef function<T(T, E)> G;
typedef function<E(E, E)> H;
typedef function<E(E, int)> P;
int n;
F f;
G g;
H h;
P p;
T d1;
E d0;
vector<T> dat;
vector<E> laz;
SegmentTree(
int n_, F f, G g, H h, T d1, E d0, vector<T> v = vector<T>(),
P p = [](E a, int b) { return a; })
: f(f), g(g), h(h), d1(d1), d0(d0), p(p) {
init(n_);
if (n_ == (int)v.size())
build(n_, v);
}
//初期化。要素配列と遅延配列を2*n-1個にする
void init(int n_) {
n = 1;
while (n < n_)
n *= 2;
dat.clear();
dat.resize(2 * n - 1, d1);
laz.clear();
laz.resize(2 * n - 1, d0);
}
//既存のvectorからセグ木を構築
void build(int n_, vector<T> v) {
for (int i = 0; i < n_; i++)
dat[i + n - 1] = v[i];
for (int i = n - 2; i >= 0; i--)
dat[i] = f(dat[i * 2 + 1], dat[i * 2 + 2]);
}
//ノードを評価する。
inline void eval(int len, int k) {
//遅延配列に単位元が入ってたら評価済みなのでおしまい
if (laz[k] == d0)
return;
//葉ノードでないなら遅延伝播する
if (k * 2 + 1 < n * 2 - 1) {
// h: 2つの作用素を引数に取り合成した作用素を返す関数
laz[k * 2 + 1] = h(laz[k * 2 + 1], laz[k]);
laz[k * 2 + 2] = h(laz[k * 2 + 2], laz[k]);
}
// p:
// このノードに対応する区間長と作用素を引数に取り、区間長に対応する作用素を返す関数
// dat[k] にlaz に溜めていた作用素を適用(g:
// 要素型と作用素型を引数に取り、要素に作用素を作用させた結果を返す関数、ここでの作用素とは区間Sum区間Addなら
// (+ 3) とか)
dat[k] = g(dat[k], p(laz[k], len));
//適用し終わったので遅延配列をクリア
laz[k] = d0;
}
//[l,r)の区間を再帰的に見ながら0-indexedの[a, b)を更新する
T update(int a, int b, E x, int k, int l, int r) {
//先に評価
eval(r - l, k);
//範囲外ならなにもしないでそのノードが持つ値を返す
if (r <= a || b <= l)
return dat[k];
//完全被覆なら既に遅延配列に入っている作用素と追加したい作用素をマージした後にそれを要素に作用させた結果を返す、pは区間長に対応する作用素を得るための（ｒｙ
if (a <= l && r <= b) {
laz[k] = h(laz[k], x);
return g(dat[k], p(laz[k], r - l));
}
//完全被覆でも範囲外でもないなら(中途半端にかぶっているなら)完全被覆と範囲外の境界が見えるまで木を潜って変化後の値を得る
return dat[k] = f(update(a, b, x, k * 2 + 1, l, (l + r) / 2),
update(a, b, x, k * 2 + 2, (l + r) / 2, r));
}
T update(int a, int b, E x) { return update(a, b, x, 0, 0, n); }
T query(int a, int b, int k, int l, int r) {
eval(r - l, k);
//範囲外なら単位元を返す
if (r <= a || b <= l)
return d1;
//完全被覆ならそのまま返す
if (a <= l && r <= b)
return dat[k];
//一部被覆なら完全被覆と範囲外に分かれるまで木を潜る
T vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
T vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return f(vl, vr);
}
// 0-indexedで[a, b)の区間*を求める
T query(int a, int b) { return query(a, b, 0, 0, n); }
};
//座標圧縮
class compress {
public:
static const int MAP = 10000000;
map<int, int> zip;
int unzip[MAP];
compress(vector<int> &x) {
sort(x.begin(), x.end());
x.erase(unique(x.begin(), x.end()), x.end());
for (int i = 0; i < x.size(); i++) {
zip[x[i]] = i;
unzip[i] = x[i];
}
}
};
unsigned euclidean_gcd(unsigned a, unsigned b) {
while (1) {
if (a < b)
swap(a, b);
if (!b)
break;
a %= b;
}
return a;
}
// https://ei1333.github.io/luzhiled/snippets/dp/cumulative-sum-2d.html
template <class T> struct CumulativeSum2D {
vector<vector<T>> data;
CumulativeSum2D(int W, int H) : data(W + 1, vector<int>(H + 1, 0)) {}
void add(int x, int y, T z) {
++x, ++y;
if (x >= data.size() || y >= data[0].size())
return;
data[x][y] += z;
}
void build() {
for (int i = 1; i < data.size(); i++) {
for (int j = 1; j < data[i].size(); j++) {
data[i][j] += data[i][j - 1] + data[i - 1][j] - data[i - 1][j - 1];
}
}
}
T query(int sx, int sy, int gx, int gy) {
return (data[gx][gy] - data[sx][gy] - data[gx][sy] + data[sx][sy]);
}
};
// lib
int nC2(int n) { return n * (n - 1) / 2; }
class node {
public:
int depth;
int num;
node(int d, int n) {
depth = d;
num = n;
}
};
CumulativeSum2D<int> sumB(4001, 4001);
template <class T> struct CumulativeSum {
vector<T> data;
CumulativeSum(int sz) : data(sz, 0){};
void add(int k, T x) { data[k] += x; }
void build() {
for (int i = 1; i < data.size(); i++) {
data[i] += data[i - 1];
}
}
T query(int k) {
if (k < 0)
return (0);
return (data[min(k, (int)data.size() - 1)]);
}
//[left, right]の和
T query(int left, int right) { return query(right) - query(left - 1); }
};
std::vector<bool> IsPrime;
void sieve(size_t max) {
if (max + 1 > IsPrime.size()) { // resizeで要素数が減らないように
IsPrime.resize(max + 1, true); // IsPrimeに必要な要素数を確保
}
IsPrime[0] = false; // 0は素数ではない
IsPrime[1] = false; // 1は素数ではない
for (size_t i = 2; i * i <= max; ++i) // 0からsqrt(max)まで調べる
if (IsPrime[i]) // iが素数ならば
for (size_t j = 2; i * j <= max; ++j) // (max以下の)iの倍数は
IsPrime[i * j] = false; // 素数ではない
}
vector<int64_t> divisor(int64_t n) {
vector<int64_t> ret;
for (int64_t i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(begin(ret), end(ret));
return (ret);
}
// k が条件を満たすかどうか
bool isOK(int k) { return false; }
// 汎用的な二分探索のテンプレ(めぐる式)
int binary_search() {
int ng = 2000000;
int ok = 1;
/* ok と ng のどちらが大きいかわからないことを考慮 */
while (abs(ok - ng) > 1) {
int mid = (ok + ng) / 2;
if (isOK(mid))
ok = mid;
else
ng = mid;
}
return ok;
}
std::pair<std::vector<Weight>, bool> bellmanFord(const Graph &g, int s) {
int n = g.size();
const Weight inf = std::numeric_limits<Weight>::max() / 8;
Edges es;
for (int i = 0; i < n; i++)
for (auto &e : g[i])
es.emplace_back(e);
//初期化、スタート地点以外の距離は無限大
std::vector<Weight> dist(n, inf);
dist[s] = 0;
bool negCycle = false;
for (int i = 0;; i++) {
bool update = false;
//すべての辺について、その辺をとおった場合に最短経路が更新できる場合は更新する
for (auto &e : es) {
if (dist[e.src] != inf && dist[e.dst] > dist[e.src] + e.weight) {
dist[e.dst] = dist[e.src] + e.weight;
update = true;
}
}
//更新がなくなったらおはり
if (!update)
break;
// n回以上更新されてたら負閉路がある
if (i > n) {
negCycle = true;
break;
}
}
return std::make_pair(dist, !negCycle);
}
//ゴールを指定して、それまでのパスに負閉路がなかったらOK
std::pair<std::vector<Weight>, bool> bellmanFord(const Graph &g, int s, int d) {
int n = g.size();
const Weight inf = std::numeric_limits<Weight>::max() / 8;
Edges es;
for (int i = 0; i < n; i++)
for (auto &e : g[i])
es.emplace_back(e);
//初期化、スタート地点以外の距離は無限大
std::vector<Weight> dist(n, inf);
dist[s] = 0;
bool negCycle = false;
for (int i = 0; i < n * 2; i++) {
bool update = false;
//すべての辺について、その辺をとおった場合に最短経路が更新できる場合は更新する
for (auto &e : es) {
if (dist[e.src] != inf && dist[e.dst] > dist[e.src] + e.weight) {
dist[e.dst] = dist[e.src] + e.weight;
update = true;
if (e.src == d && i <= n * 2 - 1 && i > n)
negCycle = true;
}
}
//更新がなくなったらおはり
if (!update)
break;
}
return std::make_pair(dist, !negCycle);
}
signed main() {
int N, M, P;
cin >> N >> M >> P;
Graph g(N + 2);
rep(i, M) {
int A, B, C;
cin >> A >> B >> C;
add_arc(g, A, B, -(C - P));
}
std::pair<std::vector<Weight>, bool> p = bellmanFord(g, 1, N);
std::vector<Weight> v = p.first;
if (p.second == false) {
cout << -1 << "\n";
} else {
cout << max(-p.first[N], 0LL) << "\n";
}
return 0;
}
| #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <assert.h>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <vector>
#define int long long
//#define ll long long
#define double long double
#define mod 1000000007
#define MAXN (int)1e+5 * 2 + 1
#define LL_MAX 9223372036854775807 //ない環境用
#define LL_HALFMAX 9223372036854775807 / 2 //ない環境用
#define MIN -(9223372036854775807 / 2)
#define INF 9223372036854775807 / 2
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define FOR(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define ALLOF(c) (c).begin(), (c).end()
#define REPS(i, x) for (int i = 1; i <= (int)(x); i++)
#define RREP(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define RREPS(i, x) for (int i = ((int)(x)); i > 0; i--)
#define repl(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define mp make_pair
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
using namespace std;
std::mt19937 mt((int)time(0));
int dx[4] = {0, 1, 0, -1}; // x軸方向への変位
int dy[4] = {1, 0, -1, 0}; // y軸方向への変位
using Weight = int;
using Flow = int;
struct Edge {
int src, dst;
Weight weight;
Flow cap;
Edge() : src(0), dst(0), weight(0) {}
Edge(int s, int d, Weight w) : src(s), dst(d), weight(w) {}
};
using Edges = std::vector<Edge>;
using Graph = std::vector<Edges>;
using Array = std::vector<Weight>;
using Matrix = std::vector<Array>;
void add_edge(Graph &g, int a, int b, Weight w = 1) {
g[a].emplace_back(a, b, w);
g[b].emplace_back(b, a, w);
}
void add_arc(Graph &g, int a, int b, Weight w = 1) {
g[a].emplace_back(a, b, w);
}
struct uf_tree {
std::vector<int> parent;
int __size;
uf_tree(int size_) : parent(size_, -1), __size(size_) {}
void unite(int x, int y) {
if ((x = find(x)) != (y = find(y))) {
if (parent[y] < parent[x])
std::swap(x, y);
parent[x] += parent[y];
parent[y] = x;
__size--;
}
}
bool is_same(int x, int y) { return find(x) == find(y); }
int find(int x) { return parent[x] < 0 ? x : parent[x] = find(parent[x]); }
int size(int x) { return -parent[find(x)]; }
int size() { return __size; }
};
//!!!問題をちゃんと読む!!!
//!!!問題をちゃんと読め!!!
//!!!問題は読みましたか？!!!
template <signed M, unsigned T> struct mod_int {
constexpr static signed MODULO = M;
constexpr static unsigned TABLE_SIZE = T;
signed x;
mod_int() : x(0) {}
mod_int(long long y)
: x(static_cast<signed>(y >= 0 ? y % MODULO : MODULO - (-y) % MODULO)) {}
mod_int(signed y) : x(y >= 0 ? y % MODULO : MODULO - (-y) % MODULO) {}
mod_int &operator+=(const mod_int &rhs) {
if ((x += rhs.x) >= MODULO)
x -= MODULO;
return *this;
}
mod_int &operator-=(const mod_int &rhs) {
if ((x += MODULO - rhs.x) >= MODULO)
x -= MODULO;
return *this;
}
mod_int &operator*=(const mod_int &rhs) {
x = static_cast<signed>(1LL * x * rhs.x % MODULO);
return *this;
}
mod_int &operator/=(const mod_int &rhs) {
x = static_cast<signed>((1LL * x * rhs.inv().x) % MODULO);
return *this;
}
mod_int operator-() const { return mod_int(-x); }
mod_int operator+(const mod_int &rhs) const { return mod_int(*this) += rhs; }
mod_int operator-(const mod_int &rhs) const { return mod_int(*this) -= rhs; }
mod_int operator*(const mod_int &rhs) const { return mod_int(*this) *= rhs; }
mod_int operator/(const mod_int &rhs) const { return mod_int(*this) /= rhs; }
bool operator<(const mod_int &rhs) const { return x < rhs.x; }
mod_int inv() const {
assert(x != 0);
if (x <= static_cast<signed>(TABLE_SIZE)) {
if (_inv[1].x == 0)
prepare();
return _inv[x];
} else {
signed a = x, b = MODULO, u = 1, v = 0, t;
while (b) {
t = a / b;
a -= t * b;
std::swap(a, b);
u -= t * v;
std::swap(u, v);
}
return mod_int(u);
}
}
mod_int pow(long long t) const {
assert(!(x == 0 && t == 0));
mod_int e = *this, res = mod_int(1);
for (; t; e *= e, t >>= 1)
if (t & 1)
res *= e;
return res;
}
mod_int fact() {
if (_fact[0].x == 0)
prepare();
return _fact[x];
}
mod_int inv_fact() {
if (_fact[0].x == 0)
prepare();
return _inv_fact[x];
}
mod_int choose(mod_int y) {
assert(y.x <= x);
return this->fact() * y.inv_fact() * mod_int(x - y.x).inv_fact();
}
static mod_int _inv[TABLE_SIZE + 1];
static mod_int _fact[TABLE_SIZE + 1];
static mod_int _inv_fact[TABLE_SIZE + 1];
static void prepare() {
_inv[1] = 1;
for (int i = 2; i <= (int)TABLE_SIZE; ++i) {
_inv[i] = 1LL * _inv[MODULO % i].x * (MODULO - MODULO / i) % MODULO;
}
_fact[0] = 1;
for (unsigned i = 1; i <= TABLE_SIZE; ++i) {
_fact[i] = _fact[i - 1] * signed(i);
}
_inv_fact[TABLE_SIZE] = _fact[TABLE_SIZE].inv();
for (int i = (int)TABLE_SIZE - 1; i >= 0; --i) {
_inv_fact[i] = _inv_fact[i + 1] * (i + 1);
}
}
};
template <signed M, unsigned F>
std::ostream &operator<<(std::ostream &os, const mod_int<M, F> &rhs) {
return os << rhs.x;
}
template <signed M, unsigned F>
std::istream &operator>>(std::istream &is, mod_int<M, F> &rhs) {
long long s;
is >> s;
rhs = mod_int<M, F>(s);
return is;
}
template <signed M, unsigned F>
mod_int<M, F> mod_int<M, F>::_inv[TABLE_SIZE + 1];
template <signed M, unsigned F>
mod_int<M, F> mod_int<M, F>::_fact[TABLE_SIZE + 1];
template <signed M, unsigned F>
mod_int<M, F> mod_int<M, F>::_inv_fact[TABLE_SIZE + 1];
template <signed M, unsigned F>
bool operator==(const mod_int<M, F> &lhs, const mod_int<M, F> &rhs) {
return lhs.x == rhs.x;
}
template <int M, unsigned F>
bool operator!=(const mod_int<M, F> &lhs, const mod_int<M, F> &rhs) {
return !(lhs == rhs);
}
const signed MF = 1000010;
const signed MOD = 1000000007;
using mint = mod_int<MOD, MF>;
mint binom(int n, int r) {
return (r < 0 || r > n || n < 0) ? 0 : mint(n).choose(r);
}
mint fact(int n) { return mint(n).fact(); }
mint inv_fact(int n) { return mint(n).inv_fact(); }
//出典 http://beet-aizu.hatenablog.com/entry/2017/12/01/225955
/*
コンストラクタ引数説明
int n_
要素数。
f
2つの要素Tをマージするための関数。
区間MAX区間更新の時: max
区間Sum区間Addの時: +
g
1つの要素Tに作用素Eを適用するための関数。
区間MAX区間更新の時: =
区間Sum区間Addの時: +
h
2つの作用素Eをマージするための関数。
区間MAX区間更新の時: =
区間Sum区間Addの時: +
T d1
演算fの単位元。
区間MAX区間更新の時: -INF
区間Sum区間Addの時: 0
E d0,
g, hの単位元。
区間MAX区間更新の時: 定義域外のどこか
区間Sum区間Addの時: 0
vector<T> v = vector<T>()
セグ木を構成するときのvector
P p = [](E a, int b) {return a; }
区間の長さbを引数に取り、区間の長さによって変化する作用素E'を返す関数。
例えば、区間MAX区間Addの時なんかは区間長によって足すべき数が変化するので必要
区間Sum区間Addの時: *
//具体例
//区間chmin, 区間min
auto myMin = [](int a, int b) {return min(a, b); };
SegmentTree<int, int> seg(n, myMin, myMin, myMin, LL_HALFMAX, LL_HALFMAX);
//区間update、区間min
SegmentTree<int, int> seg(n, myMin, myMin, myMin, LL_HALFMAX, LL_HALFMAX);
*/
template <typename T, typename E> struct SegmentTree {
typedef function<T(T, T)> F;
typedef function<T(T, E)> G;
typedef function<E(E, E)> H;
typedef function<E(E, int)> P;
int n;
F f;
G g;
H h;
P p;
T d1;
E d0;
vector<T> dat;
vector<E> laz;
SegmentTree(
int n_, F f, G g, H h, T d1, E d0, vector<T> v = vector<T>(),
P p = [](E a, int b) { return a; })
: f(f), g(g), h(h), d1(d1), d0(d0), p(p) {
init(n_);
if (n_ == (int)v.size())
build(n_, v);
}
//初期化。要素配列と遅延配列を2*n-1個にする
void init(int n_) {
n = 1;
while (n < n_)
n *= 2;
dat.clear();
dat.resize(2 * n - 1, d1);
laz.clear();
laz.resize(2 * n - 1, d0);
}
//既存のvectorからセグ木を構築
void build(int n_, vector<T> v) {
for (int i = 0; i < n_; i++)
dat[i + n - 1] = v[i];
for (int i = n - 2; i >= 0; i--)
dat[i] = f(dat[i * 2 + 1], dat[i * 2 + 2]);
}
//ノードを評価する。
inline void eval(int len, int k) {
//遅延配列に単位元が入ってたら評価済みなのでおしまい
if (laz[k] == d0)
return;
//葉ノードでないなら遅延伝播する
if (k * 2 + 1 < n * 2 - 1) {
// h: 2つの作用素を引数に取り合成した作用素を返す関数
laz[k * 2 + 1] = h(laz[k * 2 + 1], laz[k]);
laz[k * 2 + 2] = h(laz[k * 2 + 2], laz[k]);
}
// p:
// このノードに対応する区間長と作用素を引数に取り、区間長に対応する作用素を返す関数
// dat[k] にlaz に溜めていた作用素を適用(g:
// 要素型と作用素型を引数に取り、要素に作用素を作用させた結果を返す関数、ここでの作用素とは区間Sum区間Addなら
// (+ 3) とか)
dat[k] = g(dat[k], p(laz[k], len));
//適用し終わったので遅延配列をクリア
laz[k] = d0;
}
//[l,r)の区間を再帰的に見ながら0-indexedの[a, b)を更新する
T update(int a, int b, E x, int k, int l, int r) {
//先に評価
eval(r - l, k);
//範囲外ならなにもしないでそのノードが持つ値を返す
if (r <= a || b <= l)
return dat[k];
//完全被覆なら既に遅延配列に入っている作用素と追加したい作用素をマージした後にそれを要素に作用させた結果を返す、pは区間長に対応する作用素を得るための（ｒｙ
if (a <= l && r <= b) {
laz[k] = h(laz[k], x);
return g(dat[k], p(laz[k], r - l));
}
//完全被覆でも範囲外でもないなら(中途半端にかぶっているなら)完全被覆と範囲外の境界が見えるまで木を潜って変化後の値を得る
return dat[k] = f(update(a, b, x, k * 2 + 1, l, (l + r) / 2),
update(a, b, x, k * 2 + 2, (l + r) / 2, r));
}
T update(int a, int b, E x) { return update(a, b, x, 0, 0, n); }
T query(int a, int b, int k, int l, int r) {
eval(r - l, k);
//範囲外なら単位元を返す
if (r <= a || b <= l)
return d1;
//完全被覆ならそのまま返す
if (a <= l && r <= b)
return dat[k];
//一部被覆なら完全被覆と範囲外に分かれるまで木を潜る
T vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
T vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return f(vl, vr);
}
// 0-indexedで[a, b)の区間*を求める
T query(int a, int b) { return query(a, b, 0, 0, n); }
};
//座標圧縮
class compress {
public:
static const int MAP = 10000000;
map<int, int> zip;
int unzip[MAP];
compress(vector<int> &x) {
sort(x.begin(), x.end());
x.erase(unique(x.begin(), x.end()), x.end());
for (int i = 0; i < x.size(); i++) {
zip[x[i]] = i;
unzip[i] = x[i];
}
}
};
unsigned euclidean_gcd(unsigned a, unsigned b) {
while (1) {
if (a < b)
swap(a, b);
if (!b)
break;
a %= b;
}
return a;
}
// https://ei1333.github.io/luzhiled/snippets/dp/cumulative-sum-2d.html
template <class T> struct CumulativeSum2D {
vector<vector<T>> data;
CumulativeSum2D(int W, int H) : data(W + 1, vector<int>(H + 1, 0)) {}
void add(int x, int y, T z) {
++x, ++y;
if (x >= data.size() || y >= data[0].size())
return;
data[x][y] += z;
}
void build() {
for (int i = 1; i < data.size(); i++) {
for (int j = 1; j < data[i].size(); j++) {
data[i][j] += data[i][j - 1] + data[i - 1][j] - data[i - 1][j - 1];
}
}
}
T query(int sx, int sy, int gx, int gy) {
return (data[gx][gy] - data[sx][gy] - data[gx][sy] + data[sx][sy]);
}
};
// lib
int nC2(int n) { return n * (n - 1) / 2; }
class node {
public:
int depth;
int num;
node(int d, int n) {
depth = d;
num = n;
}
};
CumulativeSum2D<int> sumB(4001, 4001);
template <class T> struct CumulativeSum {
vector<T> data;
CumulativeSum(int sz) : data(sz, 0){};
void add(int k, T x) { data[k] += x; }
void build() {
for (int i = 1; i < data.size(); i++) {
data[i] += data[i - 1];
}
}
T query(int k) {
if (k < 0)
return (0);
return (data[min(k, (int)data.size() - 1)]);
}
//[left, right]の和
T query(int left, int right) { return query(right) - query(left - 1); }
};
std::vector<bool> IsPrime;
void sieve(size_t max) {
if (max + 1 > IsPrime.size()) { // resizeで要素数が減らないように
IsPrime.resize(max + 1, true); // IsPrimeに必要な要素数を確保
}
IsPrime[0] = false; // 0は素数ではない
IsPrime[1] = false; // 1は素数ではない
for (size_t i = 2; i * i <= max; ++i) // 0からsqrt(max)まで調べる
if (IsPrime[i]) // iが素数ならば
for (size_t j = 2; i * j <= max; ++j) // (max以下の)iの倍数は
IsPrime[i * j] = false; // 素数ではない
}
vector<int64_t> divisor(int64_t n) {
vector<int64_t> ret;
for (int64_t i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(begin(ret), end(ret));
return (ret);
}
// k が条件を満たすかどうか
bool isOK(int k) { return false; }
// 汎用的な二分探索のテンプレ(めぐる式)
int binary_search() {
int ng = 2000000;
int ok = 1;
/* ok と ng のどちらが大きいかわからないことを考慮 */
while (abs(ok - ng) > 1) {
int mid = (ok + ng) / 2;
if (isOK(mid))
ok = mid;
else
ng = mid;
}
return ok;
}
std::pair<std::vector<Weight>, bool> bellmanFord(const Graph &g, int s) {
int n = g.size();
const Weight inf = std::numeric_limits<Weight>::max() / 8;
Edges es;
for (int i = 0; i < n; i++)
for (auto &e : g[i])
es.emplace_back(e);
//初期化、スタート地点以外の距離は無限大
std::vector<Weight> dist(n, inf);
dist[s] = 0;
bool negCycle = false;
for (int i = 0;; i++) {
bool update = false;
//すべての辺について、その辺をとおった場合に最短経路が更新できる場合は更新する
for (auto &e : es) {
if (dist[e.src] != inf && dist[e.dst] > dist[e.src] + e.weight) {
dist[e.dst] = dist[e.src] + e.weight;
update = true;
}
}
//更新がなくなったらおはり
if (!update)
break;
// n回以上更新されてたら負閉路がある
if (i > n) {
negCycle = true;
break;
}
}
return std::make_pair(dist, !negCycle);
}
//ゴールを指定して、それまでのパスに負閉路がなかったらOK
std::pair<std::vector<Weight>, bool> bellmanFord(const Graph &g, int s, int d) {
int n = g.size();
const Weight inf = std::numeric_limits<Weight>::max() / 8;
Edges es;
for (int i = 0; i < n; i++)
for (auto &e : g[i])
es.emplace_back(e);
//初期化、スタート地点以外の距離は無限大
std::vector<Weight> dist(n, inf);
dist[s] = 0;
bool negCycle = false;
for (int i = 0; i < n * 2; i++) {
bool update = false;
//すべての辺について、その辺をとおった場合に最短経路が更新できる場合は更新する
for (auto &e : es) {
if (dist[e.src] != inf && dist[e.dst] > dist[e.src] + e.weight) {
dist[e.dst] = dist[e.src] + e.weight;
update = true;
if (e.dst == d && i <= n * 2 - 1 && i > n)
negCycle = true;
}
}
//更新がなくなったらおはり
if (!update)
break;
}
return std::make_pair(dist, !negCycle);
}
signed main() {
int N, M, P;
cin >> N >> M >> P;
Graph g(N + 2);
rep(i, M) {
int A, B, C;
cin >> A >> B >> C;
add_arc(g, A, B, -(C - P));
}
std::pair<std::vector<Weight>, bool> p = bellmanFord(g, 1, N);
std::vector<Weight> v = p.first;
if (p.second == false) {
cout << -1 << "\n";
} else {
cout << max(-p.first[N], 0LL) << "\n";
}
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 751,043 | 751,044 | u783675879 | cpp |
p02949 | #include <algorithm>
#include <iostream>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
const int VMAX = 2600, EMAX = 5010;
const ll INFLL = 1e+17;
int V, E;
ll p;
int a[5010], b[5010];
ll c[5010];
struct edge {
int from, to;
ll cost;
};
edge e[EMAX];
ll d[VMAX];
bool update;
bool bellmanford(int s) {
for (int i = 0; i < V; i++)
d[i] = INFLL;
d[s] = 0;
for (int j = 0; j < V; j++) {
update = false;
for (int i = 0; i < E; i++) {
int f = e[i].from, t = e[i].to;
ll c = e[i].cost;
if (d[f] != INFLL && d[t] > d[f] + c) {
d[t] = d[f] + c;
update = true;
if (j == V - 1 && t == V - 1)
return false;
}
}
if (!update)
break;
}
return true;
}
//負閉路の検出
bool find_negative_loop() {
for (int i = 0; i < V; i++)
d[i] = 0;
for (int i = 0; i < V; i++) {
for (int j = 0; j < E; j++) {
int f = e[i].from, t = e[i].to;
ll c = e[i].cost;
if (d[t] > d[f] + c) {
d[t] = d[f] + c;
if (i == V - 1)
return true;
}
}
}
return false;
}
int main() {
cin >> V >> E >> p;
rep(i, E) {
cin >> a[i] >> b[i] >> c[i];
e[i].from = --a[i];
e[i].to = --b[i];
e[i].cost = -c[i] + p;
}
if (!bellmanford(0))
cout << -1 << "\n";
else {
cout << max((ll)0, -d[V - 1]) << "\n";
}
return 0;
}
| #include <algorithm>
#include <iostream>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
const int VMAX = 2600, EMAX = 5010;
const ll INFLL = 1e+17;
int V, E;
ll p;
int a[5010], b[5010];
ll c[5010];
struct edge {
int from, to;
ll cost;
};
edge e[EMAX];
ll d[VMAX];
bool update;
bool bellmanford(int s) {
for (int i = 0; i < V; i++)
d[i] = INFLL;
d[s] = 0;
for (int j = 0; j < 2 * V; j++) {
update = false;
for (int i = 0; i < E; i++) {
int f = e[i].from, t = e[i].to;
ll c = e[i].cost;
if (d[f] != INFLL && d[t] > d[f] + c) {
d[t] = d[f] + c;
update = true;
if (j >= V - 1 && t == V - 1)
return false;
}
}
if (!update)
break;
}
return true;
}
//負閉路の検出
bool find_negative_loop() {
for (int i = 0; i < V; i++)
d[i] = 0;
for (int i = 0; i < V; i++) {
for (int j = 0; j < E; j++) {
int f = e[i].from, t = e[i].to;
ll c = e[i].cost;
if (d[t] > d[f] + c) {
d[t] = d[f] + c;
if (i == V - 1)
return true;
}
}
}
return false;
}
int main() {
cin >> V >> E >> p;
rep(i, E) {
cin >> a[i] >> b[i] >> c[i];
e[i].from = --a[i];
e[i].to = --b[i];
e[i].cost = -c[i] + p;
}
if (!bellmanford(0))
cout << -1 << "\n";
else {
cout << max((ll)0, -d[V - 1]) << "\n";
}
return 0;
}
| [
"control_flow.loop.for.condition.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 751,050 | 751,051 | u110996038 | cpp |
p02949 | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(vec) vec.begin(), vec.end()
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
typedef tuple<ll, ll, ll> tlll;
typedef tuple<int, int, int> tiii;
const ll mod = 1e9 + 7;
const int inf = 1 << 30;
vector<int> to[2510];
vector<int> rto[2510];
bool reachablefrom1[2510];
bool reachabletoN[2510];
bool ok[2510];
void dfs(int v) {
if (reachablefrom1[v])
return;
reachablefrom1[v] = 1;
for (int nv : to[v]) {
dfs(nv);
}
}
void rdfs(int v) {
if (reachabletoN[v])
return;
reachabletoN[v] = 1;
for (int nv : rto[v]) {
rdfs(nv);
}
}
int main() {
int n, m, p;
cin >> n >> m >> p;
vector<tiii> edges;
rep(i, m) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
c -= p;
c = -c;
edges.emplace_back(a, b, c);
to[a].push_back(b);
rto[b].push_back(a);
}
dfs(0);
rdfs(n - 1);
rep(i, n) ok[i] = reachablefrom1[i] && reachabletoN[i];
// bellman-ford
vector<int> dist(n, inf);
dist[0] = 0;
bool update = true;
int step = 0;
while (update) {
update = false;
rep(i, m) {
int a, b, c;
tie(a, b, c) = edges[i];
if (!ok[a] || !ok[b])
continue;
if (dist[a] + c < dist[b]) {
update = true;
dist[b] = dist[a] + c;
}
}
step++;
if (step >= n) {
cout << -1 << endl;
return 0;
}
}
int ans = -dist[n - 1];
ans = max(ans, 0);
cout << ans << endl;
} | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(vec) vec.begin(), vec.end()
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
typedef tuple<ll, ll, ll> tlll;
typedef tuple<int, int, int> tiii;
const ll mod = 1e9 + 7;
const int inf = 1 << 30;
vector<int> to[2510];
vector<int> rto[2510];
bool reachablefrom1[2510];
bool reachabletoN[2510];
bool ok[2510];
void dfs(int v) {
if (reachablefrom1[v])
return;
reachablefrom1[v] = 1;
for (int nv : to[v]) {
dfs(nv);
}
}
void rdfs(int v) {
if (reachabletoN[v])
return;
reachabletoN[v] = 1;
for (int nv : rto[v]) {
rdfs(nv);
}
}
int main() {
int n, m, p;
cin >> n >> m >> p;
vector<tiii> edges;
rep(i, m) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
c -= p;
c = -c;
edges.emplace_back(a, b, c);
to[a].push_back(b);
rto[b].push_back(a);
}
dfs(0);
rdfs(n - 1);
rep(i, n) ok[i] = reachablefrom1[i] && reachabletoN[i];
// bellman-ford
vector<int> dist(n, inf);
dist[0] = 0;
bool update = true;
int step = 0;
while (update) {
update = false;
rep(i, m) {
int a, b, c;
tie(a, b, c) = edges[i];
if (!ok[a] || !ok[b])
continue;
if (dist[a] + c < dist[b]) {
update = true;
dist[b] = dist[a] + c;
}
}
step++;
if (step > n) {
cout << -1 << endl;
return 0;
}
}
int ans = -dist[n - 1];
ans = max(ans, 0);
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 751,054 | 751,055 | u136342563 | cpp |
p02949 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define MOD (1000000007)
using namespace std;
typedef long long int Int;
constexpr Int TEN(int n) { return n == 0 ? 1 : 10 * TEN(n - 1); }
const int max_n = 2600;
const int inf = 1001001001;
int N, M, P;
vector<int> V[max_n];
vector<int> rV[max_n];
bool from[max_n];
bool to[max_n];
bool ok[max_n];
void dfs(int x) {
if (from[x])
return;
from[x] = true;
for (auto u : V[x]) {
dfs(u);
}
return;
}
void rdfs(int x) {
if (to[x])
return;
to[x] = true;
for (auto u : rV[x]) {
rdfs(u);
}
return;
}
int main(void) {
cin >> N >> M >> P;
vector<tuple<int, int, int>> edges;
for (int i = 0; i < N; i++) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
c -= P;
c = -c; // to solve minimize distance
edges.emplace_back(a, b, c);
V[a].push_back(b);
rV[b].push_back(a);
}
dfs(0);
rdfs(N - 1);
for (int i = 0; i < N; i++)
ok[i] = to[i] && from[i];
{
vector<int> d(N, inf);
d[0] = 0;
bool upd = true;
int step = 0;
while (upd) {
upd = false;
for (int i = 0; i < M; i++) {
int a, b, c;
tie(a, b, c) = edges[i];
if (!ok[a])
continue;
if (!ok[b])
continue;
int newD = d[a] + c;
if (newD < d[b]) {
upd = true;
d[b] = newD;
}
}
step++;
if (step > N) {
cout << -1 << endl;
return 0;
}
}
int ans = -d[N - 1];
cout << max(ans, 0) << endl;
}
return 0;
}
| #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define MOD (1000000007)
using namespace std;
typedef long long int Int;
constexpr Int TEN(int n) { return n == 0 ? 1 : 10 * TEN(n - 1); }
const int max_n = 2600;
const int inf = 1001001001;
int N, M, P;
vector<int> V[max_n];
vector<int> rV[max_n];
bool from[max_n];
bool to[max_n];
bool ok[max_n];
void dfs(int x) {
if (from[x])
return;
from[x] = true;
for (auto u : V[x]) {
dfs(u);
}
return;
}
void rdfs(int x) {
if (to[x])
return;
to[x] = true;
for (auto u : rV[x]) {
rdfs(u);
}
return;
}
int main(void) {
cin >> N >> M >> P;
vector<tuple<int, int, int>> edges;
for (int i = 0; i < M; i++) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
c -= P;
c = -c; // to solve minimize distance
edges.emplace_back(a, b, c);
V[a].push_back(b);
rV[b].push_back(a);
}
dfs(0);
rdfs(N - 1);
for (int i = 0; i < N; i++)
ok[i] = to[i] && from[i];
{
vector<int> d(N, inf);
d[0] = 0;
bool upd = true;
int step = 0;
while (upd) {
upd = false;
for (int i = 0; i < M; i++) {
int a, b, c;
tie(a, b, c) = edges[i];
if (!ok[a])
continue;
if (!ok[b])
continue;
int newD = d[a] + c;
if (newD < d[b]) {
upd = true;
d[b] = newD;
}
}
step++;
if (step > N) {
cout << -1 << endl;
return 0;
}
}
int ans = -d[N - 1];
cout << max(ans, 0) << endl;
}
return 0;
}
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 751,062 | 751,063 | u498141549 | cpp |
p02949 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define MOD (1000000007)
using namespace std;
typedef long long int Int;
constexpr Int TEN(int n) { return n == 0 ? 1 : 10 * TEN(n - 1); }
const int max_n = 2600;
const int inf = 1000000000 + 10;
int N, M, P;
vector<int> V[max_n];
vector<int> rV[max_n];
bool from[max_n];
bool to[max_n];
bool ok[max_n];
void dfs(int x) {
if (from[x])
return;
from[x] = true;
for (auto u : V[x]) {
dfs(u);
}
return;
}
void rdfs(int x) {
if (to[x])
return;
to[x] = true;
for (auto u : rV[x]) {
rdfs(u);
}
return;
}
int main(void) {
cin >> N >> M >> P;
vector<tuple<int, int, int>> edges;
for (int i = 0; i < N; i++) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
c -= P;
c = -c; // to solve minimize distance
edges.emplace_back(a, b, c);
V[a].push_back(b);
rV[b].push_back(a);
}
dfs(0);
rdfs(N - 1);
for (int i = 0; i < N; i++)
ok[i] = to[i] && from[i];
{
vector<int> d(N, inf);
d[0] = 0;
bool upd = true;
int step = 0;
while (upd) {
upd = false;
for (int i = 0; i < M; i++) {
int a, b, c;
tie(a, b, c) = edges[i];
if (!ok[a])
continue;
if (!ok[b])
continue;
int newD = d[a] + c;
if (newD < d[b]) {
upd = true;
d[b] = newD;
}
}
step++;
if (step > N) {
cout << -1 << endl;
return 0;
}
}
int ans = -d[N - 1];
cout << max(ans, 0) << endl;
}
return 0;
}
| #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define MOD (1000000007)
using namespace std;
typedef long long int Int;
constexpr Int TEN(int n) { return n == 0 ? 1 : 10 * TEN(n - 1); }
const int max_n = 2600;
const int inf = 1001001001;
int N, M, P;
vector<int> V[max_n];
vector<int> rV[max_n];
bool from[max_n];
bool to[max_n];
bool ok[max_n];
void dfs(int x) {
if (from[x])
return;
from[x] = true;
for (auto u : V[x]) {
dfs(u);
}
return;
}
void rdfs(int x) {
if (to[x])
return;
to[x] = true;
for (auto u : rV[x]) {
rdfs(u);
}
return;
}
int main(void) {
cin >> N >> M >> P;
vector<tuple<int, int, int>> edges;
for (int i = 0; i < M; i++) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
c -= P;
c = -c; // to solve minimize distance
edges.emplace_back(a, b, c);
V[a].push_back(b);
rV[b].push_back(a);
}
dfs(0);
rdfs(N - 1);
for (int i = 0; i < N; i++)
ok[i] = to[i] && from[i];
{
vector<int> d(N, inf);
d[0] = 0;
bool upd = true;
int step = 0;
while (upd) {
upd = false;
for (int i = 0; i < M; i++) {
int a, b, c;
tie(a, b, c) = edges[i];
if (!ok[a])
continue;
if (!ok[b])
continue;
int newD = d[a] + c;
if (newD < d[b]) {
upd = true;
d[b] = newD;
}
}
step++;
if (step > N) {
cout << -1 << endl;
return 0;
}
}
int ans = -d[N - 1];
cout << max(ans, 0) << endl;
}
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"expression.operation.binary.change",
"expression.operation.binary.remove",
"identifier.change",
"control_flow.loop.for.condition.change"
] | 751,064 | 751,063 | u498141549 | cpp |
p02949 | /*
/T￣「ヽ
│ ｌ | |
| l l !
l l ! L_
／ヽ ｀丶 , -─┐
/ ｎ ｎ ,r‐ヽ ／ ,r─,'
ャ‐ﾊ ﾋ! ﾋ! / └ｧ′／ /
ム ヽ! ＿'__'_ j く ／ /
ヽﾍ! ￣（-‐ヽrｰﾄ──/
｀Tヽ､ 弋 Y ト--'
ｊ_,_,ﾉ￣｀j_,_,ﾉ｀'‐'′No.258:ミズゴロウ
*/
// AOJだとboostライブラリは使えない...(悲しい)
//#include <boost/multiprecision/cpp_int.hpp>
// namespace mp = boost::multiprecision;
#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
// using INT = mp::cpp_int;
using namespace std;
using ll = long long;
using vec = vector<ll>;
using vect = vector<double>;
using Graph = vector<vector<ll>>;
#define loop(i, n) for (ll i = 0; i < n; i++)
#define Loop(i, m, n) for (ll i = m; i < n; i++)
#define pool(i, n) for (ll i = n; i >= 0; i--)
#define Pool(i, m, n) for (ll i = n; i >= m; i--)
#define mod 1000000007ll;
#define setbit bitset<8>
#define flagcount __builtin_popcount
#define flag(x) (1 << x)
#define flagadd(bit, x) bit |= flag(x)
#define flagpop(bit, x) bit &= ~flag(x)
#define flagon(bit, i) bit &flag(i)
#define flagoff(bit, i) !(bit & (1 << i))
#define all(v) v.begin(), v.end()
#define low2way(v, x) lower_bound(all(v), x)
#define high2way(v, x) upper_bound(all(v), x)
#define count2way(v, x) high2way(v, x) - low2way(v, x)
#define lower(v, x) \
low2way(v, x) - v.begin() // 1番左が0、もし見つから無いならｎを出力
#define higher(v, x) \
high2way(v, x) - v.begin() - \
1 // 1番左が0、もし見つからないならn-1を出力（注意）
#define putout(a) cout << a << endl
#define putout2(a, b) \
putout(a); \
putout(b)
#define putout3(a, b, c) \
putout(a); \
putout(b); \
putout(c)
#define putout4(a, b, c, d) \
putout(a); \
putout(b); \
putout(c); \
putout(d)
#define putout5(a, b, c, d, e) \
putout(a); \
putout(b); \
putout(c); \
putout(d); \
putout(e)
#define Gput(a, b) G[a].push_back(b)
#define cin1(a) cin >> a
#define cin2(a, b) cin >> a >> b
#define cin3(a, b, c) cin >> a >> b >> c
#define cin4(a, b, c, d) cin >> a >> b >> c >> d
#define cin5(a, b, c, d, e) cin >> a >> b >> c >> d >> e
#define sum(v) accumulate(all(v), 0ll)
#define gcd(x, y) __gcd(x, y)
ll ctoi(char c) {
if (c >= '0' && c <= '9') {
return c - '0';
}
return 0;
}
template <typename T> T lcm(T x, T y) {
T z = gcd(x, y);
return x * y / z;
}
template <typename T> T primejudge(T n) {
if (n < 2)
return 0;
else if (n == 2)
return 1;
else if (n % 2 == 0)
return 0;
double sqrtn = sqrt(n);
Loop(i, 3, sqrtn + 1) {
if (n % i == 0) {
return 0;
}
i++;
}
return 1;
}
template <typename T> T modinv(T a, T m) {
T b = m, u = 1, v = 0;
while (b) {
T t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
//場合によって使い分ける
// const ll dx[4]={1,0,-1,0};
// const ll dy[4]={0,1,0,-1};
const ll dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
/*
//TIMESTAMPbfs
vector<bool> seen;
vec first;
vec last;
void dfs(const Graph &G,ll v,ll &time){
if(!(seen[v])){
seen[v]=true;
first[v]=time++;
for(auto next_v:G[v]){
if(seen[next_v])continue;
dfs(G,next_v,time);
}
last[v]=time++;
}
}
//main関数内で
seen.assign(n, false); // 全頂点を「未訪問」に初期化
first.resize(n);
last.resize(n);
*/
//多次元配列の宣言名
// vector<vector<ll>> field(h, vector<ll>(w));
//記念
/*
field.assign(h, vector<ll>(w, 0));
vector<vector<ll>> field;
void dfs(ll x,ll y,ll h,ll w){
field[x][y]=0;
loop(i,8){
ll next_x=x+dx[i],next_y=y+dy[i];
if(next_x<0||next_x>=h||next_y<0||next_y>=w)continue;
if(field[next_x][next_y]==0)continue;
dfs(next_x,next_y,h,w);
}
}
*/
template <class T> inline void chmax(T &a, T b) {
if (a < b)
a = b;
}
template <class T> inline void chmin(T &a, T b) {
if (a > b)
a = b;
}
//頂点fromから頂点toへと結ぶコストcostの有向辺
struct edge {
ll from;
ll cost;
ll to;
};
ll V, E;
vector<edge> side;
vec dist;
vector<bool> find_negative_loop;
/*
始点vから各頂点への最短距離を求め(経路が存在しなければ1e18)、
また各頂点につくまでに負閉路が存在するかどうかも調べる
*/
void bellman_ford(ll v) {
loop(i, V) dist[i] = 1e18;
dist[v] = 0;
ll count = 0;
while ("neko") {
count++;
bool update = false;
//通常の最短経路探索
if (count <= V - 1) {
loop(i, E) {
edge e = side[i];
/*
現在いる頂点の最短距離がinfでなく、
かつ行先の最短距離が(現在いる頂点の最短距離+有向辺のコスト)よりも大きいとき更新
*/
if (dist[e.from] != 1e18 && dist[e.to] > dist[e.from] + e.cost) {
dist[e.to] = dist[e.from] + e.cost;
update = true; //探索継続
}
}
}
//各頂点までに負閉路が存在するかチェック
if (count >= V) {
loop(i, E) {
edge e = side[i];
/*
現在いる頂点の最短距離がinfでなく、
かつ行先の最短距離が(現在いる頂点の最短距離+有向辺のコスト)よりも大きいとき更新
+負閉路発見
*/
if (dist[e.from] != 1e18 && dist[e.to] > dist[e.from] + e.cost) {
dist[e.to] = dist[e.from] + e.cost;
find_negative_loop[e.to] = true;
update = true; //探索継続
}
//前(from)がtrueなら次(to)もtrue
if (find_negative_loop[e.from])
find_negative_loop[e.to] = true;
}
}
if ((!update) || count == 2 * V - 1)
break; //更新がなくなるか2*V-1回のwhileループが終了すれば終了
}
}
int main() {
ll P;
cin >> V >> E >> P;
side.resize(E);
dist.resize(V);
find_negative_loop.assign(V, false);
loop(i, E) {
ll a, b, c;
cin >> a >> b >> c;
side[i].from = a - 1;
side[i].to = b - 1;
side[i].cost = (-1) * c + P;
}
bellman_ford(0);
ll ans = (-1) * dist[V - 1];
if (find_negative_loop[V - 1])
putout(-1);
else
putout(ans);
return 0;
} | /*
/T￣「ヽ
│ ｌ | |
| l l !
l l ! L_
／ヽ ｀丶 , -─┐
/ ｎ ｎ ,r‐ヽ ／ ,r─,'
ャ‐ﾊ ﾋ! ﾋ! / └ｧ′／ /
ム ヽ! ＿'__'_ j く ／ /
ヽﾍ! ￣（-‐ヽrｰﾄ──/
｀Tヽ､ 弋 Y ト--'
ｊ_,_,ﾉ￣｀j_,_,ﾉ｀'‐'′No.258:ミズゴロウ
*/
// AOJだとboostライブラリは使えない...(悲しい)
//#include <boost/multiprecision/cpp_int.hpp>
// namespace mp = boost::multiprecision;
#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
// using INT = mp::cpp_int;
using namespace std;
using ll = long long;
using vec = vector<ll>;
using vect = vector<double>;
using Graph = vector<vector<ll>>;
#define loop(i, n) for (ll i = 0; i < n; i++)
#define Loop(i, m, n) for (ll i = m; i < n; i++)
#define pool(i, n) for (ll i = n; i >= 0; i--)
#define Pool(i, m, n) for (ll i = n; i >= m; i--)
#define mod 1000000007ll;
#define setbit bitset<8>
#define flagcount __builtin_popcount
#define flag(x) (1 << x)
#define flagadd(bit, x) bit |= flag(x)
#define flagpop(bit, x) bit &= ~flag(x)
#define flagon(bit, i) bit &flag(i)
#define flagoff(bit, i) !(bit & (1 << i))
#define all(v) v.begin(), v.end()
#define low2way(v, x) lower_bound(all(v), x)
#define high2way(v, x) upper_bound(all(v), x)
#define count2way(v, x) high2way(v, x) - low2way(v, x)
#define lower(v, x) \
low2way(v, x) - v.begin() // 1番左が0、もし見つから無いならｎを出力
#define higher(v, x) \
high2way(v, x) - v.begin() - \
1 // 1番左が0、もし見つからないならn-1を出力（注意）
#define putout(a) cout << a << endl
#define putout2(a, b) \
putout(a); \
putout(b)
#define putout3(a, b, c) \
putout(a); \
putout(b); \
putout(c)
#define putout4(a, b, c, d) \
putout(a); \
putout(b); \
putout(c); \
putout(d)
#define putout5(a, b, c, d, e) \
putout(a); \
putout(b); \
putout(c); \
putout(d); \
putout(e)
#define Gput(a, b) G[a].push_back(b)
#define cin1(a) cin >> a
#define cin2(a, b) cin >> a >> b
#define cin3(a, b, c) cin >> a >> b >> c
#define cin4(a, b, c, d) cin >> a >> b >> c >> d
#define cin5(a, b, c, d, e) cin >> a >> b >> c >> d >> e
#define sum(v) accumulate(all(v), 0ll)
#define gcd(x, y) __gcd(x, y)
ll ctoi(char c) {
if (c >= '0' && c <= '9') {
return c - '0';
}
return 0;
}
template <typename T> T lcm(T x, T y) {
T z = gcd(x, y);
return x * y / z;
}
template <typename T> T primejudge(T n) {
if (n < 2)
return 0;
else if (n == 2)
return 1;
else if (n % 2 == 0)
return 0;
double sqrtn = sqrt(n);
Loop(i, 3, sqrtn + 1) {
if (n % i == 0) {
return 0;
}
i++;
}
return 1;
}
template <typename T> T modinv(T a, T m) {
T b = m, u = 1, v = 0;
while (b) {
T t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
//場合によって使い分ける
// const ll dx[4]={1,0,-1,0};
// const ll dy[4]={0,1,0,-1};
const ll dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
/*
//TIMESTAMPbfs
vector<bool> seen;
vec first;
vec last;
void dfs(const Graph &G,ll v,ll &time){
if(!(seen[v])){
seen[v]=true;
first[v]=time++;
for(auto next_v:G[v]){
if(seen[next_v])continue;
dfs(G,next_v,time);
}
last[v]=time++;
}
}
//main関数内で
seen.assign(n, false); // 全頂点を「未訪問」に初期化
first.resize(n);
last.resize(n);
*/
//多次元配列の宣言名
// vector<vector<ll>> field(h, vector<ll>(w));
//記念
/*
field.assign(h, vector<ll>(w, 0));
vector<vector<ll>> field;
void dfs(ll x,ll y,ll h,ll w){
field[x][y]=0;
loop(i,8){
ll next_x=x+dx[i],next_y=y+dy[i];
if(next_x<0||next_x>=h||next_y<0||next_y>=w)continue;
if(field[next_x][next_y]==0)continue;
dfs(next_x,next_y,h,w);
}
}
*/
template <class T> inline void chmax(T &a, T b) {
if (a < b)
a = b;
}
template <class T> inline void chmin(T &a, T b) {
if (a > b)
a = b;
}
//頂点fromから頂点toへと結ぶコストcostの有向辺
struct edge {
ll from;
ll cost;
ll to;
};
ll V, E;
vector<edge> side;
vec dist;
vector<bool> find_negative_loop;
/*
始点vから各頂点への最短距離を求め(経路が存在しなければ1e18)、
また各頂点につくまでに負閉路が存在するかどうかも調べる
*/
void bellman_ford(ll v) {
loop(i, V) dist[i] = 1e18;
dist[v] = 0;
ll count = 0;
while ("neko") {
count++;
bool update = false;
//通常の最短経路探索
if (count <= V - 1) {
loop(i, E) {
edge e = side[i];
/*
現在いる頂点の最短距離がinfでなく、
かつ行先の最短距離が(現在いる頂点の最短距離+有向辺のコスト)よりも大きいとき更新
*/
if (dist[e.from] != 1e18 && dist[e.to] > dist[e.from] + e.cost) {
dist[e.to] = dist[e.from] + e.cost;
update = true; //探索継続
}
}
}
//各頂点までに負閉路が存在するかチェック
if (count >= V) {
loop(i, E) {
edge e = side[i];
/*
現在いる頂点の最短距離がinfでなく、
かつ行先の最短距離が(現在いる頂点の最短距離+有向辺のコスト)よりも大きいとき更新
+負閉路発見
*/
if (dist[e.from] != 1e18 && dist[e.to] > dist[e.from] + e.cost) {
dist[e.to] = dist[e.from] + e.cost;
find_negative_loop[e.to] = true;
update = true; //探索継続
}
//前(from)がtrueなら次(to)もtrue
if (find_negative_loop[e.from])
find_negative_loop[e.to] = true;
}
}
if ((!update) || count == 2 * V - 1)
break; //更新がなくなるか2*V-1回のwhileループが終了すれば終了
}
}
int main() {
ll P;
cin >> V >> E >> P;
side.resize(E);
dist.resize(V);
find_negative_loop.assign(V, false);
loop(i, E) {
ll a, b, c;
cin >> a >> b >> c;
side[i].from = a - 1;
side[i].to = b - 1;
side[i].cost = (-1) * c + P;
}
bellman_ford(0);
ll ans = (-1) * dist[V - 1];
if (find_negative_loop[V - 1])
putout(-1);
else
putout(max(ans, 0ll));
return 0;
} | [
"call.add",
"call.arguments.add"
] | 751,065 | 751,066 | u607229598 | cpp |
p02949 | // g++ -std=c++14 test.cpp -o test.out
//問題URL
// https://atcoder.jp/contests/abc137/tasks/abc137_e
//有向グラフの、負の辺を含む最短路問題→ベルマンフォード法
//ベルマンフォード法について
// https://qiita.com/wakimiko/items/69b86627bea0e8fe29d5
// Bellman-Ford法とは、グラフの二点間の最短距離を求めるアルゴリズムです。
// Dijkstra法と比べて辺の重みが負でも動きますが、重みに負の数がないならDijkstra法を使った方が高速です。
//負の閉路があると正しい距離を求められませんが、負の閉路があることを検出できます。
//頂点の数をV、辺の数をEとした場合、計算量はO(VE)になります。
#include <algorithm>
#include <bitset>
#include <cassert>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdlib.h>
#include <string.h>
#include <utility>
#include <vector>
using namespace std;
#define LL long long int
const LL INF = (LL)(1e18) + 1;
const int INF_INT = 2147483647;
const LL mod = 1000000007ll;
int N, M, P;
// a->bへ行く際の、c=-(コインの価値-P)をtuple<a,b,c>のような感じでまとめる
vector<tuple<int, int, int>> edges;
int ans = 0;
//隣接リスト 点iから行ける点の集合をto[i]とおく
vector<int> to[2500];
// Nに辿り着けるかを調べるのに使う
// 点jへ行くことのできる点の集合をrev_to[j]とおく
vector<int> rev_to[2500];
bool reachable_from_1[2500]; //点iが点1から見て到達可能かどうか
bool reachable_to_N[2500]; //点Nが点iから見て到達可能かどうか
void dfs_from_1() {
queue<int> q;
q.push(0);
reachable_from_1[0] = true;
while (!q.empty()) {
int now = q.front();
q.pop();
for (int u : to[now]) {
if (!reachable_from_1[u]) {
q.push(u);
reachable_from_1[u] = true;
}
}
}
}
void dfs_to_N() {
queue<int> q;
q.push(N - 1);
reachable_to_N[N - 1] = true;
while (!q.empty()) {
int now = q.front();
q.pop();
for (int u : rev_to[now]) {
if (!reachable_to_N[u]) {
q.push(u);
reachable_to_N[u] = true;
}
}
}
}
void solve() {
for (int i = 0; i < N; i++) {
reachable_from_1[i] = false;
reachable_to_N[i] = false;
}
// DFSで1から到達可能か調べる
dfs_from_1();
// Nへ到達可能か調べる
dfs_to_N();
bool ok[2500]; //点iが 1から到達可能 かつ Nへ到達可能 ならok[i]=true;
for (int i = 0; i < N; i++)
ok[i] = reachable_from_1[i] & reachable_to_N[i];
//ベルマンフォード開始
vector<int> d(N, INF_INT);
d[0] = 0;
bool update = true;
int step = 0; //何ループかかったかを記録
while (update) {
update = false;
for (int i = 0; i < M; i++) {
int a, b, c;
tie(a, b, c) = edges[i];
if (!ok[a])
continue;
if (!ok[b])
continue;
int newD = d[a] + c;
if (newD < d[b]) {
update = true;
d[b] = newD;
}
}
step++;
if (step > N) { //負閉路の検出
ans = -1;
return;
}
}
ans = -d[N - 1];
ans = max(ans, 0);
}
int main() {
cin >> N >> M >> P;
for (int i = 0; i < M; i++) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
c = -(c - P);
edges.emplace_back(a, b, c);
to[a].push_back(b);
rev_to[b].push_back(a);
}
solve();
cout << ans << endl;
return 0;
} | // g++ -std=c++14 test.cpp -o test.out
//問題URL
// https://atcoder.jp/contests/abc137/tasks/abc137_e
//有向グラフの、負の辺を含む最短路問題→ベルマンフォード法
//ベルマンフォード法について
// https://qiita.com/wakimiko/items/69b86627bea0e8fe29d5
// Bellman-Ford法とは、グラフの二点間の最短距離を求めるアルゴリズムです。
// Dijkstra法と比べて辺の重みが負でも動きますが、重みに負の数がないならDijkstra法を使った方が高速です。
//負の閉路があると正しい距離を求められませんが、負の閉路があることを検出できます。
//頂点の数をV、辺の数をEとした場合、計算量はO(VE)になります。
#include <algorithm>
#include <bitset>
#include <cassert>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdlib.h>
#include <string.h>
#include <utility>
#include <vector>
using namespace std;
#define LL long long int
const LL INF = (LL)(1e18) + 1;
const int INF_INT = 2147483647 - 1e6;
const LL mod = 1000000007ll;
int N, M, P;
// a->bへ行く際の、c=-(コインの価値-P)をtuple<a,b,c>のような感じでまとめる
vector<tuple<int, int, int>> edges;
int ans = 0;
//隣接リスト 点iから行ける点の集合をto[i]とおく
vector<int> to[2500];
// Nに辿り着けるかを調べるのに使う
// 点jへ行くことのできる点の集合をrev_to[j]とおく
vector<int> rev_to[2500];
bool reachable_from_1[2500]; //点iが点1から見て到達可能かどうか
bool reachable_to_N[2500]; //点Nが点iから見て到達可能かどうか
void dfs_from_1() {
queue<int> q;
q.push(0);
reachable_from_1[0] = true;
while (!q.empty()) {
int now = q.front();
q.pop();
for (int u : to[now]) {
if (!reachable_from_1[u]) {
q.push(u);
reachable_from_1[u] = true;
}
}
}
}
void dfs_to_N() {
queue<int> q;
q.push(N - 1);
reachable_to_N[N - 1] = true;
while (!q.empty()) {
int now = q.front();
q.pop();
for (int u : rev_to[now]) {
if (!reachable_to_N[u]) {
q.push(u);
reachable_to_N[u] = true;
}
}
}
}
void solve() {
for (int i = 0; i < N; i++) {
reachable_from_1[i] = false;
reachable_to_N[i] = false;
}
// DFSで1から到達可能か調べる
dfs_from_1();
// Nへ到達可能か調べる
dfs_to_N();
bool ok[2500]; //点iが 1から到達可能 かつ Nへ到達可能 ならok[i]=true;
for (int i = 0; i < N; i++)
ok[i] = reachable_from_1[i] & reachable_to_N[i];
//ベルマンフォード開始
vector<int> d(N, INF_INT);
d[0] = 0;
bool update = true;
int step = 0; //何ループかかったかを記録
while (update) {
update = false;
for (int i = 0; i < M; i++) {
int a, b, c;
tie(a, b, c) = edges[i];
if (!ok[a])
continue;
if (!ok[b])
continue;
int newD = d[a] + c;
if (newD < d[b]) {
update = true;
d[b] = newD;
}
}
step++;
if (step > N) { //負閉路の検出
ans = -1;
return;
}
}
ans = -d[N - 1];
ans = max(ans, 0);
}
int main() {
cin >> N >> M >> P;
for (int i = 0; i < M; i++) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
c = -(c - P);
edges.emplace_back(a, b, c);
to[a].push_back(b);
rev_to[b].push_back(a);
}
solve();
cout << ans << endl;
return 0;
} | [
"assignment.change"
] | 751,077 | 751,076 | u302000346 | cpp |
p02949 | //#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
constexpr ll INF = 1e16;
constexpr ll MOD = 1000000007;
// modint: mod 計算を int を扱うように扱える構造体
template <int MOD> struct Fp {
long long val;
constexpr Fp(long long v = 0) noexcept : val(v % MOD) {
if (val < 0)
v += MOD;
}
constexpr int getmod() { return MOD; }
constexpr Fp operator-() const noexcept { return val ? MOD - val : 0; }
constexpr Fp operator+(const Fp &r) const noexcept { return Fp(*this) += r; }
constexpr Fp operator-(const Fp &r) const noexcept { return Fp(*this) -= r; }
constexpr Fp operator*(const Fp &r) const noexcept { return Fp(*this) *= r; }
constexpr Fp operator/(const Fp &r) const noexcept { return Fp(*this) /= r; }
constexpr Fp &operator+=(const Fp &r) noexcept {
val += r.val;
if (val >= MOD)
val -= MOD;
return *this;
}
constexpr Fp &operator-=(const Fp &r) noexcept {
val -= r.val;
if (val < 0)
val += MOD;
return *this;
}
constexpr Fp &operator*=(const Fp &r) noexcept {
val = val * r.val % MOD;
return *this;
}
constexpr Fp &operator/=(const Fp &r) noexcept {
long long a = r.val, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
val = val * u % MOD;
if (val < 0)
val += MOD;
return *this;
}
constexpr bool operator==(const Fp &r) const noexcept {
return this->val == r.val;
}
constexpr bool operator!=(const Fp &r) const noexcept {
return this->val != r.val;
}
friend constexpr ostream &operator<<(ostream &os, const Fp<MOD> &x) noexcept {
return os << x.val;
}
friend constexpr istream &operator>>(istream &is, Fp<MOD> &x) noexcept {
return is >> x.val;
}
friend constexpr Fp<MOD> modpow(const Fp<MOD> &a, long long n) noexcept {
if (n == 0)
return 1;
auto t = modpow(a, n / 2);
t = t * t;
if (n & 1)
t = t * a;
return t;
}
};
using mint = Fp<((int)MOD)>;
#define rep(i, N) for (ll i = 0; i < (N); ++i)
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
} else {
return 0;
}
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
} else {
return 0;
}
}
ll max(ll a, ll b) { return a < b ? b : a; }
ll min(ll a, ll b) { return a > b ? b : a; }
double maxf(double a, double b) { return a < b ? b : a; }
template <typename T> inline string toString(const T &a) {
ostringstream oss;
oss << a;
return oss.str();
}
ll gcd(ll x, ll y) { return x % y ? gcd(y, x % y) : y; }
ll lcm(ll x, ll y) { return x * y / gcd(x, y); }
struct hash_pair {
template <class T1, class T2> size_t operator()(const pair<T1, T2> &p) const {
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
// lower_bound: equal or greater than
// upper_bound: greater than
// Remember "upper_bound is greater"
template <typename T>
unordered_set<T> unionset(unordered_set<T> &t1, unordered_set<T> &t2) {
unordered_set<T> t3;
for (T e : t1) {
if (t2.find(e) != t2.end()) {
t3.emplace(e);
}
}
return t3;
}
void dfsReach(vector<vector<int>> &pointf, unordered_set<int> &seen, int cur) {
for (int next : pointf[cur]) {
if (seen.find(next) == seen.end()) {
seen.emplace(next);
dfsReach(pointf, seen, next);
}
}
}
// BFSで
unordered_set<int> reach(int N, vector<pair<pair<int, int>, int>> &edges) {
//頂点から出る辺
vector<vector<int>> pointf(N + 1, vector<int>());
vector<vector<int>> pointr(N + 1, vector<int>());
for (auto pr : edges) {
pointf[pr.first.first].push_back(pr.first.second);
pointr[pr.first.second].push_back(pr.first.first);
}
unordered_set<int> r1;
dfsReach(pointf, r1, 1);
unordered_set<int> rn;
dfsReach(pointf, rn, N);
return unionset(r1, rn);
}
int main() {
int N;
int M;
int P;
cin >> N >> M >> P;
// vector<vector<pair<int, int>>> ve(N + 1, vector<pair<int, int>>());
vector<pair<pair<int, int>, int>> edges;
rep(i, M) {
int A, B, C;
cin >> A >> B >> C;
// ve[A].push_back(make_pair(B, C - P));
edges.push_back(make_pair(make_pair(A, B), -(C - P)));
}
//経路の値が負になったときは0にする
//ベルマンフォード法で最短経路（*-1してある）
//頂点は1-baseなので注意
// for each vertex
vector<pair<ll, int>> vd(N + 1);
for (int i = 1; i <= N; ++i) {
vd[i] = make_pair(INF, -1);
}
vd[1] = make_pair(0, -1);
for (int i = 1; i <= N; ++i) {
for (int j = 0; j < edges.size(); ++j) {
auto pr = edges[j];
if (vd[pr.first.first].first + pr.second < vd[pr.first.second].first) {
vd[pr.first.second] =
make_pair(vd[pr.first.first].first + pr.second, pr.first.first);
}
}
}
//経路に現れる点を取得
unordered_set<int> seen;
int curv = N;
while (curv != 1) {
seen.emplace(curv);
curv = vd[curv].second;
if (curv == -1 || seen.find(curv) != seen.end()) {
cout << "-1" << endl;
return 0;
}
}
seen.emplace(1);
// //負閉路検出 => 嘘解法
// for(int j = 0; j < edges.size(); ++j) {
// auto pr = edges[j];
// if(seen.find(pr.first.first) != seen.end() && seen.find(pr.first.second)
// != seen.end() && vd[pr.first.first].first + pr.second <
// vd[pr.first.second].first) {
// cout << "-1" << endl;
// return 0;
// }
// }
//頂点1かつNから到達可能な範囲
unordered_set<int> reach1 = reach(N, edges);
// NM回回して更新するか
for (int i = 1; i <= N; ++i) {
for (int j = 0; j < edges.size(); ++j) {
auto pr = edges[j];
if (vd[pr.first.first].first + pr.second < vd[pr.first.second].first) {
if (reach1.find(pr.first.first) != reach1.end() &&
reach1.find(pr.first.second) != reach1.end()) {
//関係のある閉路
cout << "-1" << endl;
return 0;
}
vd[pr.first.second] =
make_pair(vd[pr.first.first].first + pr.second, pr.first.first);
}
}
}
//経路
ll sum = vd[N].first;
sum = -sum;
if (sum < 0)
sum = 0;
cout << sum << endl;
}
| //#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
constexpr ll INF = 1e16;
constexpr ll MOD = 1000000007;
// modint: mod 計算を int を扱うように扱える構造体
template <int MOD> struct Fp {
long long val;
constexpr Fp(long long v = 0) noexcept : val(v % MOD) {
if (val < 0)
v += MOD;
}
constexpr int getmod() { return MOD; }
constexpr Fp operator-() const noexcept { return val ? MOD - val : 0; }
constexpr Fp operator+(const Fp &r) const noexcept { return Fp(*this) += r; }
constexpr Fp operator-(const Fp &r) const noexcept { return Fp(*this) -= r; }
constexpr Fp operator*(const Fp &r) const noexcept { return Fp(*this) *= r; }
constexpr Fp operator/(const Fp &r) const noexcept { return Fp(*this) /= r; }
constexpr Fp &operator+=(const Fp &r) noexcept {
val += r.val;
if (val >= MOD)
val -= MOD;
return *this;
}
constexpr Fp &operator-=(const Fp &r) noexcept {
val -= r.val;
if (val < 0)
val += MOD;
return *this;
}
constexpr Fp &operator*=(const Fp &r) noexcept {
val = val * r.val % MOD;
return *this;
}
constexpr Fp &operator/=(const Fp &r) noexcept {
long long a = r.val, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
val = val * u % MOD;
if (val < 0)
val += MOD;
return *this;
}
constexpr bool operator==(const Fp &r) const noexcept {
return this->val == r.val;
}
constexpr bool operator!=(const Fp &r) const noexcept {
return this->val != r.val;
}
friend constexpr ostream &operator<<(ostream &os, const Fp<MOD> &x) noexcept {
return os << x.val;
}
friend constexpr istream &operator>>(istream &is, Fp<MOD> &x) noexcept {
return is >> x.val;
}
friend constexpr Fp<MOD> modpow(const Fp<MOD> &a, long long n) noexcept {
if (n == 0)
return 1;
auto t = modpow(a, n / 2);
t = t * t;
if (n & 1)
t = t * a;
return t;
}
};
using mint = Fp<((int)MOD)>;
#define rep(i, N) for (ll i = 0; i < (N); ++i)
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
} else {
return 0;
}
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
} else {
return 0;
}
}
ll max(ll a, ll b) { return a < b ? b : a; }
ll min(ll a, ll b) { return a > b ? b : a; }
double maxf(double a, double b) { return a < b ? b : a; }
template <typename T> inline string toString(const T &a) {
ostringstream oss;
oss << a;
return oss.str();
}
ll gcd(ll x, ll y) { return x % y ? gcd(y, x % y) : y; }
ll lcm(ll x, ll y) { return x * y / gcd(x, y); }
struct hash_pair {
template <class T1, class T2> size_t operator()(const pair<T1, T2> &p) const {
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
// lower_bound: equal or greater than
// upper_bound: greater than
// Remember "upper_bound is greater"
template <typename T>
unordered_set<T> unionset(unordered_set<T> &t1, unordered_set<T> &t2) {
unordered_set<T> t3;
for (T e : t1) {
if (t2.find(e) != t2.end()) {
t3.emplace(e);
}
}
return t3;
}
// DFSを使用し，curから到達可能な頂点集合をseenに返す
void dfsReach(vector<vector<int>> &pointf, unordered_set<int> &seen, int cur) {
for (int next : pointf[cur]) {
if (seen.find(next) == seen.end()) {
seen.emplace(next);
dfsReach(pointf, seen, next);
}
}
}
// BFSで
unordered_set<int> reach(int N, vector<pair<pair<int, int>, int>> &edges) {
//頂点から出る辺
vector<vector<int>> pointf(N + 1, vector<int>());
vector<vector<int>> pointr(N + 1, vector<int>());
for (auto pr : edges) {
pointf[pr.first.first].push_back(pr.first.second);
pointr[pr.first.second].push_back(pr.first.first);
}
unordered_set<int> r1;
dfsReach(pointf, r1, 1);
unordered_set<int> rn;
dfsReach(pointr, rn, N);
return unionset(r1, rn);
}
int main() {
int N;
int M;
int P;
cin >> N >> M >> P;
// vector<vector<pair<int, int>>> ve(N + 1, vector<pair<int, int>>());
vector<pair<pair<int, int>, int>> edges;
rep(i, M) {
int A, B, C;
cin >> A >> B >> C;
// ve[A].push_back(make_pair(B, C - P));
edges.push_back(make_pair(make_pair(A, B), -(C - P)));
}
//経路の値が負になったときは0にする
//ベルマンフォード法で最短経路（*-1してある）
//頂点は1-baseなので注意
// for each vertex
vector<pair<ll, int>> vd(N + 1);
for (int i = 1; i <= N; ++i) {
vd[i] = make_pair(INF, -1);
}
vd[1] = make_pair(0, -1);
for (int i = 1; i <= N; ++i) {
for (int j = 0; j < edges.size(); ++j) {
auto pr = edges[j];
if (vd[pr.first.first].first + pr.second < vd[pr.first.second].first) {
vd[pr.first.second] =
make_pair(vd[pr.first.first].first + pr.second, pr.first.first);
}
}
}
//経路に現れる点を取得
unordered_set<int> seen;
int curv = N;
while (curv != 1) {
seen.emplace(curv);
curv = vd[curv].second;
if (curv == -1 || seen.find(curv) != seen.end()) {
cout << "-1" << endl;
return 0;
}
}
seen.emplace(1);
// //負閉路検出 => 嘘解法
// for(int j = 0; j < edges.size(); ++j) {
// auto pr = edges[j];
// if(seen.find(pr.first.first) != seen.end() && seen.find(pr.first.second)
// != seen.end() && vd[pr.first.first].first + pr.second <
// vd[pr.first.second].first) {
// cout << "-1" << endl;
// return 0;
// }
// }
//頂点1かつNから到達可能な範囲
unordered_set<int> reach1 = reach(N, edges);
// NM回回して更新するか
for (int i = 1; i <= N; ++i) {
for (int j = 0; j < edges.size(); ++j) {
auto pr = edges[j];
if (vd[pr.first.first].first + pr.second < vd[pr.first.second].first) {
if (reach1.find(pr.first.first) != reach1.end() &&
reach1.find(pr.first.second) != reach1.end()) {
//関係のある閉路
cout << "-1" << endl;
return 0;
}
vd[pr.first.second] =
make_pair(vd[pr.first.first].first + pr.second, pr.first.first);
}
}
}
//経路
ll sum = vd[N].first;
sum = -sum;
if (sum < 0)
sum = 0;
cout << sum << endl;
}
| [
"identifier.change",
"call.arguments.change"
] | 751,078 | 751,079 | u554843701 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
struct edge {
int64_t from;
int64_t to;
int64_t cost;
};
int main() {
int64_t N, M, P;
cin >> N >> M >> P;
vector<edge> G(M);
for (int i = 0; i < M; i++) {
int64_t a, b, c;
cin >> a >> b >> c;
a--;
b--;
c -= P;
edge add;
add.from = a;
add.to = b;
add.cost = c * -1;
G.at(i) = add;
}
int64_t INF = 1e18;
vector<int64_t> dist(N, INF);
dist.at(0) = 0;
vector<bool> inf(N, false);
for (int i = 0; i < 2 * N; i++) {
for (int j = 0; j < M; j++) {
edge e = G.at(j);
if (dist.at(e.to) != INF && dist.at(e.to) > dist.at(e.from) + e.cost) {
dist.at(e.to) = dist.at(e.from) + e.cost;
if (i >= N - 1) {
dist.at(e.to) = -INF;
}
}
}
}
if (dist.at(N - 1) == -INF) {
cout << -1 << endl;
} else {
cout << max((int64_t)0, dist.at(N - 1) * -1) << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
struct edge {
int64_t from;
int64_t to;
int64_t cost;
};
int main() {
int64_t N, M, P;
cin >> N >> M >> P;
vector<edge> G(M);
for (int i = 0; i < M; i++) {
int64_t a, b, c;
cin >> a >> b >> c;
a--;
b--;
c -= P;
edge add;
add.from = a;
add.to = b;
add.cost = c * -1;
G.at(i) = add;
}
int64_t INF = 1e18;
vector<int64_t> dist(N, INF);
dist.at(0) = 0;
vector<bool> inf(N, false);
for (int i = 0; i < 2 * N; i++) {
for (int j = 0; j < M; j++) {
edge e = G.at(j);
if (dist.at(e.from) != INF && dist.at(e.to) > dist.at(e.from) + e.cost) {
dist.at(e.to) = dist.at(e.from) + e.cost;
if (i >= N - 1) {
dist.at(e.to) = -INF;
}
}
}
}
if (dist.at(N - 1) == -INF) {
cout << -1 << endl;
} else {
cout << max((int64_t)0, dist.at(N - 1) * -1) << endl;
}
}
| [
"control_flow.branch.if.condition.change"
] | 751,080 | 751,081 | u835534008 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
struct edge {
int64_t from;
int64_t to;
int64_t cost;
};
int main() {
int64_t N, M, P;
cin >> N >> M >> P;
vector<edge> G(M);
for (int i = 0; i < M; i++) {
int64_t a, b, c;
cin >> a >> b >> c;
a--;
b--;
c -= P;
edge add;
add.from = a;
add.to = b;
add.cost = c * -1;
G.at(i) = add;
}
int64_t INF = 1e18;
vector<int64_t> dist(N, INF);
dist.at(0) = 0;
bool negative = false;
for (int i = 0; i < 2 * N; i++) {
for (int j = 0; j < M; j++) {
edge e = G.at(j);
if (dist.at(e.to) != INF && dist.at(e.to) > dist.at(e.from) + e.cost) {
dist.at(e.to) = dist.at(e.from) + e.cost;
if (i >= N - 1) {
dist.at(e.to) = -INF;
if (e.to == N - 1) {
negative = true;
}
}
}
}
}
if (negative) {
cout << -1 << endl;
} else {
cout << max((int64_t)0, dist.at(N - 1) * -1) << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
struct edge {
int64_t from;
int64_t to;
int64_t cost;
};
int main() {
int64_t N, M, P;
cin >> N >> M >> P;
vector<edge> G(M);
for (int i = 0; i < M; i++) {
int64_t a, b, c;
cin >> a >> b >> c;
a--;
b--;
c -= P;
edge add;
add.from = a;
add.to = b;
add.cost = c * -1;
G.at(i) = add;
}
int64_t INF = 1e18;
vector<int64_t> dist(N, INF);
dist.at(0) = 0;
bool negative = false;
for (int i = 0; i < 2 * N; i++) {
for (int j = 0; j < M; j++) {
edge e = G.at(j);
if (dist.at(e.from) != INF && dist.at(e.to) > dist.at(e.from) + e.cost) {
dist.at(e.to) = dist.at(e.from) + e.cost;
if (i >= N - 1) {
dist.at(e.to) = -INF;
if (e.to == N - 1) {
negative = true;
}
}
}
}
}
if (negative) {
cout << -1 << endl;
} else {
cout << max((int64_t)0, dist.at(N - 1) * -1) << endl;
}
}
| [
"control_flow.branch.if.condition.change"
] | 751,082 | 751,083 | u835534008 | cpp |
p02949 | #include <cstring>
#include <iostream>
#include <tuple>
#include <vector>
using namespace std;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
// const int INF = 1001001001;
const int INF = 2147483647;
vector<int> to[2505];
vector<int> ot[2505];
bool ok1[2505]; // 頂点1から到達できたらtrue
bool okN[2505]; // 頂点nに到達できたらtrue
bool ok[2505]; // ok1 & okN
void dfs(int v) {
if (ok1[v])
return;
ok1[v] = true;
for (int u : to[v])
dfs(u);
}
void rdfs(int v) {
if (okN[v])
return;
okN[v] = true;
for (int u : ot[v])
rdfs(u);
}
int main() {
int n, m, p;
vector<tuple<int, int, int>> edges;
cin >> n >> m >> p;
for (int i = 0; i < m; ++i) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
c = c - p;
c = -c;
edges.emplace_back(a, b, c);
to[a].push_back(b);
ot[b].push_back(a);
}
dfs(0);
rdfs(n - 1);
for (int i = 0; i <= n; ++i) {
ok[i] = ok1[i] & okN[i];
}
{
vector<int> dist(n, INF);
dist[0] = 0;
bool upd = true;
int step = 0;
while (upd) {
upd = false;
for (int i = 0; i < m; ++i) {
int a, b, c;
tie(a, b, c) = edges[i];
if (!ok[a])
continue;
if (!ok[b])
continue;
int nc = dist[a] + c;
if (nc < dist[b]) {
upd = true;
dist[b] = nc;
}
}
step++;
if (step > n) {
puts("-1");
return 0;
}
}
int ans = -dist[n - 1];
ans = max(ans, 0);
cout << ans << endl;
}
}
| #include <cstring>
#include <iostream>
#include <tuple>
#include <vector>
using namespace std;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
const int INF = 1001001001;
vector<int> to[2505];
vector<int> ot[2505];
bool ok1[2505]; // 頂点1から到達できたらtrue
bool okN[2505]; // 頂点nに到達できたらtrue
bool ok[2505]; // ok1 & okN
void dfs(int v) {
if (ok1[v])
return;
ok1[v] = true;
for (int u : to[v])
dfs(u);
}
void rdfs(int v) {
if (okN[v])
return;
okN[v] = true;
for (int u : ot[v])
rdfs(u);
}
int main() {
int n, m, p;
vector<tuple<int, int, int>> edges;
cin >> n >> m >> p;
for (int i = 0; i < m; ++i) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
c = c - p;
c = -c;
edges.emplace_back(a, b, c);
to[a].push_back(b);
ot[b].push_back(a);
}
dfs(0);
rdfs(n - 1);
for (int i = 0; i <= n; ++i) {
ok[i] = ok1[i] & okN[i];
}
{
vector<int> dist(n, INF);
dist[0] = 0;
bool upd = true;
int step = 0;
while (upd) {
upd = false;
for (int i = 0; i < m; ++i) {
int a, b, c;
tie(a, b, c) = edges[i];
if (!ok[a])
continue;
if (!ok[b])
continue;
int nc = dist[a] + c;
if (nc < dist[b]) {
upd = true;
dist[b] = nc;
}
}
step++;
if (step > n) {
puts("-1");
return 0;
}
}
int ans = -dist[n - 1];
ans = max(ans, 0);
cout << ans << endl;
}
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 751,089 | 751,090 | u537905693 | cpp |
p02949 | #include <algorithm>
#include <iostream>
#include <stack>
#include <tuple>
#include <unordered_map>
#include <vector>
using namespace std;
int main() {
int N, M, P;
cin >> N >> M >> P;
vector<vector<int>> adj(N);
vector<vector<int>> adj_rev(N);
vector<tuple<int, int, int>> edges(M);
for (int i = 0; i < M; i++) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
c = -(c - P);
edges[i] = make_tuple(a, b, c);
adj[a].push_back(b);
adj_rev[b].push_back(a);
}
vector<bool> reachable_from_0(N, false);
stack<int> st;
reachable_from_0[0] = true;
st.push(0);
while (!st.empty()) {
int now = st.top();
st.pop();
for (auto next : adj[now]) {
if (reachable_from_0[next] == false) {
reachable_from_0[next] = true;
st.push(next);
}
}
}
vector<bool> reachable_to_last(N, false);
reachable_to_last[N - 1] = true;
st.push(N - 1);
while (!st.empty()) {
int now = st.top();
st.pop();
for (auto prev : adj_rev[now]) {
if (reachable_to_last[prev] == false) {
reachable_to_last[prev] = true;
st.push(prev);
}
}
}
// Bellman-Ford
vector<long long> distance(N, 1e12);
distance[0] = 0;
for (int i = 0; i < M - 1; i++) {
for (auto edge : edges) {
int from, to, dist;
tie(from, to, dist) = edge;
distance[to] = min(distance[to], distance[from] + dist);
}
}
long long ans = max(0LL, -distance[N - 1]);
for (auto edge : edges) {
int from, to, dist;
tie(from, to, dist) = edge;
if (distance[to] > distance[from] + dist && reachable_from_0[from] &&
reachable_to_last[to]) {
ans = -1;
}
}
cout << ans << endl;
}
| #include <algorithm>
#include <iostream>
#include <stack>
#include <tuple>
#include <unordered_map>
#include <vector>
using namespace std;
int main() {
int N, M, P;
cin >> N >> M >> P;
vector<vector<int>> adj(N);
vector<vector<int>> adj_rev(N);
vector<tuple<int, int, int>> edges(M);
for (int i = 0; i < M; i++) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
c = -(c - P);
edges[i] = make_tuple(a, b, c);
adj[a].push_back(b);
adj_rev[b].push_back(a);
}
vector<bool> reachable_from_0(N, false);
stack<int> st;
reachable_from_0[0] = true;
st.push(0);
while (!st.empty()) {
int now = st.top();
st.pop();
for (auto next : adj[now]) {
if (reachable_from_0[next] == false) {
reachable_from_0[next] = true;
st.push(next);
}
}
}
vector<bool> reachable_to_last(N, false);
reachable_to_last[N - 1] = true;
st.push(N - 1);
while (!st.empty()) {
int now = st.top();
st.pop();
for (auto prev : adj_rev[now]) {
if (reachable_to_last[prev] == false) {
reachable_to_last[prev] = true;
st.push(prev);
}
}
}
// Bellman-Ford
vector<long long> distance(N, 1e12);
distance[0] = 0;
for (int i = 0; i < N - 1; i++) {
for (auto edge : edges) {
int from, to, dist;
tie(from, to, dist) = edge;
distance[to] = min(distance[to], distance[from] + dist);
}
}
long long ans = max(0LL, -distance[N - 1]);
for (auto edge : edges) {
int from, to, dist;
tie(from, to, dist) = edge;
if (distance[to] > distance[from] + dist && reachable_from_0[from] &&
reachable_to_last[to]) {
ans = -1;
}
}
cout << ans << endl;
}
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 751,095 | 751,096 | u425351967 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct Edge {
int to;
ll cost;
};
vector<Edge> G[2510];
ll INF = 1e18;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int V, E;
cin >> V >> E;
ll P;
cin >> P;
vector<ll> d(V, INF);
for (int i = 0; i < E; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
ll c;
cin >> c;
G[a].emplace_back(Edge({b, -(c - P)}));
}
d[0] = 0;
for (int t = 0; t < V * 2; t++) {
for (int i = 0; i < V; i++) {
if (d[i] == INF)
continue;
if (t >= V && d[i] > -INF)
continue;
for (auto e : G[i]) {
if (d[e.to] > d[i] + e.cost) {
d[e.to] = d[i] + e.cost;
if (t == V - 1) {
d[e.to] = -INF;
}
}
}
}
}
if (d[V - 1] <= -INF)
cout << "-1\n";
else
cout << max(-d[V - 1], 0ll) << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct Edge {
int to;
ll cost;
};
vector<Edge> G[2510];
ll INF = 1e18;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int V, E;
cin >> V >> E;
ll P;
cin >> P;
vector<ll> d(V, INF);
for (int i = 0; i < E; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
ll c;
cin >> c;
G[a].emplace_back(Edge({b, -(c - P)}));
}
d[0] = 0;
for (int t = 0; t < V * 2; t++) {
for (int i = 0; i < V; i++) {
if (d[i] == INF)
continue;
if (t >= V && d[i] > -INF / 2)
continue;
for (auto e : G[i]) {
if (d[e.to] > d[i] + e.cost) {
d[e.to] = d[i] + e.cost;
if (t == V - 1) {
d[e.to] = -INF;
}
}
}
}
}
if (d[V - 1] < -INF / 2)
cout << "-1\n";
else
cout << max(-d[V - 1], 0ll) << '\n';
return 0;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"expression.operator.compare.change"
] | 751,108 | 751,107 | u339233484 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define repr(i, a, b) for (int i = a; i < b; i++)
#define rep(i, n) for (int i = 0; i < n; i++)
#define reprrev(i, a, b) for (int i = b - 1; i >= a; i--) // [a, b)
#define reprev(i, n) reprrev(i, 0, n)
typedef long long ll;
typedef unsigned long long ull;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
/* attention
long longのシフト演算には気をつけよう
タイポした時のデバッグが死ぬほどきつくなるので変数名は最低3字くらい使った方がいいかも
sizeは(int)とキャストしよう
cin.tie(0);
ios::sync_with_stdio(false);<- これら、printfとかと併用しない方が良さそう
*/
const ll mod = 1e9 + 7;
void chmod(ll &M) {
if (M >= mod)
M %= mod;
else if (M < 0) {
M += (abs(M) / mod + 1) * mod;
M %= mod;
}
}
ll modpow(ll x, ll n) {
if (n == 0)
return 1;
ll res = modpow(x, n / 2);
if (n % 2 == 0)
return res * res % mod;
else
return res * res % mod * x % mod;
}
int getl(int i, int N) { return i == 0 ? N - 1 : i - 1; };
int getr(int i, int N) { return i == N - 1 ? 0 : i + 1; };
// 線分 ab の偏角 返り値は[-π, π]
double argument(const pair<double, double> &a, const pair<double, double> &b) {
double ax = a.first, ay = a.second, bx = b.first, by = b.second;
return atan2(by - ay, bx - ax);
}
/* <----------------------------------------------------------------------------------->
*/
/* <----------------------------------------------------------------------------------->
*/
/* <----------------------------------------------------------------------------------->
*/
/* <----------------------------------------------------------------------------------->
*/
struct Edge {
ll from, to, cost;
Edge(ll _from = 0, ll _to = 0, ll _cost = 0)
: from(_from), to(_to), cost(_cost) {}
};
struct BellmanFord {
ll const inf = 1LL << 60;
int V; // number of vertix
vector<ll> d;
vector<bool> negative;
vector<Edge> edges;
// コンストラクタ
BellmanFord(int _V) : V(_V) {
d.resize(V, inf);
negative.resize(V, false);
}
void addEdge(ll from, ll to, ll cost) {
edges.push_back(Edge{from, to, cost});
}
// 最短距離の計算と負閉路検出
void calcMinDistFrom(int s) {
d[s] = 0;
rep(loop, V) {
rep(i, (int)edges.size()) {
if (d[edges[i].from] == inf)
continue;
if (d[edges[i].to] > d[edges[i].from] + edges[i].cost) {
d[edges[i].to] = d[edges[i].from] + edges[i].cost;
};
}
}
rep(loop, 2 * V) {
rep(i, (int)edges.size()) {
if (d[edges[i].from] == inf)
continue;
if (d[edges[i].to] > d[edges[i].from] + edges[i].cost) {
d[edges[i].to] = d[edges[i].from] + edges[i].cost;
negative[edges[i].to] = true;
}
if (negative[edges[i].from])
negative[edges[i].to] = true;
}
}
}
};
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
ll N, M, P;
cin >> N >> M >> P;
BellmanFord bf(N);
rep(i, M) {
ll a, b, c;
cin >> a >> b >> c;
--a;
--b;
bf.addEdge(a, b, P - c);
}
bf.calcMinDistFrom(0);
if (bf.negative[N - 1]) {
cout << -1 << endl;
return 0;
} else
cout << -bf.d[N - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define repr(i, a, b) for (int i = a; i < b; i++)
#define rep(i, n) for (int i = 0; i < n; i++)
#define reprrev(i, a, b) for (int i = b - 1; i >= a; i--) // [a, b)
#define reprev(i, n) reprrev(i, 0, n)
typedef long long ll;
typedef unsigned long long ull;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
/* attention
long longのシフト演算には気をつけよう
タイポした時のデバッグが死ぬほどきつくなるので変数名は最低3字くらい使った方がいいかも
sizeは(int)とキャストしよう
cin.tie(0);
ios::sync_with_stdio(false);<- これら、printfとかと併用しない方が良さそう
*/
const ll mod = 1e9 + 7;
void chmod(ll &M) {
if (M >= mod)
M %= mod;
else if (M < 0) {
M += (abs(M) / mod + 1) * mod;
M %= mod;
}
}
ll modpow(ll x, ll n) {
if (n == 0)
return 1;
ll res = modpow(x, n / 2);
if (n % 2 == 0)
return res * res % mod;
else
return res * res % mod * x % mod;
}
int getl(int i, int N) { return i == 0 ? N - 1 : i - 1; };
int getr(int i, int N) { return i == N - 1 ? 0 : i + 1; };
// 線分 ab の偏角 返り値は[-π, π]
double argument(const pair<double, double> &a, const pair<double, double> &b) {
double ax = a.first, ay = a.second, bx = b.first, by = b.second;
return atan2(by - ay, bx - ax);
}
/* <----------------------------------------------------------------------------------->
*/
/* <----------------------------------------------------------------------------------->
*/
/* <----------------------------------------------------------------------------------->
*/
/* <----------------------------------------------------------------------------------->
*/
struct Edge {
ll from, to, cost;
Edge(ll _from = 0, ll _to = 0, ll _cost = 0)
: from(_from), to(_to), cost(_cost) {}
};
struct BellmanFord {
ll const inf = 1LL << 60;
int V; // number of vertix
vector<ll> d;
vector<bool> negative;
vector<Edge> edges;
// コンストラクタ
BellmanFord(int _V) : V(_V) {
d.resize(V, inf);
negative.resize(V, false);
}
void addEdge(ll from, ll to, ll cost) {
edges.push_back(Edge{from, to, cost});
}
// 最短距離の計算と負閉路検出
void calcMinDistFrom(int s) {
d[s] = 0;
rep(loop, V) {
rep(i, (int)edges.size()) {
if (d[edges[i].from] == inf)
continue;
if (d[edges[i].to] > d[edges[i].from] + edges[i].cost) {
d[edges[i].to] = d[edges[i].from] + edges[i].cost;
};
}
}
rep(loop, 2 * V) {
rep(i, (int)edges.size()) {
if (d[edges[i].from] == inf)
continue;
if (d[edges[i].to] > d[edges[i].from] + edges[i].cost) {
d[edges[i].to] = d[edges[i].from] + edges[i].cost;
negative[edges[i].to] = true;
}
if (negative[edges[i].from])
negative[edges[i].to] = true;
}
}
}
};
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
ll N, M, P;
cin >> N >> M >> P;
BellmanFord bf(N);
rep(i, M) {
ll a, b, c;
cin >> a >> b >> c;
--a;
--b;
bf.addEdge(a, b, P - c);
}
bf.calcMinDistFrom(0);
if (bf.negative[N - 1]) {
cout << -1 << endl;
return 0;
} else
cout << max(0LL, -bf.d[N - 1]) << endl;
return 0;
} | [
"call.add",
"call.arguments.change"
] | 751,111 | 751,112 | u052332717 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
typedef long long int ll;
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
#define endl "\n"
const double EPS = 1e-7;
const int INF = 1 << 30;
const ll LLINF = 1LL << 60;
const double PI = acos(-1);
const int MOD = 1000000007;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
//-------------------------------------
struct edge {
int from, to;
ll cost;
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
ll p;
cin >> n >> m >> p;
vector<edge> g(m);
for (int i = 0; i < m; i++) {
int a, b;
ll c;
cin >> a >> b >> c;
g[i] = edge{a - 1, b - 1, -(c - p)};
}
vector<ll> d(n, LLINF);
auto bellmanFord = [&](int s, int goal) {
d[s] = 0;
bool res = true;
for (int i = 0; i < n; i++) {
for (auto e : g) {
if (d[e.from] != LLINF && d[e.to] > d[e.from] + e.cost) {
if (i == n - 1 && e.to == goal) {
res = false;
} else if (i == n - 1) {
d[e.to] = -LLINF;
} else {
d[e.to] = d[e.from] + e.cost;
}
}
}
}
return res;
};
bool check = bellmanFord(0, n - 1);
if (!check) {
cout << -1 << endl;
} else {
cout << max(0LL, -d[n - 1]) << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
typedef long long int ll;
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
#define endl "\n"
const double EPS = 1e-7;
const int INF = 1 << 30;
const ll LLINF = 1LL << 60;
const double PI = acos(-1);
const int MOD = 1000000007;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
//-------------------------------------
struct edge {
int from, to;
ll cost;
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
ll p;
cin >> n >> m >> p;
vector<edge> g(m);
for (int i = 0; i < m; i++) {
int a, b;
ll c;
cin >> a >> b >> c;
g[i] = edge{a - 1, b - 1, -(c - p)};
}
vector<ll> d(n, LLINF);
auto bellmanFord = [&](int s, int goal) {
d[s] = 0;
bool res = true;
for (int i = 0; i < n * 2; i++) {
for (auto e : g) {
if (d[e.from] != LLINF && d[e.to] > d[e.from] + e.cost) {
if (i >= n - 1 && e.to == goal) {
res = false;
} else if (i >= n - 1) {
d[e.to] = -LLINF;
} else {
d[e.to] = d[e.from] + e.cost;
}
}
}
}
return res;
};
bool check = bellmanFord(0, n - 1);
if (!check) {
cout << -1 << endl;
} else {
cout << max(0LL, -d[n - 1]) << endl;
}
} | [
"control_flow.loop.for.condition.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 751,115 | 751,116 | u551351897 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
//#define MOD 998244353
#define INF 1145141919810893364
#define PI 3.141592653589
typedef pair<int, int> PP;
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
#define int ll
#define setdouble setprecision
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define OREP(i, n) for (int i = 1; i <= (n); ++i)
#define RREP(i, n) for (int i = (n)-1; i >= 0; --i)
#define GOODBYE \
cout << "NO" << endl; \
return 0
#define MM << " " <<
#define Endl endl
/*
const int max_E = 6000;
const int max_V = 3000;
struct edge{int from,end,cost;};
edge es[max_E];
int d[max_V];
int V,E;
void BellmanFord(int s){
for(int i=0;i<V;i++)d[i]=INF;
d[s]=0;
int dend[max_V];
for(int j=0;j<V+2;j++){
if(j==V){
for(int i=0;i<V;i++){
dend[i]=d[i];
}
}
if(j==V+1){
bool c=true;
for(int i=0;i<V;i++){
if(dend[i]!=d[i]){
c=false;
}
}
if(c==false){
d[V-1]=-INF;
}
break;
}
bool update=false;
for(int i=0;i<E;i++){
edge k=es[i];
if(d[k.from]!=INF && d[k.end]>d[k.from]+k.cost){
d[k.end]=d[k.from]+k.cost;
update=true;
}
}
if(!update)break;
}
}*/
struct edge {
int from, end, cost;
};
vector<int> BellmanFord(vector<edge> es, int s) {
int E = es.size();
int V = 0;
int dend[3000];
vector<int> d;
for (int i = 0; i < E; i++) {
V = max(V, es[i].from + 1);
V = max(V, es[i].end + 1);
}
for (int i = 0; i < V; i++)
d.push_back(INF);
d[s] = 0;
for (int j = 0; j < V; j++) {
if (j == V) {
for (int i = 0; i < V; i++) {
dend[i] = d[i];
}
}
if (j == V + 1) {
bool c = true;
for (int i = 0; i < V; i++) {
if (dend[i] != d[i]) {
c = false;
}
}
if (c == false) {
d[V - 1] = -INF;
}
break;
}
bool update = false;
for (int i = 0; i < E; i++) {
edge k = es[i];
if (d[k.from] != INF && d[k.end] > d[k.from] + k.cost) {
d[k.end] = d[k.from] + k.cost;
update = true;
}
}
if (!update)
break;
}
return d;
}
// struct edge{int from,end,cost;};
vector<int> DFS(vector<edge> G, int s) {
int M = G.size();
int N = 0;
vector<bool> already;
vector<int> R;
queue<int> P;
vector<vector<pair<int, int>>> E;
for (int i = 0; i < M; i++) {
N = max(N, G[i].from);
N = max(N, G[i].end);
}
N++;
for (int i = 0; i < N; i++) {
E.push_back({{0, 0}});
}
for (int i = 0; i < N; i++) {
already.push_back(false);
R.push_back(INF);
}
for (int i = 0; i < M; i++) {
E[G[i].from].push_back({G[i].end, G[i].cost});
}
R[s] = 0;
P.push(s);
while (!P.empty()) {
int t = P.front();
P.pop();
if (already[t]) {
continue;
}
already[t] = true;
for (int i = 0; i < E[t].size(); i++) {
R[E[t][i].first] = min(R[E[t][i].first], R[t] + E[t][i].second);
P.push(E[t][i].first);
}
}
return R;
}
signed main(void) {
int N, M, P;
int A[5141], B[5141], C[5141];
cin >> N >> M >> P;
REP(i, M) {
cin >> A[i] >> B[i] >> C[i];
A[i]--;
B[i]--;
}
edge h;
vector<edge> D, F;
vector<int> G, H;
REP(i, M) {
h.from = A[i];
h.end = B[i];
h.cost = C[i] - P;
D.push_back(h);
}
REP(i, M) {
h.from = B[i];
h.end = A[i];
h.cost = C[i] - P;
F.push_back(h);
}
G = DFS(D, 0);
H = DFS(F, N - 1);
vector<edge> es;
int now = 0;
REP(i, M) {
h.from = A[i];
h.end = B[i];
h.cost = -C[i] + P;
if (G[A[i]] != INF && G[B[i]] != INF && H[A[i]] != INF && H[B[i]] != INF) {
es.push_back(h);
now++;
// cout << A[i] MM B[i] << endl;
}
}
vector<int> d;
d = BellmanFord(es, 0);
if (d[N - 1] == -INF) {
cout << -1 << endl;
} else {
cout << max(-d[N - 1], 0ll) << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
//#define MOD 998244353
#define INF 1145141919810893364
#define PI 3.141592653589
typedef pair<int, int> PP;
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
#define int ll
#define setdouble setprecision
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define OREP(i, n) for (int i = 1; i <= (n); ++i)
#define RREP(i, n) for (int i = (n)-1; i >= 0; --i)
#define GOODBYE \
cout << "NO" << endl; \
return 0
#define MM << " " <<
#define Endl endl
struct edge {
int from, end, cost;
};
vector<int> BellmanFord(vector<edge> es, int s) {
int E = es.size();
int V = 0;
int dend[3000];
vector<int> d;
for (int i = 0; i < E; i++) {
V = max(V, es[i].from + 1);
V = max(V, es[i].end + 1);
}
for (int i = 0; i < V; i++)
d.push_back(INF);
d[s] = 0;
for (int j = 0; j < V + 2; j++) {
if (j == V) {
for (int i = 0; i < V; i++) {
dend[i] = d[i];
}
}
if (j == V + 1) {
bool c = true;
for (int i = 0; i < V; i++) {
if (dend[i] != d[i]) {
c = false;
}
}
if (c == false) {
d[V - 1] = -INF;
}
break;
}
bool update = false;
for (int i = 0; i < E; i++) {
edge k = es[i];
if (d[k.from] != INF && d[k.end] > d[k.from] + k.cost) {
d[k.end] = d[k.from] + k.cost;
update = true;
}
}
if (!update)
break;
}
return d;
}
// struct edge{int from,end,cost;};
vector<int> DFS(vector<edge> G, int s) {
int M = G.size();
int N = 0;
vector<bool> already;
vector<int> R;
queue<int> P;
vector<vector<pair<int, int>>> E;
for (int i = 0; i < M; i++) {
N = max(N, G[i].from);
N = max(N, G[i].end);
}
N++;
for (int i = 0; i < N; i++) {
E.push_back({{0, 0}});
}
for (int i = 0; i < N; i++) {
already.push_back(false);
R.push_back(INF);
}
for (int i = 0; i < M; i++) {
E[G[i].from].push_back({G[i].end, G[i].cost});
}
R[s] = 0;
P.push(s);
while (!P.empty()) {
int t = P.front();
P.pop();
if (already[t]) {
continue;
}
already[t] = true;
for (int i = 0; i < E[t].size(); i++) {
R[E[t][i].first] = min(R[E[t][i].first], R[t] + E[t][i].second);
P.push(E[t][i].first);
}
}
return R;
}
signed main(void) {
int N, M, P;
int A[5141], B[5141], C[5141];
cin >> N >> M >> P;
REP(i, M) {
cin >> A[i] >> B[i] >> C[i];
A[i]--;
B[i]--;
}
edge h;
vector<edge> D, F;
vector<int> G, H;
REP(i, M) {
h.from = A[i];
h.end = B[i];
h.cost = C[i] - P;
D.push_back(h);
}
REP(i, M) {
h.from = B[i];
h.end = A[i];
h.cost = C[i] - P;
F.push_back(h);
}
G = DFS(D, 0);
H = DFS(F, N - 1);
vector<edge> es;
int now = 0;
REP(i, M) {
h.from = A[i];
h.end = B[i];
h.cost = -C[i] + P;
if (G[A[i]] != INF && G[B[i]] != INF && H[A[i]] != INF && H[B[i]] != INF) {
es.push_back(h);
now++;
}
}
vector<int> d;
d = BellmanFord(es, 0);
if (d[N - 1] == -INF) {
cout << -1 << endl;
} else {
cout << max(-d[N - 1], 0ll) << endl;
}
return 0;
}
| [
"control_flow.loop.for.condition.change"
] | 751,122 | 751,123 | u554953477 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
//#define MOD 998244353
#define INF 1145141919810893364
#define PI 3.141592653589
typedef pair<int, int> PP;
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
#define int ll
#define setdouble setprecision
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define OREP(i, n) for (int i = 1; i <= (n); ++i)
#define RREP(i, n) for (int i = (n)-1; i >= 0; --i)
#define GOODBYE \
cout << "NO" << endl; \
return 0
#define MM << " " <<
#define Endl endl
/*
const int max_E = 6000;
const int max_V = 3000;
struct edge{int from,end,cost;};
edge es[max_E];
int d[max_V];
int V,E;
void BellmanFord(int s){
for(int i=0;i<V;i++)d[i]=INF;
d[s]=0;
int dend[max_V];
for(int j=0;j<V+2;j++){
if(j==V){
for(int i=0;i<V;i++){
dend[i]=d[i];
}
}
if(j==V+1){
bool c=true;
for(int i=0;i<V;i++){
if(dend[i]!=d[i]){
c=false;
}
}
if(c==false){
d[V-1]=-INF;
}
break;
}
bool update=false;
for(int i=0;i<E;i++){
edge k=es[i];
if(d[k.from]!=INF && d[k.end]>d[k.from]+k.cost){
d[k.end]=d[k.from]+k.cost;
update=true;
}
}
if(!update)break;
}
}*/
struct edge {
int from, end, cost;
};
vector<int> BellmanFord(vector<edge> es, int s) {
int E = es.size();
int V = 0;
int dend[3000];
vector<int> d;
for (int i = 0; i < E; i++) {
V = max(V, es[i].from + 1);
V = max(V, es[i].end + 1);
}
for (int i = 0; i < V; i++)
d.push_back(INF);
d[s] = 0;
for (int j = 0; j < V; j++) {
if (j == V) {
for (int i = 0; i < V; i++) {
dend[i] = d[i];
}
}
if (j == V + 1) {
bool c = true;
for (int i = 0; i < V; i++) {
if (dend[i] != d[i]) {
c = false;
}
}
if (c == false) {
d[V - 1] = -INF;
}
break;
}
bool update = false;
for (int i = 0; i < E; i++) {
edge k = es[i];
if (d[k.from] != INF && d[k.end] > d[k.from] + k.cost) {
d[k.end] = d[k.from] + k.cost;
update = true;
}
}
if (!update)
break;
}
return d;
}
// struct edge{int from,end,cost;};
vector<int> DFS(vector<edge> G, int s) {
int M = G.size();
int N = 0;
vector<bool> already;
vector<int> R;
queue<int> P;
vector<vector<pair<int, int>>> E;
for (int i = 0; i < M; i++) {
N = max(N, G[i].from);
N = max(N, G[i].end);
}
N++;
for (int i = 0; i < N; i++) {
E.push_back({{0, 0}});
}
for (int i = 0; i < N; i++) {
already.push_back(false);
R.push_back(INF);
}
for (int i = 0; i < M; i++) {
E[G[i].from].push_back({G[i].end, G[i].cost});
}
R[s] = 0;
P.push(s);
while (!P.empty()) {
int t = P.front();
P.pop();
if (already[t]) {
continue;
}
already[t] = true;
for (int i = 0; i < E[t].size(); i++) {
R[E[t][i].first] = min(R[E[t][i].first], R[t] + E[t][i].second);
P.push(E[t][i].first);
}
}
return R;
}
signed main(void) {
int N, M, P;
int A[5141], B[5141], C[5141];
cin >> N >> M >> P;
REP(i, M) {
cin >> A[i] >> B[i] >> C[i];
A[i]--;
B[i]--;
}
edge h;
vector<edge> D, F;
vector<int> G, H;
REP(i, M) {
h.from = A[i];
h.end = B[i];
h.cost = C[i] - P;
D.push_back(h);
}
REP(i, M) {
h.from = B[i];
h.end = A[i];
h.cost = C[i] - P;
F.push_back(h);
}
G = DFS(D, 0);
H = DFS(F, N - 1);
vector<edge> es;
int now = 0;
REP(i, M) {
h.from = A[i];
h.end = B[i];
h.cost = -C[i] + P;
if (G[A[i]] != INF && G[B[i]] != INF && H[A[i]] != INF && H[B[i]] != INF) {
es.push_back(h);
now++;
// cout << A[i] MM B[i] << endl;
}
}
vector<int> d;
d = BellmanFord(es, 0);
if (d[N - 1] == -INF) {
cout << -1 << endl;
} else {
cout << max(-d[N - 1], 0ll) << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
//#define MOD 998244353
#define INF 1145141919810893364
#define PI 3.141592653589
typedef pair<int, int> PP;
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
#define int ll
#define setdouble setprecision
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define OREP(i, n) for (int i = 1; i <= (n); ++i)
#define RREP(i, n) for (int i = (n)-1; i >= 0; --i)
#define GOODBYE \
cout << "NO" << endl; \
return 0
#define MM << " " <<
#define Endl endl
/*
const int max_E = 6000;
const int max_V = 3000;
struct edge{int from,end,cost;};
edge es[max_E];
int d[max_V];
int V,E;
void BellmanFord(int s){
for(int i=0;i<V;i++)d[i]=INF;
d[s]=0;
int dend[max_V];
for(int j=0;j<V+2;j++){
if(j==V){
for(int i=0;i<V;i++){
dend[i]=d[i];
}
}
if(j==V+1){
bool c=true;
for(int i=0;i<V;i++){
if(dend[i]!=d[i]){
c=false;
}
}
if(c==false){
d[V-1]=-INF;
}
break;
}
bool update=false;
for(int i=0;i<E;i++){
edge k=es[i];
if(d[k.from]!=INF && d[k.end]>d[k.from]+k.cost){
d[k.end]=d[k.from]+k.cost;
update=true;
}
}
if(!update)break;
}
}*/
struct edge {
int from, end, cost;
};
vector<int> BellmanFord(vector<edge> es, int s) {
int E = es.size();
int V = 0;
int dend[3000];
vector<int> d;
for (int i = 0; i < E; i++) {
V = max(V, es[i].from + 1);
V = max(V, es[i].end + 1);
}
for (int i = 0; i < V; i++)
d.push_back(INF);
d[s] = 0;
for (int j = 0; j < V + 2; j++) {
if (j == V) {
for (int i = 0; i < V; i++) {
dend[i] = d[i];
}
}
if (j == V + 1) {
bool c = true;
for (int i = 0; i < V; i++) {
if (dend[i] != d[i]) {
c = false;
}
}
if (c == false) {
d[V - 1] = -INF;
}
break;
}
bool update = false;
for (int i = 0; i < E; i++) {
edge k = es[i];
if (d[k.from] != INF && d[k.end] > d[k.from] + k.cost) {
d[k.end] = d[k.from] + k.cost;
update = true;
}
}
if (!update)
break;
}
return d;
}
// struct edge{int from,end,cost;};
vector<int> DFS(vector<edge> G, int s) {
int M = G.size();
int N = 0;
vector<bool> already;
vector<int> R;
queue<int> P;
vector<vector<pair<int, int>>> E;
for (int i = 0; i < M; i++) {
N = max(N, G[i].from);
N = max(N, G[i].end);
}
N++;
for (int i = 0; i < N; i++) {
E.push_back({{0, 0}});
}
for (int i = 0; i < N; i++) {
already.push_back(false);
R.push_back(INF);
}
for (int i = 0; i < M; i++) {
E[G[i].from].push_back({G[i].end, G[i].cost});
}
R[s] = 0;
P.push(s);
while (!P.empty()) {
int t = P.front();
P.pop();
if (already[t]) {
continue;
}
already[t] = true;
for (int i = 0; i < E[t].size(); i++) {
R[E[t][i].first] = min(R[E[t][i].first], R[t] + E[t][i].second);
P.push(E[t][i].first);
}
}
return R;
}
signed main(void) {
int N, M, P;
int A[5141], B[5141], C[5141];
cin >> N >> M >> P;
REP(i, M) {
cin >> A[i] >> B[i] >> C[i];
A[i]--;
B[i]--;
}
edge h;
vector<edge> D, F;
vector<int> G, H;
REP(i, M) {
h.from = A[i];
h.end = B[i];
h.cost = C[i] - P;
D.push_back(h);
}
REP(i, M) {
h.from = B[i];
h.end = A[i];
h.cost = C[i] - P;
F.push_back(h);
}
G = DFS(D, 0);
H = DFS(F, N - 1);
vector<edge> es;
int now = 0;
REP(i, M) {
h.from = A[i];
h.end = B[i];
h.cost = -C[i] + P;
if (G[A[i]] != INF && G[B[i]] != INF && H[A[i]] != INF && H[B[i]] != INF) {
es.push_back(h);
now++;
// cout << A[i] MM B[i] << endl;
}
}
vector<int> d;
d = BellmanFord(es, 0);
if (d[N - 1] == -INF) {
cout << -1 << endl;
} else {
cout << max(-d[N - 1], 0ll) << endl;
}
return 0;
}
| [
"control_flow.loop.for.condition.change"
] | 751,122 | 751,124 | u554953477 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
//#define MOD 998244353
#define INF 1145141919810893364
#define PI 3.141592653589
typedef pair<int, int> PP;
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
#define int ll
#define setdouble setprecision
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define OREP(i, n) for (int i = 1; i <= (n); ++i)
#define RREP(i, n) for (int i = (n)-1; i >= 0; --i)
#define GOODBYE \
cout << "NO" << endl; \
return 0
#define MM << " " <<
#define Endl endl
const int max_E = 6000;
const int max_V = 3000;
struct edge {
int from, end, cost;
};
edge es[max_E];
int d[max_V];
int V, E;
void BellmanFord(int s) {
for (int i = 0; i < V; i++)
d[i] = INF;
d[s] = 0;
int dend[max_V];
for (int j = 0; j < V + 2; j++) {
if (j == V) {
for (int i = 0; i < V; i++) {
dend[i] = d[i];
}
}
if (j == V + 1) {
bool c = true;
for (int i = 0; i < V; i++) {
if (dend[i] != d[i]) {
c = false;
}
}
if (c == false) {
d[V - 1] = -INF;
}
break;
}
bool update = false;
for (int i = 0; i < E; i++) {
edge k = es[i];
if (d[k.from] != INF && d[k.end] > d[k.from] + k.cost) {
d[k.end] = d[k.from] + k.cost;
update = true;
}
}
if (!update)
break;
}
}
// struct edge{int from,end,cost;};
vector<int> DFS(vector<edge> G, int s) {
int M = G.size();
int N = 0;
vector<bool> already;
vector<int> R;
queue<int> P;
vector<vector<pair<int, int>>> E;
for (int i = 0; i < M; i++) {
N = max(N, G[i].from);
N = max(N, G[i].end);
}
N++;
for (int i = 0; i < M; i++) {
E.push_back({{}});
}
for (int i = 0; i < N; i++) {
already.push_back(false);
R.push_back(INF);
}
for (int i = 0; i < M; i++) {
E[G[i].from].push_back({G[i].end, G[i].cost});
}
R[s] = 0;
P.push(s);
while (!P.empty()) {
int t = P.front();
P.pop();
if (already[t]) {
continue;
}
already[t] = true;
for (int i = 0; i < E[t].size(); i++) {
R[E[t][i].first] = min(R[E[t][i].first], R[t] + E[t][i].second);
P.push(E[t][i].first);
}
}
return R;
}
signed main(void) {
int N, M, P;
int A[5141], B[5141], C[5141];
cin >> N >> M >> P;
REP(i, M) {
cin >> A[i] >> B[i] >> C[i];
A[i]--;
B[i]--;
}
edge h;
vector<edge> D, F;
vector<int> G, H;
REP(i, M) {
h.from = A[i];
h.end = B[i];
h.cost = C[i] - P;
D.push_back(h);
}
REP(i, M) {
h.from = B[i];
h.end = A[i];
h.cost = C[i] - P;
F.push_back(h);
}
G = DFS(D, 0);
H = DFS(F, N - 1);
// REP(i,G.size()){cout << G[i] << " ";}cout << endl;
// REP(i,H.size()){cout << H[i] << " ";}cout << endl;
int now = 0;
REP(i, M) {
h.from = A[i];
h.end = B[i];
h.cost = -C[i] + P;
if (G[A[i]] != INF && G[B[i]] != INF && H[A[i]] != INF && H[B[i]] != INF) {
es[now] = h;
now++;
// cout << A[i] MM B[i] << endl;
}
}
V = N;
E = now;
BellmanFord(0);
if (d[N - 1] == -INF) {
cout << -1 << endl;
} else {
cout << max(-d[N - 1], 0ll) << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
//#define MOD 998244353
#define INF 1145141919810893364
#define PI 3.141592653589
typedef pair<int, int> PP;
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
#define int ll
#define setdouble setprecision
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define OREP(i, n) for (int i = 1; i <= (n); ++i)
#define RREP(i, n) for (int i = (n)-1; i >= 0; --i)
#define GOODBYE \
cout << "NO" << endl; \
return 0
#define MM << " " <<
#define Endl endl
const int max_E = 6000;
const int max_V = 3000;
struct edge {
int from, end, cost;
};
edge es[max_E];
int d[max_V];
int V, E;
void BellmanFord(int s) {
for (int i = 0; i < V; i++)
d[i] = INF;
d[s] = 0;
int dend[max_V];
for (int j = 0; j < V + 2; j++) {
if (j == V) {
for (int i = 0; i < V; i++) {
dend[i] = d[i];
}
}
if (j == V + 1) {
bool c = true;
for (int i = 0; i < V; i++) {
if (dend[i] != d[i]) {
c = false;
}
}
if (c == false) {
d[V - 1] = -INF;
}
break;
}
bool update = false;
for (int i = 0; i < E; i++) {
edge k = es[i];
if (d[k.from] != INF && d[k.end] > d[k.from] + k.cost) {
d[k.end] = d[k.from] + k.cost;
update = true;
}
}
if (!update)
break;
}
}
// struct edge{int from,end,cost;};
vector<int> DFS(vector<edge> G, int s) {
int M = G.size();
int N = 0;
vector<bool> already;
vector<int> R;
queue<int> P;
vector<vector<pair<int, int>>> E;
for (int i = 0; i < M; i++) {
N = max(N, G[i].from);
N = max(N, G[i].end);
}
N++;
for (int i = 0; i < N; i++) {
E.push_back({{0, 0}});
}
for (int i = 0; i < N; i++) {
already.push_back(false);
R.push_back(INF);
}
for (int i = 0; i < M; i++) {
E[G[i].from].push_back({G[i].end, G[i].cost});
}
R[s] = 0;
P.push(s);
while (!P.empty()) {
int t = P.front();
P.pop();
if (already[t]) {
continue;
}
already[t] = true;
for (int i = 0; i < E[t].size(); i++) {
R[E[t][i].first] = min(R[E[t][i].first], R[t] + E[t][i].second);
P.push(E[t][i].first);
}
}
return R;
}
signed main(void) {
int N, M, P;
int A[5141], B[5141], C[5141];
cin >> N >> M >> P;
REP(i, M) {
cin >> A[i] >> B[i] >> C[i];
A[i]--;
B[i]--;
}
edge h;
vector<edge> D, F;
vector<int> G, H;
REP(i, M) {
h.from = A[i];
h.end = B[i];
h.cost = C[i] - P;
D.push_back(h);
}
REP(i, M) {
h.from = B[i];
h.end = A[i];
h.cost = C[i] - P;
F.push_back(h);
}
G = DFS(D, 0);
H = DFS(F, N - 1);
// REP(i,G.size()){cout << G[i] << " ";}cout << endl;
// REP(i,H.size()){cout << H[i] << " ";}cout << endl;
int now = 0;
REP(i, M) {
h.from = A[i];
h.end = B[i];
h.cost = -C[i] + P;
if (G[A[i]] != INF && G[B[i]] != INF && H[A[i]] != INF && H[B[i]] != INF) {
es[now] = h;
now++;
// cout << A[i] MM B[i] << endl;
}
}
V = N;
E = now;
BellmanFord(0);
if (d[N - 1] == -INF) {
cout << -1 << endl;
} else {
cout << max(-d[N - 1], 0ll) << endl;
}
return 0;
}
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 751,125 | 751,126 | u554953477 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
//#define MOD 998244353
#define INF 1145141919810893364
#define PI 3.141592653589
typedef pair<int, int> PP;
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
#define int ll
#define setdouble setprecision
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define OREP(i, n) for (int i = 1; i <= (n); ++i)
#define RREP(i, n) for (int i = (n)-1; i >= 0; --i)
#define GOODBYE \
cout << "NO" << endl; \
return 0
#define MM << " " <<
#define Endl endl
const int max_E = 6000;
const int max_V = 3000;
struct edge {
int from, end, cost;
};
edge es[max_E];
int d[max_V];
int V, E;
void BellmanFord(int s) {
for (int i = 0; i < V; i++)
d[i] = INF;
d[s] = 0;
int dend[max_V];
for (int j = 0; j < V + 2; j++) {
if (j == V) {
for (int i = 0; i < V; i++) {
dend[i] = d[i];
}
}
if (j == V + 1) {
bool c = true;
for (int i = 0; i < V; i++) {
if (dend[i] != d[i]) {
c = false;
}
}
if (c == false) {
d[V - 1] = -INF;
}
break;
}
bool update = false;
for (int i = 0; i < E; i++) {
edge k = es[i];
if (d[k.from] != INF && d[k.end] > d[k.from] + k.cost) {
d[k.end] = d[k.from] + k.cost;
update = true;
}
}
if (!update)
break;
}
}
// struct edge{int from,end,cost;};
vector<int> DFS(vector<edge> G, int s) {
int M = G.size();
int N = 0;
vector<bool> already;
vector<int> R;
queue<int> P;
vector<vector<pair<int, int>>> E;
for (int i = 0; i < M; i++) {
N = max(N, G[i].from);
N = max(N, G[i].end);
}
N++;
for (int i = 0; i < M; i++) {
E.push_back({});
}
for (int i = 0; i < N; i++) {
already.push_back(false);
R.push_back(INF);
}
for (int i = 0; i < M; i++) {
E[G[i].from].push_back({G[i].end, G[i].cost});
}
R[s] = 0;
P.push(s);
while (!P.empty()) {
int t = P.front();
P.pop();
if (already[t]) {
continue;
}
already[t] = true;
for (int i = 0; i < E[t].size(); i++) {
R[E[t][i].first] = min(R[E[t][i].first], R[t] + E[t][i].second);
P.push(E[t][i].first);
}
}
return R;
}
signed main(void) {
int N, M, P;
int A[5141], B[5141], C[5141];
cin >> N >> M >> P;
REP(i, M) {
cin >> A[i] >> B[i] >> C[i];
A[i]--;
B[i]--;
}
edge h;
vector<edge> D, F;
vector<int> G, H;
REP(i, M) {
h.from = A[i];
h.end = B[i];
h.cost = C[i] - P;
D.push_back(h);
}
REP(i, M) {
h.from = B[i];
h.end = A[i];
h.cost = C[i] - P;
F.push_back(h);
}
G = DFS(D, 0);
H = DFS(F, N - 1);
// REP(i,G.size()){cout << G[i] << " ";}cout << endl;
// REP(i,H.size()){cout << H[i] << " ";}cout << endl;
int now = 0;
REP(i, M) {
h.from = A[i];
h.end = B[i];
h.cost = -C[i] + P;
if (G[A[i]] != INF && G[B[i]] != INF && H[A[i]] != INF && H[B[i]] != INF) {
es[now] = h;
now++;
// cout << A[i] MM B[i] << endl;
}
}
V = N;
E = now;
BellmanFord(0);
if (d[N - 1] == -INF) {
cout << -1 << endl;
} else {
cout << max(-d[N - 1], 0ll) << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
//#define MOD 998244353
#define INF 1145141919810893364
#define PI 3.141592653589
typedef pair<int, int> PP;
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
#define int ll
#define setdouble setprecision
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define OREP(i, n) for (int i = 1; i <= (n); ++i)
#define RREP(i, n) for (int i = (n)-1; i >= 0; --i)
#define GOODBYE \
cout << "NO" << endl; \
return 0
#define MM << " " <<
#define Endl endl
const int max_E = 6000;
const int max_V = 3000;
struct edge {
int from, end, cost;
};
edge es[max_E];
int d[max_V];
int V, E;
void BellmanFord(int s) {
for (int i = 0; i < V; i++)
d[i] = INF;
d[s] = 0;
int dend[max_V];
for (int j = 0; j < V + 2; j++) {
if (j == V) {
for (int i = 0; i < V; i++) {
dend[i] = d[i];
}
}
if (j == V + 1) {
bool c = true;
for (int i = 0; i < V; i++) {
if (dend[i] != d[i]) {
c = false;
}
}
if (c == false) {
d[V - 1] = -INF;
}
break;
}
bool update = false;
for (int i = 0; i < E; i++) {
edge k = es[i];
if (d[k.from] != INF && d[k.end] > d[k.from] + k.cost) {
d[k.end] = d[k.from] + k.cost;
update = true;
}
}
if (!update)
break;
}
}
// struct edge{int from,end,cost;};
vector<int> DFS(vector<edge> G, int s) {
int M = G.size();
int N = 0;
vector<bool> already;
vector<int> R;
queue<int> P;
vector<vector<pair<int, int>>> E;
for (int i = 0; i < M; i++) {
N = max(N, G[i].from);
N = max(N, G[i].end);
}
N++;
for (int i = 0; i < N; i++) {
E.push_back({{0, 0}});
}
for (int i = 0; i < N; i++) {
already.push_back(false);
R.push_back(INF);
}
for (int i = 0; i < M; i++) {
E[G[i].from].push_back({G[i].end, G[i].cost});
}
R[s] = 0;
P.push(s);
while (!P.empty()) {
int t = P.front();
P.pop();
if (already[t]) {
continue;
}
already[t] = true;
for (int i = 0; i < E[t].size(); i++) {
R[E[t][i].first] = min(R[E[t][i].first], R[t] + E[t][i].second);
P.push(E[t][i].first);
}
}
return R;
}
signed main(void) {
int N, M, P;
int A[5141], B[5141], C[5141];
cin >> N >> M >> P;
REP(i, M) {
cin >> A[i] >> B[i] >> C[i];
A[i]--;
B[i]--;
}
edge h;
vector<edge> D, F;
vector<int> G, H;
REP(i, M) {
h.from = A[i];
h.end = B[i];
h.cost = C[i] - P;
D.push_back(h);
}
REP(i, M) {
h.from = B[i];
h.end = A[i];
h.cost = C[i] - P;
F.push_back(h);
}
G = DFS(D, 0);
H = DFS(F, N - 1);
// REP(i,G.size()){cout << G[i] << " ";}cout << endl;
// REP(i,H.size()){cout << H[i] << " ";}cout << endl;
int now = 0;
REP(i, M) {
h.from = A[i];
h.end = B[i];
h.cost = -C[i] + P;
if (G[A[i]] != INF && G[B[i]] != INF && H[A[i]] != INF && H[B[i]] != INF) {
es[now] = h;
now++;
// cout << A[i] MM B[i] << endl;
}
}
V = N;
E = now;
BellmanFord(0);
if (d[N - 1] == -INF) {
cout << -1 << endl;
} else {
cout << max(-d[N - 1], 0ll) << endl;
}
return 0;
}
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 751,127 | 751,126 | u554953477 | cpp |
p02949 | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#define MOD 1000000007
#define MOD2 998244353
#define int long long
//#define PI 3.14159265358979
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
template <typename T> ostream &operator<<(ostream &os, const vector<T> &A) {
for (int i = 0; i < A.size(); i++)
os << A[i] << " ";
os << endl;
return os;
}
template <> ostream &operator<<(ostream &os, const vector<vector<int>> &A) {
int N = A.size();
int M;
if (N > 0)
M = A[0].size();
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++)
os << A[i][j] << " ";
os << endl;
}
return os;
}
typedef pair<int, int> pii;
typedef long long ll;
struct edge {
int from, to, d, c;
edge(int _from = 0, int _to = 0, int _d = 0, int _c = 0) {
from = _from;
to = _to;
d = _d;
c = _c;
}
bool operator<(const edge &rhs) const {
return (d == rhs.d) ? (c < rhs.c) : (d < rhs.d);
}
};
typedef vector<edge> edges;
typedef vector<edges> graph;
struct flow {
int to, cap, rev, cost;
flow(int to = 0, int cap = 0, int rev = 0, int cost = 0)
: to(to), cap(cap), rev(rev), cost(cost) {}
};
typedef vector<vector<flow>> flows;
const int di[4] = {0, -1, 0, 1};
const int dj[4] = {-1, 0, 1, 0};
const int ci[5] = {0, 0, -1, 0, 1};
const int cj[5] = {0, -1, 0, 1, 0};
const ll LINF = LLONG_MAX / 2;
const int INF = INT_MAX / 2;
const double PI = acos(-1);
template <typename T, typename U> bool chmin(T &x, const U &y) {
if (x > y) {
x = y;
return true;
}
return false;
}
template <typename T, typename U> bool chmax(T &x, const U &y) {
if (x < y) {
x = y;
return true;
}
return false;
}
struct initializer {
initializer() { cout << fixed << setprecision(11); }
};
initializer _____;
int N, M, K, T, Q;
void dfs(vector<bool> &done, graph &G, int x) {
done[x] = true;
rep(i, G[x].size()) {
edge j = G[x][i];
if (done[j.to])
continue;
dfs(done, G, j.to);
}
}
signed main() {
int P;
cin >> N >> M >> P;
graph G(N), Gb(N);
edges es(M);
rep(i, M) {
int A, B, C;
cin >> A >> B >> C;
--A;
--B;
C -= P;
G[A].push_back(edge(A, B, C));
Gb[B].push_back(edge(B, A, C));
es[i] = edge(A, B, C);
}
vector<bool> done1(N, false), done2(N, false), done(N, false);
dfs(done1, G, 0);
dfs(done2, Gb, N - 1);
rep(i, N) if (done1[i] & done2[i]) done[i] = true;
vector<int> ans(N, 0);
bool f = false;
rep(i, N) {
rep(j, M) {
edge e = es[j];
if (!done[e.to] || !done[e.from])
continue;
if (ans[e.to] < ans[e.from] + e.d) {
ans[e.to] = ans[e.from] + e.d;
if (i == N - 1) {
f = true;
break;
}
}
}
}
ans.assign(N, -1);
ans[0] = 0;
// ans[N - 1] = 0;
rep(i, N) {
rep(j, M) {
edge e = es[j];
if (ans[e.from] == -1 || !done[e.to] || !done[e.from])
continue;
if (ans[e.to] < ans[e.from] + e.d) {
ans[e.to] = ans[e.from] + e.d;
}
}
}
if (f) {
cout << -1 << endl;
} else {
cout << max(0LL, ans[N - 1]) << endl;
}
return 0;
} | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#define MOD 1000000007
#define MOD2 998244353
#define int long long
//#define PI 3.14159265358979
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
template <typename T> ostream &operator<<(ostream &os, const vector<T> &A) {
for (int i = 0; i < A.size(); i++)
os << A[i] << " ";
os << endl;
return os;
}
template <> ostream &operator<<(ostream &os, const vector<vector<int>> &A) {
int N = A.size();
int M;
if (N > 0)
M = A[0].size();
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++)
os << A[i][j] << " ";
os << endl;
}
return os;
}
typedef pair<int, int> pii;
typedef long long ll;
struct edge {
int from, to, d, c;
edge(int _from = 0, int _to = 0, int _d = 0, int _c = 0) {
from = _from;
to = _to;
d = _d;
c = _c;
}
bool operator<(const edge &rhs) const {
return (d == rhs.d) ? (c < rhs.c) : (d < rhs.d);
}
};
typedef vector<edge> edges;
typedef vector<edges> graph;
struct flow {
int to, cap, rev, cost;
flow(int to = 0, int cap = 0, int rev = 0, int cost = 0)
: to(to), cap(cap), rev(rev), cost(cost) {}
};
typedef vector<vector<flow>> flows;
const int di[4] = {0, -1, 0, 1};
const int dj[4] = {-1, 0, 1, 0};
const int ci[5] = {0, 0, -1, 0, 1};
const int cj[5] = {0, -1, 0, 1, 0};
const ll LINF = LLONG_MAX / 2;
const int INF = INT_MAX / 2;
const double PI = acos(-1);
template <typename T, typename U> bool chmin(T &x, const U &y) {
if (x > y) {
x = y;
return true;
}
return false;
}
template <typename T, typename U> bool chmax(T &x, const U &y) {
if (x < y) {
x = y;
return true;
}
return false;
}
struct initializer {
initializer() { cout << fixed << setprecision(11); }
};
initializer _____;
int N, M, K, T, Q;
void dfs(vector<bool> &done, graph &G, int x) {
done[x] = true;
rep(i, G[x].size()) {
edge j = G[x][i];
if (done[j.to])
continue;
dfs(done, G, j.to);
}
}
signed main() {
int P;
cin >> N >> M >> P;
graph G(N), Gb(N);
edges es(M);
rep(i, M) {
int A, B, C;
cin >> A >> B >> C;
--A;
--B;
C -= P;
G[A].push_back(edge(A, B, C));
Gb[B].push_back(edge(B, A, C));
es[i] = edge(A, B, C);
}
vector<bool> done1(N, false), done2(N, false), done(N, false);
dfs(done1, G, 0);
dfs(done2, Gb, N - 1);
rep(i, N) if (done1[i] & done2[i]) done[i] = true;
vector<int> ans(N, 0);
bool f = false;
rep(i, N) {
rep(j, M) {
edge e = es[j];
if (!done[e.to] || !done[e.from])
continue;
if (ans[e.to] < ans[e.from] + e.d) {
ans[e.to] = ans[e.from] + e.d;
if (i == N - 1) {
f = true;
break;
}
}
}
}
ans.assign(N, -LINF);
ans[0] = 0;
// ans[N - 1] = 0;
rep(i, N) {
rep(j, M) {
edge e = es[j];
if (ans[e.from] == -1 || !done[e.to] || !done[e.from])
continue;
if (ans[e.to] < ans[e.from] + e.d) {
ans[e.to] = ans[e.from] + e.d;
}
}
}
if (f) {
cout << -1 << endl;
} else {
cout << max(0LL, ans[N - 1]) << endl;
}
return 0;
} | [
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change"
] | 751,130 | 751,131 | u537874719 | cpp |
p02949 | #include <bits/stdc++.h>
#include <math.h>
#define _GLIBCXX_DEBUG
#define _LIBCPP_DEBUG 0
using namespace std;
#define ll long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define MOD (1000000007)
#define vi vector<int>
#define vl vector<ll>
#define vvi vector<vi>
#define vvl vector<vl>
#define pii pair<int, int>
#define pli pair<ll, int>
#define pb push_back
#define mp make_pair
#define all(a) (a).begin(), (a).end()
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
ll keta(ll n) {
string s = to_string(n);
ll num = s.size();
return num;
}
const ll INF = 1LL << 60;
const int dh[4] = {1, 0, -1, 0};
const int dw[4] = {0, 1, 0, -1};
struct Edge {
int to;
int weight;
Edge(int t, int w) : to(t), weight(w) {}
};
using Graph = vector<vector<Edge>>;
using P = pair<ll, int>;
void dfs(int v, vvi &G, vector<bool> &seen) {
if (seen[v])
return;
seen[v] = true;
for (auto nv : G[v]) {
dfs(nv, G, seen);
}
}
int main() {
int n, m, p;
cin >> n >> m >> p;
vvi G(n), rG(n);
vector<tuple<int, int, int>> edges;
rep(i, m) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
c -= p;
c = -c;
edges.emplace_back(a, b, c);
G[a].pb(b);
rG[b].pb(a);
}
vector<bool> seen1(n, false);
vector<bool> seen2(n, false);
dfs(0, G, seen1);
dfs(n - 1, rG, seen2);
vector<bool> ok(n);
rep(i, n) ok[i] = seen1[i] & seen2[i];
vi d(n, 1e9);
d[0] = 0;
int step = 0;
bool upd = true;
while (upd) {
upd = false;
rep(i, m) {
int a, b, c;
tie(a, b, c) = edges[i];
if (!ok[a] || !ok[b])
continue;
upd = chmin(d[b], d[a] + c);
}
step++;
if (step > n) {
cout << -1 << endl;
return 0;
}
}
int ans = -d[n - 1];
ans = max(ans, 0);
cout << ans << endl;
}
| #include <bits/stdc++.h>
#include <math.h>
#define _GLIBCXX_DEBUG
#define _LIBCPP_DEBUG 0
using namespace std;
#define ll long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define MOD (1000000007)
#define vi vector<int>
#define vl vector<ll>
#define vvi vector<vi>
#define vvl vector<vl>
#define pii pair<int, int>
#define pli pair<ll, int>
#define pb push_back
#define mp make_pair
#define all(a) (a).begin(), (a).end()
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
ll keta(ll n) {
string s = to_string(n);
ll num = s.size();
return num;
}
const ll INF = 1LL << 60;
const int dh[4] = {1, 0, -1, 0};
const int dw[4] = {0, 1, 0, -1};
struct Edge {
int to;
int weight;
Edge(int t, int w) : to(t), weight(w) {}
};
using Graph = vector<vector<Edge>>;
using P = pair<ll, int>;
void dfs(int v, vvi &G, vector<bool> &seen) {
if (seen[v])
return;
seen[v] = true;
for (auto nv : G[v]) {
dfs(nv, G, seen);
}
}
int main() {
int n, m, p;
cin >> n >> m >> p;
vvi G(n), rG(n);
vector<tuple<int, int, int>> edges;
rep(i, m) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
c -= p;
c = -c;
edges.emplace_back(a, b, c);
G[a].pb(b);
rG[b].pb(a);
}
vector<bool> seen1(n, false);
vector<bool> seen2(n, false);
dfs(0, G, seen1);
dfs(n - 1, rG, seen2);
vector<bool> ok(n);
rep(i, n) ok[i] = seen1[i] & seen2[i];
vi d(n, 1e9);
d[0] = 0;
int step = 0;
bool upd = true;
while (upd) {
upd = false;
rep(i, m) {
int a, b, c;
tie(a, b, c) = edges[i];
if (!ok[a] || !ok[b])
continue;
if (chmin(d[b], d[a] + c))
upd = true;
}
step++;
if (step > n) {
cout << -1 << endl;
return 0;
}
}
int ans = -d[n - 1];
ans = max(ans, 0);
cout << ans << endl;
}
| [
"control_flow.branch.if.condition.change",
"assignment.change"
] | 751,132 | 751,133 | u354567428 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
//#include <boost/multiprecision/cpp_int.hpp>
// using multiInt = boost::multiprecision::cpp_int;
using ll = long long int;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename Q_temp>
using smaller_queue = priority_queue<Q_temp, vector<Q_temp>, greater<Q_temp>>;
const ll MOD = (ll)(1e9 + 7);
const int INF = (int)1e9;
const ll LINF = (ll)2e18;
const double PI = acos(-1.0);
#define REP(i, m, n) for (ll i = m; i < (ll)(n); ++i)
#define rep(i, n) REP(i, 0, n)
#define MP make_pair
#define MT make_tuple
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define Possible(n) cout << ((n) ? "Possible" : "Impossible") << endl
#define all(v) v.begin(), v.end()
#define NP(v) next_permutation(all(v))
#define dbg(x) cerr << #x << ":" << x << endl;
vector<int> Dx = {0, 0, -1, 1, -1, 1, -1, 1, 0};
vector<int> Dy = {1, -1, 0, 0, -1, -1, 1, 1, 0};
const ll MAX_V = 200010;
struct edge {
ll from, to;
ll cost;
};
class BellmanFord {
public:
ll V;
vector<edge> E;
ll d[MAX_V];
BellmanFord(ll V_num) : V(V_num) {}
void calc(ll s) {
rep(i, V + 1) d[i] = LINF;
d[s] = 0;
bool update;
while (1) {
update = false;
for (auto e : E) {
if (d[e.from] != LINF && d[e.to] > d[e.from] + e.cost) {
d[e.to] = d[e.from] + e.cost;
update = true;
}
}
if (!update)
return;
}
}
bool calc_and_find_negative_loop(ll s, ll g) {
ll negative[MAX_V];
rep(i, V + 1) d[i] = LINF;
d[s] = 0;
rep(i, V) {
bool update = false;
for (auto e : E) {
if (d[e.from] != LINF && d[e.to] > d[e.from] + e.cost) {
d[e.to] = d[e.from] + e.cost;
update = true;
if (i == V - 1)
negative[e.from] = negative[e.to] = true;
}
}
if (!update)
return false;
}
return negative[g];
}
bool find_any_negative_loop() {
ll d_[MAX_V];
rep(i, V) for (auto e : E) {
if (d_[e.to] > d_[e.from] + e.cost) {
d_[e.to] = d_[e.from] + e.cost;
if (i == V - 1)
return true;
}
}
return false;
}
};
inline void finish() {
cout << -1 << endl;
exit(0);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(20) << setiosflags(ios::fixed);
ll n, m, p;
cin >> n >> m >> p;
vector<ll> E[5010], E_rev[5010];
vector<edge> E_log;
rep(i, n) {
ll a, b, c;
cin >> a >> b >> c;
a--, b--, c = p - c;
E_log.push_back({a, b, c});
E[a].push_back(b);
E_rev[b].push_back(a);
}
bool s[2510] = {}, g[2510] = {};
s[0] = g[n - 1] = true;
queue<ll> que;
que.push(0);
while (!que.empty()) {
ll q = que.front();
que.pop();
for (auto to : E[q]) {
if (!s[to]) {
que.push(to);
s[to] = true;
}
}
}
que.push(n - 1);
while (!que.empty()) {
ll q = que.front();
que.pop();
for (auto to : E_rev[q]) {
if (!g[to]) {
que.push(to);
g[to] = true;
}
}
}
BellmanFord bf(n);
for (auto e : E_log) {
if (s[e.from] && g[e.to])
bf.E.push_back(e);
}
if (bf.find_any_negative_loop())
finish();
bf.calc(0);
cout << max(0LL, -bf.d[n - 1]) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
//#include <boost/multiprecision/cpp_int.hpp>
// using multiInt = boost::multiprecision::cpp_int;
using ll = long long int;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename Q_temp>
using smaller_queue = priority_queue<Q_temp, vector<Q_temp>, greater<Q_temp>>;
const ll MOD = (ll)(1e9 + 7);
const int INF = (int)1e9;
const ll LINF = (ll)2e18;
const double PI = acos(-1.0);
#define REP(i, m, n) for (ll i = m; i < (ll)(n); ++i)
#define rep(i, n) REP(i, 0, n)
#define MP make_pair
#define MT make_tuple
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define Possible(n) cout << ((n) ? "Possible" : "Impossible") << endl
#define all(v) v.begin(), v.end()
#define NP(v) next_permutation(all(v))
#define dbg(x) cerr << #x << ":" << x << endl;
vector<int> Dx = {0, 0, -1, 1, -1, 1, -1, 1, 0};
vector<int> Dy = {1, -1, 0, 0, -1, -1, 1, 1, 0};
const ll MAX_V = 200010;
struct edge {
ll from, to;
ll cost;
};
class BellmanFord {
public:
ll V;
vector<edge> E;
ll d[MAX_V];
BellmanFord(ll V_num) : V(V_num) {}
void calc(ll s) {
rep(i, V + 1) d[i] = LINF;
d[s] = 0;
bool update;
while (1) {
update = false;
for (auto e : E) {
if (d[e.from] != LINF && d[e.to] > d[e.from] + e.cost) {
d[e.to] = d[e.from] + e.cost;
update = true;
}
}
if (!update)
return;
}
}
bool calc_and_find_negative_loop(ll s, ll g) {
ll negative[MAX_V];
rep(i, V + 1) d[i] = LINF;
d[s] = 0;
rep(i, V) {
bool update = false;
for (auto e : E) {
if (d[e.from] != LINF && d[e.to] > d[e.from] + e.cost) {
d[e.to] = d[e.from] + e.cost;
update = true;
if (i == V - 1)
negative[e.from] = negative[e.to] = true;
}
}
if (!update)
return false;
}
return negative[g];
}
bool find_any_negative_loop() {
ll d_[MAX_V];
rep(i, V) for (auto e : E) {
if (d_[e.to] > d_[e.from] + e.cost) {
d_[e.to] = d_[e.from] + e.cost;
if (i == V - 1)
return true;
}
}
return false;
}
};
inline void finish() {
cout << -1 << endl;
exit(0);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(20) << setiosflags(ios::fixed);
ll n, m, p;
cin >> n >> m >> p;
vector<ll> E[5010], E_rev[5010];
vector<edge> E_log;
rep(i, m) {
ll a, b, c;
cin >> a >> b >> c;
a--, b--, c = p - c;
E_log.push_back({a, b, c});
E[a].push_back(b);
E_rev[b].push_back(a);
}
bool s[2510] = {}, g[2510] = {};
s[0] = g[n - 1] = true;
queue<ll> que;
que.push(0);
while (!que.empty()) {
ll q = que.front();
que.pop();
for (auto to : E[q]) {
if (!s[to]) {
que.push(to);
s[to] = true;
}
}
}
que.push(n - 1);
while (!que.empty()) {
ll q = que.front();
que.pop();
for (auto to : E_rev[q]) {
if (!g[to]) {
que.push(to);
g[to] = true;
}
}
}
BellmanFord bf(n);
for (auto e : E_log) {
if (s[e.from] && g[e.to])
bf.E.push_back(e);
}
if (bf.find_any_negative_loop())
finish();
bf.calc(0);
cout << max(0LL, -bf.d[n - 1]) << endl;
return 0;
}
| [] | 751,141 | 751,142 | u878615689 | cpp |
p02949 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
const int INF = 1001001001;
vector<int> to[2505];
vector<int> ot[2505];
bool reach[2505];
bool reach1[2505];
bool ok[2505];
void dfs(int i) {
if (reach[i])
return;
reach[i] = true;
for (int j : to[i]) {
dfs(j);
}
}
void dfs1(int i) {
if (reach1[i])
return;
reach1[i] = true;
for (int j : ot[i]) {
dfs1(j);
}
}
int main() {
int n, m, p;
cin >> n >> m >> p;
vector<tuple<int, int, int>> edges;
rep(i, m) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
c -= p;
c = -c;
edges.emplace_back(a, b, c);
to[a].push_back(b);
ot[b].push_back(a);
}
dfs(0);
dfs1(n - 1);
rep(i, n) { ok[i] = reach[i] & reach1[i]; }
int step = 0;
bool flg = true;
vector<int> d(n, INF);
d[0] = 0;
while (true) {
flg = false;
rep(i, m) {
int a, b, c;
tie(a, b, c) = edges[i];
if (!ok[a])
continue;
if (!ok[b])
continue;
int newD = d[a] + c;
if (newD < d[b]) {
d[b] = newD;
flg = true;
}
}
step++;
if (step > n) {
puts("-1");
return 0;
}
}
int ans = -d[n - 1];
ans = max(0, ans);
cout << ans << endl;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
const int INF = 1001001001;
vector<int> to[2505];
vector<int> ot[2505];
bool reach[2505];
bool reach1[2505];
bool ok[2505];
void dfs(int i) {
if (reach[i])
return;
reach[i] = true;
for (int j : to[i]) {
dfs(j);
}
}
void dfs1(int i) {
if (reach1[i])
return;
reach1[i] = true;
for (int j : ot[i]) {
dfs1(j);
}
}
int main() {
int n, m, p;
cin >> n >> m >> p;
vector<tuple<int, int, int>> edges;
rep(i, m) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
c -= p;
c = -c;
edges.emplace_back(a, b, c);
to[a].push_back(b);
ot[b].push_back(a);
}
dfs(0);
dfs1(n - 1);
rep(i, n) { ok[i] = reach[i] & reach1[i]; }
int step = 0;
bool flg = true;
vector<int> d(n, INF);
d[0] = 0;
while (flg) {
flg = false;
rep(i, m) {
int a, b, c;
tie(a, b, c) = edges[i];
if (!ok[a])
continue;
if (!ok[b])
continue;
int newD = d[a] + c;
if (newD < d[b]) {
d[b] = newD;
flg = true;
}
}
step++;
if (step > n) {
puts("-1");
return 0;
}
}
int ans = -d[n - 1];
ans = max(0, ans);
cout << ans << endl;
}
| [
"control_flow.loop.condition.change"
] | 751,143 | 751,144 | u147556624 | cpp |
p02949 | #define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#pragma comment(linker, "/STACK:16777216")
#pragma warning(disable : 6031)
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define all(a) (a).begin(), (a).end()
#define sz(a) (int)(a).size()
#define eps (1e-9)
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
typedef tuple<int, int, int> tiii;
const long long inf = 1e12;
int main() {
#ifdef LOCAL_MACHINE
freopen("input.txt", "rt", stdin);
freopen("output.txt", "wt", stdout);
#endif
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << setprecision(18) << fixed;
int n, m, p;
cin >> n >> m >> p;
vector<tiii> g;
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
g.emplace_back(a, b, -(c - p));
}
vector<ll> d(n, LLONG_MAX);
d[0] = 0;
for (int i = 0; i < 2 * n; i++) {
for (int j = 0; j < m; j++) {
int a, b, c;
a = get<0>(g[j]);
b = get<1>(g[j]);
c = get<2>(g[j]);
if (d[a] < LLONG_MAX) {
if (d[b] > d[a] + c) {
if (i < n - 1) {
d[b] = d[a] + c;
} else
d[b] = -inf;
}
}
}
}
if (d[n - 1] <= -inf)
cout << -1;
else if (d[n - 1] >= 0)
cout << 0;
else
cout << d[n - 1];
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#pragma comment(linker, "/STACK:16777216")
#pragma warning(disable : 6031)
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define all(a) (a).begin(), (a).end()
#define sz(a) (int)(a).size()
#define eps (1e-9)
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
typedef tuple<int, int, int> tiii;
const long long inf = 1e12;
int main() {
#ifdef LOCAL_MACHINE
freopen("input.txt", "rt", stdin);
freopen("output.txt", "wt", stdout);
#endif
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << setprecision(18) << fixed;
int n, m, p;
cin >> n >> m >> p;
vector<tiii> g;
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
g.emplace_back(a, b, -(c - p));
}
vector<ll> d(n, LLONG_MAX);
d[0] = 0;
for (int i = 0; i < 2 * n; i++) {
for (int j = 0; j < m; j++) {
int a, b, c;
a = get<0>(g[j]);
b = get<1>(g[j]);
c = get<2>(g[j]);
if (d[a] < LLONG_MAX) {
if (d[b] > d[a] + c) {
if (i < n - 1) {
d[b] = d[a] + c;
} else
d[b] = -inf;
}
}
}
}
if (d[n - 1] <= -inf)
cout << -1;
else if (d[n - 1] >= 0)
cout << 0;
else
cout << -d[n - 1];
return 0;
} | [
"expression.operation.unary.add"
] | 751,151 | 751,152 | u648324897 | cpp |
p02949 | #define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#pragma comment(linker, "/STACK:16777216")
#pragma warning(disable : 6031)
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define all(a) (a).begin(), (a).end()
#define sz(a) (int)(a).size()
#define eps (1e-9)
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
typedef tuple<int, int, int> tiii;
const long long inf = 1e12;
int main() {
#ifdef LOCAL_MACHINE
freopen("input.txt", "rt", stdin);
freopen("output.txt", "wt", stdout);
#endif
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << setprecision(18) << fixed;
int n, m, p;
cin >> n >> m >> p;
vector<tiii> g;
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
g.emplace_back(a, b, -(c - p));
}
vector<ll> d(n, LLONG_MAX);
d[0] = 0;
for (int i = 0; i < 2 * n; i++) {
for (int j = 0; j < m; j++) {
int a, b, c;
a = get<0>(g[j]);
b = get<1>(g[j]);
c = get<2>(g[j]);
if (d[a] < LLONG_MAX) {
if (d[b] > d[a] + c) {
if (i < n - 1) {
d[b] = d[a] + c;
} else
d[b] = -inf;
}
}
}
}
if (d[n - 1] == -inf)
cout << -1;
else if (d[n - 1] >= 0)
cout << 0;
else
cout << d[n - 1];
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#pragma comment(linker, "/STACK:16777216")
#pragma warning(disable : 6031)
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define all(a) (a).begin(), (a).end()
#define sz(a) (int)(a).size()
#define eps (1e-9)
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
typedef tuple<int, int, int> tiii;
const long long inf = 1e12;
int main() {
#ifdef LOCAL_MACHINE
freopen("input.txt", "rt", stdin);
freopen("output.txt", "wt", stdout);
#endif
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << setprecision(18) << fixed;
int n, m, p;
cin >> n >> m >> p;
vector<tiii> g;
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
g.emplace_back(a, b, -(c - p));
}
vector<ll> d(n, LLONG_MAX);
d[0] = 0;
for (int i = 0; i < 2 * n; i++) {
for (int j = 0; j < m; j++) {
int a, b, c;
a = get<0>(g[j]);
b = get<1>(g[j]);
c = get<2>(g[j]);
if (d[a] < LLONG_MAX) {
if (d[b] > d[a] + c) {
if (i < n - 1) {
d[b] = d[a] + c;
} else
d[b] = -inf;
}
}
}
}
if (d[n - 1] <= -inf)
cout << -1;
else if (d[n - 1] >= 0)
cout << 0;
else
cout << -d[n - 1];
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"expression.operation.unary.add"
] | 751,153 | 751,152 | u648324897 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
#define rep(i, m, n) for (ll i = (m); i <= (n); i++)
#define rrep(i, m, n) for (ll i = (m); i >= (n); i--)
#define print(x) cout << (x) << endl;
#define printa(x, m, n) \
for (ll i = (m); i <= n; i++) { \
cout << (x[i]) << " "; \
} \
cout << endl;
struct bellman_fold { // 1-origin
vector<ll> min_dst;
vector<vector<ll>> edge;
ll ans;
bellman_fold(ll n) { min_dst.resize(n); }
void append(ll u, ll v, ll cost) { edge.push_back({u - 1, v - 1, cost}); }
void run(ll s) {
fill(min_dst.begin(), min_dst.end(), 1e18);
min_dst[s - 1] = 0;
for (ll ite = 1; ite < min_dst.size(); ite++) {
for (ll j = 0; j < edge.size(); j++) {
if (min_dst[edge[j][0]] != 1e18 &&
min_dst[edge[j][0]] + edge[j][2] < min_dst[edge[j][1]]) {
min_dst[edge[j][1]] = min_dst[edge[j][0]] + edge[j][2];
}
}
}
}
ll get(ll at) { return min_dst[at - 1]; }
bool loop() {
for (ll ite = 1; ite <= min_dst.size(); ite++) {
for (ll j = 0; j < edge.size(); j++) {
if (min_dst[edge[j][0]] != 1e18 &&
min_dst[edge[j][0]] + edge[j][2] < min_dst[edge[j][1]]) {
min_dst[edge[j][1]] = -1e18;
}
}
}
if (min_dst[min_dst.size() - 1] <= -1e18) {
return true;
} else {
return false;
}
}
};
ll n, m, p, a, b, c;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m >> p;
bellman_fold bf(n);
rep(i, 1, n) {
cin >> a >> b >> c;
bf.append(a, b, -c + p);
}
bf.run(1);
if (bf.loop()) {
print(-1)
} else {
print(max(-bf.get(n), 0LL))
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
#define rep(i, m, n) for (ll i = (m); i <= (n); i++)
#define rrep(i, m, n) for (ll i = (m); i >= (n); i--)
#define print(x) cout << (x) << endl;
#define printa(x, m, n) \
for (ll i = (m); i <= n; i++) { \
cout << (x[i]) << " "; \
} \
cout << endl;
struct bellman_fold { // 1-origin
vector<ll> min_dst;
vector<vector<ll>> edge;
ll ans;
bellman_fold(ll n) { min_dst.resize(n); }
void append(ll u, ll v, ll cost) { edge.push_back({u - 1, v - 1, cost}); }
void run(ll s) {
fill(min_dst.begin(), min_dst.end(), 1e18);
min_dst[s - 1] = 0;
for (ll ite = 1; ite < min_dst.size(); ite++) {
for (ll j = 0; j < edge.size(); j++) {
if (min_dst[edge[j][0]] != 1e18 &&
min_dst[edge[j][0]] + edge[j][2] < min_dst[edge[j][1]]) {
min_dst[edge[j][1]] = min_dst[edge[j][0]] + edge[j][2];
}
}
}
}
ll get(ll at) { return min_dst[at - 1]; }
bool loop() {
for (ll ite = 1; ite <= min_dst.size(); ite++) {
for (ll j = 0; j < edge.size(); j++) {
if (min_dst[edge[j][0]] != 1e18 &&
min_dst[edge[j][0]] + edge[j][2] < min_dst[edge[j][1]]) {
min_dst[edge[j][1]] = -1e18;
}
}
}
if (min_dst[min_dst.size() - 1] <= -1e18) {
return true;
} else {
return false;
}
}
};
ll n, m, p, a, b, c;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m >> p;
bellman_fold bf(n);
rep(i, 1, m) {
cin >> a >> b >> c;
bf.append(a, b, -c + p);
}
bf.run(1);
if (bf.loop()) {
print(-1)
} else {
print(max(-bf.get(n), 0LL))
}
return 0;
} | [
"identifier.change",
"call.arguments.change"
] | 751,156 | 751,157 | u388697579 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
#define rep(i, m, n) for (ll i = (m); i <= (n); i++)
#define rrep(i, m, n) for (ll i = (m); i >= (n); i--)
#define print(x) cout << (x) << endl;
#define printa(x, m, n) \
for (ll i = (m); i <= n; i++) { \
cout << (x[i]) << " "; \
} \
cout << endl;
struct bellman_fold { // 1-origin
vector<ll> min_dst;
vector<vector<ll>> edge;
ll ans;
bellman_fold(ll n) { min_dst.resize(n); }
void append(ll u, ll v, ll cost) { edge.push_back({u - 1, v - 1, cost}); }
void run(ll s) {
fill(min_dst.begin(), min_dst.end(), 1e18);
min_dst[s - 1] = 0;
for (ll ite = 1; ite < min_dst.size(); ite++) {
for (ll j = 0; j < edge.size(); j++) {
if (min_dst[edge[j][0]] != 1e18 &&
min_dst[edge[j][0]] + edge[j][2] < min_dst[edge[j][1]]) {
min_dst[edge[j][1]] = min_dst[edge[j][0]] + edge[j][2];
}
}
}
}
ll get(ll at) { return min_dst[at - 1]; }
bool loop() {
for (ll ite = 1; ite < min_dst.size(); ite++) {
for (ll j = 0; j < edge.size(); j++) {
if (min_dst[edge[j][0]] != 1e18 &&
min_dst[edge[j][0]] + edge[j][2] < min_dst[edge[j][1]]) {
min_dst[edge[j][1]] = -1e18;
}
}
}
if (min_dst[min_dst.size() - 1] <= -1e18) {
return true;
} else {
return false;
}
}
};
ll n, m, p, a, b, c;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m >> p;
bellman_fold bf(n);
rep(i, 1, n) {
cin >> a >> b >> c;
bf.append(a, b, -c + p);
}
bf.run(1);
if (bf.loop()) {
print(-1)
} else {
print(max(-bf.get(n), 0LL))
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
#define rep(i, m, n) for (ll i = (m); i <= (n); i++)
#define rrep(i, m, n) for (ll i = (m); i >= (n); i--)
#define print(x) cout << (x) << endl;
#define printa(x, m, n) \
for (ll i = (m); i <= n; i++) { \
cout << (x[i]) << " "; \
} \
cout << endl;
struct bellman_fold { // 1-origin
vector<ll> min_dst;
vector<vector<ll>> edge;
ll ans;
bellman_fold(ll n) { min_dst.resize(n); }
void append(ll u, ll v, ll cost) { edge.push_back({u - 1, v - 1, cost}); }
void run(ll s) {
fill(min_dst.begin(), min_dst.end(), 1e18);
min_dst[s - 1] = 0;
for (ll ite = 1; ite < min_dst.size(); ite++) {
for (ll j = 0; j < edge.size(); j++) {
if (min_dst[edge[j][0]] != 1e18 &&
min_dst[edge[j][0]] + edge[j][2] < min_dst[edge[j][1]]) {
min_dst[edge[j][1]] = min_dst[edge[j][0]] + edge[j][2];
}
}
}
}
ll get(ll at) { return min_dst[at - 1]; }
bool loop() {
for (ll ite = 1; ite <= min_dst.size(); ite++) {
for (ll j = 0; j < edge.size(); j++) {
if (min_dst[edge[j][0]] != 1e18 &&
min_dst[edge[j][0]] + edge[j][2] < min_dst[edge[j][1]]) {
min_dst[edge[j][1]] = -1e18;
}
}
}
if (min_dst[min_dst.size() - 1] <= -1e18) {
return true;
} else {
return false;
}
}
};
ll n, m, p, a, b, c;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m >> p;
bellman_fold bf(n);
rep(i, 1, m) {
cin >> a >> b >> c;
bf.append(a, b, -c + p);
}
bf.run(1);
if (bf.loop()) {
print(-1)
} else {
print(max(-bf.get(n), 0LL))
}
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"identifier.change",
"call.arguments.change"
] | 751,158 | 751,157 | u388697579 | cpp |
p02949 | #include <algorithm>
#include <climits>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
using P = pair<long, long>;
typedef long long int ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
#define fillInt(xs) \
for (int i = 0; i < (xs).size(); i++) \
scanf("%d", &xs[i]);
#define fillLong(xs) \
for (int i = 0; i < (xs).size(); i++) \
scanf("%ld", &xs[i]);
#define fillDouble(xs) \
for (int i = 0; i < (xs).size(); i++) \
scanf("%lf", &xs[i]);
#define fillString(xs) \
for (int i = 0; i < (xs).size(); i++) \
cin >> xs[i];
#define sortv(xs) sort(xs.begin(), xs.end())
#define sortvinv(xs) sort(xs.begin(), xs.end(), std::greater<long>())
#define lbv(xs, x) lower_bound(xs.begin(), xs.end(), x) - xs.begin()
#define ubv(xs, x) upper_bound(xs.begin(), xs.end(), x) - xs.begin()
#define bs(xs, x) binary_search(xs.begin(), xs.end(), x)
#define index_of(as, x) \
distance(as.begin(), lower_bound(as.begin(), as.end(), x))
#define rad_to_deg(rad) (((rad) / 2 / M_PI) * 360)
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define concat(xs, ys) (xs).insert((xs).end(), (ys).begin(), (ys).end())
const int mod = 1000000007;
struct edge {
long to;
long cost;
};
const int MAX_V = 100005;
vector<edge> G[MAX_V];
vector<edge> Ginv[MAX_V];
long d[MAX_V];
long n;
bool use1[MAX_V];
bool usen[MAX_V];
bool bellmanFord(long s) {
fill(d, d + n, INF * INF);
d[s] = 0;
for (int i = 0; i < n; i++) {
for (int v = 0; v < n; v++) {
if (!use1[v] || !usen[v])
continue;
for (int k = 0; k < G[v].size(); k++) {
edge e = G[v][k];
if (d[v] != INF * INF && d[e.to] > d[v] + e.cost) {
d[e.to] = d[v] + e.cost;
if (i == n - 1) {
return true;
}
}
}
}
}
return false;
}
void dfs(long s) {
if (use1[s])
return;
use1[s] = true;
for (auto v : G[s]) {
dfs(v.to);
}
return;
}
void dfsn(long s) {
if (usen[s])
return;
usen[s] = true;
for (auto v : Ginv[s]) {
dfs(v.to);
}
return;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
long m, p;
cin >> n >> m >> p;
rep(i, m) {
long a, b, c;
cin >> a >> b >> c;
a--;
b--;
G[a].push_back({b, p - c});
Ginv[b].push_back({a, p - c});
}
dfs(0);
dfsn(n - 1);
bool res = bellmanFord(0);
cout << (res ? -1 : max(0L, -d[n - 1])) << endl;
}
| #include <algorithm>
#include <climits>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
using P = pair<long, long>;
typedef long long int ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
#define fillInt(xs) \
for (int i = 0; i < (xs).size(); i++) \
scanf("%d", &xs[i]);
#define fillLong(xs) \
for (int i = 0; i < (xs).size(); i++) \
scanf("%ld", &xs[i]);
#define fillDouble(xs) \
for (int i = 0; i < (xs).size(); i++) \
scanf("%lf", &xs[i]);
#define fillString(xs) \
for (int i = 0; i < (xs).size(); i++) \
cin >> xs[i];
#define sortv(xs) sort(xs.begin(), xs.end())
#define sortvinv(xs) sort(xs.begin(), xs.end(), std::greater<long>())
#define lbv(xs, x) lower_bound(xs.begin(), xs.end(), x) - xs.begin()
#define ubv(xs, x) upper_bound(xs.begin(), xs.end(), x) - xs.begin()
#define bs(xs, x) binary_search(xs.begin(), xs.end(), x)
#define index_of(as, x) \
distance(as.begin(), lower_bound(as.begin(), as.end(), x))
#define rad_to_deg(rad) (((rad) / 2 / M_PI) * 360)
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define concat(xs, ys) (xs).insert((xs).end(), (ys).begin(), (ys).end())
const int mod = 1000000007;
struct edge {
long to;
long cost;
};
const int MAX_V = 100005;
vector<edge> G[MAX_V];
vector<edge> Ginv[MAX_V];
long d[MAX_V];
long n;
bool use1[MAX_V];
bool usen[MAX_V];
bool bellmanFord(long s) {
fill(d, d + n, INF * INF);
d[s] = 0;
for (int i = 0; i < n; i++) {
for (int v = 0; v < n; v++) {
if (!use1[v] || !usen[v])
continue;
for (int k = 0; k < G[v].size(); k++) {
edge e = G[v][k];
if (d[v] != INF * INF && d[e.to] > d[v] + e.cost) {
d[e.to] = d[v] + e.cost;
if (i == n - 1) {
return true;
}
}
}
}
}
return false;
}
void dfs(long s) {
if (use1[s])
return;
use1[s] = true;
for (auto v : G[s]) {
dfs(v.to);
}
return;
}
void dfsn(long s) {
if (usen[s])
return;
usen[s] = true;
for (auto v : Ginv[s]) {
dfsn(v.to);
}
return;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
long m, p;
cin >> n >> m >> p;
rep(i, m) {
long a, b, c;
cin >> a >> b >> c;
a--;
b--;
G[a].push_back({b, p - c});
Ginv[b].push_back({a, p - c});
}
dfs(0);
dfsn(n - 1);
bool res = bellmanFord(0);
cout << (res ? -1 : max(0L, -d[n - 1])) << endl;
}
| [
"identifier.change",
"call.function.change"
] | 751,159 | 751,160 | u917048429 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
using i64 = int_fast64_t;
#define rep(i, N) for (int(i) = 0; (i) < (N); (i)++)
using GraphType = vector<vector<pair<int, i64>>>;
template <typename Int>
bool Bellman_Ford(GraphType &Graph, vector<Int> &dist, int V, int start) {
dist[start] = 0;
for (int i = 0; i < V; ++i) {
for (int v = 0; v < V; ++v) {
for (auto &e : Graph[v]) {
if (dist[v] == 1e18)
continue;
if (dist[e.first] > dist[v] + e.second) {
dist[e.first] = dist[v] + e.second;
if (i == V - 1)
return true;
}
}
}
}
return false;
}
int main() {
i64 N, M, P;
cin >> N >> M >> P;
vector<int> A(M), B(M);
vector<i64> C(M);
rep(i, M) cin >> A[i] >> B[i] >> C[i], A[i]--, B[i]--;
vector<i64> C_inv(M);
rep(i, M) C_inv[i] = -(C[i] - P);
vector<bool> visited(N, false);
{
vector<vector<int>> Graph(N);
rep(i, M) Graph[B[i]].emplace_back(A[i]);
function<void(int)> dfs = [&](int v) {
visited[v] = 1;
for (int nxt : Graph[v]) {
if (visited[nxt])
continue;
dfs(nxt);
}
};
dfs(N - 1);
}
vector<vector<pair<int, i64>>> Graph(N);
vector<i64> dist(N, 1e18);
rep(i, M) {
if (!visited[A[i]] || !visited[B[i]])
continue;
Graph[A[i]].emplace_back(make_pair(B[i], C_inv[i]));
}
bool circle = Bellman_Ford(Graph, dist, N - 1, 0);
if (circle)
cout << -1 << endl;
else
cout << max(-dist[N - 1], (i64)0) << endl;
} | #include <bits/stdc++.h>
using namespace std;
using i64 = int_fast64_t;
#define rep(i, N) for (int(i) = 0; (i) < (N); (i)++)
using GraphType = vector<vector<pair<int, int>>>;
template <typename Int>
bool Bellman_Ford(GraphType &Graph, vector<Int> &dist, int V, int start) {
dist[start] = 0;
for (int i = 0; i < V; ++i) {
for (int v = 0; v < V; ++v) {
for (auto &e : Graph[v]) {
if (dist[v] == 1e18)
continue;
if (dist[e.first] > dist[v] + e.second) {
dist[e.first] = dist[v] + e.second;
if (i == V - 1)
return true;
}
}
}
}
return false;
}
int main() {
i64 N, M, P;
cin >> N >> M >> P;
vector<int> A(M), B(M);
vector<i64> C(M);
rep(i, M) cin >> A[i] >> B[i] >> C[i], A[i]--, B[i]--;
vector<i64> C_inv(M);
rep(i, M) C_inv[i] = -(C[i] - P);
vector<bool> visited(N, false);
{
vector<vector<int>> Graph(N);
rep(i, M) Graph[B[i]].emplace_back(A[i]);
function<void(int)> dfs = [&](int v) {
visited[v] = 1;
for (int nxt : Graph[v]) {
if (visited[nxt])
continue;
dfs(nxt);
}
};
dfs(N - 1);
}
vector<vector<pair<int, int>>> Graph(N);
vector<i64> dist(N, 1e18);
rep(i, M) {
if (!visited[A[i]] || !visited[B[i]])
continue;
Graph[A[i]].emplace_back(make_pair(B[i], C_inv[i]));
}
bool circle = Bellman_Ford(Graph, dist, N, 0);
if (circle)
cout << -1 << endl;
else
cout << max(-dist[N - 1], (i64)0) << endl;
}
| [
"expression.operation.binary.remove"
] | 751,161 | 751,162 | u031178961 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
using i64 = int_fast64_t;
#define rep(i, N) for (int(i) = 0; (i) < (N); (i)++)
using GraphType = vector<vector<pair<int, int>>>;
template <typename Int>
bool Bellman_Ford(GraphType &Graph, vector<Int> &dist, int V, int start) {
dist[start] = 0;
for (int i = 0; i < V; ++i) {
for (int v = 0; v < V; ++v) {
for (auto &e : Graph[v]) {
if (dist[v] == 1e18)
continue;
if (dist[e.first] > dist[v] + e.second) {
dist[e.first] = dist[v] + e.second;
if (i == V - 1)
return true;
}
}
}
}
return false;
}
int main() {
i64 N, M, P;
cin >> N >> M >> P;
vector<int> A(M), B(M);
vector<i64> C(M);
rep(i, M) cin >> A[i] >> B[i] >> C[i], A[i]--, B[i]--;
vector<i64> C_inv(M);
rep(i, M) C_inv[i] = -(C[i] - P);
vector<bool> visited(N, false);
{
vector<vector<int>> Graph(N);
rep(i, M) Graph[B[i]].emplace_back(A[i]);
function<void(int)> dfs = [&](int v) {
visited[v] = 1;
for (int nxt : Graph[v]) {
if (visited[nxt])
continue;
dfs(nxt);
}
};
dfs(N - 1);
}
vector<vector<pair<int, int>>> Graph(N);
vector<i64> dist(N, 1e18);
rep(i, M) {
if (!visited[A[i]] || !visited[B[i]])
continue;
Graph[A[i]].emplace_back(make_pair(B[i], C_inv[i]));
}
bool circle = Bellman_Ford(Graph, dist, N - 1, 0);
if (circle)
cout << -1 << endl;
else
cout << max(-dist[N - 1], (i64)0) << endl;
} | #include <bits/stdc++.h>
using namespace std;
using i64 = int_fast64_t;
#define rep(i, N) for (int(i) = 0; (i) < (N); (i)++)
using GraphType = vector<vector<pair<int, int>>>;
template <typename Int>
bool Bellman_Ford(GraphType &Graph, vector<Int> &dist, int V, int start) {
dist[start] = 0;
for (int i = 0; i < V; ++i) {
for (int v = 0; v < V; ++v) {
for (auto &e : Graph[v]) {
if (dist[v] == 1e18)
continue;
if (dist[e.first] > dist[v] + e.second) {
dist[e.first] = dist[v] + e.second;
if (i == V - 1)
return true;
}
}
}
}
return false;
}
int main() {
i64 N, M, P;
cin >> N >> M >> P;
vector<int> A(M), B(M);
vector<i64> C(M);
rep(i, M) cin >> A[i] >> B[i] >> C[i], A[i]--, B[i]--;
vector<i64> C_inv(M);
rep(i, M) C_inv[i] = -(C[i] - P);
vector<bool> visited(N, false);
{
vector<vector<int>> Graph(N);
rep(i, M) Graph[B[i]].emplace_back(A[i]);
function<void(int)> dfs = [&](int v) {
visited[v] = 1;
for (int nxt : Graph[v]) {
if (visited[nxt])
continue;
dfs(nxt);
}
};
dfs(N - 1);
}
vector<vector<pair<int, int>>> Graph(N);
vector<i64> dist(N, 1e18);
rep(i, M) {
if (!visited[A[i]] || !visited[B[i]])
continue;
Graph[A[i]].emplace_back(make_pair(B[i], C_inv[i]));
}
bool circle = Bellman_Ford(Graph, dist, N, 0);
if (circle)
cout << -1 << endl;
else
cout << max(-dist[N - 1], (i64)0) << endl;
}
| [
"expression.operation.binary.remove"
] | 751,163 | 751,162 | u031178961 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
using i64 = int_fast64_t;
#define rep(i, N) for (int(i) = 0; (i) < (N); (i)++)
struct edge {
int from, to;
i64 wei;
};
using GraphType = vector<edge>;
template <typename Int>
bool Bellman_Ford(GraphType &Graph, vector<Int> &dist, int V, int start) {
dist[start] = 0;
for (int v = 0; v < V; ++v) {
for (auto &e : Graph) {
if (dist[e.from] == 1e18)
continue;
if (dist[e.to] > dist[e.from] + e.wei) {
dist[e.to] = dist[e.from] + e.wei;
if (v == V - 1)
return true;
}
}
}
return false;
}
int main() {
i64 N, M, P;
cin >> N >> M >> P;
vector<int> A(M), B(M);
vector<i64> C(M);
rep(i, M) cin >> A[i] >> B[i] >> C[i], A[i]--, B[i]--;
vector<i64> C_inv(M);
rep(i, M) C_inv[i] = -(C[i] - P);
vector<bool> visited_start(N, false);
vector<bool> visited_end(N, false);
{
vector<vector<int>> Graph_start(N);
vector<vector<int>> Graph_end(N);
rep(i, M) {
Graph_start[A[i]].emplace_back(B[i]);
Graph_end[B[i]].emplace_back(A[i]);
}
function<void(vector<vector<int>> &, vector<bool> &, int)> dfs =
[&](vector<vector<int>> &Graph, vector<bool> &visited, int v) {
visited[v] = 1;
for (int nxt : Graph[v]) {
if (visited[nxt])
continue;
dfs(Graph, visited, nxt);
}
};
dfs(Graph_start, visited_start, 0);
dfs(Graph_end, visited_end, N - 1);
}
vector<edge> Graph(N);
vector<i64> dist(N, 1e18);
rep(i, M) {
if (visited_start[A[i]] && visited_end[A[i]] && visited_start[B[i]] &&
visited_end[B[i]])
Graph.push_back({A[i], B[i], C_inv[i]});
}
bool circle = Bellman_Ford(Graph, dist, N - 1, 0);
if (circle)
cout << -1 << endl;
else
cout << max(-dist[N - 1], (i64)0) << endl;
} | #include <bits/stdc++.h>
using namespace std;
using i64 = int_fast64_t;
#define rep(i, N) for (int(i) = 0; (i) < (N); (i)++)
struct edge {
int from, to;
i64 wei;
};
using GraphType = vector<edge>;
template <typename Int>
bool Bellman_Ford(GraphType &Graph, vector<Int> &dist, int V, int start) {
dist[start] = 0;
for (int v = 0; v < V; ++v) {
for (auto &e : Graph) {
if (dist[e.from] == 1e18)
continue;
if (dist[e.to] > dist[e.from] + e.wei) {
dist[e.to] = dist[e.from] + e.wei;
if (v == V - 1)
return true;
}
}
}
return false;
}
int main() {
i64 N, M, P;
cin >> N >> M >> P;
vector<int> A(M), B(M);
vector<i64> C(M);
rep(i, M) cin >> A[i] >> B[i] >> C[i], A[i]--, B[i]--;
vector<i64> C_inv(M);
rep(i, M) C_inv[i] = -(C[i] - P);
vector<bool> visited_start(N, false);
vector<bool> visited_end(N, false);
{
vector<vector<int>> Graph_start(N);
vector<vector<int>> Graph_end(N);
rep(i, M) {
Graph_start[A[i]].emplace_back(B[i]);
Graph_end[B[i]].emplace_back(A[i]);
}
function<void(vector<vector<int>> &, vector<bool> &, int)> dfs =
[&](vector<vector<int>> &Graph, vector<bool> &visited, int v) {
visited[v] = 1;
for (int nxt : Graph[v]) {
if (visited[nxt])
continue;
dfs(Graph, visited, nxt);
}
};
dfs(Graph_start, visited_start, 0);
dfs(Graph_end, visited_end, N - 1);
}
vector<edge> Graph(N);
vector<i64> dist(N, 1e18);
rep(i, M) {
if (visited_start[A[i]] && visited_end[A[i]] && visited_start[B[i]] &&
visited_end[B[i]])
Graph.push_back({A[i], B[i], C_inv[i]});
}
bool circle = Bellman_Ford(Graph, dist, N, 0);
if (circle)
cout << -1 << endl;
else
cout << max(-dist[N - 1], (i64)0) << endl;
} | [
"expression.operation.binary.remove"
] | 751,164 | 751,165 | u031178961 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
using ll = int_fast64_t;
using ld = long double;
using pll = pair<ll, ll>;
using pld = pair<ld, ld>;
const ll INF = 1LL << 60;
void solve();
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
solve();
}
#define fi first
#define se second
#define SELECTOR(_1, _2, _3, SELECT, ...) SELECT
#define rep(...) SELECTOR(__VA_ARGS__, _rep1, _rep0)(__VA_ARGS__)
#define _rep0(i, n) for (ll i = 0; i < n; ++i)
#define _rep1(i, k, n) for (ll i = k; i < n; ++i)
template <class T> vector<T> make_v(size_t a, T b) { return vector<T>(a, b); }
template <class... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v(ts...))>(a, make_v(ts...));
}
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> void contout(const T &v) {
for (auto it = v.begin(); it != v.end();
++it, cout << (it != v.end() ? " " : "\n"))
cout << *it;
}
void solve() {
ll n, m, p;
cin >> n >> m >> p;
vector<tuple<ll, ll, ll>> E;
vector<vector<ll>> to(n), ot(n);
vector<ll> state(n);
rep(_, m) {
ll a, b, c;
cin >> a >> b >> c;
--a;
--b;
to[a].push_back(b);
ot[b].push_back(a);
E.emplace_back(a, b, p - c);
}
// dfs
function<void(ll)> dfs = [&](ll v) {
if (state[v] & 1)
return;
state[v] += 1;
for (ll nv : to[v])
dfs(v);
};
dfs(0);
function<void(ll)> rdfs = [&](ll v) {
if (state[v] & 2)
return;
state[v] += 2;
for (ll nv : ot[v])
rdfs(v);
};
rdfs(n - 1);
// Bellman-Ford
vector<ll> d(n, INF);
d[0] = 0;
rep(step, n) {
for (auto tup : E) {
ll a, b, c;
tie(a, b, c) = tup;
if (!state[a] & 1 || !state[b] & 2)
continue;
if (chmin(d[b], d[a] + c) && step == n - 1) {
cout << -1 << "\n";
return;
}
}
}
cout << max(-d[n - 1], (ll)0) << "\n";
} | #include <bits/stdc++.h>
using namespace std;
using ll = int_fast64_t;
using ld = long double;
using pll = pair<ll, ll>;
using pld = pair<ld, ld>;
const ll INF = 1LL << 60;
void solve();
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
solve();
}
#define fi first
#define se second
#define SELECTOR(_1, _2, _3, SELECT, ...) SELECT
#define rep(...) SELECTOR(__VA_ARGS__, _rep1, _rep0)(__VA_ARGS__)
#define _rep0(i, n) for (ll i = 0; i < n; ++i)
#define _rep1(i, k, n) for (ll i = k; i < n; ++i)
template <class T> vector<T> make_v(size_t a, T b) { return vector<T>(a, b); }
template <class... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v(ts...))>(a, make_v(ts...));
}
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> void contout(const T &v) {
for (auto it = v.begin(); it != v.end();
++it, cout << (it != v.end() ? " " : "\n"))
cout << *it;
}
void solve() {
ll n, m, p;
cin >> n >> m >> p;
vector<tuple<ll, ll, ll>> E;
vector<vector<ll>> to(n), ot(n);
vector<ll> state(n);
rep(_, m) {
ll a, b, c;
cin >> a >> b >> c;
--a;
--b;
to[a].push_back(b);
ot[b].push_back(a);
E.emplace_back(a, b, p - c);
}
// dfs
function<void(ll)> dfs = [&](ll v) {
if (state[v] & 1)
return;
state[v] += 1;
for (ll nv : to[v])
dfs(nv);
};
dfs(0);
function<void(ll)> rdfs = [&](ll v) {
if (state[v] & 2)
return;
state[v] += 2;
for (ll nv : ot[v])
rdfs(nv);
};
rdfs(n - 1);
// Bellman-Ford
vector<ll> d(n, INF);
d[0] = 0;
rep(step, n) {
for (auto tup : E) {
ll a, b, c;
tie(a, b, c) = tup;
if (!(state[a] & 1) || !(state[b] & 2))
continue;
if (chmin(d[b], d[a] + c) && step == n - 1) {
cout << -1 << "\n";
return;
}
}
}
cout << max(-d[n - 1], (ll)0) << "\n";
} | [
"identifier.change",
"call.arguments.change",
"control_flow.branch.if.condition.change"
] | 751,166 | 751,167 | u440566786 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int maxM = 1e5 + 7;
const int maxV = 90010;
const int MOD = 1e9 + 7;
int T;
const int maxN = 1e5 + 8;
const ll INF = 1000000000000000010LL;
const int K = 15;
vector<pii> v[maxN];
ll dis[maxN];
int vis[maxN];
int main() {
int n, m, p;
scanf("%d%d%d", &n, &m, &p);
for (int i = 1; i <= m; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
v[x].push_back(pii(y, z - p));
}
for (int i = 1; i <= n; i++) {
dis[i] = -INF;
}
dis[1] = 0;
queue<int> Q;
Q.push(1);
vis[1]++;
while (!Q.empty()) {
int x = Q.front();
Q.pop();
for (auto e : v[x]) {
int to = e.first;
int w = e.second;
ll d;
if (dis[x] == INF)
d = INF;
else
d = dis[x] + w;
if (dis[to] < d) {
dis[to] = d;
vis[to]++;
if (vis[to] > m)
dis[to] = INF;
else
Q.push(to);
}
}
}
ll ans = max(0ll, dis[n]);
if (ans == INF)
ans = -1;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int maxM = 1e5 + 7;
const int maxV = 90010;
const int MOD = 1e9 + 7;
int T;
const int maxN = 1e5 + 8;
const ll INF = 1000000000000000010LL;
const int K = 15;
vector<pii> v[maxN];
ll dis[maxN];
int vis[maxN];
int main() {
int n, m, p;
scanf("%d%d%d", &n, &m, &p);
for (int i = 1; i <= m; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
v[x].push_back(pii(y, z - p));
}
for (int i = 1; i <= n; i++) {
dis[i] = -INF;
}
dis[1] = 0;
queue<int> Q;
Q.push(1);
vis[1]++;
while (!Q.empty()) {
int x = Q.front();
Q.pop();
for (auto e : v[x]) {
int to = e.first;
int w = e.second;
ll d;
if (dis[x] == INF)
d = INF;
else
d = dis[x] + w;
if (dis[to] < d) {
dis[to] = d;
vis[to]++;
if (vis[to] > m)
dis[to] = INF;
Q.push(to);
}
}
}
ll ans = max(0ll, dis[n]);
if (ans == INF)
ans = -1;
cout << ans << endl;
return 0;
} | [
"control_flow.branch.else.remove"
] | 751,177 | 751,178 | u807919574 | cpp |
p02949 | #include <algorithm>
#include <iostream>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
#define mod 1000000007
#define mad(a, b) a = (a + b) % mod;
#define chmax(a, b) a = max(a, b)
#define N 3010
#define M 5010
ll a[M], b[M], c[M];
ll d[N], e[N];
ll n, m, p;
int main() {
cin >> n >> m >> p;
for (int i = 0; i < m; i++) {
cin >> a[i] >> b[i] >> c[i];
c[i] -= p;
}
for (int i = 1; i <= n; i++)
d[i] = -1e17;
d[1] = 0;
ll bef;
for (int k = 0; k < 10000; k++) {
// for(int i=1;i<=n;i++)e[i]=d[i];
for (int i = 0; i < m; i++) {
if (d[a[i]] == -1e17)
continue;
chmax(d[b[i]], d[a[i]] + c[i]);
}
// for(int i=1;i<=n;i++)d[i]=e[i];
if (k == 9998)
bef = d[n];
if (k == 9999) {
if (bef != d[n]) {
cout << -1 << endl;
return 0;
}
}
}
cout << max(0LL, d[n]) << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
#define mod 1000000007
#define mad(a, b) a = (a + b) % mod;
#define chmax(a, b) a = max(a, b)
#define N 3010
#define M 5010
ll a[M], b[M], c[M];
ll d[N], e[N];
ll n, m, p;
int main() {
cin >> n >> m >> p;
for (int i = 0; i < m; i++) {
cin >> a[i] >> b[i] >> c[i];
c[i] -= p;
}
for (int i = 1; i <= n; i++)
d[i] = -1e17;
d[1] = 0;
ll bef;
for (int k = 0; k < 20000; k++) {
// for(int i=1;i<=n;i++)e[i]=d[i];
for (int i = 0; i < m; i++) {
if (d[a[i]] == -1e17)
continue;
chmax(d[b[i]], d[a[i]] + c[i]);
}
// for(int i=1;i<=n;i++)d[i]=e[i];
if (k == 9998)
bef = d[n];
if (k == 19999) {
if (bef != d[n]) {
cout << -1 << endl;
return 0;
}
}
}
cout << max(0LL, d[n]) << endl;
return 0;
}
| [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change"
] | 751,203 | 751,204 | u924885571 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.