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>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPr(i, n) for (int i = (n)-1; i >= 0; --i)
#define FORq(i, m, n) for (int i = (m); i <= (n); ++i)
#define FORqr(i, m, n) for (int i = (n); i >= (m); --i)
#define PB push_back
#define MP make_pair
#define DEBUG printf("%s\n", "debug")
#define fst first
#define snd second
#define SIN(x, S) (S.count(x) != 0)
#define M0(x) memset(x, 0, sizeof(x))
#define FILL(x, y) memset(x, y, sizeof(x))
#define MM(x) memset(x, -1, sizeof(x))
#define ALL(x) (x).begin(), (x).end()
#define SCD(n) scanf("%d", &n)
#define SCD2(m, n) scanf("%d%d", &m, &n)
#define SCD3(m, n, k) scanf("%d%d%d", &m, &n, &k)
#define SCLLD(n) scanf("%lld", &n)
#define SCLLD2(m, n) scanf("%lld%lld", &m, &n)
#define SCLLD3(m, n, k) scanf("%lld%lld%lld", &m, &n, &k)
using namespace std;
typedef pair<int, int> PII;
typedef pair<long long, long long> PLL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<long long> VL;
typedef long long ll;
typedef long long integer;
///////////////////////////////////////////////
const ll MOD = 1e9 + 7;
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
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;
}
///////////////////////////////////////////////
/*(._.)*/
const long long INF = 9223372036854775000;
const int VMAX = 3000;
const int EMAX = 6000;
struct Edge {
int from;
int to;
int cost;
};
int main() { // 1 --> N minimum cost
ll N, M, P;
cin >> N >> M >> P;
struct Edge e[EMAX];
long long d[VMAX];
bool negcycle[VMAX] = {};
REP(i, M) {
ll a, b, c;
cin >> a >> b >> c;
e[i].from = b;
e[i].to = a; // reverse
e[i].cost = -c + P; // -1
}
REP(i, VMAX) { d[i] = INF; }
d[N] = 0;
REP(i, N - 1) { // loop V times --> NEGCYCLE
bool update = false;
REP(j, M) {
int u = e[j].from;
int v = e[j].to;
int c = e[j].cost;
if ((d[u] + c < d[v]) and (d[u] != INF)) { // s-->uへ現状行けないときを弾く
d[v] = d[u] + c;
update = true;
}
}
}
ll ans = d[1];
REP(i, N) {
REP(j, M) {
int u = e[j].from;
int v = e[j].to;
int c = e[j].cost;
if (d[u] == INF)
continue;
if (d[v] > d[u] + c) {
d[v] = d[u] + c;
negcycle[v] = true;
}
if (negcycle[u] == true) {
negcycle[v] = true;
}
}
}
if (negcycle[N]) {
printf("-1");
return 0;
}
cout << max(0LL, -ans) << endl;
return 0;
}
| #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPr(i, n) for (int i = (n)-1; i >= 0; --i)
#define FORq(i, m, n) for (int i = (m); i <= (n); ++i)
#define FORqr(i, m, n) for (int i = (n); i >= (m); --i)
#define PB push_back
#define MP make_pair
#define DEBUG printf("%s\n", "debug")
#define fst first
#define snd second
#define SIN(x, S) (S.count(x) != 0)
#define M0(x) memset(x, 0, sizeof(x))
#define FILL(x, y) memset(x, y, sizeof(x))
#define MM(x) memset(x, -1, sizeof(x))
#define ALL(x) (x).begin(), (x).end()
#define SCD(n) scanf("%d", &n)
#define SCD2(m, n) scanf("%d%d", &m, &n)
#define SCD3(m, n, k) scanf("%d%d%d", &m, &n, &k)
#define SCLLD(n) scanf("%lld", &n)
#define SCLLD2(m, n) scanf("%lld%lld", &m, &n)
#define SCLLD3(m, n, k) scanf("%lld%lld%lld", &m, &n, &k)
using namespace std;
typedef pair<int, int> PII;
typedef pair<long long, long long> PLL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<long long> VL;
typedef long long ll;
typedef long long integer;
///////////////////////////////////////////////
const ll MOD = 1e9 + 7;
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
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;
}
///////////////////////////////////////////////
/*(._.)*/
const long long INF = 9223372036854775000;
const int VMAX = 3000;
const int EMAX = 5000;
struct Edge {
int from;
int to;
int cost;
};
int main() { // 1 --> N minimum cost
ll N, M, P;
cin >> N >> M >> P;
struct Edge e[EMAX];
long long d[VMAX];
bool negcycle[VMAX] = {};
REP(i, M) {
ll a, b, c;
cin >> a >> b >> c;
e[i].from = b;
e[i].to = a; // reverse
e[i].cost = -c + P; // -1
}
REP(i, VMAX) { d[i] = INF; }
d[N] = 0;
REP(i, N - 1) { // loop V times --> NEGCYCLE
bool update = false;
REP(j, M) {
int u = e[j].from;
int v = e[j].to;
int c = e[j].cost;
if ((d[u] + c < d[v]) and (d[u] != INF)) { // s-->uへ現状行けないときを弾く
d[v] = d[u] + c;
update = true;
}
}
}
ll ans = d[1];
REP(i, N) {
REP(j, M) {
int u = e[j].from;
int v = e[j].to;
int c = e[j].cost;
if (d[u] == INF)
continue;
if (d[v] > d[u] + c) {
d[v] = d[u] + c;
negcycle[v] = true;
}
if (negcycle[u] == true) {
negcycle[v] = true;
}
}
}
if (negcycle[1]) {
printf("-1");
return 0;
}
cout << max(0LL, -ans) << endl;
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 753,934 | 753,936 | u236433947 | cpp |
p02949 | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPr(i, n) for (int i = (n)-1; i >= 0; --i)
#define FORq(i, m, n) for (int i = (m); i <= (n); ++i)
#define FORqr(i, m, n) for (int i = (n); i >= (m); --i)
#define PB push_back
#define MP make_pair
#define DEBUG printf("%s\n", "debug")
#define fst first
#define snd second
#define SIN(x, S) (S.count(x) != 0)
#define M0(x) memset(x, 0, sizeof(x))
#define FILL(x, y) memset(x, y, sizeof(x))
#define MM(x) memset(x, -1, sizeof(x))
#define ALL(x) (x).begin(), (x).end()
#define SCD(n) scanf("%d", &n)
#define SCD2(m, n) scanf("%d%d", &m, &n)
#define SCD3(m, n, k) scanf("%d%d%d", &m, &n, &k)
#define SCLLD(n) scanf("%lld", &n)
#define SCLLD2(m, n) scanf("%lld%lld", &m, &n)
#define SCLLD3(m, n, k) scanf("%lld%lld%lld", &m, &n, &k)
using namespace std;
typedef pair<int, int> PII;
typedef pair<long long, long long> PLL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<long long> VL;
typedef long long ll;
typedef long long integer;
///////////////////////////////////////////////
const ll MOD = 1e9 + 7;
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
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;
}
///////////////////////////////////////////////
/*(._.)*/
const long long INF = 9223372036854775000;
const int VMAX = 3000;
const int EMAX = 5000;
struct Edge {
int from;
int to;
int cost;
};
int main() { // 1 --> N minimum cost
ll N, M, P;
cin >> N >> M >> P;
struct Edge e[EMAX];
long long d[VMAX];
bool negcycle[VMAX] = {};
REP(i, M) {
ll a, b, c;
cin >> a >> b >> c;
e[i].from = b;
e[i].to = a; // reverse
e[i].cost = -c + P; // -1
}
REP(i, VMAX) { d[i] = INF; }
d[N] = 0;
REP(i, N - 1) { // loop V times --> NEGCYCLE
bool update = false;
REP(j, M) {
int u = e[j].from;
int v = e[j].to;
int c = e[j].cost;
if ((d[u] + c < d[v]) and (d[u] != INF)) { // s-->uへ現状行けないときを弾く
d[v] = d[u] + c;
update = true;
}
}
}
ll ans = d[1];
REP(i, N) {
REP(j, M) {
int u = e[j].from;
int v = e[j].to;
int c = e[j].cost;
if (d[u] == INF)
continue;
if (d[v] > d[u] + c) {
d[v] = d[u] + c;
negcycle[v] = true;
}
if (negcycle[u] == true) {
negcycle[v] = true;
}
}
}
if (negcycle[N]) {
printf("-1");
return 0;
}
cout << max(0LL, -ans) << endl;
return 0;
}
| #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPr(i, n) for (int i = (n)-1; i >= 0; --i)
#define FORq(i, m, n) for (int i = (m); i <= (n); ++i)
#define FORqr(i, m, n) for (int i = (n); i >= (m); --i)
#define PB push_back
#define MP make_pair
#define DEBUG printf("%s\n", "debug")
#define fst first
#define snd second
#define SIN(x, S) (S.count(x) != 0)
#define M0(x) memset(x, 0, sizeof(x))
#define FILL(x, y) memset(x, y, sizeof(x))
#define MM(x) memset(x, -1, sizeof(x))
#define ALL(x) (x).begin(), (x).end()
#define SCD(n) scanf("%d", &n)
#define SCD2(m, n) scanf("%d%d", &m, &n)
#define SCD3(m, n, k) scanf("%d%d%d", &m, &n, &k)
#define SCLLD(n) scanf("%lld", &n)
#define SCLLD2(m, n) scanf("%lld%lld", &m, &n)
#define SCLLD3(m, n, k) scanf("%lld%lld%lld", &m, &n, &k)
using namespace std;
typedef pair<int, int> PII;
typedef pair<long long, long long> PLL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<long long> VL;
typedef long long ll;
typedef long long integer;
///////////////////////////////////////////////
const ll MOD = 1e9 + 7;
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
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;
}
///////////////////////////////////////////////
/*(._.)*/
const long long INF = 9223372036854775000;
const int VMAX = 3000;
const int EMAX = 5000;
struct Edge {
int from;
int to;
int cost;
};
int main() { // 1 --> N minimum cost
ll N, M, P;
cin >> N >> M >> P;
struct Edge e[EMAX];
long long d[VMAX];
bool negcycle[VMAX] = {};
REP(i, M) {
ll a, b, c;
cin >> a >> b >> c;
e[i].from = b;
e[i].to = a; // reverse
e[i].cost = -c + P; // -1
}
REP(i, VMAX) { d[i] = INF; }
d[N] = 0;
REP(i, N - 1) { // loop V times --> NEGCYCLE
bool update = false;
REP(j, M) {
int u = e[j].from;
int v = e[j].to;
int c = e[j].cost;
if ((d[u] + c < d[v]) and (d[u] != INF)) { // s-->uへ現状行けないときを弾く
d[v] = d[u] + c;
update = true;
}
}
}
ll ans = d[1];
REP(i, N) {
REP(j, M) {
int u = e[j].from;
int v = e[j].to;
int c = e[j].cost;
if (d[u] == INF)
continue;
if (d[v] > d[u] + c) {
d[v] = d[u] + c;
negcycle[v] = true;
}
if (negcycle[u] == true) {
negcycle[v] = true;
}
}
}
if (negcycle[1]) {
printf("-1");
return 0;
}
cout << max(0LL, -ans) << endl;
return 0;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 753,935 | 753,936 | u236433947 | cpp |
p02949 | #include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, ll> pa;
struct edge {
int to;
ll coin;
};
int n;
ll p;
vector<vector<edge>> graph;
vector<vector<int>> b_graph;
vector<bool> reachable;
bool is_inf;
void backdfs(int now) {
reachable[now] = true;
for (auto to : b_graph[now]) {
if (reachable[to])
continue;
backdfs(to);
}
}
ll bfs() {
queue<pa> vertex;
vertex.push(pa(0, 0));
vertex.push(pa(-1, 0));
int depth = 0;
vector<ll> maxpoint(n, -3643641919810114514);
while (true) {
pa now_edge = vertex.front();
int nowv = now_edge.first;
vertex.pop();
if (nowv == -1) {
if (vertex.empty())
break;
depth++;
vertex.push(pa(-1, -1));
} else {
if (maxpoint[nowv] <= now_edge.second) {
maxpoint[nowv] = now_edge.second;
if (nowv == n - 1 && depth > 10000) {
is_inf = true;
cout << -1 << endl;
return -1;
}
for (auto next : graph[nowv]) {
ll point = now_edge.second + next.coin - p;
if (point > maxpoint[next.to] && reachable[next.to]) {
maxpoint[next.to] = point;
vertex.push(pa(next.to, point));
}
}
}
}
}
return maxpoint[n - 1];
}
int main() {
int m;
cin >> n >> m >> p;
graph = vector<vector<edge>>(n);
b_graph = vector<vector<int>>(n);
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
graph[a].push_back(edge{b, c});
b_graph[b].push_back(a);
}
reachable = vector<bool>(n);
backdfs(n - 1);
ll ret = bfs();
if (!is_inf)
cout << ret << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, ll> pa;
struct edge {
int to;
ll coin;
};
int n;
ll p;
vector<vector<edge>> graph;
vector<vector<int>> b_graph;
vector<bool> reachable;
bool is_inf;
void backdfs(int now) {
reachable[now] = true;
for (auto to : b_graph[now]) {
if (reachable[to])
continue;
backdfs(to);
}
}
ll bfs() {
queue<pa> vertex;
vertex.push(pa(0, 0));
vertex.push(pa(-1, 0));
int depth = 0;
vector<ll> maxpoint(n, -3643641919810114514);
while (true) {
pa now_edge = vertex.front();
int nowv = now_edge.first;
vertex.pop();
if (nowv == -1) {
if (vertex.empty())
break;
depth++;
vertex.push(pa(-1, -1));
} else {
if (maxpoint[nowv] <= now_edge.second) {
maxpoint[nowv] = now_edge.second;
if (nowv == n - 1 && depth > 10000) {
is_inf = true;
cout << -1 << endl;
return -1;
}
for (auto next : graph[nowv]) {
ll point = now_edge.second + next.coin - p;
if (point > maxpoint[next.to] && reachable[next.to]) {
maxpoint[next.to] = point;
vertex.push(pa(next.to, point));
}
}
}
}
}
return max(0LL, maxpoint[n - 1]);
}
int main() {
int m;
cin >> n >> m >> p;
graph = vector<vector<edge>>(n);
b_graph = vector<vector<int>>(n);
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
graph[a].push_back(edge{b, c});
b_graph[b].push_back(a);
}
reachable = vector<bool>(n);
backdfs(n - 1);
ll ret = bfs();
if (!is_inf)
cout << ret << endl;
return 0;
} | [
"call.add",
"call.arguments.change",
"function.return_value.change"
] | 753,941 | 753,942 | u412908746 | cpp |
p02949 | #include <bits/stdc++.h>
#define REP(i, n) for (long long i = 0; i < (n); i++)
#define FOR(i, a, b) for (long long i = (a); i < (b); i++)
#define dump(x) cerr << #x << " => " << (x) << endl
#define MIN(vec) *min_element(vec.begin(), vec.end())
#define MAX(vec) *max_element(vec.begin(), vec.end())
#define UNIQ(vec) \
vec.erase(unique(vec.begin(), vec.end()), vec.end()) //ソートの必要あり
#define IN(n, m) (!(m.find(n) == m.end()))
#define FINDL(vec, x) (lower_bound(vec.begin(), vec.end(), x) - vec.begin())
#define FINDU(vec, x) (upper_bound(vec.begin(), vec.end(), x) - vec.begin())
#define EQ(a, b) (abs(a - b) < 1e-10)
using namespace std;
typedef long long LL;
constexpr int dx[4] = {0, 1, 0, -1};
constexpr int dy[4] = {1, 0, -1, 0};
constexpr long double pi = M_PI;
constexpr double eps = 1e-10;
constexpr long mod = 1000000007;
// LONG_MAX,LLONG_MAX
template <class T1, class T2> ostream &operator<<(ostream &s, pair<T1, T2> P) {
return s << '<' << P.first << ", " << P.second << '>';
}
template <class T> ostream &operator<<(ostream &s, vector<T> P) {
for (int i = 0; i < P.size(); ++i) {
if (i > 0) {
s << " ";
}
s << P[i];
}
return s;
}
template <class T> ostream &operator<<(ostream &s, vector<vector<T>> P) {
for (int i = 0; i < P.size(); ++i) {
s << endl << P[i];
}
return s << endl;
}
template <class Key, class Value>
ostream &operator<<(ostream &s, map<Key, Value> M) {
for (auto itr = begin(M); itr != end(M); ++itr) {
s << itr->first << ":" << itr->second;
}
return s;
}
using Long = long long;
template <typename W> using Edge = pair<int, W>;
template <typename W> using WeightedGraph = vector<vector<Edge<W>>>;
vector<int> upd;
// 時間計算量 ; O(VE)
template <typename W>
tuple<vector<W>, bool> bellman_ford(int s, int V_size, int E_size,
WeightedGraph<W> &G) {
// true -> 負の閉路なし, false -> 負の閉路あり
// s : 始点, G : 隣接リスト G[v1][v2] : (頂点, 重み)
const W INF = numeric_limits<W>::max();
// P.first : 距離, P.second : 頂点番号
using P = pair<W, int>;
// 初期化
vector<W> d(V_size, INF);
d[s] = 0;
bool update = true;
int c = 0;
for (int k = 0; update && k < 2 * E_size; k++) {
update = false;
for (int i = 0; i < G.size(); i++) {
for (auto &&p : G[i]) {
if (d[i] != INF && d[p.first] > d[i] + p.second) {
d[p.first] = d[i] + p.second;
update = true;
if (p.first == (V_size - 1) && k >= (E_size - 1)) {
return forward_as_tuple(d, false);
}
}
}
}
}
return forward_as_tuple(d, true);
}
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int N, M, P;
cin >> N >> M >> P;
WeightedGraph<int> G(N);
int a, b, c;
REP(i, M) {
cin >> a >> b >> c;
G[a - 1].emplace_back(b - 1, -(c - P));
}
vector<int> D;
bool flg;
tie(D, flg) = bellman_ford(0, N, M, G);
if (flg) {
cout << max((-D[N - 1]), 0) << endl;
} else {
cout << -1 << endl;
}
}
| #include <bits/stdc++.h>
#define REP(i, n) for (long long i = 0; i < (n); i++)
#define FOR(i, a, b) for (long long i = (a); i < (b); i++)
#define dump(x) cerr << #x << " => " << (x) << endl
#define MIN(vec) *min_element(vec.begin(), vec.end())
#define MAX(vec) *max_element(vec.begin(), vec.end())
#define UNIQ(vec) \
vec.erase(unique(vec.begin(), vec.end()), vec.end()) //ソートの必要あり
#define IN(n, m) (!(m.find(n) == m.end()))
#define FINDL(vec, x) (lower_bound(vec.begin(), vec.end(), x) - vec.begin())
#define FINDU(vec, x) (upper_bound(vec.begin(), vec.end(), x) - vec.begin())
#define EQ(a, b) (abs(a - b) < 1e-10)
using namespace std;
typedef long long LL;
constexpr int dx[4] = {0, 1, 0, -1};
constexpr int dy[4] = {1, 0, -1, 0};
constexpr long double pi = M_PI;
constexpr double eps = 1e-10;
constexpr long mod = 1000000007;
// LONG_MAX,LLONG_MAX
template <class T1, class T2> ostream &operator<<(ostream &s, pair<T1, T2> P) {
return s << '<' << P.first << ", " << P.second << '>';
}
template <class T> ostream &operator<<(ostream &s, vector<T> P) {
for (int i = 0; i < P.size(); ++i) {
if (i > 0) {
s << " ";
}
s << P[i];
}
return s;
}
template <class T> ostream &operator<<(ostream &s, vector<vector<T>> P) {
for (int i = 0; i < P.size(); ++i) {
s << endl << P[i];
}
return s << endl;
}
template <class Key, class Value>
ostream &operator<<(ostream &s, map<Key, Value> M) {
for (auto itr = begin(M); itr != end(M); ++itr) {
s << itr->first << ":" << itr->second;
}
return s;
}
using Long = long long;
template <typename W> using Edge = pair<int, W>;
template <typename W> using WeightedGraph = vector<vector<Edge<W>>>;
vector<int> upd;
// 時間計算量 ; O(VE)
template <typename W>
tuple<vector<W>, bool> bellman_ford(int s, int V_size, int E_size,
WeightedGraph<W> &G) {
// true -> 負の閉路なし, false -> 負の閉路あり
// s : 始点, G : 隣接リスト G[v1][v2] : (頂点, 重み)
const W INF = numeric_limits<W>::max();
// P.first : 距離, P.second : 頂点番号
using P = pair<W, int>;
// 初期化
vector<W> d(V_size, INF);
d[s] = 0;
bool update = true;
int c = 0;
for (int k = 0; update && k < (2 * V_size); k++) {
update = false;
for (int i = 0; i < G.size(); i++) {
for (auto &&p : G[i]) {
if (d[i] != INF && d[p.first] > d[i] + p.second) {
d[p.first] = d[i] + p.second;
update = true;
if (p.first == (V_size - 1) && k >= (V_size)) {
return forward_as_tuple(d, false);
}
}
}
}
}
return forward_as_tuple(d, true);
}
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int N, M, P;
cin >> N >> M >> P;
WeightedGraph<int> G(N);
int a, b, c;
REP(i, M) {
cin >> a >> b >> c;
G[a - 1].emplace_back(b - 1, -(c - P));
}
vector<int> D;
bool flg;
tie(D, flg) = bellman_ford(0, N, M, G);
if (flg) {
cout << max((-D[N - 1]), 0) << endl;
} else {
cout << -1 << endl;
}
}
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 753,943 | 753,944 | u925364229 | cpp |
p02949 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end())
#define VRSORT(v) sort(v.rbegin(), v.rend())
#define ll long long
#define pb(a) push_back(a)
#define INF 1000000000
#define LINF 3e18 + 7
#define MOD 1000000007
using namespace std;
typedef pair<int, int> P;
typedef pair<ll, ll> LP;
typedef pair<int, P> PP;
typedef pair<ll, LP> LPP;
typedef vector<unsigned int> vec;
typedef vector<vec> mat;
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;
}
template <class T> inline void add(T &a, T b) {
a = ((a + b) % MOD + MOD) % MOD;
};
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const double PI = acos(-1.0);
const double EPS = 1e-10;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, M, P;
cin >> N >> M >> P;
const int NMAX = 2525;
const int MMAX = 5050;
vector<int> a(MMAX), b(MMAX);
vector<ll> c(MMAX);
REP(i, M) {
cin >> a[i] >> b[i] >> c[i];
c[i] = -c[i];
}
vector<ll> dist(NMAX);
REP(i, N) dist[i] = INF;
dist[0] = 0;
for (int loop = 0; loop < N; ++loop) {
for (int i = 0; i < M; ++i) {
if (dist[a[i] - 1] == INF)
continue;
if (dist[b[i] - 1] > dist[a[i] - 1] + c[i] + P)
dist[b[i] - 1] = dist[a[i] - 1] + c[i] + P;
}
}
ll ans = dist[N - 1];
vector<bool> negative(NMAX, 0);
for (int loop = 0; loop < N; ++loop) {
for (int i = 0; i < M; ++i) {
if (dist[a[i] - 1] == INF)
continue;
if (dist[b[i] - 1] > dist[a[i] - 1] + c[i] + P) {
dist[b[i] - 1] = dist[a[i] - 1] + c[i] + P;
negative[b[i] - 1] = true;
}
if (negative[a[i] - 1] == true)
negative[b[i] - 1] = true;
}
}
if (negative[N - 1])
cout << -1 << endl;
else if (-ans < P)
cout << 0 << endl;
else
cout << -ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end())
#define VRSORT(v) sort(v.rbegin(), v.rend())
#define ll long long
#define pb(a) push_back(a)
#define INF 1000000000
#define LINF 3e18 + 7
#define MOD 1000000007
using namespace std;
typedef pair<int, int> P;
typedef pair<ll, ll> LP;
typedef pair<int, P> PP;
typedef pair<ll, LP> LPP;
typedef vector<unsigned int> vec;
typedef vector<vec> mat;
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;
}
template <class T> inline void add(T &a, T b) {
a = ((a + b) % MOD + MOD) % MOD;
};
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const double PI = acos(-1.0);
const double EPS = 1e-10;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, M, P;
cin >> N >> M >> P;
const int NMAX = 2525;
const int MMAX = 5050;
vector<int> a(MMAX), b(MMAX);
vector<ll> c(MMAX);
REP(i, M) {
cin >> a[i] >> b[i] >> c[i];
c[i] = -c[i];
}
vector<ll> dist(NMAX);
REP(i, N) dist[i] = INF;
dist[0] = 0;
for (int loop = 0; loop < N; ++loop) {
for (int i = 0; i < M; ++i) {
if (dist[a[i] - 1] == INF)
continue;
if (dist[b[i] - 1] > dist[a[i] - 1] + c[i] + P)
dist[b[i] - 1] = dist[a[i] - 1] + c[i] + P;
}
}
ll ans = dist[N - 1];
vector<bool> negative(NMAX, 0);
for (int loop = 0; loop < N; ++loop) {
for (int i = 0; i < M; ++i) {
if (dist[a[i] - 1] == INF)
continue;
if (dist[b[i] - 1] > dist[a[i] - 1] + c[i] + P) {
dist[b[i] - 1] = dist[a[i] - 1] + c[i] + P;
negative[b[i] - 1] = true;
}
if (negative[a[i] - 1] == true)
negative[b[i] - 1] = true;
}
}
// cout<<ans<<endl;
if (negative[N - 1])
cout << -1 << endl;
else if (ans > 0)
cout << 0 << endl;
else
cout << -ans << endl;
return 0;
} | [
"expression.operation.unary.arithmetic.remove",
"control_flow.branch.if.condition.change"
] | 753,945 | 753,946 | u493750228 | cpp |
p02949 | #include <bits/stdc++.h>
#define N 2502
using namespace std;
int n, m, p, dis[N];
struct node {
int u, v, w;
} e[5002];
vector<int> s[N];
int vis[N][N];
void dfs(int st, int x) {
vis[st][x] = 1;
for (int i = 0; i < s[x].size(); i++) {
int to = s[x][i];
if (vis[st][to])
continue;
dfs(st, to);
}
}
int Bellman_ford() {
memset(dis, -1, sizeof(dis));
dis[1] = 0;
for (int i = 1; i <= n; i++) {
int f = 0;
for (int j = 1; j <= m; j++)
if (vis[1][e[j].u] && vis[e[j].v][n] &&
dis[e[j].u] + e[j].w > dis[e[j].v])
dis[e[j].v] = dis[e[j].u] + e[j].w, f = 1;
if (!f)
break;
if (i == n)
return -1;
}
return max(0, dis[n]);
}
int main() {
scanf("%d%d%d", &n, &m, &p);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w), e[i].w -= p;
s[e[i].u].push_back(e[i].v);
}
for (int i = 1; i <= n; i++)
dfs(i, i);
printf("%d\n", Bellman_ford());
return 0;
} | #include <bits/stdc++.h>
#define N 2502
using namespace std;
int n, m, p, dis[N];
struct node {
int u, v, w;
} e[5002];
vector<int> s[N];
int vis[N][N];
void dfs(int st, int x) {
vis[st][x] = 1;
for (int i = 0; i < s[x].size(); i++) {
int to = s[x][i];
if (vis[st][to])
continue;
dfs(st, to);
}
}
int Bellman_ford() {
memset(dis, -125, sizeof(dis));
dis[1] = 0;
for (int i = 1; i <= n; i++) {
int f = 0;
for (int j = 1; j <= m; j++)
if (vis[1][e[j].u] && vis[e[j].v][n] &&
dis[e[j].u] + e[j].w > dis[e[j].v])
dis[e[j].v] = dis[e[j].u] + e[j].w, f = 1;
if (!f)
break;
if (i == n)
return -1;
}
return max(0, dis[n]);
}
int main() {
scanf("%d%d%d", &n, &m, &p);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w), e[i].w -= p;
s[e[i].u].push_back(e[i].v);
}
for (int i = 1; i <= n; i++)
dfs(i, i);
printf("%d\n", Bellman_ford());
return 0;
} | [
"literal.number.change",
"call.arguments.change"
] | 753,951 | 753,952 | u196341564 | cpp |
p02949 | #include <iostream>
#include <limits>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
ll n, m, p;
cin >> n >> m >> p;
vector<vector<pair<int, int>>> to(n);
vector<vector<int>> from(n);
for (int i = 0; i < m; ++i) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
if (a == b && c - p <= 0) {
continue;
}
to.at(a).push_back(make_pair(b, c - p));
from.at(b).push_back(a);
}
vector<bool> can_goal(n, false);
can_goal.at(n - 1) = true;
unordered_set<int> pos[2];
pos[0].insert(n - 1);
for (int i = 0; i < n; ++i) {
const int j = i % 2;
const int j2 = (i + 1) % 2;
pos[j2].clear();
for (int x : pos[j]) {
for (int next : from.at(x)) {
if (!can_goal.at(next)) {
can_goal.at(next) = true;
pos[j2].insert(next);
}
}
}
}
vector<ll> coins(n, numeric_limits<ll>::min());
coins.at(0) = 0;
pos[0].clear();
pos[0].insert(0);
for (int i = 0; i < m; ++i) {
const int j = i % 2;
const int j2 = (i + 1) % 2;
pos[j2].clear();
for (int x : pos[j]) {
for (auto &p : to.at(x)) {
if (coins.at(p.first) < coins.at(x) + p.second &&
can_goal.at(p.first)) {
pos[j2].insert(p.first);
coins.at(p.first) = coins.at(x) + p.second;
}
}
}
if (i == m - 1 && pos[j2].size()) {
cout << -1 << endl;
return 0;
}
}
cout << max(0LL, coins.at(n - 1)) << endl;
return 0;
}
| #include <iostream>
#include <limits>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
ll n, m, p;
cin >> n >> m >> p;
vector<vector<pair<int, int>>> to(n);
vector<vector<int>> from(n);
for (int i = 0; i < m; ++i) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
if (a == b && c - p <= 0) {
continue;
}
to.at(a).push_back(make_pair(b, c - p));
from.at(b).push_back(a);
}
vector<bool> can_goal(n, false);
can_goal.at(n - 1) = true;
unordered_set<int> pos[2];
pos[0].insert(n - 1);
for (int i = 0; i < n; ++i) {
const int j = i % 2;
const int j2 = (i + 1) % 2;
pos[j2].clear();
for (int x : pos[j]) {
for (int next : from.at(x)) {
if (!can_goal.at(next)) {
can_goal.at(next) = true;
pos[j2].insert(next);
}
}
}
}
vector<ll> coins(n, numeric_limits<ll>::min());
coins.at(0) = 0;
pos[0].clear();
pos[0].insert(0);
for (int i = 0; i < n; ++i) {
const int j = i % 2;
const int j2 = (i + 1) % 2;
pos[j2].clear();
for (int x : pos[j]) {
for (auto &p : to.at(x)) {
if (coins.at(p.first) < coins.at(x) + p.second &&
can_goal.at(p.first)) {
pos[j2].insert(p.first);
coins.at(p.first) = coins.at(x) + p.second;
}
}
}
if (i == n - 1 && pos[j2].size()) {
cout << -1 << endl;
return 0;
}
}
cout << max(0LL, coins.at(n - 1)) << endl;
return 0;
}
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change"
] | 753,955 | 753,956 | u455757400 | cpp |
p02949 | #define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
#include <bits/stdc++.h>
using namespace std;
struct edge {
ll from;
ll to; //到達点
ll cost; //移動コスト
};
int main() {
ll n, m, p;
std::cin >> n >> m >> p;
vector<edge> edges;
for (int i = 0; i < m; i++) {
ll a, b, c;
std::cin >> a >> b >> c;
a--;
b--;
edges.push_back({a, b, p - c});
}
// infってどんなもん。
vector<ll> d(n, 1e18);
d[0] = 0;
bool has_loop = false;
ll val = -1;
for (int i = 0; i < n + 2; i++) {
for (auto e : edges) {
if (d[e.from] != 1e18 &&
d[e.to] >
d[e.from] +
e.cost) { //移動した後のコストが小さいと、頂点のコストを更新
d[e.to] = d[e.from] + e.cost;
if (i >=
n) { //頂点の数と同じ回数ループすると、負の閉路があるのでループをぬける
if (!has_loop) {
val = d[n - 1];
has_loop = true;
} else {
if (val != d[n - 1]) {
std::cout << -1 << std::endl;
return 0;
}
}
}
}
}
}
std::cout << max((ll)0, -d[n - 1]) << std::endl;
}
| #define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
#include <bits/stdc++.h>
using namespace std;
struct edge {
ll from;
ll to; //到達点
ll cost; //移動コスト
};
int main() {
ll n, m, p;
std::cin >> n >> m >> p;
vector<edge> edges;
for (int i = 0; i < m; i++) {
ll a, b, c;
std::cin >> a >> b >> c;
a--;
b--;
edges.push_back({a, b, p - c});
}
// infってどんなもん。
vector<ll> d(n, 1e18);
d[0] = 0;
bool has_loop = false;
ll val = -1;
for (int i = 0; i < n * 2; i++) {
for (auto e : edges) {
if (d[e.from] != 1e18 &&
d[e.to] >
d[e.from] +
e.cost) { //移動した後のコストが小さいと、頂点のコストを更新
d[e.to] = d[e.from] + e.cost;
if (i >=
n) { //頂点の数と同じ回数ループすると、負の閉路があるのでループをぬける
if (!has_loop) {
val = d[n - 1];
has_loop = true;
} else {
if (val != d[n - 1]) {
std::cout << -1 << std::endl;
return 0;
}
}
}
}
}
}
std::cout << max((ll)0, -d[n - 1]) << std::endl;
}
| [
"expression.operator.arithmetic.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 753,957 | 753,958 | u121794232 | cpp |
p02949 | #define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
#include <bits/stdc++.h>
using namespace std;
struct edge {
ll from;
ll to; //到達点
ll cost; //移動コスト
};
int main() {
ll n, m, p;
std::cin >> n >> m >> p;
vector<edge> edges;
for (int i = 0; i < m; i++) {
ll a, b, c;
std::cin >> a >> b >> c;
a--;
b--;
edges.push_back({a, b, p - c});
}
// infってどんなもん。
vector<ll> d(n, 1);
d[0] = 0;
bool has_loop = false;
ll val = -1;
for (int i = 0; i < n + 2; i++) {
for (auto e : edges) {
if (d[e.from] != 1 &&
d[e.to] >
d[e.from] +
e.cost) { //移動した後のコストが小さいと、頂点のコストを更新
d[e.to] = d[e.from] + e.cost;
if (i >=
n) { //頂点の数と同じ回数ループすると、負の閉路があるのでループをぬける
if (!has_loop) {
val = d[n - 1];
has_loop = true;
} else {
if (val != d[n - 1]) {
std::cout << -1 << std::endl;
return 0;
}
}
}
}
}
}
std::cout << max((ll)0, -d[n - 1]) << std::endl;
}
| #define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
#include <bits/stdc++.h>
using namespace std;
struct edge {
ll from;
ll to; //到達点
ll cost; //移動コスト
};
int main() {
ll n, m, p;
std::cin >> n >> m >> p;
vector<edge> edges;
for (int i = 0; i < m; i++) {
ll a, b, c;
std::cin >> a >> b >> c;
a--;
b--;
edges.push_back({a, b, p - c});
}
// infってどんなもん。
vector<ll> d(n, 1e18);
d[0] = 0;
bool has_loop = false;
ll val = -1;
for (int i = 0; i < n * 2; i++) {
for (auto e : edges) {
if (d[e.from] != 1e18 &&
d[e.to] >
d[e.from] +
e.cost) { //移動した後のコストが小さいと、頂点のコストを更新
d[e.to] = d[e.from] + e.cost;
if (i >=
n) { //頂点の数と同じ回数ループすると、負の閉路があるのでループをぬける
if (!has_loop) {
val = d[n - 1];
has_loop = true;
} else {
if (val != d[n - 1]) {
std::cout << -1 << std::endl;
return 0;
}
}
}
}
}
}
std::cout << max((ll)0, -d[n - 1]) << std::endl;
}
| [
"literal.number.change",
"call.arguments.change",
"expression.operator.arithmetic.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change"
] | 753,959 | 753,958 | u121794232 | cpp |
p02949 | #include <bits/stdc++.h>
#define x first
#define y second
using namespace std;
const int sz = 5005;
long long d[sz];
int n, m, p;
int f[sz], t[sz], w[sz];
long long inf = 1e18, ans;
int main() {
// freopen("in.txt","r",stdin);
// freopen("out.txt","w",stdout);
scanf("%d %d %d", &n, &m, &p);
for (int i = 0; i < m; i++) {
scanf("%d %d %d", &f[i], &t[i], &w[i]);
w[i] = p - w[i];
}
for (int i = 1; i <= n; i++)
d[i] = inf;
bool flag = 0;
d[1] = 0;
for (int i = 0; i < 3 * n; i++) {
for (int j = 0; j < m; j++) {
int u = f[j];
int v = t[j];
int k = w[j];
if (d[u] >= inf)
continue;
if (d[v] > d[u] + k) {
flag = (v == n && i >= n);
d[v] = max(d[u] + k, -inf);
}
}
if (flag) {
cout << -1;
return 0;
}
}
if (d[n] == inf)
cout << -1;
else {
d[n] = -d[n];
ans = max(ans, d[n]);
cout << ans;
}
return 0;
}
| #include <bits/stdc++.h>
#define x first
#define y second
using namespace std;
const int sz = 5005;
long long d[sz];
int n, m, p;
int f[sz], t[sz], w[sz];
long long inf = 1e18, ans;
int main() {
// freopen("in.txt","r",stdin);
// freopen("out.txt","w",stdout);
scanf("%d %d %d", &n, &m, &p);
for (int i = 0; i < m; i++) {
scanf("%d %d %d", &f[i], &t[i], &w[i]);
w[i] = p - w[i];
}
for (int i = 1; i <= n; i++)
d[i] = inf;
bool flag = 0;
d[1] = 0;
for (int i = 0; i < 10 * n; i++) {
for (int j = 0; j < m; j++) {
int u = f[j];
int v = t[j];
int k = w[j];
if (d[u] >= inf)
continue;
if (d[v] > d[u] + k) {
if (v == n && i >= n)
flag = 1;
d[v] = max(d[u] + k, -inf);
}
}
if (flag) {
cout << -1;
return 0;
}
}
if (d[n] == inf)
cout << -1;
else {
d[n] = -d[n];
ans = max(ans, d[n]);
cout << ans;
}
return 0;
}
| [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"assignment.change"
] | 753,960 | 753,961 | u353783395 | cpp |
p02949 | #include <bits/stdc++.h>
#include <cstdio>
#include <iostream>
#include <sys/time.h>
#include <sys/timeb.h>
#include <time.h>
using namespace std;
#define ll long long
#define uint unsigned int
#define ulong unsigned long long int
#define Vec vector
template <typename T> bool InRange(T t, T l, T r) { return l <= t && t < r; }
int main() {
int N, M;
ll P;
cin >> N >> M >> P;
Vec<int> A(M), B(M);
Vec<ll> C(M);
for (int i = 0; i < M; i++) {
cin >> A[i] >> B[i] >> C[i];
A[i]--;
B[i]--;
C[i] -= P;
}
ll Inf = (ll)1e18;
Vec<Vec<ll>> ma(N * 3 + 1);
for (int i = 0; i < N * 3 + 1; i++) {
ma[i].resize(N);
for (int j = 0; j < N; j++) {
ma[i][j] = -Inf;
}
}
ma[0][0] = 0;
for (int i = 0; i < 3 * N; i++) {
for (int j = 0; j < M; j++) {
int a = A[j];
int b = B[j];
ll c = C[j];
if (ma[a][i] == -Inf)
continue;
ma[i + 1][b] = max(ma[i + 1][b], ma[i][a] + c);
}
}
/*
for(int i=0;i<=2*N;i++){
ma[N-1][i] = max((ll) 0, ma[N-1][i] - i * P);
}
*/
ll ma0 = -Inf;
for (int i = 0; i <= N; i++) {
ma0 = max(ma0, ma[i][N - 1]);
}
ll ma1 = -Inf;
for (int i = N + 1; i <= 2 * N; i++) {
ma1 = max(ma1, ma[i][N - 1]);
}
ll ma2 = -Inf;
for (int i = 2 * N + 1; i <= 3 * N; i++) {
ma2 = max(ma2, ma[i][N - 1]);
}
if (ma2 > ma1) {
cout << -1 << endl;
} else {
cout << max((ll)0, max(ma1, ma0)) << endl;
}
/*
for(int i=0;i<=3*N;i++){
for(int j=0;j<N;j++) cout << ma[j][i] << " ";
cout << endl;
}
*/
return 0;
} | #include <bits/stdc++.h>
#include <cstdio>
#include <iostream>
#include <sys/time.h>
#include <sys/timeb.h>
#include <time.h>
using namespace std;
#define ll long long
#define uint unsigned int
#define ulong unsigned long long int
#define Vec vector
template <typename T> bool InRange(T t, T l, T r) { return l <= t && t < r; }
int main() {
int N, M;
ll P;
cin >> N >> M >> P;
Vec<int> A(M), B(M);
Vec<ll> C(M);
for (int i = 0; i < M; i++) {
cin >> A[i] >> B[i] >> C[i];
A[i]--;
B[i]--;
C[i] -= P;
}
ll Inf = (ll)1e18;
Vec<Vec<ll>> ma(N * 3 + 1);
for (int i = 0; i < N * 3 + 1; i++) {
ma[i].resize(N);
for (int j = 0; j < N; j++) {
ma[i][j] = -Inf;
}
}
ma[0][0] = 0;
for (int i = 0; i < 3 * N; i++) {
for (int j = 0; j < M; j++) {
int a = A[j];
int b = B[j];
ll c = C[j];
if (ma[i][a] == -Inf)
continue;
ma[i + 1][b] = max(ma[i + 1][b], ma[i][a] + c);
}
}
/*
for(int i=0;i<=2*N;i++){
ma[N-1][i] = max((ll) 0, ma[N-1][i] - i * P);
}
*/
ll ma0 = -Inf;
for (int i = 0; i <= N; i++) {
ma0 = max(ma0, ma[i][N - 1]);
}
ll ma1 = -Inf;
for (int i = N + 1; i <= 2 * N; i++) {
ma1 = max(ma1, ma[i][N - 1]);
}
ll ma2 = -Inf;
for (int i = 2 * N + 1; i <= 3 * N; i++) {
ma2 = max(ma2, ma[i][N - 1]);
}
if (ma2 > ma1) {
cout << -1 << endl;
} else {
cout << max((ll)0, max(ma1, ma0)) << endl;
}
/*
for(int i=0;i<=3*N;i++){
for(int j=0;j<N;j++) cout << ma[j][i] << " ";
cout << endl;
}
*/
return 0;
} | [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 753,962 | 753,963 | u774845108 | cpp |
p02949 | #include <bits/stdc++.h>
#define MAX 5010
using namespace std;
vector<pair<int, int>> edge[MAX];
long long mmax[MAX];
int main(void) {
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--;
edge[A].push_back({B, P - C});
}
for (int i = 1; i < N; i++)
mmax[i] = 1234567890123LL;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
for (auto e : edge[j])
mmax[e.first] = min(mmax[e.first], mmax[j] + e.second);
}
}
long long ans = mmax[N - 1];
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
for (auto e : edge[j])
mmax[e.first] = min(mmax[e.first], mmax[j] + e.second);
}
}
if (ans != mmax[N - 1])
cout << -1 << endl;
else
cout << -ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define MAX 5010
using namespace std;
vector<pair<int, int>> edge[MAX];
long long mmax[MAX];
int main(void) {
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--;
edge[A].push_back({B, P - C});
}
for (int i = 1; i < N; i++)
mmax[i] = 1234567890123LL;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
for (auto e : edge[j])
mmax[e.first] = min(mmax[e.first], mmax[j] + e.second);
}
}
long long ans = mmax[N - 1];
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
for (auto e : edge[j])
mmax[e.first] = min(mmax[e.first], mmax[j] + e.second);
}
}
if (ans != mmax[N - 1])
cout << -1 << endl;
else
cout << max(-ans, 0LL) << endl;
return 0;
}
| [
"call.add",
"call.arguments.add"
] | 753,971 | 753,972 | u305757380 | cpp |
p02949 | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
std::vector<int> to[2505];
std::vector<int> ot[2505];
bool reachableToN[2505];
bool reachableFrom1[2505];
bool ok[2505];
long long INF = 1LL << 60;
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 : ot[v]) {
rdfs(u);
}
}
int main() {
int n, m, p;
std::cin >> n >> m >> p;
std::vector<std::tuple<int, int, int>> edges;
for (int i = 0; i < m; ++i) {
int a, b, c;
std::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);
rdfs(n - 1);
for (int i = 0; i < n; ++i) {
ok[i] = reachableFrom1[i] && reachableToN[i];
}
std::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;
std::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) {
std::cout << -1 << std::endl;
return 0;
}
}
int ans = -d[n - 1];
ans = std::max(0, ans);
std::cout << ans << std::endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
std::vector<int> to[2505];
std::vector<int> ot[2505];
bool reachableToN[2505];
bool reachableFrom1[2505];
bool ok[2505];
long long INF = 1LL << 60;
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 : ot[v]) {
rdfs(u);
}
}
int main() {
int n, m, p;
std::cin >> n >> m >> p;
std::vector<std::tuple<int, int, int>> edges;
for (int i = 0; i < m; ++i) {
int a, b, c;
std::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);
rdfs(n - 1);
for (int i = 0; i < n; ++i) {
ok[i] = reachableFrom1[i] && reachableToN[i];
}
std::vector<long long> 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;
std::tie(a, b, c) = edges[i];
if (!ok[a])
continue;
if (!ok[b])
continue;
long long newD = d[a] + c;
if (newD < d[b]) {
upd = true;
d[b] = newD;
}
}
++step;
if (step > n) {
std::cout << -1 << std::endl;
return 0;
}
}
int ans = -d[n - 1];
ans = std::max(0, ans);
std::cout << ans << std::endl;
return 0;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 753,977 | 753,976 | u313111801 | cpp |
p02949 | #include <bits/stdc++.h>
#define ff first
#define ss second
#define ii pair<int, int>
#define iill pair<ii, ll>
#define lli pair<ll, int>
#define MAXN 100010
#define EPS 1e-9
#define MAXLOG
#define INF (long long)1e18
#define MOD
#define prt(a) printf("%d\n", a)
#define prt2(a, b) printf("%d %d\n", a, b)
#define prt3(a, b, c) printf("%d %d %d\n", a, b, c)
#define sc(a) scanf("%d", &a)
#define sc2(a, b) scanf("%d %d", &a, &b)
#define sc3(a, b, c) scanf("%d %d %d", &a, &b, &c)
#define readArr(arr, n) \
for (int i = 0; i < n; i++) \
scanf("%d", &arr[i]);
#define EPS 1e-9
#define ll long long
using namespace std;
struct aresta {
int de, para;
ll custo;
aresta(int a, int b, ll c) : de(a), para(b), custo(c) {}
};
int main() {
#ifdef LOCAL
freopen("input", "r", stdin);
#endif
int n, m;
ll p;
scanf("%d %d %lld", &n, &m, &p);
int de, para;
ll custo;
vector<aresta> are;
for (int i = 0; i < m; i++) {
scanf("%d %d %lld", &de, ¶, &custo);
are.emplace_back(de, para, p - custo);
}
ll dist[MAXN];
for (int i = 0; i < MAXN; i++)
dist[i] = INF;
dist[1] = 0;
for (int i = 1; i <= n * 2; i++) {
for (aresta a : are) {
if (dist[a.de] == INF)
continue;
if (dist[a.para] > dist[a.de] + a.custo) {
dist[a.para] = dist[a.de] + a.custo;
if (i >= n && a.de == n - 1) {
printf("-1\n");
return 0;
}
}
}
}
printf("%lld\n", max(0LL, -dist[n]));
return 0;
}
| #include <bits/stdc++.h>
#define ff first
#define ss second
#define ii pair<int, int>
#define iill pair<ii, ll>
#define lli pair<ll, int>
#define MAXN 100010
#define EPS 1e-9
#define MAXLOG
#define INF (long long)1e18
#define MOD
#define prt(a) printf("%d\n", a)
#define prt2(a, b) printf("%d %d\n", a, b)
#define prt3(a, b, c) printf("%d %d %d\n", a, b, c)
#define sc(a) scanf("%d", &a)
#define sc2(a, b) scanf("%d %d", &a, &b)
#define sc3(a, b, c) scanf("%d %d %d", &a, &b, &c)
#define readArr(arr, n) \
for (int i = 0; i < n; i++) \
scanf("%d", &arr[i]);
#define EPS 1e-9
#define ll long long
using namespace std;
struct aresta {
int de, para;
ll custo;
aresta(int a, int b, ll c) : de(a), para(b), custo(c) {}
};
int main() {
#ifdef LOCAL
freopen("input", "r", stdin);
#endif
int n, m;
ll p;
scanf("%d %d %lld", &n, &m, &p);
int de, para;
ll custo;
vector<aresta> are;
for (int i = 0; i < m; i++) {
scanf("%d %d %lld", &de, ¶, &custo);
are.emplace_back(de, para, p - custo);
}
ll dist[MAXN];
for (int i = 0; i < MAXN; i++)
dist[i] = INF;
dist[1] = 0;
for (int i = 1; i <= n * 2; i++) {
for (aresta a : are) {
if (dist[a.de] == INF)
continue;
if (dist[a.para] > dist[a.de] + a.custo) {
dist[a.para] = dist[a.de] + a.custo;
if (i >= n && a.para == n) {
printf("-1\n");
return 0;
}
}
}
}
printf("%lld\n", max(0LL, -dist[n]));
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 753,978 | 753,979 | u934308457 | cpp |
p02949 | #include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
typedef long long ll;
const ll M = 2505, N = 1e4 + 5;
struct node {
ll to, next, dis;
} edge[N];
vector<ll> mp[M];
ll head[M], cnt;
ll minn[M], tot[M];
bool vis[M], can[M];
queue<ll> q;
inline void add(ll x, ll y, ll d) {
edge[++cnt] = (node){y, head[x], d}, head[x] = cnt;
}
inline ll read() {
ll x = 0, f = 1;
char ch = 0;
while (!isdigit(ch))
f = (ch == '-' ? -1 : 1), ch = getchar();
while (isdigit(ch))
x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
return x * f;
}
void bfs(ll x) {
queue<ll> now;
now.push(x);
can[x] = true;
while (!now.empty()) {
ll u = now.front();
now.pop();
for (register ll i = 0; i < mp[u].size(); i++) {
ll v = mp[u][i];
if (!can[v])
now.push(v), can[v] = true;
}
}
}
int main() {
ll n = read(), m = read(), p = read();
for (register ll i = 1; i <= m; i++) {
ll x = read(), y = read(), d = read() - p;
add(x, y, d);
mp[y].push_back(x);
}
bfs(n);
memset(minn, 0x80, sizeof(minn));
q.push(1);
minn[1] = 0;
vis[1] = true;
tot[1] = 1;
while (!q.empty()) {
ll u = q.front();
q.pop();
vis[u] = false;
for (register ll i = head[u]; i; i = edge[i].next) {
ll v = edge[i].to;
if (!can[v])
continue;
if (minn[v] < minn[u] + edge[i].dis) {
tot[v] = tot[u] + 1;
if (tot[v] >= n) {
puts("-1");
return 0;
}
minn[v] = minn[u] + edge[i].dis;
if (!vis[v])
q.push(v), vis[v] = true;
}
}
}
if (minn[n] < 0)
puts("0");
else
printf("%lld\n", minn[n]);
return 0;
} | #include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
typedef long long ll;
const ll M = 2505, N = 1e4 + 5;
struct node {
ll to, next, dis;
} edge[N];
vector<ll> mp[M];
ll head[M], cnt;
ll minn[M], tot[M];
bool vis[M], can[M];
queue<ll> q;
inline void add(ll x, ll y, ll d) {
edge[++cnt] = (node){y, head[x], d}, head[x] = cnt;
}
inline ll read() {
ll x = 0, f = 1;
char ch = 0;
while (!isdigit(ch))
f = (ch == '-' ? -1 : 1), ch = getchar();
while (isdigit(ch))
x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
return x * f;
}
void bfs(ll x) {
queue<ll> now;
now.push(x);
can[x] = true;
while (!now.empty()) {
ll u = now.front();
now.pop();
for (register ll i = 0; i < mp[u].size(); i++) {
ll v = mp[u][i];
if (!can[v])
now.push(v), can[v] = true;
}
}
}
int main() {
ll n = read(), m = read(), p = read();
for (register ll i = 1; i <= m; i++) {
ll x = read(), y = read(), d = read() - p;
add(x, y, d);
mp[y].push_back(x);
}
bfs(n);
memset(minn, 0x80, sizeof(minn));
q.push(1);
minn[1] = 0;
vis[1] = true;
tot[1] = 1;
while (!q.empty()) {
ll u = q.front();
q.pop();
vis[u] = false;
for (register ll i = head[u]; i; i = edge[i].next) {
ll v = edge[i].to;
if (!can[v])
continue;
if (minn[v] < minn[u] + edge[i].dis) {
tot[v] = tot[u] + 1;
if (tot[v] > n) {
puts("-1");
return 0;
}
minn[v] = minn[u] + edge[i].dis;
if (!vis[v])
q.push(v), vis[v] = true;
}
}
}
if (minn[n] < 0)
puts("0");
else
printf("%lld\n", minn[n]);
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 753,980 | 753,981 | u660361728 | cpp |
p02949 | #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(), a.end()
#define rrng(a) a.rbegin(), a.rend()
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
#define limit(x, l, r) max(l, min(x, r))
#define lims(x, l, r) (x = max(l, min(x, r)))
#define isin(x, l, r) ((l) <= (x) && (x) < (r))
#define pb push_back
#define eb emplace_back
#define sz(x) (int)(x).size()
#define pcnt __builtin_popcountll
#define uni(x) x.erase(unique(rng(x)), x.end())
#define snuke srand((unsigned)clock() + (unsigned)time(NULL));
#define show(x) cout << #x << " = " << x << endl;
#define PQ(T) priority_queue<T, v(T), greater<T>>
#define bn(x) ((1 << x) - 1)
#define dup(x, y) (((x) + (y)-1) / (y))
#define newline puts("")
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
typedef long long int ll;
typedef unsigned uint;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef tuple<int, int, int> T;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
typedef vector<T> vt;
// inline int in() { int x; scanf("%d",&x); return x;}
inline ll in() {
ll x;
cin >> x;
return x;
}
template <typename T> inline istream &operator>>(istream &i, v(T) & v) {
rep(j, sz(v)) i >> v[j];
return i;
}
template <typename T> string join(const v(T) & v) {
stringstream s;
rep(i, sz(v)) s << ' ' << v[i];
return s.str().substr(1);
}
template <typename T> inline ostream &operator<<(ostream &o, const v(T) & v) {
if (sz(v))
o << join(v);
return o;
}
template <typename T1, typename T2>
inline istream &operator>>(istream &i, pair<T1, T2> &v) {
return i >> v.fi >> v.se;
}
template <typename T1, typename T2>
inline ostream &operator<<(ostream &o, const pair<T1, T2> &v) {
return o << v.fi << "," << v.se;
}
template <typename T> inline ll suma(const v(T) & a) {
ll res(0);
for (auto &&x : a)
res += x;
return res;
}
const double eps = 1e-10;
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
#define dame \
{ \
puts("-1"); \
return 0; \
}
#define yn \
{ puts("YES"); } \
else { \
puts("NO"); \
}
const int MX = 200005;
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 = in(), m = in(), p = in();
vector<tuple<int, int, int>> edges;
rep(i, m) {
int a = in(), b = in(), c = in();
--a;
--b;
c -= p;
c = -c;
edges.emplace_back(a, b, c);
to[a].pb(b);
rto[b].pb(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;
}
| #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(), a.end()
#define rrng(a) a.rbegin(), a.rend()
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
#define limit(x, l, r) max(l, min(x, r))
#define lims(x, l, r) (x = max(l, min(x, r)))
#define isin(x, l, r) ((l) <= (x) && (x) < (r))
#define pb push_back
#define eb emplace_back
#define sz(x) (int)(x).size()
#define pcnt __builtin_popcountll
#define uni(x) x.erase(unique(rng(x)), x.end())
#define snuke srand((unsigned)clock() + (unsigned)time(NULL));
#define show(x) cout << #x << " = " << x << endl;
#define PQ(T) priority_queue<T, v(T), greater<T>>
#define bn(x) ((1 << x) - 1)
#define dup(x, y) (((x) + (y)-1) / (y))
#define newline puts("")
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
typedef long long int ll;
typedef unsigned uint;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef tuple<int, int, int> T;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
typedef vector<T> vt;
// inline int in() { int x; scanf("%d",&x); return x;}
inline ll in() {
ll x;
cin >> x;
return x;
}
template <typename T> inline istream &operator>>(istream &i, v(T) & v) {
rep(j, sz(v)) i >> v[j];
return i;
}
template <typename T> string join(const v(T) & v) {
stringstream s;
rep(i, sz(v)) s << ' ' << v[i];
return s.str().substr(1);
}
template <typename T> inline ostream &operator<<(ostream &o, const v(T) & v) {
if (sz(v))
o << join(v);
return o;
}
template <typename T1, typename T2>
inline istream &operator>>(istream &i, pair<T1, T2> &v) {
return i >> v.fi >> v.se;
}
template <typename T1, typename T2>
inline ostream &operator<<(ostream &o, const pair<T1, T2> &v) {
return o << v.fi << "," << v.se;
}
template <typename T> inline ll suma(const v(T) & a) {
ll res(0);
for (auto &&x : a)
res += x;
return res;
}
const double eps = 1e-10;
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
#define dame \
{ \
puts("-1"); \
return 0; \
}
#define yn \
{ puts("YES"); } \
else { \
puts("NO"); \
}
const int MX = 200005;
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 = in(), m = in(), p = in();
vector<tuple<int, int, int>> edges;
rep(i, m) {
int a = in(), b = in(), c = in();
--a;
--b;
c -= p;
c = -c;
edges.emplace_back(a, b, c);
to[a].pb(b);
rto[b].pb(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;
}
| [
"expression.operation.unary.add"
] | 753,987 | 753,988 | u526630579 | cpp |
p02949 | //#pragma once
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cstdlib> // srand,rand
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
#define ll long long
#define modd 1000000007
#define INF 1000000000000000000ll
typedef pair<long long, long long> pl;
typedef string::const_iterator State;
class ParseError {};
class UnionFind {
public:
vector<ll> par;
vector<ll> siz;
// Constructor
UnionFind(ll sz_) : par(sz_), siz(sz_, 1LL) {
for (ll i = 0; i < sz_; ++i)
par[i] = i;
}
void init(ll sz_) {
par.resize(sz_);
siz.assign(sz_, 1LL); // resize だとなぜか初期化されなかった
for (ll i = 0; i < sz_; ++i)
par[i] = i; // 初期では親は自分自身
}
// Member Function
// Find
ll root(ll x) { // 根の検索
while (par[x] != x) {
x = par[x] = par[par[x]]; // x の親の親を x の親とする
}
return x;
}
// Union(Unite, Merge)
bool merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y)
return false;
// merge technique（データ構造をマージするテク．小を大にくっつける）
if (siz[x] < siz[y])
swap(x, y);
siz[x] += siz[y];
par[y] = x;
return true;
}
bool issame(ll x, ll y) { // 連結判定
return root(x) == root(y);
}
ll size(ll x) { // 素集合のサイズ
return siz[root(x)];
}
};
/*
struct SegmentTree {
private:
ll n;
vector<ll> node;
public:
// 元配列 v をセグメント木で表現する
SegmentTree(vector<ll> v) {
// 最下段のノード数は元配列のサイズ以上になる最小の 2 冪 ->
これを n とおく
// セグメント木全体で必要なノード数は 2n-1 個である
ll sz = v.size();
n = 1; while (n < sz) n *= 2;
node.resize(2 * n - 1, INF);
// 最下段に値を入れたあとに、下の段から順番に値を入れる
// 値を入れるには、自分の子の 2 値を参照すれば良い
for (ll i = 0; i < sz; i++) node[i + n - 1] = v[i];
for (ll i = n - 2; i >= 0; i--) node[i] = min(node[2 * i + 1],
node[2 * i + 2]);
}
void update(ll x, ll val) {
// 最下段のノードにアクセスする
x += (n - 1);
// 最下段のノードを更新したら、あとは親に上って更新していく
node[x] = val;
while (x > 0) {
x = (x - 1) / 2;
node[x] = min(node[2 * x + 1], node[2 * x + 2]);
}
}
};
*/
long long N, M, K, a, b, c, H, W, L, T;
ll A[300005] = {};
ll B[300005] = {};
ll C[300005] = {};
bool f, ff;
string S[200000];
string SS;
set<long long> sll;
pl bufpl;
vector<long long> vl[600005];
vector<long long> vll;
vector<pl> vpl;
vector<string> vs;
set<ll> llset;
multiset<ll> llmset;
queue<ll> ql;
struct ST {
ll first;
ll second;
ll kaisuu;
bool operator<(const ST &another) const {
return first < another.first; //比較
};
};
/*vector <ST> vst;
ST st[200005];
ST bufst;
bitset<5000> bits;*/
long long modinv(long long aa, long long mm) {
long long bb = mm, uu = 1, vv = 0;
while (bb) {
long long tt = aa / bb;
aa -= tt * bb;
swap(aa, bb);
uu -= tt * vv;
swap(uu, vv);
}
uu %= mm;
if (uu < 0)
uu += mm;
return uu;
}
ll minn, maxx;
double ansa;
ll zettai(ll aa) {
if (aa < 0) {
aa *= -1;
}
return aa;
}
double ab[20000];
ll ha[2];
ll x, y;
struct edge {
ll from;
ll to;
ll cost;
};
ll V, E, d[300000];
edge es[300000];
bool has_negative_loop(ll s) {
fill(d, d + V, 50000000000000000);
d[s] = 0;
for (ll i = 0; i <= 2 * V; i++) {
for (ll j = 0; j < E; j++) {
edge e = es[j];
if (d[(int)e.to] > d[(int)e.from] + e.cost) {
d[(int)e.to] = d[(int)e.from] + e.cost;
if (i >= V && e.to == E - 1) {
return true;
}
}
}
}
return false;
}
int main() {
cin >> E >> V >> b;
for (int i = 0; i < V; i++) {
cin >> es[i].from >> es[i].to >> es[i].cost;
es[i].from--;
es[i].to--;
es[i].cost -= b;
es[i].cost *= -1;
}
f = has_negative_loop(0);
if (f) {
cout << -1 << endl;
} else {
x = d[E - 1];
x *= -1;
x = max(x, 0ll);
cout << x << endl;
}
// cout << fixed << setprecision(10) << ansa << endl;
return 0;
}
| //#pragma once
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cstdlib> // srand,rand
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
#define ll long long
#define modd 1000000007
#define INF 1000000000000000000ll
typedef pair<long long, long long> pl;
typedef string::const_iterator State;
class ParseError {};
class UnionFind {
public:
vector<ll> par;
vector<ll> siz;
// Constructor
UnionFind(ll sz_) : par(sz_), siz(sz_, 1LL) {
for (ll i = 0; i < sz_; ++i)
par[i] = i;
}
void init(ll sz_) {
par.resize(sz_);
siz.assign(sz_, 1LL); // resize だとなぜか初期化されなかった
for (ll i = 0; i < sz_; ++i)
par[i] = i; // 初期では親は自分自身
}
// Member Function
// Find
ll root(ll x) { // 根の検索
while (par[x] != x) {
x = par[x] = par[par[x]]; // x の親の親を x の親とする
}
return x;
}
// Union(Unite, Merge)
bool merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y)
return false;
// merge technique（データ構造をマージするテク．小を大にくっつける）
if (siz[x] < siz[y])
swap(x, y);
siz[x] += siz[y];
par[y] = x;
return true;
}
bool issame(ll x, ll y) { // 連結判定
return root(x) == root(y);
}
ll size(ll x) { // 素集合のサイズ
return siz[root(x)];
}
};
/*
struct SegmentTree {
private:
ll n;
vector<ll> node;
public:
// 元配列 v をセグメント木で表現する
SegmentTree(vector<ll> v) {
// 最下段のノード数は元配列のサイズ以上になる最小の 2 冪 ->
これを n とおく
// セグメント木全体で必要なノード数は 2n-1 個である
ll sz = v.size();
n = 1; while (n < sz) n *= 2;
node.resize(2 * n - 1, INF);
// 最下段に値を入れたあとに、下の段から順番に値を入れる
// 値を入れるには、自分の子の 2 値を参照すれば良い
for (ll i = 0; i < sz; i++) node[i + n - 1] = v[i];
for (ll i = n - 2; i >= 0; i--) node[i] = min(node[2 * i + 1],
node[2 * i + 2]);
}
void update(ll x, ll val) {
// 最下段のノードにアクセスする
x += (n - 1);
// 最下段のノードを更新したら、あとは親に上って更新していく
node[x] = val;
while (x > 0) {
x = (x - 1) / 2;
node[x] = min(node[2 * x + 1], node[2 * x + 2]);
}
}
};
*/
long long N, M, K, a, b, c, H, W, L, T;
ll A[300005] = {};
ll B[300005] = {};
ll C[300005] = {};
bool f, ff;
string S[200000];
string SS;
set<long long> sll;
pl bufpl;
vector<long long> vl[600005];
vector<long long> vll;
vector<pl> vpl;
vector<string> vs;
set<ll> llset;
multiset<ll> llmset;
queue<ll> ql;
struct ST {
ll first;
ll second;
ll kaisuu;
bool operator<(const ST &another) const {
return first < another.first; //比較
};
};
/*vector <ST> vst;
ST st[200005];
ST bufst;
bitset<5000> bits;*/
long long modinv(long long aa, long long mm) {
long long bb = mm, uu = 1, vv = 0;
while (bb) {
long long tt = aa / bb;
aa -= tt * bb;
swap(aa, bb);
uu -= tt * vv;
swap(uu, vv);
}
uu %= mm;
if (uu < 0)
uu += mm;
return uu;
}
ll minn, maxx;
double ansa;
ll zettai(ll aa) {
if (aa < 0) {
aa *= -1;
}
return aa;
}
double ab[20000];
ll ha[2];
ll x, y;
struct edge {
ll from;
ll to;
ll cost;
};
ll V, E, d[300000];
edge es[300000];
bool has_negative_loop(ll s) {
fill(d, d + V, 50000000000000000);
d[s] = 0;
for (ll i = 0; i <= 2 * V; i++) {
for (ll j = 0; j < E; j++) {
edge e = es[j];
if (d[(int)e.to] > d[(int)e.from] + e.cost) {
d[(int)e.to] = d[(int)e.from] + e.cost;
if (i >= V && e.to == V - 1) {
return true;
}
}
}
}
return false;
}
int main() {
cin >> V >> E >> b;
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 -= b;
es[i].cost *= -1;
}
f = has_negative_loop(0);
if (f) {
cout << -1 << endl;
} else {
x = d[V - 1];
x *= -1;
x = max(x, 0ll);
cout << x << endl;
}
// cout << fixed << setprecision(10) << ansa << endl;
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"assignment.value.change",
"variable_access.subscript.index.change"
] | 753,989 | 753,990 | u058317639 | cpp |
p02949 | //#pragma once
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cstdlib> // srand,rand
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
#define ll long long
#define modd 1000000007
#define INF 1000000000000000000ll
typedef pair<long long, long long> pl;
typedef string::const_iterator State;
class ParseError {};
class UnionFind {
public:
vector<ll> par;
vector<ll> siz;
// Constructor
UnionFind(ll sz_) : par(sz_), siz(sz_, 1LL) {
for (ll i = 0; i < sz_; ++i)
par[i] = i;
}
void init(ll sz_) {
par.resize(sz_);
siz.assign(sz_, 1LL); // resize だとなぜか初期化されなかった
for (ll i = 0; i < sz_; ++i)
par[i] = i; // 初期では親は自分自身
}
// Member Function
// Find
ll root(ll x) { // 根の検索
while (par[x] != x) {
x = par[x] = par[par[x]]; // x の親の親を x の親とする
}
return x;
}
// Union(Unite, Merge)
bool merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y)
return false;
// merge technique（データ構造をマージするテク．小を大にくっつける）
if (siz[x] < siz[y])
swap(x, y);
siz[x] += siz[y];
par[y] = x;
return true;
}
bool issame(ll x, ll y) { // 連結判定
return root(x) == root(y);
}
ll size(ll x) { // 素集合のサイズ
return siz[root(x)];
}
};
/*
struct SegmentTree {
private:
ll n;
vector<ll> node;
public:
// 元配列 v をセグメント木で表現する
SegmentTree(vector<ll> v) {
// 最下段のノード数は元配列のサイズ以上になる最小の 2 冪 ->
これを n とおく
// セグメント木全体で必要なノード数は 2n-1 個である
ll sz = v.size();
n = 1; while (n < sz) n *= 2;
node.resize(2 * n - 1, INF);
// 最下段に値を入れたあとに、下の段から順番に値を入れる
// 値を入れるには、自分の子の 2 値を参照すれば良い
for (ll i = 0; i < sz; i++) node[i + n - 1] = v[i];
for (ll i = n - 2; i >= 0; i--) node[i] = min(node[2 * i + 1],
node[2 * i + 2]);
}
void update(ll x, ll val) {
// 最下段のノードにアクセスする
x += (n - 1);
// 最下段のノードを更新したら、あとは親に上って更新していく
node[x] = val;
while (x > 0) {
x = (x - 1) / 2;
node[x] = min(node[2 * x + 1], node[2 * x + 2]);
}
}
};
*/
long long N, M, K, a, b, c, H, W, L, T;
ll A[300005] = {};
ll B[300005] = {};
ll C[300005] = {};
bool f, ff;
string S[200000];
string SS;
set<long long> sll;
pl bufpl;
vector<long long> vl[600005];
vector<long long> vll;
vector<pl> vpl;
vector<string> vs;
set<ll> llset;
multiset<ll> llmset;
queue<ll> ql;
struct ST {
ll first;
ll second;
ll kaisuu;
bool operator<(const ST &another) const {
return first < another.first; //比較
};
};
/*vector <ST> vst;
ST st[200005];
ST bufst;
bitset<5000> bits;*/
long long modinv(long long aa, long long mm) {
long long bb = mm, uu = 1, vv = 0;
while (bb) {
long long tt = aa / bb;
aa -= tt * bb;
swap(aa, bb);
uu -= tt * vv;
swap(uu, vv);
}
uu %= mm;
if (uu < 0)
uu += mm;
return uu;
}
ll minn, maxx;
double ansa;
ll zettai(ll aa) {
if (aa < 0) {
aa *= -1;
}
return aa;
}
double ab[20000];
ll ha[2];
ll x, y;
struct edge {
ll from;
ll to;
ll cost;
};
ll V, E, d[300000];
edge es[300000];
bool has_negative_loop(ll s) {
fill(d, d + V, 500000000000000000);
d[s] = 0;
for (ll i = 0; i <= 2 * V; i++) {
for (ll j = 0; j < E; j++) {
edge e = es[j];
if (d[(int)e.to] > d[(int)e.from] + e.cost) {
d[(int)e.to] = d[(int)e.from] + e.cost;
if (i >= V && e.to == E - 1) {
return true;
}
}
}
}
return false;
}
int main() {
cin >> E >> V >> b;
for (int i = 0; i < V; i++) {
cin >> es[i].from >> es[i].to >> es[i].cost;
es[i].from--;
es[i].to--;
es[i].cost -= b;
es[i].cost *= -1;
}
f = has_negative_loop(0);
if (f) {
cout << -1 << endl;
} else {
x = d[E - 1];
x *= -1;
x = max(x, 0ll);
cout << x << endl;
}
// cout << fixed << setprecision(10) << ansa << endl;
return 0;
}
| //#pragma once
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cstdlib> // srand,rand
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
#define ll long long
#define modd 1000000007
#define INF 1000000000000000000ll
typedef pair<long long, long long> pl;
typedef string::const_iterator State;
class ParseError {};
class UnionFind {
public:
vector<ll> par;
vector<ll> siz;
// Constructor
UnionFind(ll sz_) : par(sz_), siz(sz_, 1LL) {
for (ll i = 0; i < sz_; ++i)
par[i] = i;
}
void init(ll sz_) {
par.resize(sz_);
siz.assign(sz_, 1LL); // resize だとなぜか初期化されなかった
for (ll i = 0; i < sz_; ++i)
par[i] = i; // 初期では親は自分自身
}
// Member Function
// Find
ll root(ll x) { // 根の検索
while (par[x] != x) {
x = par[x] = par[par[x]]; // x の親の親を x の親とする
}
return x;
}
// Union(Unite, Merge)
bool merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y)
return false;
// merge technique（データ構造をマージするテク．小を大にくっつける）
if (siz[x] < siz[y])
swap(x, y);
siz[x] += siz[y];
par[y] = x;
return true;
}
bool issame(ll x, ll y) { // 連結判定
return root(x) == root(y);
}
ll size(ll x) { // 素集合のサイズ
return siz[root(x)];
}
};
/*
struct SegmentTree {
private:
ll n;
vector<ll> node;
public:
// 元配列 v をセグメント木で表現する
SegmentTree(vector<ll> v) {
// 最下段のノード数は元配列のサイズ以上になる最小の 2 冪 ->
これを n とおく
// セグメント木全体で必要なノード数は 2n-1 個である
ll sz = v.size();
n = 1; while (n < sz) n *= 2;
node.resize(2 * n - 1, INF);
// 最下段に値を入れたあとに、下の段から順番に値を入れる
// 値を入れるには、自分の子の 2 値を参照すれば良い
for (ll i = 0; i < sz; i++) node[i + n - 1] = v[i];
for (ll i = n - 2; i >= 0; i--) node[i] = min(node[2 * i + 1],
node[2 * i + 2]);
}
void update(ll x, ll val) {
// 最下段のノードにアクセスする
x += (n - 1);
// 最下段のノードを更新したら、あとは親に上って更新していく
node[x] = val;
while (x > 0) {
x = (x - 1) / 2;
node[x] = min(node[2 * x + 1], node[2 * x + 2]);
}
}
};
*/
long long N, M, K, a, b, c, H, W, L, T;
ll A[300005] = {};
ll B[300005] = {};
ll C[300005] = {};
bool f, ff;
string S[200000];
string SS;
set<long long> sll;
pl bufpl;
vector<long long> vl[600005];
vector<long long> vll;
vector<pl> vpl;
vector<string> vs;
set<ll> llset;
multiset<ll> llmset;
queue<ll> ql;
struct ST {
ll first;
ll second;
ll kaisuu;
bool operator<(const ST &another) const {
return first < another.first; //比較
};
};
/*vector <ST> vst;
ST st[200005];
ST bufst;
bitset<5000> bits;*/
long long modinv(long long aa, long long mm) {
long long bb = mm, uu = 1, vv = 0;
while (bb) {
long long tt = aa / bb;
aa -= tt * bb;
swap(aa, bb);
uu -= tt * vv;
swap(uu, vv);
}
uu %= mm;
if (uu < 0)
uu += mm;
return uu;
}
ll minn, maxx;
double ansa;
ll zettai(ll aa) {
if (aa < 0) {
aa *= -1;
}
return aa;
}
double ab[20000];
ll ha[2];
ll x, y;
struct edge {
ll from;
ll to;
ll cost;
};
ll V, E, d[300000];
edge es[300000];
bool has_negative_loop(ll s) {
fill(d, d + V, 50000000000000000);
d[s] = 0;
for (ll i = 0; i <= 2 * V; i++) {
for (ll j = 0; j < E; j++) {
edge e = es[j];
if (d[(int)e.to] > d[(int)e.from] + e.cost) {
d[(int)e.to] = d[(int)e.from] + e.cost;
if (i >= V && e.to == V - 1) {
return true;
}
}
}
}
return false;
}
int main() {
cin >> V >> E >> b;
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 -= b;
es[i].cost *= -1;
}
f = has_negative_loop(0);
if (f) {
cout << -1 << endl;
} else {
x = d[V - 1];
x *= -1;
x = max(x, 0ll);
cout << x << endl;
}
// cout << fixed << setprecision(10) << ansa << endl;
return 0;
}
| [
"literal.number.change",
"call.arguments.change",
"identifier.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"assignment.value.change",
"variable_access.subscript.index.change"
] | 753,991 | 753,990 | u058317639 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
struct Graph {
struct Edge {
int u, v;
int cost;
Edge(int _u, int _v, int _cost) : u(_u), v(_v), cost(_cost) {}
};
int n, m;
bool is_digraph;
vector<vector<int>> g;
vector<Edge> e;
Graph(int _n) : n(_n), m(0) {
assert(n >= 1);
g.resize(n);
set_di(false);
}
Graph(int _n, int _m, bool _di = false) : n(_n) {
assert(n >= 1);
g.resize(n);
e.reserve(_m);
m = 0;
set_di(_di);
input(_m);
}
void set_di(bool _di) { is_digraph = _di; }
inline void add(int u, int v, int cost = 1) {
assert(0 <= u && u < n);
assert(0 <= v && v < n);
if (is_digraph) {
// outdeg[u]++; indeg[v]++;
g[u].emplace_back(m);
} else {
// deg[u]++; deg[v]++;
g[u].emplace_back(m);
g[v].emplace_back(m);
}
e.emplace_back(u, v, cost);
m++;
}
void input(int _m) {
int u, v, c;
for (int i = 0; i < _m; i++) {
cin >> u >> v >> c;
u--;
v--; // input 1-based
add(u, v, c);
}
}
template <typename T = int> vector<T> bellman_ford(int s, int normal);
};
// single source shortest path
// allow negative, but not -cycle
template <typename T> vector<T> Graph::bellman_ford(int s, int normal) {
const int INF = 0x3f3f3f3f;
vector<T> d(n, INF);
d[s] = 0;
// if detect, add another round
for (int i = 0; i < n - normal; i++) {
// add flag early stop for constant optimization
for (auto &k : e) {
if (d[k.u] < INF && d[k.v] > d[k.u] + k.cost)
d[k.v] = d[k.u] + k.cost;
}
}
return d;
}
void solve() {
int n, m, p;
cin >> n >> m >> p;
Graph g(n);
g.set_di(true);
for (int i = 0; i < m; i++) {
int x, y, c;
cin >> x >> y >> c;
x--;
y--;
g.add(x, y, p - c);
}
auto d = g.bellman_ford<int>(0, 1);
auto f = g.bellman_ford<int>(0, 0);
int res = d[n - 1] == f[n - 1] ? max(0, -d[n - 1]) : -1;
cout << res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
cout << endl;
}
| #include <bits/stdc++.h>
using namespace std;
struct Graph {
struct Edge {
int u, v;
int cost;
Edge(int _u, int _v, int _cost) : u(_u), v(_v), cost(_cost) {}
};
int n, m;
bool is_digraph;
vector<vector<int>> g;
vector<Edge> e;
Graph(int _n) : n(_n), m(0) {
assert(n >= 1);
g.resize(n);
set_di(false);
}
Graph(int _n, int _m, bool _di = false) : n(_n) {
assert(n >= 1);
g.resize(n);
e.reserve(_m);
m = 0;
set_di(_di);
input(_m);
}
void set_di(bool _di) { is_digraph = _di; }
inline void add(int u, int v, int cost = 1) {
assert(0 <= u && u < n);
assert(0 <= v && v < n);
if (is_digraph) {
// outdeg[u]++; indeg[v]++;
g[u].emplace_back(m);
} else {
// deg[u]++; deg[v]++;
g[u].emplace_back(m);
g[v].emplace_back(m);
}
e.emplace_back(u, v, cost);
m++;
}
void input(int _m) {
int u, v, c;
for (int i = 0; i < _m; i++) {
cin >> u >> v >> c;
u--;
v--; // input 1-based
add(u, v, c);
}
}
template <typename T = int> vector<T> bellman_ford(int s, int normal);
};
// single source shortest path
// allow negative, but not -cycle
template <typename T> vector<T> Graph::bellman_ford(int s, int normal) {
const int INF = 0x3f3f3f3f;
vector<T> d(n, INF);
d[s] = 0;
// if detect, add another round
for (int i = 0; i < n - normal; i++) {
// add flag early stop for constant optimization
for (auto &k : e) {
if (d[k.u] < INF && d[k.v] > d[k.u] + k.cost)
d[k.v] = d[k.u] + k.cost;
}
}
return d;
}
void solve() {
int n, m, p;
cin >> n >> m >> p;
Graph g(n);
g.set_di(true);
for (int i = 0; i < m; i++) {
int x, y, c;
cin >> x >> y >> c;
x--;
y--;
g.add(x, y, p - c);
}
auto d = g.bellman_ford<int>(0, 1);
auto f = g.bellman_ford<int>(0, -n);
int res = d[n - 1] == f[n - 1] ? max(0, -d[n - 1]) : -1;
cout << res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
cout << endl;
}
| [
"call.arguments.change",
"expression.operation.unary.add"
] | 753,997 | 753,998 | u031986221 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int i = 0, i##_max = (N); i < i##_max; ++i)
#define repp(i, l, r) for (int i = (l), i##_max = (r); i < i##_max; ++i)
#define per(i, N) for (int i = (N)-1; i >= 0; --i)
#define perr(i, l, r) for (int i = r - 1, i##_min(l); i >= i##_min; --i)
#define all(arr) (arr).begin(), (arr).end()
#define SP << " " <<
#define SPF << " "
#define SPEEDUP \
cin.tie(0); \
ios::sync_with_stdio(false);
#define MAX_I INT_MAX // 1e9
#define MIN_I INT_MIN //-1e9
#define MAX_UI UINT_MAX // 1e9
#define MAX_LL LLONG_MAX // 1e18
#define MIN_LL LLONG_MIN //-1e18
#define MAX_ULL ULLONG_MAX // 1e19
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<char, char> PCC;
typedef pair<ll, ll> PLL;
typedef pair<char, int> PCI;
typedef pair<int, char> PIC;
typedef pair<ll, int> PLI;
typedef pair<int, ll> PIL;
typedef pair<ll, char> PLC;
typedef pair<char, ll> PCL;
inline void YesNo(bool b) { cout << (b ? "Yes" : "No") << endl; }
inline void YESNO(bool b) { cout << (b ? "YES" : "NO") << endl; }
inline void Yay(bool b) { cout << (b ? "Yay!" : ":(") << endl; }
typedef struct {
int from, to;
ll cost;
} edge;
const int V_MAX = 2510, E_MAX = 5010;
int V, E;
ll P;
vector<edge> es(E_MAX);
vector<vector<int>> G(V_MAX);
vector<vector<int>> G2(V_MAX);
vector<bool> canmove(V_MAX, false);
vector<bool> canmove2(V_MAX, false);
vector<ll> d(V_MAX, MAX_I);
//ゴールまで行ける場所
int dfs(int g) {
if (canmove2[g])
return 0;
canmove2[g] = true;
for (const int &e : G[g]) {
dfs(e);
}
return 0;
}
int dfs2(int g) {
if (!canmove2[g])
return 0;
if (canmove[g])
return 0;
canmove[g] = true;
for (const int &e : G2[g]) {
dfs(e);
}
return 0;
}
int bellmanford(int s) {
rep(i, V) d[i] = MAX_I;
d[s] = 0;
if (!canmove[s])
return 0;
while (true) {
bool update = false;
for (const edge &e : es) {
if (!canmove[e.to])
continue;
if (d[e.from] != MAX_I && d[e.to] > d[e.from] + e.cost) {
d[e.to] = d[e.from] + e.cost;
update = true;
}
}
if (!update)
break;
}
return 1;
}
bool find_negative_loop() {
rep(i, V) d[i] = 0;
rep(i, V) {
for (const edge &e : es) {
if (!canmove[e.to])
continue;
if (d[e.from] != MAX_I && d[e.to] > d[e.from] + e.cost) {
d[e.to] = d[e.from] + e.cost;
if (i == V - 1)
return true;
}
}
}
return false;
}
int main(void) {
SPEEDUP
cout << setprecision(15);
cin >> V >> E >> P;
rep(i, E) {
int A, B;
ll C;
cin >> A >> B >> C;
--A;
--B;
es.push_back({A, B, P - C});
G[B].push_back(A);
G2[A].push_back(B);
}
dfs(V - 1);
dfs2(0);
if (find_negative_loop()) {
cout << -1 << endl;
return 0;
}
bellmanford(0);
cout << max(0ll, -d[V - 1]) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int i = 0, i##_max = (N); i < i##_max; ++i)
#define repp(i, l, r) for (int i = (l), i##_max = (r); i < i##_max; ++i)
#define per(i, N) for (int i = (N)-1; i >= 0; --i)
#define perr(i, l, r) for (int i = r - 1, i##_min(l); i >= i##_min; --i)
#define all(arr) (arr).begin(), (arr).end()
#define SP << " " <<
#define SPF << " "
#define SPEEDUP \
cin.tie(0); \
ios::sync_with_stdio(false);
#define MAX_I INT_MAX // 1e9
#define MIN_I INT_MIN //-1e9
#define MAX_UI UINT_MAX // 1e9
#define MAX_LL LLONG_MAX // 1e18
#define MIN_LL LLONG_MIN //-1e18
#define MAX_ULL ULLONG_MAX // 1e19
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<char, char> PCC;
typedef pair<ll, ll> PLL;
typedef pair<char, int> PCI;
typedef pair<int, char> PIC;
typedef pair<ll, int> PLI;
typedef pair<int, ll> PIL;
typedef pair<ll, char> PLC;
typedef pair<char, ll> PCL;
inline void YesNo(bool b) { cout << (b ? "Yes" : "No") << endl; }
inline void YESNO(bool b) { cout << (b ? "YES" : "NO") << endl; }
inline void Yay(bool b) { cout << (b ? "Yay!" : ":(") << endl; }
typedef struct {
int from, to;
ll cost;
} edge;
const int V_MAX = 2510, E_MAX = 5010;
int V, E;
ll P;
vector<edge> es(E_MAX);
vector<vector<int>> G(V_MAX);
vector<vector<int>> G2(V_MAX);
vector<bool> canmove(V_MAX, false);
vector<bool> canmove2(V_MAX, false);
vector<ll> d(V_MAX, MAX_I);
//ゴールまで行ける場所
int dfs(int g) {
if (canmove2[g])
return 0;
canmove2[g] = true;
for (const int &e : G[g]) {
dfs(e);
}
return 0;
}
int dfs2(int g) {
if (!canmove2[g])
return 0;
if (canmove[g])
return 0;
canmove[g] = true;
for (const int &e : G2[g]) {
dfs2(e);
}
return 0;
}
int bellmanford(int s) {
rep(i, V) d[i] = MAX_I;
d[s] = 0;
if (!canmove[s])
return 0;
while (true) {
bool update = false;
for (const edge &e : es) {
if (!canmove[e.from])
continue;
if (d[e.from] != MAX_I && d[e.to] > d[e.from] + e.cost) {
d[e.to] = d[e.from] + e.cost;
update = true;
}
}
if (!update)
break;
}
return 1;
}
bool find_negative_loop() {
rep(i, V) d[i] = 0;
rep(i, V) {
for (const edge &e : es) {
if (!canmove[e.from])
continue;
if (d[e.from] != MAX_I && d[e.to] > d[e.from] + e.cost) {
d[e.to] = d[e.from] + e.cost;
if (i == V - 1)
return true;
}
}
}
return false;
}
int main(void) {
SPEEDUP
cout << setprecision(15);
cin >> V >> E >> P;
rep(i, E) {
int A, B;
ll C;
cin >> A >> B >> C;
--A;
--B;
es.push_back({A, B, P - C});
G[B].push_back(A);
G2[A].push_back(B);
}
dfs(V - 1);
dfs2(0);
if (find_negative_loop()) {
cout << -1 << endl;
return 0;
}
bellmanford(0);
cout << max(0ll, -d[V - 1]) << endl;
return 0;
}
| [
"identifier.change",
"call.function.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 754,006 | 754,007 | u069450081 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define pb push_back
#define mp make_pair
#define forn(i, n) for (ll i = 0; i < n; i++)
#define fore(i, a, b) for (ll i = a; i <= b; i++)
#define ford(i, n) for (ll i = n - 1; i >= 0; i--)
#define fi first
#define se second
#define endl "\n"
#define all(a) a.begin(), a.end()
#define sync \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define PI 3.14159265
/******************************************************************************************************/
void file() {
#ifndef ONLINE_JUDGE
// for getting input from input.txt
freopen("input.txt", "r", stdin);
// for writing output to output.txt
freopen("output.txt", "w", stdout);
#endif
}
/******************************************************************************************************/
const ll nax = 2e5 + 1, mod = 1e9 + 7;
int main() {
sync
// file();
ll n,
m, p1;
cin >> n >> m >> p1;
pair<ll, pair<ll, ll>> p[m];
forn(i, m) cin >> p[i].fi >> p[i].se.fi >> p[i].se.se,
p[i].se.se = -p[i].se.se + p1;
vector<ll> dist(n + 1, 1e15);
dist[1] = 0;
forn(i, n - 2) {
forn(i, m) {
if (dist[p[i].fi] + p[i].se.se < dist[p[i].se.fi]) {
dist[p[i].se.fi] = dist[p[i].fi] + p[i].se.se;
}
}
}
ll ans = dist[n];
forn(i, n - 1) {
forn(i, m) {
if (dist[p[i].fi] + p[i].se.se < dist[p[i].se.fi])
dist[p[i].se.fi] = dist[p[i].fi] + p[i].se.se;
}
}
if (ans != dist[n]) {
cout << -1;
} else {
cout << max(-ans, 0LL);
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define pb push_back
#define mp make_pair
#define forn(i, n) for (ll i = 0; i < n; i++)
#define fore(i, a, b) for (ll i = a; i <= b; i++)
#define ford(i, n) for (ll i = n - 1; i >= 0; i--)
#define fi first
#define se second
#define endl "\n"
#define all(a) a.begin(), a.end()
#define sync \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define PI 3.14159265
/******************************************************************************************************/
void file() {
#ifndef ONLINE_JUDGE
// for getting input from input.txt
freopen("input.txt", "r", stdin);
// for writing output to output.txt
freopen("output.txt", "w", stdout);
#endif
}
/******************************************************************************************************/
const ll nax = 2e5 + 1, mod = 1e9 + 7;
int main() {
sync
// file();
ll n,
m, p1;
cin >> n >> m >> p1;
pair<ll, pair<ll, ll>> p[m];
forn(i, m) cin >> p[i].fi >> p[i].se.fi >> p[i].se.se,
p[i].se.se = -p[i].se.se + p1;
vector<ll> dist(n + 1, 1e15);
dist[1] = 0;
forn(i, n - 1) {
forn(i, m) {
if (dist[p[i].fi] + p[i].se.se < dist[p[i].se.fi]) {
dist[p[i].se.fi] = dist[p[i].fi] + p[i].se.se;
}
}
}
ll ans = dist[n];
forn(i, n - 1) {
forn(i, m) {
if (dist[p[i].fi] + p[i].se.se < dist[p[i].se.fi])
dist[p[i].se.fi] = dist[p[i].fi] + p[i].se.se;
}
}
if (ans != dist[n]) {
cout << -1;
} else {
cout << max(-ans, 0LL);
}
return 0;
}
| [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 754,011 | 754,012 | u576115185 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define rrep(i, a, b) for (int i = (a); i >= (b); --i)
#define MP make_pair
#define PB push_back
#define PII pair<int, int>
typedef long long LL;
const LL P = 1e9 + 7;
const int N = 3005;
const double pi = acos(-1);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
LL n, m, p, x[N], y[N], z[N];
LL d[N];
int main() {
scanf("%d%d%d", &n, &m, &p);
rep(i, 1, m) {
scanf("%d%d%d", &x[i], &y[i], &z[i]);
z[i] = p - z[i];
}
rep(i, 1, n) d[i] = 1e9;
d[1] = 0;
rep(i, 1, n - 1) rep(j, 1, m) d[y[j]] = min(d[y[j]], d[x[j]] + z[j]);
LL ans = d[n];
rep(i, 1, n) rep(j, 1, m) d[y[j]] = min(d[y[j]], d[x[j]] + z[j]);
cout << (ans == d[n] ? max(0ll, -ans) : -1) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define rrep(i, a, b) for (int i = (a); i >= (b); --i)
#define MP make_pair
#define PB push_back
#define PII pair<int, int>
typedef long long LL;
const LL P = 1e9 + 7;
const int N = 5005;
const double pi = acos(-1);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int n, m, p, x[N], y[N], z[N];
int d[N];
int main() {
scanf("%d%d%d", &n, &m, &p);
rep(i, 1, m) {
scanf("%d%d%d", &x[i], &y[i], &z[i]);
z[i] = p - z[i];
}
rep(i, 1, n) d[i] = 1e9;
d[1] = 0;
rep(i, 1, n - 1) rep(j, 1, m) d[y[j]] = min(d[y[j]], d[x[j]] + z[j]);
int ans = d[n];
rep(i, 1, n) rep(j, 1, m) d[y[j]] = min(d[y[j]], d[x[j]] + z[j]);
cout << (ans == d[n] ? max(0, -ans) : -1) << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"variable_declaration.type.change",
"call.arguments.change"
] | 754,013 | 754,014 | u847307867 | 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 MAXN = 2500;
int N, M, P;
vector<pii> adj[MAXN + 10];
ll dist[MAXN + 10], ans;
int main() {
int i, j;
scanf("%d%d%d", &N, &M, &P);
for (i = 1; i <= M; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
c -= P;
adj[a].push_back({b, c});
}
for (i = 1; i <= N; i++)
dist[i] = -987654321;
dist[1] = 0;
for (i = 1; i <= N; i++) {
for (int now = 1; now <= N; now++) {
for (pii nxt : adj[now]) {
if (dist[now] + nxt.second > dist[nxt.first]) {
dist[nxt.first] = dist[now] + nxt.second;
}
}
}
if (i == N - 1)
ans = dist[N];
}
if (ans != dist[N])
printf("-1");
else
printf("%lld", max(0ll, dist[N]));
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int MAXN = 2500;
int N, M, P;
vector<pii> adj[MAXN + 10];
ll dist[MAXN + 10], ans;
int main() {
int i, j;
scanf("%d%d%d", &N, &M, &P);
for (i = 1; i <= M; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
c -= P;
adj[a].push_back({b, c});
}
for (i = 1; i <= N; i++)
dist[i] = -987654321;
dist[1] = 0;
for (i = 1; i <= N * 2; i++) {
for (int now = 1; now <= N; now++) {
for (pii nxt : adj[now]) {
if (dist[now] + nxt.second > dist[nxt.first]) {
dist[nxt.first] = dist[now] + nxt.second;
}
}
}
if (i == N - 1)
ans = dist[N];
}
if (ans != dist[N])
printf("-1");
else
printf("%lld", max(0ll, dist[N]));
}
| [
"control_flow.loop.for.condition.change"
] | 754,033 | 754,034 | u539847337 | 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 MAXN = 2500;
int N, M, P;
vector<pii> adj[MAXN + 10];
int dist[MAXN + 10], ans;
int main() {
int i, j;
scanf("%d%d%d", &N, &M, &P);
for (i = 1; i <= M; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
c -= P;
adj[a].push_back({b, c});
}
for (i = 1; i <= N; i++)
dist[i] = -987654321;
dist[1] = 0;
for (i = 1; i <= N; i++) {
for (int now = 1; now <= N; now++) {
for (pii nxt : adj[now]) {
if (dist[now] + nxt.second > dist[nxt.first]) {
dist[nxt.first] = dist[now] + nxt.second;
}
}
}
if (i == N - 1)
ans = dist[N];
}
if (ans != dist[N])
printf("-1");
else
printf("%d", max(0, dist[N]));
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int MAXN = 2500;
int N, M, P;
vector<pii> adj[MAXN + 10];
ll dist[MAXN + 10], ans;
int main() {
int i, j;
scanf("%d%d%d", &N, &M, &P);
for (i = 1; i <= M; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
c -= P;
adj[a].push_back({b, c});
}
for (i = 1; i <= N; i++)
dist[i] = -987654321;
dist[1] = 0;
for (i = 1; i <= N * 2; i++) {
for (int now = 1; now <= N; now++) {
for (pii nxt : adj[now]) {
if (dist[now] + nxt.second > dist[nxt.first]) {
dist[nxt.first] = dist[now] + nxt.second;
}
}
}
if (i == N - 1)
ans = dist[N];
}
if (ans != dist[N])
printf("-1");
else
printf("%lld", max(0ll, dist[N]));
}
| [
"variable_declaration.type.change",
"control_flow.loop.for.condition.change",
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 754,035 | 754,034 | u539847337 | cpp |
p02949 | #include <bits/stdc++.h>
#if MYDEBUG
#include "lib/cp_debug.hpp"
#else
#define DBG(...) ;
#endif
#if __cplusplus <= 201402L
template <typename T> T gcd(T a, T b) {
return ((a % b == 0) ? b : gcd(b, a % b));
}
template <typename T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
#endif
using LL = long long;
constexpr LL LINF = 334ll << 53;
constexpr int INF = 15 << 26;
constexpr LL MOD = 1E9 + 7;
namespace Problem {
using namespace std;
class Solver2 {
public:
int n, m, p;
vector<int> reach;
typedef pair<LL, int> PLI;
struct Edge {
int from, to;
LL cost;
Edge(int from, int to, LL cost) : from(from), to(to), cost(cost){};
};
typedef vector<vector<Edge>> Graph;
Graph g, rev;
Solver2(LL n, LL m, LL p)
: n(n), m(m), p(p), reach(n + 1), g(n + 1), rev(n){};
bool Bellman_Ford(const int start, const vector<vector<Edge>> &graph,
vector<PLI> &prev) {
int s = graph.size();
bool update = true;
fill(prev.begin(), prev.end(), make_pair(LINF, -1));
prev[start] = make_pair(0ll, start);
for (int i = 0; i < s && update; ++i, update = false) {
for (int j = 0; j < s; ++j) {
for (auto &e : graph[j]) {
if (e.to < 0)
continue;
if (prev[j].first != LINF &&
prev[e.to].first > prev[j].first + e.cost) {
prev[e.to].first = prev[j].first + e.cost;
prev[e.to].second = j;
update = true;
if (i == s - 1)
return false;
}
}
}
}
return true;
}
void solve() {
for (int i = 0; i < m; ++i) {
int a, b;
LL c;
cin >> a >> b >> c;
--a;
--b;
g[a].emplace_back(a, b, p - c);
rev[b].emplace_back(b, a, p - c);
}
g[n - 1].emplace_back(n - 1, n, 0);
reach[n - 1] = 1;
reach[n] = 1;
queue<int> Q;
Q.push(n - 1);
while (!Q.empty()) {
int now = Q.front();
Q.pop();
for (auto &x : rev[now]) {
if (!reach[x.to]) {
reach[x.to] = 1;
Q.push(x.to);
}
}
}
for (int i = 0; i < n; ++i) {
for (auto &x : g[i]) {
if (!reach[x.to]) {
x.to = -1;
}
}
}
vector<PLI> prev(n + 1);
bool ans = Bellman_Ford(0, g, prev);
if (ans == false) {
cout << -1 << endl;
} else {
cout << max(0LL, -prev[n].first) << endl;
}
}
};
} // namespace Problem
int main() {
std::cin.tie(0);
std::ios_base::sync_with_stdio(false);
// std::cout << std::fixed << std::setprecision(12);
long long n = 0, m, p;
std::cin >> n >> m >> p;
Problem::Solver2 sol(n, m, p);
sol.solve();
return 0;
}
| #include <bits/stdc++.h>
#if MYDEBUG
#include "lib/cp_debug.hpp"
#else
#define DBG(...) ;
#endif
#if __cplusplus <= 201402L
template <typename T> T gcd(T a, T b) {
return ((a % b == 0) ? b : gcd(b, a % b));
}
template <typename T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
#endif
using LL = long long;
constexpr LL LINF = 334ll << 53;
constexpr int INF = 15 << 26;
constexpr LL MOD = 1E9 + 7;
namespace Problem {
using namespace std;
class Solver2 {
public:
int n, m, p;
vector<int> reach;
typedef pair<LL, int> PLI;
struct Edge {
int from, to;
LL cost;
Edge(int from, int to, LL cost) : from(from), to(to), cost(cost){};
};
typedef vector<vector<Edge>> Graph;
Graph g, rev;
Solver2(LL n, LL m, LL p)
: n(n), m(m), p(p), reach(n + 1), g(n + 1), rev(n){};
bool Bellman_Ford(const int start, const vector<vector<Edge>> &graph,
vector<PLI> &prev) {
int s = graph.size();
bool update = true;
fill(prev.begin(), prev.end(), make_pair(LINF, -1));
prev[start] = make_pair(0ll, start);
for (int i = 0; i < s && update; ++i) {
update = false;
for (int j = 0; j < s; ++j) {
for (auto &e : graph[j]) {
if (e.to < 0)
continue;
if (prev[j].first != LINF &&
prev[e.to].first > prev[j].first + e.cost) {
prev[e.to].first = prev[j].first + e.cost;
prev[e.to].second = j;
update = true;
if (i == s - 1)
return false;
}
}
}
}
return true;
}
void solve() {
for (int i = 0; i < m; ++i) {
int a, b;
LL c;
cin >> a >> b >> c;
--a;
--b;
g[a].emplace_back(a, b, p - c);
rev[b].emplace_back(b, a, p - c);
}
g[n - 1].emplace_back(n - 1, n, 0);
reach[n - 1] = 1;
reach[n] = 1;
queue<int> Q;
Q.push(n - 1);
while (!Q.empty()) {
int now = Q.front();
Q.pop();
for (auto &x : rev[now]) {
if (!reach[x.to]) {
reach[x.to] = 1;
Q.push(x.to);
}
}
}
for (int i = 0; i < n; ++i) {
for (auto &x : g[i]) {
if (!reach[x.to]) {
x.to = -1;
}
}
}
vector<PLI> prev(n + 1);
bool ans = Bellman_Ford(0, g, prev);
if (ans == false) {
cout << -1 << endl;
} else {
cout << max(0LL, -prev[n].first) << endl;
}
}
};
} // namespace Problem
int main() {
std::cin.tie(0);
std::ios_base::sync_with_stdio(false);
// std::cout << std::fixed << std::setprecision(12);
long long n = 0, m, p;
std::cin >> n >> m >> p;
Problem::Solver2 sol(n, m, p);
sol.solve();
return 0;
}
| [] | 754,040 | 754,041 | u028496463 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int count = 0;
int j = 1;
vector<int> A(N);
for (int i = 1; i < N + 1; i++) {
int S = i / pow(10, j);
if (S >= 1)
j++;
A.at(j)++;
}
for (int j = 1; j < N; j += 2) {
count += A.at(j);
}
cout << count << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int count = 0;
int j = 1;
vector<int> A(N + 1);
for (int i = 1; i < N + 1; i++) {
int S = i / pow(10, j);
if (S >= 1)
j++;
A.at(j)++;
}
for (int j = 1; j < N + 1; j += 2) {
count += A.at(j);
}
cout << count << endl;
}
| [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 754,064 | 754,065 | u028906014 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
#define fori(x) for (int i = 0; i < x; ++i)
#define forj(x) for (int j = 0; j < x; ++j)
int main() {
int n;
cin >> n;
int s = 0;
fori(n + 1) { s += ((to_string(i + 1).size()) % 2); }
cout << s;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define fori(x) for (int i = 0; i < x; ++i)
#define forj(x) for (int j = 0; j < x; ++j)
int main() {
int n;
cin >> n;
int s = 0;
fori(n) { s += ((to_string(i + 1).size()) % 2); }
cout << s;
return 0;
} | [
"expression.operation.binary.remove"
] | 754,066 | 754,067 | u344810256 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
int power(int a, int b) {
long long int mul = 1;
while (b > 0) {
mul *= a;
b--;
}
return mul;
}
int main() {
int n, a, d = 0, sum = 0;
cin >> n;
a = n;
while (a > 0) {
a /= 10;
d++;
}
if (d % 2 == 0) {
d--;
while (d > 0) {
sum += 9 * power(10, d - 1);
d -= 2;
}
} else {
sum = n % (power(10, d - 1)) + 1;
d -= 2;
while (d > 0) {
sum += 9 * power(10, d - 1);
d -= 2;
}
}
cout << sum << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int power(int a, int b) {
long long int mul = 1;
while (b > 0) {
mul *= a;
b--;
}
return mul;
}
int main() {
int n, a, d = 0, sum = 0;
cin >> n;
a = n;
while (a > 0) {
a /= 10;
d++;
}
if (d % 2 == 0) {
d--;
while (d > 0) {
sum += 9 * (power(10, d - 1));
d -= 2;
}
} else {
sum += n - (power(10, d - 1)) + 1;
d -= 2;
while (d > 0) {
sum += 9 * (power(10, d - 1));
d -= 2;
}
}
cout << sum << endl;
return 0;
}
| [
"call.arguments.change",
"assignment.value.change",
"expression.operator.arithmetic.change",
"expression.operation.binary.change"
] | 754,068 | 754,069 | u559021558 | cpp |
p02952 | #include <iostream>
#include <stdio.h>
//#include <bits/stdc++.h>
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cmath>
#include <cstdint>
#include <cstring>
#include <float.h>
#include <iomanip>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define INF 1e7
#define rep(i, n) for (int i = 0; (i) < (int)(n); i++)
#define REP(i, a, b) for (int i = (int)(a); (i) <= (int)(b); i++)
#define VEC(type, c, n) \
std::vector<type> c(n); \
for (auto &i : c) \
std::cin >> i;
#define vec(type, n) vector<type>(n)
#define vvec(m, n) vector<vector<int>>(int(m), vector<int>(n))
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using P = pair<int, int>;
int main() {
int n;
cin >> n;
int res = 0;
REP(i, 1, n) {
int now = i, cnt = 0;
while (now) {
now /= 10;
cnt++;
if (cnt % 2 == 1)
res++;
}
}
cout << res;
}
| #include <iostream>
#include <stdio.h>
//#include <bits/stdc++.h>
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cmath>
#include <cstdint>
#include <cstring>
#include <float.h>
#include <iomanip>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define INF 1e7
#define rep(i, n) for (int i = 0; (i) < (int)(n); i++)
#define REP(i, a, b) for (int i = (int)(a); (i) <= (int)(b); i++)
#define VEC(type, c, n) \
std::vector<type> c(n); \
for (auto &i : c) \
std::cin >> i;
#define vec(type, n) vector<type>(n)
#define vvec(m, n) vector<vector<int>>(int(m), vector<int>(n))
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using P = pair<int, int>;
int main() {
int n;
cin >> n;
int res = 0;
REP(i, 1, n) {
int now = i, cnt = 0;
while (now > 0) {
now /= 10;
cnt++;
}
if (cnt % 2 == 1)
res++;
}
cout << res;
}
| [
"control_flow.loop.condition.change"
] | 754,071 | 754,072 | u516525290 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int ans = 0;
cin >> n;
for (int i = 1; i < n; i++) {
string s = to_string(i);
if (s.length() % 2 == 1)
ans++;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int ans = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
string s = to_string(i);
if (s.length() % 2 == 1)
ans++;
}
cout << ans << endl;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 754,087 | 754,088 | u503841284 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
int CountOfDigits(int n) {
int sum = 0;
while (n > 0) {
sum++;
n /= 10;
}
return sum;
}
int main() {
int N;
cin >> N;
int count = 0;
for (int i = 0; i < N; i++) {
if (CountOfDigits(i) % 2 == 1)
count++;
}
cout << count << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int CountOfDigits(int n) {
int sum = 0;
while (n > 0) { // n が 0 になるまで
sum++;
n /= 10;
}
return sum;
}
int main() {
int N;
cin >> N;
int count = 0;
for (int i = 1; i <= N; i++) {
if (CountOfDigits(i) % 2 == 1)
count++;
}
cout << count << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 754,101 | 754,102 | u533566373 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (1 <= i || i <= 9) {
ans++;
}
if (100 <= i || i <= 999) {
ans++;
}
if (10000 <= i || i <= 99999) {
ans++;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (1 <= i && i <= 9) {
ans++;
}
if (100 <= i && i <= 999) {
ans++;
}
if (10000 <= i && i <= 99999) {
ans++;
}
}
cout << ans << endl;
}
| [
"misc.opposites",
"control_flow.branch.if.condition.change"
] | 754,111 | 754,112 | u420514616 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int count = 0;
if (n < 10)
count = n;
else {
count += 9;
if (n > 100) {
if (n < 1000)
count += (n - 100) + 1;
else if (n < 10000)
count += 1000 - 100;
else {
count += 1000 - 100;
if (n <= 99999)
count += n - 9999;
else
count += 100000 - 10000;
}
}
}
cout << count << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int count = 0;
if (n < 10)
count = n;
else {
count += 9;
if (n >= 100) {
if (n < 1000)
count += (n - 100) + 1;
else if (n < 10000)
count += 1000 - 100;
else {
count += 1000 - 100;
if (n <= 99999)
count += n - 9999;
else
count += 100000 - 10000;
}
}
}
cout << count << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 754,119 | 754,120 | u538400413 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ans = 0;
for (int i = 1; i <= n; i++) {
int ctr = 0;
int cpy = n;
while (cpy) {
cpy /= 10;
ctr++;
}
if (ctr % 2 == 1)
ans++;
}
cout << ans << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ans = 0;
for (int i = 1; i <= n; i++) {
int ctr = 0;
int cpy = i;
while (cpy) {
cpy /= 10;
ctr++;
}
if (ctr % 2 == 1)
ans++;
}
cout << ans << '\n';
return 0;
} | [
"variable_declaration.value.change",
"identifier.change"
] | 754,125 | 754,126 | u248554859 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
int m = log10(i);
if (m % 2 == 1)
ans++;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
int m = log10(i) + 1;
if (m % 2 == 1)
ans++;
}
cout << ans << endl;
} | [
"assignment.change"
] | 754,139 | 754,140 | u873762144 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main(void) {
int n, ans = 0;
cin >> n;
int k = 0, tmp = n;
while (tmp > 0) {
tmp /= 10;
k++;
}
if (k == 1)
ans += n % 10;
if (k == 2)
ans += 9;
if (k == 3)
ans += n % 100 + 9 + 1;
if (k == 4)
ans += 900 + 9;
if (k == 5)
ans += n % 10000 + 900 + 9 + 1;
if (k == 6)
ans += 90000 + 900 + 9;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main(void) {
int n, ans = 0;
cin >> n;
int k = 0, tmp = n;
while (tmp > 0) {
tmp /= 10;
k++;
}
if (k == 1)
ans += n % 10;
if (k == 2)
ans += 9;
if (k == 3)
ans += n - 100 + 9 + 1;
if (k == 4)
ans += 900 + 9;
if (k == 5)
ans += n - 10000 + 900 + 9 + 1;
if (k == 6)
ans += 90000 + 900 + 9;
cout << ans << endl;
return 0;
} | [
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 754,143 | 754,144 | u690475097 | cpp |
p02952 | #include <iostream>
int digit(int n) {
int c = 0;
while (n != 0) {
c++;
n /= 10;
}
return c;
}
int main() {
int n, c = 0;
std::cin >> n;
for (int i = 1; i <= n; i++)
if (digit(i))
c++;
std::cout << c;
return 0;
}
| #include <iostream>
int digit(int n) {
int c = 0;
while (n != 0) {
c++;
n /= 10;
}
return c;
}
int main() {
int n, c = 0;
std::cin >> n;
for (int i = 1; i <= n; i++)
if (digit(i) % 2)
c++;
std::cout << c;
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 754,147 | 754,148 | u467710662 | cpp |
p02952 | #include <cmath>
#include <iostream>
int main() {
int n;
std::cin >> n;
int cnt = 1;
int temp = n;
while (temp > 9) {
++cnt;
temp /= 10;
}
int ans = 0;
for (int i = 1; i < cnt; ++i)
if (i % 2 == 1)
ans += 9 * std::pow(10, cnt - 1);
if (cnt % 2 == 1)
ans += n - std::pow(10, cnt - 1) + 1;
std::cout << ans << std::endl;
return 0;
} | #include <cmath>
#include <iostream>
int main() {
int n;
std::cin >> n;
int cnt = 1;
int temp = n;
while (temp > 9) {
++cnt;
temp /= 10;
}
int ans = 0;
for (int i = 1; i < cnt; ++i)
if (i % 2 == 1)
ans += 9 * std::pow(10, i - 1);
if (cnt % 2 == 1)
ans += n - std::pow(10, cnt - 1) + 1;
std::cout << ans << std::endl;
return 0;
} | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 754,149 | 754,150 | u864752370 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
if (N < 10) {
cout << N - 1 << endl;
} else if (N < 100) {
cout << 9 << endl;
} else if (N < 1000) {
cout << 9 + (N - 99) << endl;
} else if (N < 10000) {
cout << 909 << endl;
} else if (N < 100000) {
cout << 909 + (N - 9999) << endl;
} else {
cout << 90909 << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
if (N < 10) {
cout << N << endl;
} else if (N < 100) {
cout << 9 << endl;
} else if (N < 1000) {
cout << 9 + (N - 99) << endl;
} else if (N < 10000) {
cout << 909 << endl;
} else if (N < 100000) {
cout << 909 + (N - 9999) << endl;
} else {
cout << 90909 << endl;
}
} | [
"expression.operation.binary.remove"
] | 754,163 | 754,164 | u313124728 | cpp |
p02952 | #pragma gcc optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(V) (V).begin(), (V).end()
#define SORT(V) sort(ALL(V)) //小さい方からソート
#define REV(V) reverse(ALL(V)) //リバース
#define RSORT(V) REV(SORT(V)) //大きい方からソート
#define NPN(V) next_permutation(ALL(V)) //順列
#define pb(n) push_back(n)
#define endl '\n'
#define Endl '\n'
#define DUMP(x) cout << #x << " = " << (x) << endl
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define RAPID \
cin.tie(0); \
ios::sync_with_stdio(false)
#define IN(n) cin >> n
#define IN2(a, b) cin >> a >> b
#define IN3(a, b, c) cin >> a >> b >> c
#define VIN(V) \
for (int i = 0; i < (V).size(); i++) { \
cin >> (V).at(i); \
}
#define OUT(n) cout << n << endl
#define VOUT(V) \
for (int i = 0; i < (V).size(); i++) { \
cout << (V).at(i) << endl; \
}
// 型マクロ定義
#define int long long
#define P pair<ll, ll>
#define Vi vector<ll>
#define Vd vector<double>
#define Vs vector<string>
#define Vc vector<char>
#define M map<ll, ll>
#define S set<ll>
#define PQ priority_queue<ll>
#define PQG priority_queue < ll, V, greater<ll>
//
const int MOD = 1000000007;
const int INF = 1061109567;
const double EPS = 1e-10;
const double PI = acos(-1.0);
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; } //最小公倍数
// デフォルト変数定義
int n, m, a, b, c = 0, x, y, z;
double d, e, f;
string s, t;
//
signed main() {
RAPID;
IN(n);
REP(i, n) {
if (to_string(i).length() % 2 == 1) {
c++;
}
}
OUT(c);
} | #pragma gcc optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(V) (V).begin(), (V).end()
#define SORT(V) sort(ALL(V)) //小さい方からソート
#define REV(V) reverse(ALL(V)) //リバース
#define RSORT(V) REV(SORT(V)) //大きい方からソート
#define NPN(V) next_permutation(ALL(V)) //順列
#define pb(n) push_back(n)
#define endl '\n'
#define Endl '\n'
#define DUMP(x) cout << #x << " = " << (x) << endl
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define RAPID \
cin.tie(0); \
ios::sync_with_stdio(false)
#define IN(n) cin >> n
#define IN2(a, b) cin >> a >> b
#define IN3(a, b, c) cin >> a >> b >> c
#define VIN(V) \
for (int i = 0; i < (V).size(); i++) { \
cin >> (V).at(i); \
}
#define OUT(n) cout << n << endl
#define VOUT(V) \
for (int i = 0; i < (V).size(); i++) { \
cout << (V).at(i) << endl; \
}
// 型マクロ定義
#define int long long
#define P pair<ll, ll>
#define Vi vector<ll>
#define Vd vector<double>
#define Vs vector<string>
#define Vc vector<char>
#define M map<ll, ll>
#define S set<ll>
#define PQ priority_queue<ll>
#define PQG priority_queue < ll, V, greater<ll>
//
const int MOD = 1000000007;
const int INF = 1061109567;
const double EPS = 1e-10;
const double PI = acos(-1.0);
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; } //最小公倍数
// デフォルト変数定義
int n, m, a, b, c = 0, x, y, z;
double d, e, f;
string s, t;
//
signed main() {
RAPID;
IN(n);
FOR(i, 1, n + 1) {
if (to_string(i).length() % 2 == 1) {
c++;
}
}
OUT(c);
} | [
"call.arguments.add"
] | 754,167 | 754,168 | u154645927 | cpp |
p02952 | #include <algorithm> //辞書順はnext_permutation
#include <cmath>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stdio.h>
#include <string.h>
#include <string>
#include <time.h>
#include <utility> //swap(数値交換)
#include <vector>
#define rt "\n"
#define rep(i, n) for (int i = 0; i < n; i++)
#define rop(i, n) for (int i = 1; i <= n; i++)
#define drep(i, n) for (int i = n - 1; 0 <= i; i--)
#define yes(ans) \
if (ans) \
cout << "yes" << rt; \
else \
cout << "no" << rt;
#define Yes(ans) \
if (ans) \
cout << "Yes" << rt; \
else \
cout << "No" << rt;
#define YES(ans) \
if (ans) \
cout << "YES" << rt; \
else \
cout << "NO" << rt;
#define sort(s) sort(s.begin(), s.end())
#define reve(s) reverse(s.begin(), s.end())
#define asas int ans = 0
#define cncn int cnt = 0
#define please return
#define AC 0
using namespace std;
typedef vector<int> vint;
typedef vector<string> vstr;
typedef vector<char> vcha;
typedef long long int llint;
typedef pair<int, int> pint;
typedef pair<llint, llint> pllint;
typedef vector<llint> vllint;
typedef vector<pint> vpint;
typedef vector<pair<llint, llint>> vpllint;
typedef vector<vector<int>> vvint;
typedef vector<vector<llint>> vvllint;
typedef vector<vector<pint>> vvpint;
typedef vector<bool> vbool;
//最大公約数（GCD）を求めるよ
//最小公倍数（LCM）は＜＜ （A＋B）÷ GCD ＞＞で求まるよ
long long GCD(long long a, long long b) {
if (b == 0)
return a;
else
return GCD(b, a % b);
}
int main(void) {
int n;
cin >> n;
asas;
if (n >= 10000) {
if (n >= 100000) {
ans += 990000;
} else
ans += n - 9999;
}
if (n >= 100) {
if (n >= 1000) {
ans += 990;
} else
ans += n - 99;
}
if (n > 0) {
if (n >= 10) {
ans += 9;
} else
ans += n;
}
cout << ans << rt;
please AC;
}
// abc : 141 , aoj : ITP1_6_D
// sort, abs, swap, reverse, max, min
//__gcd, sbstring, erase, push_back,stoll、stoi | #include <algorithm> //辞書順はnext_permutation
#include <cmath>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stdio.h>
#include <string.h>
#include <string>
#include <time.h>
#include <utility> //swap(数値交換)
#include <vector>
#define rt "\n"
#define rep(i, n) for (int i = 0; i < n; i++)
#define rop(i, n) for (int i = 1; i <= n; i++)
#define drep(i, n) for (int i = n - 1; 0 <= i; i--)
#define yes(ans) \
if (ans) \
cout << "yes" << rt; \
else \
cout << "no" << rt;
#define Yes(ans) \
if (ans) \
cout << "Yes" << rt; \
else \
cout << "No" << rt;
#define YES(ans) \
if (ans) \
cout << "YES" << rt; \
else \
cout << "NO" << rt;
#define sort(s) sort(s.begin(), s.end())
#define reve(s) reverse(s.begin(), s.end())
#define asas int ans = 0
#define cncn int cnt = 0
#define please return
#define AC 0
using namespace std;
typedef vector<int> vint;
typedef vector<string> vstr;
typedef vector<char> vcha;
typedef long long int llint;
typedef pair<int, int> pint;
typedef pair<llint, llint> pllint;
typedef vector<llint> vllint;
typedef vector<pint> vpint;
typedef vector<pair<llint, llint>> vpllint;
typedef vector<vector<int>> vvint;
typedef vector<vector<llint>> vvllint;
typedef vector<vector<pint>> vvpint;
typedef vector<bool> vbool;
//最大公約数（GCD）を求めるよ
//最小公倍数（LCM）は＜＜ （A＋B）÷ GCD ＞＞で求まるよ
long long GCD(long long a, long long b) {
if (b == 0)
return a;
else
return GCD(b, a % b);
}
int main(void) {
int n;
cin >> n;
asas;
if (n >= 10000) {
if (n >= 100000) {
ans += 90000;
} else
ans += n - 9999;
}
if (n >= 100) {
if (n >= 1000) {
ans += 900;
} else
ans += n - 99;
}
if (n > 0) {
if (n >= 10) {
ans += 9;
} else
ans += n;
}
cout << ans << rt;
please AC;
}
// abc : 141 , aoj : ITP1_6_D
// sort, abs, swap, reverse, max, min
//__gcd, sbstring, erase, push_back,stoll、stoi | [
"literal.number.change",
"assignment.value.change"
] | 754,174 | 754,175 | u742306624 | cpp |
p02952 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int power(int a) {
if (a == 0)
return 1;
else
return 10 * power(a - 1);
}
int main() {
int N;
cin >> N;
int tmp = N;
int dig = 0;
while (tmp) {
dig++;
tmp /= 10;
}
int ans = 0;
if (dig % 2 != 0)
ans += N % power(dig - 1) + 1;
int ten = 1;
while (dig >= 2) {
ans += 9 * ten;
ten *= 100;
dig -= 2;
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int power(int a) {
if (a == 0)
return 1;
else
return 10 * power(a - 1);
}
int main() {
int N;
cin >> N;
int tmp = N;
int dig = 0;
while (tmp) {
dig++;
tmp /= 10;
}
// cout << dig <<endl;
int ans = 0;
if (dig % 2 != 0)
ans += N - power(dig - 1) + 1;
int ten = 1;
while (dig >= 2) {
ans += 9 * ten;
ten *= 100;
dig -= 2;
}
cout << ans << endl;
return 0;
}
| [
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 754,180 | 754,181 | u797165415 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define REP2(i, a, b) for (int i = (a); i < (int)(b); i++)
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef long long ll;
#define ALL(V) V.begin(), V.end()
template <class T, class U> bool chmin(T &a, const U &b) {
if (a <= b)
return false;
a = b;
return true;
}
template <class T, class U> bool chmax(T &a, const U &b) {
if (a >= b)
return false;
a = b;
return true;
}
int Main(int N) {
int d = to_string(N).size();
if (d == 1) {
return N;
} else if (d == 2) {
return 9;
} else if (d == 3) {
return 9 + N - 100;
} else if (d == 4) {
return 909;
} else if (d == 5) {
return 909 + N - 10000;
} else if (d == 6) {
return 90909;
} else {
return -1; // can't happen
}
}
int main(void) {
int N;
cin >> N;
cout << Main(N) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define REP2(i, a, b) for (int i = (a); i < (int)(b); i++)
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef long long ll;
#define ALL(V) V.begin(), V.end()
template <class T, class U> bool chmin(T &a, const U &b) {
if (a <= b)
return false;
a = b;
return true;
}
template <class T, class U> bool chmax(T &a, const U &b) {
if (a >= b)
return false;
a = b;
return true;
}
int Main(int N) {
int d = to_string(N).size();
if (d == 1) {
return N;
} else if (d == 2) {
return 9;
} else if (d == 3) {
return 9 + N - 99;
} else if (d == 4) {
return 909;
} else if (d == 5) {
return 909 + N - 9999;
} else if (d == 6) {
return 90909;
} else {
return -1; // can't happen
}
}
int main(void) {
int N;
cin >> N;
cout << Main(N) << endl;
return 0;
} | [
"literal.number.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 754,182 | 754,183 | u132687480 | cpp |
p02952 | #include <algorithm>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define reps(i, n) for (int i = 1; i <= (n); i++)
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
int n;
cin >> n;
int sum = 0;
for (int i = 1; i < min(10, n); i++) {
sum++;
}
for (int i = 100; i <= min(999, n); i++) {
sum++;
}
for (int i = 10000; i <= min(99999, n); i++) {
sum++;
}
cout << sum << '\n';
return 0;
}
| #include <algorithm>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define reps(i, n) for (int i = 1; i <= (n); i++)
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
int n;
cin >> n;
int sum = 0;
for (int i = 1; i <= min(9, n); i++) {
sum++;
}
for (int i = 100; i <= min(999, n); i++) {
sum++;
}
for (int i = 10000; i <= min(99999, n); i++) {
sum++;
}
cout << sum << '\n';
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"literal.number.change",
"call.arguments.change"
] | 754,191 | 754,192 | u623468376 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ans = 0;
for (int i = 0; i < n; i++) {
if (std::to_string(i).size() % 2 == 1) {
ans++;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (std::to_string(i).size() % 2 == 1) {
ans++;
}
}
cout << ans << endl;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 754,201 | 754,202 | u249218227 | cpp |
p02952 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <fstream>
#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 <tuple>
#include <unordered_map>
#include <vector>
using namespace std;
#define ll long long
#define ld long double
#define int long long
#define all(a) (a).begin(), (a).end()
#define EPS (1e-13)
#define fs first
#define sc second
#define xx first
#define yy second.first
#define zz second.second
#define H pair<int, int>
#define P pair<int, pair<int, int>>
#define Q(i, j, k) mkp(i, mkp(j, k))
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define mkp make_pair
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define crdcomp(b) \
sort(all((b))); \
(b).erase(unique(all((b))), (b).end())
#define ssp(i, n) (i == n - 1 ? "\n" : " ")
#define tpop(p) \
p.top(); \
p.pop()
const int mod = 1e9 + 7;
const int Mod = 998244353;
const ll Inf = 3 * 1e18;
const int inf = 15 * 1e8;
ll read() {
ll u, k = scanf("%lld", &u);
return u;
}
ll gcd(ll i, ll j) {
if (i > j)
swap(i, j);
if (i == 0)
return j;
return gcd(j % i, i);
}
ll mod_pow(ll x, ll n, ll p) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * x % p;
x = x * x % p;
n >>= 1;
}
return res;
}
ll bitcount(ll x) {
int sum = 0;
for (int i = 0; i < 20; i++)
if ((1ll << i) & x)
sum++;
return sum;
}
/*const int fn_ = 2000000;
ll fact_[fn_], comp_[fn_];
ll comb(ll x, ll y, ll Mod = mod) {
if (!fact_[0]) {
fact_[0] = 1; comp_[0] = 1;
for (int i = 1; i < fn_; i++) {
fact_[i] = fact_[i - 1] * i % Mod;
comp_[i] = mod_pow(fact_[i], Mod - 2, Mod);
}
}
if (x < y) return 0;
return fact_[x] * comp_[x - y] % Mod * comp_[y] % Mod;
}*/
//---------------------------------------------------
signed main() {
int n;
cin >> n;
int t = 1, ans = 0;
while (t <= n) {
for (int i = t; i < n && i < t * 10; i++) {
ans++;
}
t *= 100;
}
cout << ans << endl;
} | #define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <fstream>
#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 <tuple>
#include <unordered_map>
#include <vector>
using namespace std;
#define ll long long
#define ld long double
#define int long long
#define all(a) (a).begin(), (a).end()
#define EPS (1e-13)
#define fs first
#define sc second
#define xx first
#define yy second.first
#define zz second.second
#define H pair<int, int>
#define P pair<int, pair<int, int>>
#define Q(i, j, k) mkp(i, mkp(j, k))
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define mkp make_pair
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define crdcomp(b) \
sort(all((b))); \
(b).erase(unique(all((b))), (b).end())
#define ssp(i, n) (i == n - 1 ? "\n" : " ")
#define tpop(p) \
p.top(); \
p.pop()
const int mod = 1e9 + 7;
const int Mod = 998244353;
const ll Inf = 3 * 1e18;
const int inf = 15 * 1e8;
ll read() {
ll u, k = scanf("%lld", &u);
return u;
}
ll gcd(ll i, ll j) {
if (i > j)
swap(i, j);
if (i == 0)
return j;
return gcd(j % i, i);
}
ll mod_pow(ll x, ll n, ll p) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * x % p;
x = x * x % p;
n >>= 1;
}
return res;
}
ll bitcount(ll x) {
int sum = 0;
for (int i = 0; i < 20; i++)
if ((1ll << i) & x)
sum++;
return sum;
}
/*const int fn_ = 2000000;
ll fact_[fn_], comp_[fn_];
ll comb(ll x, ll y, ll Mod = mod) {
if (!fact_[0]) {
fact_[0] = 1; comp_[0] = 1;
for (int i = 1; i < fn_; i++) {
fact_[i] = fact_[i - 1] * i % Mod;
comp_[i] = mod_pow(fact_[i], Mod - 2, Mod);
}
}
if (x < y) return 0;
return fact_[x] * comp_[x - y] % Mod * comp_[y] % Mod;
}*/
//---------------------------------------------------
signed main() {
int n;
cin >> n;
int t = 1, ans = 0;
while (t <= n) {
for (int i = t; i <= n && i < t * 10; i++) {
ans++;
}
t *= 100;
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 754,217 | 754,218 | u811004127 | cpp |
p02952 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
// ascending order
#define vsort(v) sort(v.begin(), v.end())
// descending order
#define vsort_r(v) sort(v.begin(), v.end(), greater<int>())
#define vunique(v) v.erase(unique(v.begin(), v.end()), v.end())
#define mp make_pair
#define ts(x) to_string(x)
#define rep(i, a, b) for (int i = (int)a; i < (int)b; i++)
#define repm(i, a, b) for (int i = (int)a; i > (int)b; i--)
#define bit(a) bitset<8>(a)
#define des_priority_queue priority_queue<int, vector<int>, greater<int>>
typedef long long ll;
typedef pair<int, int> P;
const ll INF = 1e18;
#define MAX_V 1000000
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
int rsl = 0;
if (n / 9 >= 1)
rsl += 9;
else {
rsl += min(0, n);
cout << rsl << endl;
return 0;
}
if (n / 999 >= 1)
rsl += 999 - 100 + 1;
else {
rsl += max(0, n - 100 + 1);
cout << rsl << endl;
return 0;
}
if (n / 99999 >= 1)
rsl += 99999 - 10000 + 1;
else {
rsl += max(0, n - 10000 + 1);
cout << rsl << endl;
return 0;
}
cout << rsl << endl;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
// ascending order
#define vsort(v) sort(v.begin(), v.end())
// descending order
#define vsort_r(v) sort(v.begin(), v.end(), greater<int>())
#define vunique(v) v.erase(unique(v.begin(), v.end()), v.end())
#define mp make_pair
#define ts(x) to_string(x)
#define rep(i, a, b) for (int i = (int)a; i < (int)b; i++)
#define repm(i, a, b) for (int i = (int)a; i > (int)b; i--)
#define bit(a) bitset<8>(a)
#define des_priority_queue priority_queue<int, vector<int>, greater<int>>
typedef long long ll;
typedef pair<int, int> P;
const ll INF = 1e18;
#define MAX_V 1000000
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
int rsl = 0;
if (n / 9 >= 1)
rsl += 9;
else {
rsl += n;
cout << rsl << endl;
return 0;
}
if (n / 999 >= 1)
rsl += 999 - 100 + 1;
else {
rsl += max(0, n - 100 + 1);
cout << rsl << endl;
return 0;
}
if (n / 99999 >= 1)
rsl += 99999 - 10000 + 1;
else {
rsl += max(0, n - 10000 + 1);
cout << rsl << endl;
return 0;
}
cout << rsl << endl;
}
| [
"call.remove",
"call.arguments.change"
] | 754,219 | 754,220 | u355254193 | cpp |
p02952 | #include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int cnt = 0;
for (int i = 1; i < n; i++) {
if (to_string(i).size() % 2 == 1)
cnt++;
}
cout << cnt << endl;
return 0;
} | #include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (to_string(i).size() % 2 == 1)
cnt++;
}
cout << cnt << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 754,228 | 754,229 | u094619686 | cpp |
p02952 | #include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int cnt = 0;
for (int i = 0; i < n; i++) {
if (to_string(i).size() % 2 == 1)
cnt++;
}
cout << cnt << endl;
return 0;
} | #include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (to_string(i).size() % 2 == 1)
cnt++;
}
cout << cnt << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 754,230 | 754,229 | u094619686 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int ans;
for (int i = 1; i < N + 1; i++) {
if ((to_string(i).size() % 2 == 1))
ans++;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int ans = 0;
for (int i = 1; i < N + 1; i++) {
if ((to_string(i)).size() % 2 == 1)
ans++;
}
cout << ans << endl;
} | [
"variable_declaration.value.change",
"control_flow.branch.if.condition.change"
] | 754,232 | 754,233 | u297195722 | cpp |
p02952 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
int n;
cin >> n;
int ans = 0;
rep(i, n) {
if (to_string(i).size() % 2 == 1)
ans++;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
int n;
cin >> n;
int ans = 0;
rep(i, n) {
if (to_string(i + 1).size() % 2 == 1)
ans++;
}
cout << ans << endl;
}
| [
"control_flow.branch.if.condition.change"
] | 754,241 | 754,242 | u924451152 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
using vi = vector<int>; // intの1次元の型に vi という別名をつける
using vvi = vector<vi>; // intの2次元の型に vvi という別名をつける
typedef pair<int, int> pii; // pair<int, int> に pii という別名を付ける
int main() {
int N, count = 0;
cin >> N;
if (N > 10000) {
count += min(90000, N - 10000 + 1);
}
if (N > 100) {
count += min(900, N - 100 + 1);
}
if (N > 10) {
count += 9;
}
if (N < 10) {
count += N;
}
cout << count << endl;
} | #include <bits/stdc++.h>
using namespace std;
using vi = vector<int>; // intの1次元の型に vi という別名をつける
using vvi = vector<vi>; // intの2次元の型に vvi という別名をつける
typedef pair<int, int> pii; // pair<int, int> に pii という別名を付ける
int main() {
int N, count = 0;
cin >> N;
if (N >= 10000) {
count += min(90000, N - 10000 + 1);
}
if (N >= 100) {
count += min(900, N - 100 + 1);
}
if (N >= 10) {
count += 9;
}
if (N < 10) {
count += N;
}
cout << count << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 754,243 | 754,244 | u275212209 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int result = 0;
for (int i = 1; i <= n; i++) {
if (i < 10)
result++;
if (99 < i && i < 1000)
result++;
if (9999 < i)
result++;
}
cout << result << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int result = 0;
for (int i = 1; i <= n; i++) {
if (i < 10)
result++;
if (99 < i && i < 1000)
result++;
if (9999 < i && i < 100000)
result++;
}
cout << result << endl;
return 0;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 754,250 | 754,251 | u334553376 | cpp |
p02952 | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int count = 0;
while (n > 0) {
if (n >= 1 && n <= 9 || n >= 100 && n <= 999 || n >= 10000 && n <= 9999) {
count++;
}
n--;
}
cout << count << endl;
} | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int count = 0;
while (n > 0) {
if (n >= 1 && n <= 9 || n >= 100 && n <= 999 || n >= 10000 && n <= 99999) {
count++;
}
n--;
}
cout << count << endl;
} | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 754,257 | 754,258 | u553461888 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int NT = N;
int pom = 1;
long long suma = 0;
bool czy = true;
while (N /= 10) {
pom *= 10;
if (czy) {
suma += pom - pom / 10;
}
czy = !czy;
}
if (czy)
suma += NT % pom + 1;
cout << suma;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int NT = N;
int pom = 1;
long long suma = 0;
bool czy = true;
while (N /= 10) {
pom *= 10;
if (czy) {
suma += pom - pom / 10;
}
czy = !czy;
}
if (czy)
suma += NT - pom + 1;
cout << suma;
}
| [
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 754,263 | 754,264 | u898595510 | cpp |
p02952 | #include <bits/stdc++.h>
#include <string>
using namespace std;
int main() {
int count = 0;
int N;
cin >> N;
for (int i = 1; i < N; i++) {
if ((int(log10(i)) + 1) % 2) {
count++;
}
}
cout << count;
}
| #include <bits/stdc++.h>
#include <string>
using namespace std;
int main() {
int count = 0;
int N;
cin >> N;
for (int i = 1; i < N + 1; i++) {
if ((int(log10(i)) + 1) % 2) {
count++;
}
}
cout << count;
}
| [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 754,269 | 754,270 | u573537453 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int cnt = 0;
for (int i = 1; i <= n; i++)
if (to_string(i).size() % 2 == 0)
cnt++;
cout << cnt << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int cnt = 0;
for (int i = 1; i <= n; i++)
if (to_string(i).size() % 2 == 1)
cnt++;
cout << cnt << endl;
} | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 754,276 | 754,277 | u071019032 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int ans = 0;
for (int i = 0; i < N; i++) {
string s = to_string(i);
if (s.size() % 2 == 1) {
ans++;
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int ans = 0;
for (int i = 1; i <= N; i++) {
string s = to_string(i);
if (s.size() % 2 == 1) {
ans++;
}
}
cout << ans << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 754,282 | 754,283 | u584139221 | cpp |
p02952 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
int main() {
int n;
cin >> n;
int ans;
if (n < 10) {
ans = n;
} else if (n < 100) {
ans = 9;
} else if (n < 1000) {
ans = n - 99 + 9;
} else if (n < 10000) {
ans = 909;
} else if (n < 100000) {
ans = n - 999 + 909;
} else {
ans = 99000 + 909;
}
cout << ans;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
int main() {
int n;
cin >> n;
int ans;
if (n < 10) {
ans = n;
} else if (n < 100) {
ans = 9;
} else if (n < 1000) {
ans = n - 99 + 9;
} else if (n < 10000) {
ans = 909;
} else if (n < 100000) {
ans = n - 9999 + 909;
} else {
ans = 90000 + 909;
}
cout << ans;
} | [
"literal.number.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 754,288 | 754,289 | u741134767 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int count = 0;
for (int s = 0; pow(10, s) < N; ++s) {
if (s % 2 == 0 && pow(10, s + 1) <= N) {
count = count + (pow(10, s + 1) - pow(10, s));
} else if (s % 2 == 0) {
count = count + (N - pow(10, s) + 1);
}
}
cout << count << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int count = 0;
for (int s = 0; pow(10, s) <= N; ++s) {
if (s % 2 == 0 && pow(10, s + 1) <= N) {
count = count + (pow(10, s + 1) - pow(10, s));
} else if (s % 2 == 0) {
count = count + (N - pow(10, s) + 1);
}
}
cout << count << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 754,296 | 754,297 | u304862095 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, i, cnt = 0;
cin >> N;
for (i = 1; i <= N; i++) {
if (1 <= i <= 9 || 100 <= i <= 999 || 10000 <= i <= 99999)
cnt++;
}
cout << cnt << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, i, cnt = 0;
cin >> N;
for (i = 1; i <= N; i++) {
if (1 <= i && i <= 9 || 100 <= i && i <= 999 || 10000 <= i && i <= 99999)
cnt++;
}
cout << cnt << endl;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 754,298 | 754,299 | u089241640 | cpp |
p02952 | #include <iostream>
using namespace std;
int main() {
int n, u;
cin >> n;
int c = n, n_d = 0;
while (c > 0) {
n_d++;
c = c / 10;
}
int sum = 0, k = 1;
for (int i = 1; i <= n_d - 1; i++) {
if (i % 2 == 1) {
sum = sum + (9 * k);
}
k = k * 10;
}
if (n_d % 2 == 1) {
for (int i = 1; i <= n_d; i++)
u = u * 10;
sum = sum + n - u + 1;
}
cout << sum;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, u = 1;
cin >> n;
int c = n, n_d = 0;
while (c > 0) {
n_d++;
c = c / 10;
}
int sum = 0, k = 1;
for (int i = 1; i <= n_d - 1; i++) {
if (i % 2 == 1) {
sum = sum + (9 * k);
}
k = k * 10;
}
if (n_d % 2 == 1) {
for (int i = 1; i <= n_d - 1; i++)
u = u * 10;
sum = sum + n - u + 1;
}
cout << sum;
return 0;
} | [
"variable_declaration.value.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 754,310 | 754,311 | u476054945 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, cnt;
int n;
cin >> n;
if (9 >= n)
cout << n;
else if (99 >= n)
cout << 9;
else if (999 >= n)
cout << n - 90;
else if (9999 >= n)
cout << 909;
else if (99999 >= n)
cout << n - 9090;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, cnt;
int n;
cin >> n;
if (9 >= n)
cout << n;
else if (99 >= n)
cout << 9;
else if (999 >= n)
cout << n - 90;
else if (9999 >= n)
cout << 909;
else if (99999 >= n)
cout << n - 9090;
else
cout << 90909;
} | [
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add"
] | 754,314 | 754,315 | u952130512 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, ans;
cin >> a;
if (a < 10) {
ans = a;
} else if (a >= 10 && a < 100) {
ans = 9;
} else if (a >= 100 && a < 1000) {
ans = a - 90;
} else if (a >= 1000 && a < 10000) {
ans = 909;
} else if (a >= 10000 && a < 100000) {
ans = a - 9090;
} else {
ans = 90910;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, ans;
cin >> a;
if (a < 10) {
ans = a;
} else if (a >= 10 && a < 100) {
ans = 9;
} else if (a >= 100 && a < 1000) {
ans = a - 90;
} else if (a >= 1000 && a < 10000) {
ans = 909;
} else if (a >= 10000 && a < 100000) {
ans = a - 9090;
} else {
ans = 90909;
}
cout << ans << endl;
}
| [
"literal.number.change",
"assignment.value.change"
] | 754,316 | 754,317 | u431125128 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, ans;
cin >> a;
if (a < 10) {
ans = a;
} else if (a >= 10 && a < 100) {
ans = 9;
} else if (a >= 100 && a < 1000) {
ans = a - 90;
} else if (a >= 1000 && a < 10000) {
ans = 909;
} else if (a >= 10000 && a < 100000) {
ans = a - 9900;
} else {
ans = 9091;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, ans;
cin >> a;
if (a < 10) {
ans = a;
} else if (a >= 10 && a < 100) {
ans = 9;
} else if (a >= 100 && a < 1000) {
ans = a - 90;
} else if (a >= 1000 && a < 10000) {
ans = 909;
} else if (a >= 10000 && a < 100000) {
ans = a - 9090;
} else {
ans = 90909;
}
cout << ans << endl;
}
| [
"literal.number.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 754,318 | 754,317 | u431125128 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
int n, c;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
if (to_string(i).length() % 2 == 1) {
c++;
}
}
cout << n;
} | #include <bits/stdc++.h>
using namespace std;
int n, c;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
if (to_string(i).length() % 2 == 1) {
c++;
}
}
cout << c;
} | [
"identifier.change",
"io.output.change"
] | 754,319 | 754,320 | u397732894 | cpp |
p02952 | /*
Author: Arham_doshi
@quote "Code like there's no tommorow!"
*************************************** UNAUTHORISED COPYING OF CODE
PROHIBITED **********************************
*/
#include <bits/stdc++.h>
#define int long long
#define double long double
#define pb push_back
#define pf push_front
#define pii pair<int, int>
#define vi vector<int>
#define vii vector<pii>
#define mi map<int, int>
#define mii map<pii, int>
#define piii pair<int, pair<int, int>>
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define x first
#define y second
#define sz(x) (int)x.size()
#define endl '\n'
#define hell 998244353
#define PI 3.141592653589
#define bs(v, n) binary_search(all((v)), (n))
#define lb(v, n) lower_bound(all((v)), (n))
#define ub(v, n) upper_bound(all((v)), (n))
#define fo(i, l, u) for (i = l; i < u; i++)
#define rfo(i, l, u) for (i = l; i >= u; i--)
#define allfo(s) for (auto it = (s).begin(); it != (s).end(); it++)
#define _init(b) memset(b, -1, sizeof(b))
#define _init0(b) memset(b, 0, sizeof(b))
#define MOD 1000000007
#define ef else if
using namespace std;
int gcd(int a, int b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
bool mod(double a, double b) { return a / b - floor(a / b); }
int occurs(vi v, int n) {
auto it = lb(v, n);
auto it1 = ub(v, n);
int x = it1 - it;
return x;
}
int logb(int base, int x) { return (log(x) / log(base)); }
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int i, j, x, a, b, c;
cin >> a;
b = 0;
fo(i, 1, a) {
if (i < 10 || (i > 99 && i < 1000) || (i > 9999 && i < 100000))
b++;
}
cout << b;
return 0;
} | /*
Author: Arham_doshi
@quote "Code like there's no tommorow!"
*************************************** UNAUTHORISED COPYING OF CODE
PROHIBITED **********************************
*/
#include <bits/stdc++.h>
#define int long long
#define double long double
#define pb push_back
#define pf push_front
#define pii pair<int, int>
#define vi vector<int>
#define vii vector<pii>
#define mi map<int, int>
#define mii map<pii, int>
#define piii pair<int, pair<int, int>>
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define x first
#define y second
#define sz(x) (int)x.size()
#define endl '\n'
#define hell 998244353
#define PI 3.141592653589
#define bs(v, n) binary_search(all((v)), (n))
#define lb(v, n) lower_bound(all((v)), (n))
#define ub(v, n) upper_bound(all((v)), (n))
#define fo(i, l, u) for (i = l; i < u; i++)
#define rfo(i, l, u) for (i = l; i >= u; i--)
#define allfo(s) for (auto it = (s).begin(); it != (s).end(); it++)
#define _init(b) memset(b, -1, sizeof(b))
#define _init0(b) memset(b, 0, sizeof(b))
#define MOD 1000000007
#define ef else if
using namespace std;
int gcd(int a, int b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
bool mod(double a, double b) { return a / b - floor(a / b); }
int occurs(vi v, int n) {
auto it = lb(v, n);
auto it1 = ub(v, n);
int x = it1 - it;
return x;
}
int logb(int base, int x) { return (log(x) / log(base)); }
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int i, j, x, a, b, c;
cin >> a;
b = 0;
fo(i, 1, a + 1) {
if (i < 10 || (i > 99 && i < 1000) || (i > 9999 && i < 100000))
b++;
}
cout << b;
return 0;
} | [
"expression.operation.binary.add"
] | 754,321 | 754,322 | u488763956 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n < 10) {
cout << n << endl;
} else if (n < 100) {
cout << 9 << endl;
} else if (n < 1000) {
cout << 9 + n - 90 << endl;
} else if (n < 10000) {
cout << 909 << endl;
} else if (n < 100000) {
cout << 909 + n - 9000 << endl;
} else {
cout << 90909 << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n < 10) {
cout << n << endl;
} else if (n < 100) {
cout << 9 << endl;
} else if (n < 1000) {
cout << 9 + n - 99 << endl;
} else if (n < 10000) {
cout << 909 << endl;
} else if (n < 100000) {
cout << 909 + n - 9999 << endl;
} else {
cout << 90909 << endl;
}
}
| [
"literal.number.change",
"io.output.change"
] | 754,341 | 754,342 | u974931918 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vd = vector<double>;
using vc = vector<char>;
#define REP(i, x, n) for (int i = x; i < n; i++)
#define rep(i, n) REP(i, 0, n)
#define all(x) x.begin(), x.end()
int main() {
int n, ans = 0;
cin >> n;
rep(i, n) {
if (i == 10 || i == 1000 || i == 100000) {
i = i * 10 - 1;
continue;
}
ans++;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vd = vector<double>;
using vc = vector<char>;
#define REP(i, x, n) for (int i = x; i < n; i++)
#define rep(i, n) REP(i, 0, n)
#define all(x) x.begin(), x.end()
int main() {
int n, ans = 0;
cin >> n;
REP(i, 1, n + 1) {
if (i == 10 || i == 1000 || i == 100000) {
i = i * 10 - 1;
continue;
}
ans++;
}
cout << ans << endl;
} | [
"call.arguments.add"
] | 754,367 | 754,368 | u688825490 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int number = 0;
for (int i = 1; i < N + 1; i++) {
int count = 0;
int number = i;
while (number != 0) {
number /= 10;
count++;
}
if (count % 2 == 1) {
number++;
}
}
cout << number << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int number = 0;
for (int i = 1; i < N + 1; i++) {
int count = 0;
int a = i;
while (a != 0) {
a /= 10;
count++;
}
if (count % 2 == 1) {
number++;
}
}
cout << number << endl;
} | [
"variable_declaration.name.change",
"identifier.change",
"control_flow.loop.condition.change",
"assignment.variable.change"
] | 754,375 | 754,376 | u025287757 | cpp |
p02952 | #include <iostream>
#include <string>
using namespace std;
int main() {
int ans = 0;
int N;
cin >> N;
for (int i = 0; i <= N; ++i) {
if (to_string(i).size() % 2)
++ans;
}
cout << ans << endl;
} | #include <iostream>
#include <string>
using namespace std;
int main() {
int ans = 0;
int N;
cin >> N;
for (int i = 1; i <= N; ++i) {
if (to_string(i).size() % 2)
++ans;
}
cout << ans << endl;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 754,377 | 754,378 | u318334550 | cpp |
p02952 | #include <bits/stdc++.h>
#include <math.h>
using namespace std;
int main() {
int N;
cin >> N;
int ans = 0;
for (int i = 1; i < N + 1; i++) {
if (1 <= i && i < 10)
ans++;
if (100 <= i && i < 1000)
ans++;
if (10000 <= i && i < 1000000)
ans++;
if (1000000 <= i && i < 100000000)
ans++;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#include <math.h>
using namespace std;
int main() {
int N;
cin >> N;
int ans = 0;
for (int i = 1; i < N + 1; i++) {
if (1 <= i && i < 10)
ans++;
if (100 <= i && i < 1000)
ans++;
if (10000 <= i && i < 100000)
ans++;
if (1000000 <= i && i < 100000000)
ans++;
}
cout << ans << endl;
}
| [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 754,397 | 754,398 | u393754572 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int a, s;
cin >> a;
s = 0;
rep(i, a) {
if (i < 10)
s++;
else if (i > 99 && i < 1000)
s++;
else if (i > 9999 && i < 100000)
s++;
}
cout << s << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 1; i < n; i++)
int main() {
int a, s;
cin >> a;
s = 0;
rep(i, a + 1) {
if (i < 10)
s++;
else if (i > 99 && i < 1000)
s++;
else if (i > 9999 && i < 100000)
s++;
}
cout << s << endl;
} | [
"preprocessor.define.value.change",
"literal.integer.change"
] | 754,410 | 754,411 | u551813187 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int a, s;
cin >> a;
s = 0;
rep(i, a) {
if (i < 10)
s++;
else if (i > 99 && i < 1000)
s++;
else if (i > 10000 && i < 100000)
s++;
}
cout << s << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 1; i < n; i++)
int main() {
int a, s;
cin >> a;
s = 0;
rep(i, a + 1) {
if (i < 10)
s++;
else if (i > 99 && i < 1000)
s++;
else if (i > 9999 && i < 100000)
s++;
}
cout << s << endl;
} | [
"preprocessor.define.value.change",
"literal.integer.change",
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 754,412 | 754,411 | u551813187 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 1; i < n; i++)
int main() {
int a, s;
cin >> a;
s = 0;
rep(i, a + 1) {
if (i < 10)
s++;
else if (i > 99 && i < 1000)
s++;
else if (i > 1000 && i < 100000)
s++;
}
cout << s << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 1; i < n; i++)
int main() {
int a, s;
cin >> a;
s = 0;
rep(i, a + 1) {
if (i < 10)
s++;
else if (i > 99 && i < 1000)
s++;
else if (i > 9999 && i < 100000)
s++;
}
cout << s << endl;
} | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 754,413 | 754,411 | u551813187 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int a, s;
cin >> a;
s = 0;
rep(i, a) {
if (i < 10)
s++;
else if (i > 99 && i < 1000)
s++;
else if (i > 1000 && i < 100000)
s++;
}
cout << s << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 1; i < n; i++)
int main() {
int a, s;
cin >> a;
s = 0;
rep(i, a + 1) {
if (i < 10)
s++;
else if (i > 99 && i < 1000)
s++;
else if (i > 9999 && i < 100000)
s++;
}
cout << s << endl;
} | [
"preprocessor.define.value.change",
"literal.integer.change",
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 754,414 | 754,411 | u551813187 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5, M = 1e3 + 5, OO = 0x3f3f3f3f;
typedef long long ll;
int n;
int main() {
cin >> n;
if (n <= 9)
cout << n << endl;
else if (n <= 100)
cout << 9 << endl;
else if (n <= 999)
cout << n - 100 + 10;
else if (n <= 10000)
cout << 909 << endl;
else if (n <= 99999)
cout << n - 10000 + 910;
else
cout << 90909 << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5, M = 1e3 + 5, OO = 0x3f3f3f3f;
typedef long long ll;
int n;
int main() {
cin >> n;
if (n <= 9)
cout << n << endl;
else if (n < 100)
cout << 9 << endl;
else if (n <= 999)
cout << n - 100 + 10;
else if (n < 10000)
cout << 909 << endl;
else if (n <= 99999)
cout << n - 10000 + 910;
else
cout << 90909 << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 754,415 | 754,416 | u563495615 | cpp |
p02952 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repd(i, a, b) for (int i = (a); i < (b); i++)
typedef long long ll;
using namespace std;
int main() {
int n;
cin >> n;
int num = 0;
repd(i, 1, n) {
string s = to_string(i);
if (s.size() % 2 != 0)
num++;
}
cout << num << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repd(i, a, b) for (int i = (a); i < (b); i++)
typedef long long ll;
using namespace std;
int main() {
int n;
cin >> n;
int num = 0;
repd(i, 1, n + 1) {
string s = to_string(i);
if (s.size() % 2 != 0)
num++;
}
cout << num << endl;
} | [
"expression.operation.binary.add"
] | 754,417 | 754,418 | u199846743 | cpp |
p02952 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repd(i, a, b) for (int i = (a); i < (b); i++)
typedef long long ll;
using namespace std;
int main() {
int n;
cin >> n;
int num = 0;
rep(i, n) {
string s = to_string(i);
if (s.size() % 2 != 0)
num++;
}
cout << num << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repd(i, a, b) for (int i = (a); i < (b); i++)
typedef long long ll;
using namespace std;
int main() {
int n;
cin >> n;
int num = 0;
repd(i, 1, n + 1) {
string s = to_string(i);
if (s.size() % 2 != 0)
num++;
}
cout << num << endl;
} | [
"call.arguments.add"
] | 754,419 | 754,418 | u199846743 | cpp |
p02952 | #include <algorithm>
#include <iostream>
int main() {
int n;
int r = 0;
std::cin >> n;
int a = 1;
while (a < n) {
r += std::min(a * 10, n + 1) - a;
a *= 100;
}
std::cout << r;
return 0;
} | #include <algorithm>
#include <iostream>
int main() {
int n;
int r = 0;
std::cin >> n;
int a = 1;
while (a <= n) {
r += std::min(a * 10, n + 1) - a;
a *= 100;
}
std::cout << r;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 754,423 | 754,424 | u628544249 | cpp |
p02952 | #include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
bool kisu(int x) { return to_string(x).size() % 2 ? true : false; }
int main() {
int n, ans = 0;
cin >> n;
for (int i = 1; i < n; i++) {
if (kisu(i))
ans++;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
bool kisu(int x) { return to_string(x).size() % 2 == 1 ? true : false; }
int main() {
int n, ans = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
if (kisu(i))
ans++;
}
cout << ans << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 754,425 | 754,426 | u654240084 | cpp |
p02952 | #include <algorithm>
#include <cstdio>
#include <iostream>
using namespace std;
int main(void) {
int N;
scanf("%d", &N);
if (N < 10) {
printf("%d\n", N);
} else if (10 <= N && N < 100) {
printf("%d\n", 9);
} else if (100 <= N && N < 1000) {
printf("%d\n", 9 + N - 99);
} else if (1000 <= N && N < 10000) {
printf("%d\n", 9 + 999 - 99);
} else if (10000 <= N && N < 100000) {
printf("%d\n", 9 + 999 - 99 + N - 9999);
} else {
printf("%d\n", 9 + 999 - 99 + 100000 - 9999);
}
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <iostream>
using namespace std;
int main(void) {
int N;
scanf("%d", &N);
if (N < 10) {
printf("%d\n", N);
} else if (10 <= N && N < 100) {
printf("%d\n", 9);
} else if (100 <= N && N < 1000) {
printf("%d\n", 9 + N - 99);
} else if (1000 <= N && N < 10000) {
printf("%d\n", 9 + 999 - 99);
} else if (10000 <= N && N < 100000) {
printf("%d\n", 9 + 999 - 99 + N - 9999);
} else {
printf("%d\n", 9 + 999 - 99 + 99999 - 9999);
}
return 0;
}
| [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 754,441 | 754,442 | u684448032 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define pi \
3.1415926535897932384626433832795028841971693993751058209749445923078164062
#define ll long long
#define pb push_back
#define pf push_front
#define mp make_pair
#define mt make_tuple
#define popb pop_back()
#define popf pop_front()
#define ff first
#define ss second
#define vl vector<ll>
#define vi vector<int>
#define vs vector<string>
#define vll vector<pair<ll, ll>>
#define vii vector<pair<int, int>>
#define viii vector<tuple<int, int, int>>
#define vlll vector<tuple<ll, ll, ll>>
#define vvl vector<vector<ll>>
#define vv vector<vector<int>>
#define all(v) v.begin(), v.end()
#define sqrt sqrtl
#define cbrt cbrtl
#define pll pair<ll, ll>
#define pii pair<int, int>
#define mapcl map<char, ll>
#define mapci map<char, int>
#define mapll map<ll, ll>
#define mapii map<int, int>
#define seti set<int>
ifstream fin("input.txt");
ofstream fout("output.txt");
int gcd(int a, int b) {
while (a && b)
a > b ? a %= b : b %= a;
return a + b;
}
ll pows(int a, int b) {
ll res = 1;
for (int i = 0; i < b; ++i) {
res *= a;
}
return res;
}
ll logx(ll base, ll num) {
int cnt = 0;
while (num != 1) {
num /= base;
++cnt;
}
return cnt;
}
vi vis(100001, 0);
vi adj[100001];
int cnt_dig(int x) {
int cntx = 0;
while (x) {
x /= 10;
++cntx;
}
if (cntx % 2)
return 1;
else
return 0;
}
int main() {
std::ios::sync_with_stdio(false);
// cin.tie(NULL);
// cout.tie(NULL);
int n, sum = 0;
cin >> n;
for (int i = 1; i < n; ++i) {
sum += cnt_dig(i);
}
cout << sum << "\n";
} | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define pi \
3.1415926535897932384626433832795028841971693993751058209749445923078164062
#define ll long long
#define pb push_back
#define pf push_front
#define mp make_pair
#define mt make_tuple
#define popb pop_back()
#define popf pop_front()
#define ff first
#define ss second
#define vl vector<ll>
#define vi vector<int>
#define vs vector<string>
#define vll vector<pair<ll, ll>>
#define vii vector<pair<int, int>>
#define viii vector<tuple<int, int, int>>
#define vlll vector<tuple<ll, ll, ll>>
#define vvl vector<vector<ll>>
#define vv vector<vector<int>>
#define all(v) v.begin(), v.end()
#define sqrt sqrtl
#define cbrt cbrtl
#define pll pair<ll, ll>
#define pii pair<int, int>
#define mapcl map<char, ll>
#define mapci map<char, int>
#define mapll map<ll, ll>
#define mapii map<int, int>
#define seti set<int>
ifstream fin("input.txt");
ofstream fout("output.txt");
int gcd(int a, int b) {
while (a && b)
a > b ? a %= b : b %= a;
return a + b;
}
ll pows(int a, int b) {
ll res = 1;
for (int i = 0; i < b; ++i) {
res *= a;
}
return res;
}
ll logx(ll base, ll num) {
int cnt = 0;
while (num != 1) {
num /= base;
++cnt;
}
return cnt;
}
vi vis(100001, 0);
vi adj[100001];
int cnt_dig(int x) {
int cntx = 0;
while (x) {
x /= 10;
++cntx;
}
if (cntx % 2)
return 1;
else
return 0;
}
int main() {
std::ios::sync_with_stdio(false);
// cin.tie(NULL);
// cout.tie(NULL);
int n, sum = 0;
cin >> n;
for (int i = 1; i <= n; ++i) {
sum += cnt_dig(i);
}
cout << sum << "\n";
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 754,450 | 754,451 | u186089447 | cpp |
p02952 | #include <cstdio>
int main() {
int N;
scanf("%d", &N);
int count = 0;
int dec = 10;
if (N < dec)
count = N;
else
while (N >= dec) {
count += dec * 0.9;
if (N < dec * 100 && N > dec * 10) {
count += N - dec * 10;
break;
}
dec *= 100;
}
printf("%d", count);
} | #include <cstdio>
int main() {
int N;
scanf("%d", &N);
int count = 0;
int dec = 10;
if (N < dec)
count = N;
else
while (N >= dec) {
count += dec * 0.9;
if (N < dec * 100 && N >= dec * 10) {
count += N - dec * 10 + 1;
break;
}
dec *= 100;
}
printf("%d", count);
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"assignment.change"
] | 754,454 | 754,455 | u568501780 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, ans = 0;
cin >> n;
ans += (n, 9);
if (n > 99) {
ans += min(n - 99, 999 - 99);
}
if (n > 9999) {
ans += min(n - 9999, 99999 - 9999);
}
cout << ans;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, ans = 0;
cin >> n;
ans += min(n, 9);
if (n > 99) {
ans += min(n - 99, 999 - 99);
}
if (n > 9999) {
ans += min(n - 9999, 99999 - 9999);
}
cout << ans;
return 0;
}
| [
"call.add"
] | 754,458 | 754,459 | u380762346 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
if (n < 10)
printf("%d", n);
else if (n < 100)
printf("9");
else if (n < 1000)
printf("%d", n - 90);
else if (n < 10000)
printf("909");
else if (n < 100000)
printf("%d", n - 90909);
else
printf("90990");
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
if (n < 10)
printf("%d", n);
else if (n < 100)
printf("9");
else if (n < 1000)
printf("%d", n - 90);
else if (n < 10000)
printf("909");
else if (n < 100000)
printf("%d", n - 9090);
else
printf("90909");
return 0;
} | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change",
"literal.string.change"
] | 754,472 | 754,471 | u735447709 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int cnt = 0;
for (int i = 0; i < n; i++) {
int cp = i, digit = 0;
while (cp) {
digit++;
cp /= 10;
}
if (digit % 2)
cnt++;
}
cout << cnt << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int cnt = 0;
for (int i = 1; i <= n; i++) {
int cp = i, digit = 0;
while (cp) {
digit++;
cp /= 10;
}
if (digit % 2)
cnt++;
}
cout << cnt << endl;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 754,473 | 754,474 | u288432959 | cpp |
p02952 | #ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
using namespace std;
typedef long long int ll;
typedef long double ld;
typedef vector<ll> vi;
typedef vector<string> vs;
typedef pair<ll, ll> P;
typedef vector<P> vp;
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define REPR(i, n) for (int i = n - 1; i >= 0; i--)
#define FORR(i, n, m) for (int i = n - 1; i >= m; i--)
#define ARR(array) for (int i = 0; i < array.size(); i++)
#define all(in) in.begin(), in.end()
#define ALL(in, K) in, in + K
#define INF 1e18
#define MOD 1000000007
#define SIZE 10005
#define PI 3.14159265358979323846
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; } //最小公約数
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; } //最大公倍数
ll input() {
ll a;
cin >> a;
return a;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n = input();
ll ans = 0;
for (int i = 1; i < n; i *= 100) {
if (i * 10 > n)
ans += n - i + 1;
else
ans += i * 9;
// cout << ans << endl;
}
cout << ans << endl;
} | #ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
using namespace std;
typedef long long int ll;
typedef long double ld;
typedef vector<ll> vi;
typedef vector<string> vs;
typedef pair<ll, ll> P;
typedef vector<P> vp;
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define REPR(i, n) for (int i = n - 1; i >= 0; i--)
#define FORR(i, n, m) for (int i = n - 1; i >= m; i--)
#define ARR(array) for (int i = 0; i < array.size(); i++)
#define all(in) in.begin(), in.end()
#define ALL(in, K) in, in + K
#define INF 1e18
#define MOD 1000000007
#define SIZE 10005
#define PI 3.14159265358979323846
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; } //最小公約数
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; } //最大公倍数
ll input() {
ll a;
cin >> a;
return a;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n = input();
ll ans = 0;
for (int i = 1; i <= n; i *= 100) {
if (i * 10 > n)
ans += n - i + 1;
else
ans += i * 9;
// cout << ans << endl;
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 754,475 | 754,476 | u288432959 | cpp |
p02952 | #ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
using namespace std;
typedef long long int ll;
typedef long double ld;
typedef vector<ll> vi;
typedef vector<string> vs;
typedef pair<ll, ll> P;
typedef vector<P> vp;
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define REPR(i, n) for (int i = n - 1; i >= 0; i--)
#define FORR(i, n, m) for (int i = n - 1; i >= m; i--)
#define ARR(array) for (int i = 0; i < array.size(); i++)
#define all(in) in.begin(), in.end()
#define ALL(in, K) in, in + K
#define INF 1e18
#define MOD 1000000007
#define SIZE 10005
#define PI 3.14159265358979323846
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; } //最小公約数
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; } //最大公倍数
ll input() {
ll a;
cin >> a;
return a;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n = input();
ll ans = 0;
for (int i = 1; i < n; i *= 100) {
if (i * 10 > n)
ans += n % i + 1;
else
ans += i * 9;
// cout << ans << endl;
}
cout << ans << endl;
} | #ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
using namespace std;
typedef long long int ll;
typedef long double ld;
typedef vector<ll> vi;
typedef vector<string> vs;
typedef pair<ll, ll> P;
typedef vector<P> vp;
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define REPR(i, n) for (int i = n - 1; i >= 0; i--)
#define FORR(i, n, m) for (int i = n - 1; i >= m; i--)
#define ARR(array) for (int i = 0; i < array.size(); i++)
#define all(in) in.begin(), in.end()
#define ALL(in, K) in, in + K
#define INF 1e18
#define MOD 1000000007
#define SIZE 10005
#define PI 3.14159265358979323846
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; } //最小公約数
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; } //最大公倍数
ll input() {
ll a;
cin >> a;
return a;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n = input();
ll ans = 0;
for (int i = 1; i <= n; i *= 100) {
if (i * 10 > n)
ans += n - i + 1;
else
ans += i * 9;
// cout << ans << endl;
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"expression.operator.arithmetic.change",
"assignment.value.change"
] | 754,477 | 754,476 | u288432959 | cpp |
p02952 | #ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
using namespace std;
typedef long long int ll;
typedef long double ld;
typedef vector<ll> vi;
typedef vector<string> vs;
typedef pair<ll, ll> P;
typedef vector<P> vp;
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define REPR(i, n) for (int i = n - 1; i >= 0; i--)
#define FORR(i, n, m) for (int i = n - 1; i >= m; i--)
#define ARR(array) for (int i = 0; i < array.size(); i++)
#define all(in) in.begin(), in.end()
#define ALL(in, K) in, in + K
#define INF 1e18
#define MOD 1000000007
#define SIZE 10005
#define PI 3.14159265358979323846
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; } //最小公約数
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; } //最大公倍数
ll input() {
ll a;
cin >> a;
return a;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n = input();
ll ans = 0;
for (int i = 1; i < n; i *= 100) {
if (i * 10 > n)
ans += n % 100 + 1;
else
ans += i * 9;
}
cout << ans << endl;
} | #ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
using namespace std;
typedef long long int ll;
typedef long double ld;
typedef vector<ll> vi;
typedef vector<string> vs;
typedef pair<ll, ll> P;
typedef vector<P> vp;
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define REPR(i, n) for (int i = n - 1; i >= 0; i--)
#define FORR(i, n, m) for (int i = n - 1; i >= m; i--)
#define ARR(array) for (int i = 0; i < array.size(); i++)
#define all(in) in.begin(), in.end()
#define ALL(in, K) in, in + K
#define INF 1e18
#define MOD 1000000007
#define SIZE 10005
#define PI 3.14159265358979323846
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; } //最小公約数
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; } //最大公倍数
ll input() {
ll a;
cin >> a;
return a;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n = input();
ll ans = 0;
for (int i = 1; i <= n; i *= 100) {
if (i * 10 > n)
ans += n - i + 1;
else
ans += i * 9;
// cout << ans << endl;
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 754,478 | 754,476 | u288432959 | cpp |
p02952 | #include <algorithm>
#include <array>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
int main(int argc, char **argv) {
int n;
cin >> n;
if (n < 10) {
cout << n << endl;
} else if (n < 100) {
cout << 9 << endl;
} else if (n < 1000) {
cout << 9 + (n % 100 + 1) << endl;
} else if (n < 10000) {
cout << 909 << endl;
} else if (n < 100000) {
cout << 909 + (n % 10000 + 1) << endl;
} else if (n < 1000000) {
cout << 90909 << endl;
}
return 0;
}
| #include <algorithm>
#include <array>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
int main(int argc, char **argv) {
int n;
cin >> n;
if (n < 10) {
cout << n << endl;
} else if (n < 100) {
cout << 9 << endl;
} else if (n < 1000) {
cout << 9 + (n - 100 + 1) << endl;
} else if (n < 10000) {
cout << 909 << endl;
} else if (n < 100000) {
cout << 909 + (n - 10000 + 1) << endl;
} else if (n < 1000000) {
cout << 90909 << endl;
}
return 0;
}
| [
"expression.operator.arithmetic.change",
"io.output.change"
] | 754,487 | 754,488 | u229008310 | cpp |
p02952 | #include "bits/stdc++.h"
using namespace std;
int main() {
int n;
cin >> n;
int l = to_string(n).size();
int ans = 0;
switch (l) {
case 1:
ans = n;
break;
case 2:
ans = 9;
break;
case 3:
ans = 9 + n % 100 + 1;
break;
case 4:
ans = 909;
break;
case 5:
ans = 909 + n % 10000 + 1;
break;
case 6:
ans = 90909;
break;
default:
break;
}
cout << ans << endl;
} | #include "bits/stdc++.h"
using namespace std;
int main() {
int n;
cin >> n;
int l = to_string(n).size();
int ans = 0;
switch (l) {
case 1:
ans = n;
break;
case 2:
ans = 9;
break;
case 3:
ans = 9 + n - 100 + 1;
break;
case 4:
ans = 909;
break;
case 5:
ans = 909 + n - 10000 + 1;
break;
case 6:
ans = 90909;
break;
default:
break;
}
cout << ans << endl;
} | [
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 754,492 | 754,493 | u709142358 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ans = 0;
int high, low;
for (int i = 0; i < 5; i += 2) {
high = pow(10, i + 1);
low = pow(10, i);
if (high <= n)
ans += 9 * low;
else if (low < n) {
ans += n - low + 1;
break;
} else
break;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ans = 0;
int high, low;
for (int i = 0; i < 5; i += 2) {
high = pow(10, i + 1);
low = pow(10, i);
if (high <= n)
ans += 9 * low;
else if (low <= n) {
ans += n - low + 1;
break;
} else
break;
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 754,498 | 754,499 | u661308718 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
if (N < 10) {
cout << N << endl;
}
if (N >= 10 && N < 100) {
cout << "9" << endl;
}
if (N >= 100 && N < 1000) {
cout << N - 90 << endl;
}
if (N >= 1000 && N < 10000) {
cout << "909" << endl;
}
if (N >= 10000 && N < 100000) {
cout << N - 9090 << endl;
}
if (N = 100000) {
cout << "90909" << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
if (N < 10) {
cout << N << endl;
}
if (N >= 10 && N < 100) {
cout << "9" << endl;
}
if (N >= 100 && N < 1000) {
cout << N - 90 << endl;
}
if (N >= 1000 && N < 10000) {
cout << "909" << endl;
}
if (N >= 10000 && N < 100000) {
cout << N - 9090 << endl;
}
if (N >= 100000) {
cout << 90909 << endl;
}
}
| [
"control_flow.branch.if.condition.change"
] | 754,503 | 754,505 | u387371565 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, count;
cin >> n;
count = 0;
for (int i = 0; i <= n; i++) {
if (to_string(i).size() % 2 == 1) {
count++;
}
}
cout << count << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, count;
cin >> n;
count = 0;
for (int i = 1; i <= n; i++) {
if (to_string(i).size() % 2 == 1) {
count++;
}
}
cout << count << endl;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 754,512 | 754,513 | u770009793 | cpp |
p02952 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
ll mod = 1000000007;
typedef pair<int, int> P;
int main() {
int n;
cin >> n;
int cnt = 0;
for (int i = 0; i < n; i++) {
string s;
s = to_string(i);
if (s.size() % 2 == 1)
cnt++;
}
cout << cnt << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
ll mod = 1000000007;
typedef pair<int, int> P;
int main() {
int n;
cin >> n;
int cnt = 0;
for (int i = 1; i <= n; i++) {
string s;
s = to_string(i);
if (s.size() % 2 == 1)
cnt++;
}
cout << cnt << endl;
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 754,516 | 754,517 | u227379863 | cpp |
p02952 | #include <algorithm>
#include <bitset>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
// #define for(i,a,b) for (int i=(a);i<(b);++i)
typedef long long ll;
typedef pair<ll, ll> P;
#define REP(i, n) for (long long i = 0; i < (long long)(n); i++)
#define pb push_back // vectorに要素追加
#define INF (ll)1e18
ll mod = 1e9 + 7;
int main() {
// 入力
ll N;
cin >> N;
// 解法
ll ans = 0;
REP(i, N) {
if (i + 1 < 10)
ans++;
else if (100 <= i + 1 and i + 1 < 1000)
ans++;
else if (10000 <= i + 1)
ans++;
}
//出力
cout << ans << endl;
}
| #include <algorithm>
#include <bitset>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
// #define for(i,a,b) for (int i=(a);i<(b);++i)
typedef long long ll;
typedef pair<ll, ll> P;
#define REP(i, n) for (long long i = 0; i < (long long)(n); i++)
#define pb push_back // vectorに要素追加
#define INF (ll)1e18
ll mod = 1e9 + 7;
int main() {
// 入力
ll N;
cin >> N;
// 解法
ll ans = 0;
REP(i, N) {
if (i + 1 < 10)
ans++;
else if (100 <= i + 1 and i + 1 < 1000)
ans++;
else if (10000 <= i + 1 and i + 1 < 100000)
ans++;
}
//出力
cout << ans << endl;
}
| [
"control_flow.branch.if.condition.change"
] | 754,532 | 754,533 | u757738907 | cpp |
p02952 | #include <iostream>
#include <string>
using namespace std;
int main() {
int N;
cin >> N;
int counter = 0;
for (int i = 1; i < N; ++i) {
if (to_string(i).size() % 2 == 1)
counter++;
}
cout << counter << endl;
} | #include <iostream>
#include <string>
using namespace std;
int main() {
int N;
cin >> N;
int counter = 0;
for (int i = 1; i <= N; ++i) {
if (to_string(i).size() % 2 == 1)
counter++;
}
cout << counter << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 754,538 | 754,539 | u419501474 | cpp |
p02952 | #include <stdio.h>
int main(void) {
int n;
int ans = 0;
int a = 10;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
if (i < a) {
ans++;
}
if (i == a * 10) {
ans++;
a *= 100;
}
printf("%d", ans);
}
return 0;
}
| #include <stdio.h>
int main(void) {
int n;
int ans = 0;
int a = 10;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
if (i < a) {
ans++;
}
if (i == a * 10) {
ans++;
a *= 100;
}
}
printf("%d", ans);
return 0;
}
| [] | 754,540 | 754,541 | u195269284 | cpp |
p02952 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const long long mod = 1e9 + 7;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
int n;
cin >> n;
ll ans = 0;
for (int i = 1; i < n; i++) {
string s = to_string(i);
if (s.size() % 2 == 1) {
ans++;
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const long long mod = 1e9 + 7;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
int n;
cin >> n;
ll ans = 0;
for (int i = 1; i <= n; i++) {
string s = to_string(i);
if (s.size() % 2 == 1) {
ans++;
}
}
cout << ans << endl;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 754,548 | 754,549 | u291178324 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.