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 |
|---|---|---|---|---|---|---|---|
p03129 | #include <iostream>
using namespace std;
int main() {
int n, k;
cin >> n;
cin >> k;
if ((n / 2) + 1 >= k) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, k;
cin >> n;
cin >> k;
if (((n + 1) / 2) >= k) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
} | [
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 932,481 | 932,482 | u991974907 | cpp |
p03129 | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main() {
int N = 0;
int K = 0;
int ans = 0;
cin >> N >> K;
if (0 == N % 2) {
ans = N / 2;
} else {
ans = N / 2 + 1;
}
if (ans < K) {
cout << "No" << endl;
} else {
cout << "Yes" << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main() {
int N = 0;
int K = 0;
int ans = 0;
cin >> N >> K;
if (0 == N % 2) {
ans = N / 2;
} else {
ans = N / 2 + 1;
}
if (ans < K) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 932,487 | 932,488 | u566436791 | cpp |
p03129 | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
int N, K;
int main() {
cin >> N >> K;
cout << ((N + 1) / 2 + 1 >= K ? "YES" : "NO") << endl;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
int N, K;
int main() {
cin >> N >> K;
cout << ((N + 1) / 2 >= K ? "YES" : "NO") << endl;
}
| [
"expression.operation.binary.remove"
] | 932,491 | 932,492 | u430527172 | cpp |
p03129 | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
int N, K;
int main() {
cin >> N >> K;
cout << ((N + 1) / 2 + 1 >= K ? "Yes" : "No") << endl;
} | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
int N, K;
int main() {
cin >> N >> K;
cout << ((N + 1) / 2 >= K ? "YES" : "NO") << endl;
}
| [
"expression.operation.binary.remove",
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 932,493 | 932,492 | u430527172 | cpp |
p03129 | // N K
// YES NO
#include <stdio.h>
int main() {
int N, K;
scanf("%d %d", &N, &K);
if (2 * K + 1 <= N)
printf("YES");
else
printf("NO");
return 0;
}
| // N K
// YES NO
#include <stdio.h>
int main() {
int N, K;
scanf("%d %d", &N, &K);
if (2 * K - 1 <= N)
printf("YES");
else
printf("NO");
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 932,498 | 932,499 | u174028570 | cpp |
p03129 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
ll N, K;
cin >> N >> K;
if (2 * K - 1 < N) {
printf("YES\n");
return 0;
}
printf("NO\n");
}
| #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
ll N, K;
cin >> N >> K;
if (2 * K - 1 <= N) {
printf("YES\n");
return 0;
}
printf("NO\n");
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 932,500 | 932,501 | u546736430 | cpp |
p03129 | #include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
int main() {
int N, K;
cin >> N >> K;
if (N >= 2 * K + 1) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
int main() {
int N, K;
cin >> N >> K;
if (N >= 2 * K - 1) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 932,505 | 932,506 | u816742421 | cpp |
p03129 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, b, ans1, ans2;
cin >> n >> k >> b;
if (n / 2 + 1 >= k)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, b, ans1, ans2;
cin >> n >> k >> b;
if ((n + 1) / 2 >= k)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | [
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 932,509 | 932,510 | u982022271 | cpp |
p03129 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const double PI = 3.14159265358979323846;
const double EPS = 1e-12;
const ll INF = 1LL << 29;
const ll mod = 1e9 + 7;
#define rep(i, a, b) for (ll(i) = (a); (i) < (b); ++i)
int main() {
ll N, M;
cin >> N >> M;
if (N > M) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const double PI = 3.14159265358979323846;
const double EPS = 1e-12;
const ll INF = 1LL << 29;
const ll mod = 1e9 + 7;
#define rep(i, a, b) for (ll(i) = (a); (i) < (b); ++i)
int main() {
ll N, M;
cin >> N >> M;
if (N >= M * 2 - 1) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 932,513 | 932,514 | u386806796 | cpp |
p03129 | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <vector>
#define reps(i, s, n) for (int(i) = (s); (i) < (n); (i)++)
#define rep(i, n) reps(i, 0, n)
using namespace std;
using ll = long long;
int main() {
int n, k;
cin >> n >> k;
int res;
if (n % 2 == 0)
res = n - 2;
else
res = n - 1;
if (res >= k)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <vector>
#define reps(i, s, n) for (int(i) = (s); (i) < (n); (i)++)
#define rep(i, n) reps(i, 0, n)
using namespace std;
using ll = long long;
int main() {
int n, k;
cin >> n >> k;
int res;
if (n % 2 == 0)
res = n / 2;
else
res = (n + 1) / 2;
if (res >= k)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
} | [
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change",
"misc.opposites",
"assignment.change"
] | 932,515 | 932,516 | u704411633 | cpp |
p03129 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, a;
cin >> N >> a;
if (N > a - 1) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, a;
cin >> N >> a;
if (N >= 2 * a - 1) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 932,518 | 932,519 | u403984573 | cpp |
p03129 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, a;
cin >> N >> a;
if (N > a) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, a;
cin >> N >> a;
if (N >= 2 * a - 1) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 932,520 | 932,519 | u403984573 | cpp |
p03129 | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
if ((N + 1) / 2 >= K) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
if ((N + 1) / 2 >= K) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 932,521 | 932,522 | u815863697 | cpp |
p03129 | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
if ((N + 1) / 2 > K) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
if ((N + 1) / 2 >= K) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 932,523 | 932,522 | u815863697 | cpp |
p03129 | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
if ((N + 1 / 2) > K) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
if ((N + 1) / 2 >= K) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} | [
"control_flow.branch.if.condition.change",
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 932,524 | 932,522 | u815863697 | cpp |
p03129 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
if (N % 2 == 1) {
N--;
}
if (N >= K) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
if (N % 2 == 1) {
N++;
}
if (N / 2 >= K) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 932,536 | 932,537 | u979920726 | cpp |
p03129 | #include <iostream>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
if (N % 2 == 0) {
if (N / 2 >= K) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} else {
if (N > K)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
if (N % 2 == 0) {
if (N / 2 >= K) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} else {
if (N / 2 + 1 >= K)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 932,538 | 932,539 | u806800460 | cpp |
p03129 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define llong long long
#define pb(a) push_back(a)
using namespace std;
typedef pair<int, int> pii;
typedef long long int ll;
typedef pair<ll, ll> pll;
int dx[4] = {1, 0, 0, -1};
int dy[4] = {0, 1, -1, 0};
#define MOD 1000000007
#define ARRAY_MAX 100005
const int INF = 1e9 + 7;
int main() {
int n, k;
cin >> n >> k;
if (k + k - 1 <= n) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define llong long long
#define pb(a) push_back(a)
using namespace std;
typedef pair<int, int> pii;
typedef long long int ll;
typedef pair<ll, ll> pll;
int dx[4] = {1, 0, 0, -1};
int dy[4] = {0, 1, -1, 0};
#define MOD 1000000007
#define ARRAY_MAX 100005
const int INF = 1e9 + 7;
int main() {
int n, k;
cin >> n >> k;
if (k + k - 1 <= n) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 932,540 | 932,541 | u504142483 | cpp |
p03129 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int i, j;
i = n / 2;
j = n % 2;
if (j == 0) {
if (k <= i)
cout << "yes" << endl;
else
cout << "no" << endl;
} else {
if (k <= i + 1)
cout << "yes" << endl;
else
cout << "no" << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int i, j;
i = n / 2;
j = n % 2;
if (j == 0) {
if (k <= i)
cout << "YES" << endl;
else
cout << "NO" << endl;
} else {
if (k <= i + 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 932,542 | 932,543 | u567480139 | cpp |
p03129 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <string>
using namespace std;
int main() {
int k, n, t = 0;
cin >> n >> k;
n % 2 == 0 ? t = n / 2 : t = (n + 1) / 2;
cout << (t <= k ? "YES" : "NO") << endl;
} | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <string>
using namespace std;
int main() {
int k, n, t = 0;
cin >> n >> k;
n % 2 == 0 ? t = n / 2 : t = (n + 1) / 2;
cout << (k <= t ? "YES" : "NO") << endl;
} | [
"expression.operation.binary.remove"
] | 932,546 | 932,547 | u317177661 | cpp |
p03129 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <string>
using namespace std;
int main() {
int k, n, t = 0;
cin >> n, k;
n % 2 == 0 ? t = n / 2 : t = (n + 1) / 2;
cout << (t <= k ? "YES" : "NO") << endl;
} | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <string>
using namespace std;
int main() {
int k, n, t = 0;
cin >> n >> k;
n % 2 == 0 ? t = n / 2 : t = (n + 1) / 2;
cout << (k <= t ? "YES" : "NO") << endl;
} | [
"expression.operation.binary.remove"
] | 932,548 | 932,547 | u317177661 | cpp |
p03129 | #include <algorithm>
#include <cstdio>
#define REP(i, n) for (int i = 0; i < n; i++)
int N, K;
int main() {
scanf("%d %d", &N, &K);
if (N % 2 == 0) {
if (K <= N / 2)
printf("Yes\n");
else
printf("No\n");
} else {
if (K <= N / 2 + 1)
printf("Yes\n");
else
printf("No\n");
}
return 0;
}
| #include <algorithm>
#include <cstdio>
#define REP(i, n) for (int i = 0; i < n; i++)
int N, K;
int main() {
scanf("%d %d\n", &N, &K);
if (N % 2 == 0) {
if (K <= N / 2)
printf("YES\n");
else
printf("NO\n");
} else {
if (K <= N / 2 + 1)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| [
"literal.string.change",
"call.arguments.change",
"literal.string.case.change",
"io.output.change"
] | 932,549 | 932,550 | u236162829 | cpp |
p03129 | #include <algorithm>
#include <cstdio>
#define REP(i, n) for (int i = 0; i < n; i++)
int N, K;
int main() {
scanf("%d %d\n", &N, &K);
if (N % 2 == 0) {
if (K <= N / 2)
printf("Yes\n");
else
printf("No\n");
} else {
if (K <= N / 2 + 1)
printf("Yes\n");
else
printf("No\n");
}
return 0;
}
| #include <algorithm>
#include <cstdio>
#define REP(i, n) for (int i = 0; i < n; i++)
int N, K;
int main() {
scanf("%d %d\n", &N, &K);
if (N % 2 == 0) {
if (K <= N / 2)
printf("YES\n");
else
printf("NO\n");
} else {
if (K <= N / 2 + 1)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| [
"literal.string.change",
"literal.string.case.change",
"call.arguments.change",
"io.output.change"
] | 932,551 | 932,550 | u236162829 | cpp |
p03129 | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = int(a); i < int(b); ++i)
using namespace std;
typedef long long ll;
int INF = (1LL << 30) - 1;
int MOD = 1e9 + 7;
main() {
int N, K;
cin >> N >> K;
if (K <= N / 2 + 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = int(a); i < int(b); ++i)
using namespace std;
typedef long long ll;
int INF = (1LL << 30) - 1;
int MOD = 1e9 + 7;
main() {
int N, K;
cin >> N >> K;
if (K <= (N + 1) / 2)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | [
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 932,552 | 932,553 | u157322125 | cpp |
p03129 | #include <iostream>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if (n / 2.0 + 1 > k) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if (n / 2.0 + 1 > k) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 932,562 | 932,563 | u465669072 | cpp |
p03129 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
int main(void) {
int n, k;
std::cin >> n >> k;
int count = 0;
for (size_t i = 1; i < n; i += 2) {
count++;
}
if (count >= k) {
std::cout << "YES" << std::endl;
} else {
std::cout << "NO" << std::endl;
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
int main(void) {
int n, k;
std::cin >> n >> k;
int count = 0;
for (size_t i = 1; i <= n; i += 2) {
count++;
}
if (count >= k) {
std::cout << "YES" << std::endl;
} else {
std::cout << "NO" << std::endl;
}
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 932,564 | 932,565 | u914739916 | cpp |
p03129 | #include <iostream>
int main() {
unsigned int n, k;
std::cin >> n >> k;
if (n >= k + 2 - 1)
std::cout << "YES";
else
std::cout << "NO";
std::cout << std::endl;
} | #include <iostream>
int main() {
unsigned int n, k;
std::cin >> n >> k;
if (n >= k * 2 - 1)
std::cout << "YES";
else
std::cout << "NO";
std::cout << std::endl;
} | [
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 932,568 | 932,569 | u532096498 | cpp |
p03129 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if (n % 2 == 1) {
if (n / 2 + 1 >= k)
puts("Yes");
else
puts("No");
} else {
if (n / 2 >= k)
puts("Yes");
else
puts("No");
}
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if (n % 2 == 1) {
if (n / 2 + 1 >= k)
puts("YES");
else
puts("NO");
} else {
if (n / 2 >= k)
puts("YES");
else
puts("NO");
}
return 0;
}
| [
"literal.string.change",
"literal.string.case.change",
"call.arguments.change",
"io.output.change"
] | 932,579 | 932,580 | u635992896 | cpp |
p03131 | #include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)
#define all(x) (x).begin(), (x).end()
#define PI 3.14159265358979323846264338327950L
using namespace std;
typedef long long ll;
typedef long double ld;
int main() {
ll k, a, b;
cin >> k >> a >> b;
ll bisket = 1;
if (a - b <= 2)
bisket += k;
else {
bisket += a - 1;
k -= a - 1;
if (k % 2 == 1)
bisket++, k--;
bisket += (b - a) * (k / 2);
}
cout << bisket;
} | #include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)
#define all(x) (x).begin(), (x).end()
#define PI 3.14159265358979323846264338327950L
using namespace std;
typedef long long ll;
typedef long double ld;
int main() {
ll k, a, b;
cin >> k >> a >> b;
ll bisket = 1;
if (b - a <= 2)
bisket += k;
else {
bisket += a - 1;
k -= a - 1;
if (k % 2 == 1)
bisket++, k--;
bisket += (b - a) * (k / 2);
}
cout << bisket;
} | [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 932,591 | 932,592 | u151236434 | cpp |
p03131 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <unordered_map>
#include <vector>
#include <bits/stdc++.h>
#include <cmath>
#include <limits>
using namespace std;
typedef long long LL;
using Graph = vector<vector<int>>;
typedef long long LL;
static LL INF = (1LL << 62);
int main(int argc, char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
LL K, A, B;
cin >> K >> A >> B;
LL ans = 0;
if (A >= B - 1) {
ans = K + 1;
printf("%lld\n", ans);
return 0;
}
if (K <= A - 1 || K == A) {
ans += K;
printf("%lld\n", ans);
return 0;
}
K -= (A - 1);
ans = A;
LL k = K / 2;
ans += ((B - A) * k);
LL r = K % 2;
if (r != 0) {
ans++;
}
printf("%lld\n", ans);
return 0;
}
| #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <unordered_map>
#include <vector>
#include <bits/stdc++.h>
#include <cmath>
#include <limits>
using namespace std;
typedef long long LL;
using Graph = vector<vector<int>>;
typedef long long LL;
static LL INF = (1LL << 62);
int main(int argc, char *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
LL K, A, B;
cin >> K >> A >> B;
LL ans = 0;
if (A >= B - 1) {
ans = K + 1;
printf("%lld\n", ans);
return 0;
}
if (K <= A - 1 || K == A) {
ans = K + 1;
printf("%lld\n", ans);
return 0;
}
K -= (A - 1);
ans = A;
LL k = K / 2;
ans += ((B - A) * k);
LL r = K % 2;
if (r != 0) {
ans++;
}
printf("%lld\n", ans);
return 0;
}
| [
"assignment.value.change",
"assignment.change"
] | 932,597 | 932,598 | u606600497 | cpp |
p03131 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll k, a, b;
cin >> k >> a >> b;
if (b - a <= 2) {
cout << k + 1;
return 0;
} else if (a - 1 >= k) {
cout << k + 1 << endl;
} else {
ll rest = k - (a - 1);
ll ans = a;
ans += (rest / 2) * (b - a);
if (rest % 2 == 1)
rest++;
cout << ans;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll k, a, b;
cin >> k >> a >> b;
if (b - a <= 2) {
cout << k + 1;
return 0;
} else if (a - 1 >= k) {
cout << k + 1 << endl;
} else {
ll rest = k - (a - 1);
ll ans = a;
ans += (rest / 2) * (b - a);
if (rest % 2 == 1)
ans++;
cout << ans;
}
return 0;
}
| [
"identifier.change"
] | 932,601 | 932,602 | u027630431 | cpp |
p03131 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<int, ll> Pil;
typedef pair<ll, ll> Pll;
typedef pair<ll, int> Pli;
#define fi first
#define se second
const ll MOD = 1e9 + 7;
const ll MOD2 = 998244353;
const ll MOD3 = 1812447359;
const ll INF = 1ll << 62;
const double PI = 2 * asin(1);
void yes() { printf("yes\n"); }
void no() { printf("no\n"); }
void Yes() { printf("Yes\n"); }
void No() { printf("No\n"); }
void YES() { printf("YES\n"); }
void NO() { printf("NO\n"); }
ll K, A, B;
int main() {
cin >> K >> A >> B;
if (A >= B + 2 || K < A + 1) {
cout << K + 1 << endl;
return 0;
}
ll ans = B;
K -= A + 1;
ans += (B - A) * (K / 2);
if (K % 2 != 0)
ans++;
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<int, ll> Pil;
typedef pair<ll, ll> Pll;
typedef pair<ll, int> Pli;
#define fi first
#define se second
const ll MOD = 1e9 + 7;
const ll MOD2 = 998244353;
const ll MOD3 = 1812447359;
const ll INF = 1ll << 62;
const double PI = 2 * asin(1);
void yes() { printf("yes\n"); }
void no() { printf("no\n"); }
void Yes() { printf("Yes\n"); }
void No() { printf("No\n"); }
void YES() { printf("YES\n"); }
void NO() { printf("NO\n"); }
ll K, A, B;
int main() {
cin >> K >> A >> B;
if (A + 2 >= B || K < A + 1) {
cout << K + 1 << endl;
return 0;
}
ll ans = B;
K -= A + 1;
ans += (B - A) * (K / 2);
if (K % 2 != 0)
ans++;
cout << ans << endl;
return 0;
}
| [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 932,615 | 932,616 | u280096880 | cpp |
p03131 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<int, ll> Pil;
typedef pair<ll, ll> Pll;
typedef pair<ll, int> Pli;
#define fi first
#define se second
const ll MOD = 1e9 + 7;
const ll MOD2 = 998244353;
const ll MOD3 = 1812447359;
const ll INF = 1ll << 62;
const double PI = 2 * asin(1);
void yes() { printf("yes\n"); }
void no() { printf("no\n"); }
void Yes() { printf("Yes\n"); }
void No() { printf("No\n"); }
void YES() { printf("YES\n"); }
void NO() { printf("NO\n"); }
ll K, A, B;
int main() {
cin >> K >> A >> B;
if (A >= B || K < A + 1) {
cout << K + 1 << endl;
return 0;
}
ll ans = B;
K -= A + 1;
ans += (B - A) * (K / 2);
if (K % 2 != 0)
ans++;
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<int, ll> Pil;
typedef pair<ll, ll> Pll;
typedef pair<ll, int> Pli;
#define fi first
#define se second
const ll MOD = 1e9 + 7;
const ll MOD2 = 998244353;
const ll MOD3 = 1812447359;
const ll INF = 1ll << 62;
const double PI = 2 * asin(1);
void yes() { printf("yes\n"); }
void no() { printf("no\n"); }
void Yes() { printf("Yes\n"); }
void No() { printf("No\n"); }
void YES() { printf("YES\n"); }
void NO() { printf("NO\n"); }
ll K, A, B;
int main() {
cin >> K >> A >> B;
if (A + 2 >= B || K < A + 1) {
cout << K + 1 << endl;
return 0;
}
ll ans = B;
K -= A + 1;
ans += (B - A) * (K / 2);
if (K % 2 != 0)
ans++;
cout << ans << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 932,617 | 932,616 | u280096880 | cpp |
p03131 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n) for (int i = 1; i <= n; i++)
typedef long long ll;
int main() {
ll k, a, b;
cin >> k >> a >> b;
if (a + 2 >= b) {
cout << k + 1 << endl;
return 0;
} else if (k <= a) {
cout << k + 1 << endl;
}
ll ans = a;
ans += (b - a) * ((k - a + 1) / (2)) + (k - a + 1) % 2;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n) for (int i = 1; i <= n; i++)
typedef long long ll;
int main() {
ll k, a, b;
cin >> k >> a >> b;
if (a + 2 >= b) {
cout << k + 1 << endl;
return 0;
} else if (k <= a - 1) {
cout << k + 1 << endl;
}
ll ans = a;
ans += (b - a) * ((k - a + 1) / (2)) + (k - a + 1) % 2;
cout << ans << endl;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 932,622 | 932,623 | u024191315 | cpp |
p03131 | #include <bits/stdc++.h>
#include <bits/stdint-intn.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int64_t k, a, b;
std::cin >> k >> a >> b;
if (b - a <= 2) {
std::cout << k + 1 << std::endl;
} else {
k -= a - 1;
std::cout << (b - a) * k / 2 + (k % 2) << std::endl;
}
return 0;
}
| #include <bits/stdc++.h>
#include <bits/stdint-intn.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int64_t k, a, b;
std::cin >> k >> a >> b;
if (b - a <= 2) {
std::cout << k + 1 << std::endl;
} else {
k -= a - 1;
std::cout << (b - a) * (k / 2) + (k % 2) + a << std::endl;
}
return 0;
}
| [
"expression.operation.binary.add"
] | 932,634 | 932,635 | u222625974 | cpp |
p03131 | #define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repn(i, x) for (int i = 1; i <= x; i++)
#define SORT(x) sort(x.begin(), x.end())
#define dupl(s) s.erase(unique(s.begin(), s.end()), s.end()); //重複取り除き
#include <bits/stdc++.h>
using namespace std;
int sum(vector<int> s) { return accumulate(s.begin(), s.end(), 0); }
void p(vector<int> A) {
rep(i, A.size()) { cout << A[i] << " "; }
cout << "\n";
}
int main() {
int k, a, b;
cin >> k >> a >> b;
if (b - a <= 2 || k < a - 1)
cout << k + 1;
else {
long long ans = a;
k -= a - 1;
if (k % 2 == 1)
k--, ans++;
ans += (b - a) * (k / 2);
cout << ans;
}
} | #define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repn(i, x) for (int i = 1; i <= x; i++)
#define SORT(x) sort(x.begin(), x.end())
#define dupl(s) s.erase(unique(s.begin(), s.end()), s.end()); //重複取り除き
#include <bits/stdc++.h>
using namespace std;
int sum(vector<int> s) { return accumulate(s.begin(), s.end(), 0); }
void p(vector<int> A) {
rep(i, A.size()) { cout << A[i] << " "; }
cout << "\n";
}
int main() {
long long k, a, b;
cin >> k >> a >> b;
if (b - a <= 2 || k < a - 1)
cout << k + 1;
else {
long long ans = a;
k -= a - 1;
if (k % 2 == 1)
k--, ans++;
ans += (b - a) * (k / 2);
cout << ans;
}
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 932,636 | 932,637 | u854685063 | cpp |
p03131 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long k, a, b;
cin >> k >> a >> b;
// a->b;
if ((a - 1) + 1 + 1 > k || b <= a) {
cout << k + 1 << '\n';
} else {
long long x = a;
long long kk = k;
kk -= (a - 1); // get b biscuit
x += (long long)(b - a) * kk / 2;
if (kk % 2) {
x++;
}
cout << max(k + 1, x) << '\n';
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long k, a, b;
cin >> k >> a >> b;
// a->b;
if ((a - 1) + 1 + 1 > k || b <= a + 2) {
cout << k + 1 << '\n';
} else {
long long x = a;
long long kk = k;
kk -= (a - 1); // get b biscuit
x += (long long)(b - a) * (kk / 2);
if (kk % 2) {
x++;
}
cout << max(k + 1, x) << '\n';
}
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 932,638 | 932,639 | u385825353 | cpp |
p03131 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long k, a, b;
cin >> k >> a >> b;
// a->b;
if ((a - 1) + 1 + 1 > k || b <= a) {
cout << k + 1 << '\n';
} else {
long long x = a;
long long kk = k;
kk -= (a - 1); // get b biscuit
x += (long long)(b - a) * kk / 2;
if (kk % 2) {
x++;
}
cout << max(k + 1, x) << '\n';
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long k, a, b;
cin >> k >> a >> b;
// a->b;
if ((a - 1) + 1 + 1 > k || b <= a) {
cout << k + 1 << '\n';
} else {
long long x = a;
long long kk = k;
kk -= (a - 1); // get b biscuit
x += (long long)(b - a) * (kk / 2);
if (kk % 2) {
x++;
}
cout << max(k + 1, x) << '\n';
}
return 0;
}
| [] | 932,638 | 932,640 | u385825353 | cpp |
p03131 | #include <algorithm>
#include <cmath>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define ll long long
const int mod = 1000000007;
const ll INF = 1000000000000000000;
int main() {
ll K, A, B;
cin >> K >> A >> B;
if (B - A <= 2) {
cout << K + 1 << endl;
} else {
if (A >= K) {
cout << K + 1 << endl;
} else {
K -= A - 3;
cout << B + (B - A) * (K / 2) + (K % 2) << endl;
}
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define ll long long
const int mod = 1000000007;
const ll INF = 1000000000000000000;
int main() {
ll K, A, B;
cin >> K >> A >> B;
if (B - A <= 2) {
cout << K + 1 << endl;
} else {
if (A >= K) {
cout << K + 1 << endl;
} else {
K -= A - 1;
K -= 2;
cout << B + (B - A) * (K / 2) + (K % 2) << endl;
}
}
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"expression.operation.binary.change",
"assignment.add"
] | 932,647 | 932,648 | u475843109 | cpp |
p03131 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, k;
cin >> k >> a >> b;
long long ans;
if (k < a)
ans = k + 1;
else {
if (a + 2 >= b)
ans = k + 1;
else {
k -= (a - 1);
ans = (k / 2) * b - (k / 2 - 1) * a + k / 2;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, k;
cin >> k >> a >> b;
long long ans;
if (k < a)
ans = k + 1;
else {
if (a + 2 >= b)
ans = k + 1;
else {
k -= (a - 1);
ans = (k / 2) * b - (k / 2 - 1) * a + k % 2;
}
}
cout << ans << endl;
} | [
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 932,657 | 932,658 | u605833494 | cpp |
p03131 | #include <bits/stdc++.h>
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define vec_input(v) \
for (auto it = v.begin(); it != v.end(); it++) { \
cin >> *it; \
}
#define vec_output(v) \
for (auto it = v.begin(); it != v.end(); it++) { \
if (it != v.begin()) \
cout << " "; \
cout << *it; \
} \
cout << endl;
#define vec_debug(v) \
for (auto it = v.begin(); it != v.end(); it++) { \
cerr << *it << " "; \
} \
cerr << endl;
#define yn(ans) cout << (ans ? "Yes" : "No") << endl
#define YN(ans) cout << (ans ? "YES" : "NO") << endl
#define umap unordered_map
#define uset unordered_set
using namespace std;
using ll = long long;
template <typename T> T digitsum(T n);
template <typename T> bool isPrime(T n);
template <typename T> vector<pair<T, T>> prime_factor(T n);
long long int intpow(long long int, long long int);
template <typename T> T intlog(T);
long long int combination(long long int, long long int);
long long int arith_sum1(long long int, long long int, long long int);
long long int arith_sum2(long long int, long long int, long long int);
long long int series_sum(long long int);
int main() {
int k, a, b, ans;
cin >> k >> a >> b;
if (b <= a + 2) {
cout << k + 1 << endl;
} else {
k -= a - 1;
ans = a;
if (k % 2 == 1) {
k--;
ans += 1;
}
ans += k * (b - a) / 2;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define vec_input(v) \
for (auto it = v.begin(); it != v.end(); it++) { \
cin >> *it; \
}
#define vec_output(v) \
for (auto it = v.begin(); it != v.end(); it++) { \
if (it != v.begin()) \
cout << " "; \
cout << *it; \
} \
cout << endl;
#define vec_debug(v) \
for (auto it = v.begin(); it != v.end(); it++) { \
cerr << *it << " "; \
} \
cerr << endl;
#define yn(ans) cout << (ans ? "Yes" : "No") << endl
#define YN(ans) cout << (ans ? "YES" : "NO") << endl
#define umap unordered_map
#define uset unordered_set
using namespace std;
using ll = long long;
template <typename T> T digitsum(T n);
template <typename T> bool isPrime(T n);
template <typename T> vector<pair<T, T>> prime_factor(T n);
long long int intpow(long long int, long long int);
template <typename T> T intlog(T);
long long int combination(long long int, long long int);
long long int arith_sum1(long long int, long long int, long long int);
long long int arith_sum2(long long int, long long int, long long int);
long long int series_sum(long long int);
int main() {
ll k, a, b, ans;
cin >> k >> a >> b;
if (b <= a + 2) {
cout << k + 1 << endl;
return 0;
} else {
k -= a - 1;
ans = a;
if (k % 2 == 1) {
k--;
ans += 1;
}
ans += k * (b - a) / 2;
}
cout << ans << endl;
} | [
"variable_declaration.type.change",
"control_flow.return.add",
"control_flow.return.0.add"
] | 932,663 | 932,662 | u225660136 | cpp |
p03131 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define repl(i, l, r) for (ll i = (l); i < (r); i++)
#define per(i, n) for (ll i = n - 1; i >= 0; i--)
#define perl(i, r, l) for (ll i = r - 1; i >= l; i--)
#define fi first
#define se second
#define pb push_back
#define ins insert
#define pqueue(x) priority_queue<x, vector<x>, greater<x>>
#define all(x) (x).begin(), (x).end()
#define CST(x) cout << fixed << setprecision(x)
#define vtpl(x, y, z) vector<tuple<x, y, z>>
#define rev(x) reverse(x);
using ll = long long;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using pl = pair<ll, ll>;
using vpl = vector<pl>;
using vvpl = vector<vpl>;
const ll MOD = 1000000007;
const ll MOD9 = 998244353;
const int inf = 1e9 + 10;
const ll INF = 4e18;
const ll dy[8] = {1, 0, -1, 0, 1, 1, -1, -1};
const ll dx[8] = {0, -1, 0, 1, 1, -1, 1, -1};
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
ll k, a, b;
cin >> k >> a >> b;
if (a >= b + 2)
cout << k + 1 << endl;
else {
ll t = k - (a - 1);
if (t < 0) {
cout << k + 1 << endl;
} else {
cout << a + (t / 2) * (b - a) + (t % 2) << endl;
}
}
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define repl(i, l, r) for (ll i = (l); i < (r); i++)
#define per(i, n) for (ll i = n - 1; i >= 0; i--)
#define perl(i, r, l) for (ll i = r - 1; i >= l; i--)
#define fi first
#define se second
#define pb push_back
#define ins insert
#define pqueue(x) priority_queue<x, vector<x>, greater<x>>
#define all(x) (x).begin(), (x).end()
#define CST(x) cout << fixed << setprecision(x)
#define vtpl(x, y, z) vector<tuple<x, y, z>>
#define rev(x) reverse(x);
using ll = long long;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using pl = pair<ll, ll>;
using vpl = vector<pl>;
using vvpl = vector<vpl>;
const ll MOD = 1000000007;
const ll MOD9 = 998244353;
const int inf = 1e9 + 10;
const ll INF = 4e18;
const ll dy[8] = {1, 0, -1, 0, 1, 1, -1, -1};
const ll dx[8] = {0, -1, 0, 1, 1, -1, 1, -1};
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
ll k, a, b;
cin >> k >> a >> b;
if (a >= b - 2)
cout << k + 1 << endl;
else {
ll t = k - (a - 1);
if (t < 0) {
cout << k + 1 << endl;
} else {
cout << a + (t / 2) * (b - a) + (t % 2) << endl;
}
}
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 932,664 | 932,665 | u160429264 | cpp |
p03131 | #pragma region template
#include <bits/stdc++.h>
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define sz(a) (int)(a).size()
#define last(a) (a).at((int)(a).size() - 1)
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; i++)
#define brep(i, a, b) for (int i = (a), i##_len = (b); i <= i##_len; i++)
#define rrep(i, n) \
int i = (n); \
int now = -1; \
while (i-- && (now++ || 1))
#define xrep(i, n) for (int i = 1, i##_len = (n); i <= i##_len; i++)
#define Yes(n) cout << ((n) ? YES : NO) << '\n'
#define co(n) cout << (n) << '\n'
#define Sort(v) sort(all(v))
#define rSort(v) sort(all(v), greater<typeof(v[0])>())
#define Rev(v) reverse(all(v))
#define Unique(v) (v).erase(unique(all(v)), (v).end())
#define eb emplace_back
#define fi first
#define se second
#ifdef ONLINE_JUDGE
#define here()
#define cprint(vec)
#define comment(msg)
#define observe(var)
#define local(x)
#define alter(x, y) y
#else
#define here() cerr << __func__ << '/' << __LINE__ << ": passed\n"
#define cprint(vec) print_e(vec)
#define comment(msg) cerr << "{ " << msg << " }\n"
#define observe(var) cerr << "{ " << #var << " : " << var << " }\n"
#define local(x) x
#define alter(x, y) x
#endif
using namespace std;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using vbl = vector<bool>;
using dqbl = deque<bool>;
using vint = vector<int>;
using vll = vector<long long>;
using vdbl = vector<double>;
using vstr = vector<string>;
using vvbl = vector<vector<bool>>;
using vdqbl = vector<deque<bool>>;
using vvint = vector<vector<int>>;
using vvll = vector<vector<long long>>;
constexpr int INF = 1e9;
constexpr long long LINF = 1e18;
constexpr double EPS = 1e-9;
constexpr long double LEPS = 1e-18;
// --- functions which take 1 argument --- //
inline void ignore_ret(int x) { x++; }
template <class T> inline int sgn(const T &x) { return (x > 0) - (x < 0); }
template <class T> inline int digit(T x) {
int r = 1;
while ((x /= 10) >= 1)
r++;
return r;
}
template <class T> inline double deg_to_rad(const T &a) {
return a / 180.0 * M_PI;
}
template <class T> inline double rad_to_deg(const T &a) {
return a / M_PI * 180.0;
}
template <class T> inline ll factorial(const T &n) {
if (n == 0)
return 1;
ll r = 1;
brep(i, 2, n) r *= i;
return r;
}
template <class T> inline map<T, T> factorize(T n) {
map<T, T> r;
for (T i = 2; i * i <= n; i++) {
while (n % i == 0) {
r[i]++;
n /= i;
}
}
if (n != 1)
r[n] = 1;
return r;
}
template <class T> inline vector<T> divisor(const T &n) {
vector<T> r;
for (T i = 1; i * i <= n; i++) {
if (!(n % i)) {
r.eb(i);
if (i * i != n)
r.eb(n / i);
}
}
Sort(r);
return r;
}
// --- functions which take 2 arguments --- //
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline T nPr(const T &n, const T &k) {
if (n < k || n < 0 || k < 0)
return 0;
T r = 1;
brep(i, n - k + 1, n) r *= i;
return r;
}
template <class T> inline T nCr(const T &n, const T &k) {
if (n < k || n < 0 || k < 0)
return 0;
T r = 1;
k = min(k, n - k);
brep(i, n - k + 1, n) r *= i;
return r / factorial(k);
}
// --- functions which take vector(s) as argument(s) --- //
template <class T> inline void print(const vector<T> &v) {
cout << "[ ";
for (auto &x : v)
cout << x << ' ';
cout << "]\n";
}
template <class T> inline void print(const vector<vector<T>> &v) {
for (auto &x : v)
print<T>(x);
}
template <class T> inline void print_d(const vector<T> &v, string d) {
rep(i, sz(v) - 1) cout << v[i] << d;
cout << last(v) << '\n';
}
template <class T> inline void print_d(const vector<vector<T>> &v, string d) {
for (auto &x : v)
print_d(x, d);
}
template <class T> inline void print_e(const vector<T> &v) {
cerr << "[ ";
for (auto &x : v)
cerr << x << ' ';
cerr << "]\n";
}
template <class T> inline void print_e(const vector<vector<T>> &v) {
for (auto &x : v)
print_e<T>(x);
}
template <class T> inline bool in(const T &k, const vector<T> &v) {
return find(all(v), k) != v.end();
}
inline bool in(const int &k, const vector<ll> &v) {
return find(all(v), k) != v.end();
}
inline bool in(const ll &k, const vector<int> &v) {
return find(all(v), k) != v.end();
}
inline bool in(const char &k, const string &v) {
return find(all(v), k) != v.end();
}
inline bool in(const char *&k, const vector<string> &v) {
return find(all(v), k) != v.end();
}
template <class T> inline T min(const vector<T> &v) {
return *min_element(all(v));
}
template <class T> inline T max(const vector<T> &v) {
return *max_element(all(v));
}
template <class T> inline T sum(const T &v) { return reduce(all(v), (T)0); }
template <class T> inline T gcd(const vector<T> &v) {
T r = v[0];
brep(i, 1, sz(v) - 1) r = gcd(r, v[i]);
return r;
}
template <class T> inline T lcm(const vector<T> &v) {
T r = v[0];
brep(i, 1, sz(v) - 1) r = lcm(r, v[i]);
return r;
}
template <class T> inline double abs(const vector<T> &v) {
return sqrt(reduce(all(v), 0.0, [](T s, T v) { return s += v * v; }));
}
template <class T> inline T vector_add(const T &u, const T &v) {
T r(u.size());
rep(i, u.size()) r[i] = u[i] + v[i];
return r;
}
template <class T> inline T vector_subtract(const T &u, const T &v) {
T r(u.size());
rep(i, u.size()) r[i] = u[i] - v[i];
return r;
}
template <class T> inline T vector_multiply(const T &u, const T &v) {
T r(u.size());
rep(i, u.size()) r[i] = u[i] * v[i];
return r;
}
template <class S, class T>
inline common_type<S, T> dot_product(const vector<S> &u, const vector<T> &v) {
T r = 0;
rep(i, u.size()) r += u[i] * v[i];
return r;
}
template <class S, class T> inline void sort_by_second(vector<pair<S, T>> &v) {
sort(all(v), [](auto &L, auto &R) { return L.second < R.second; });
}
// --- functions which take set/map as argument --- //
template <class T> inline bool in(const T &k, const set<T> &v) {
return find(all(v), k) != v.end();
}
template <class T> inline bool in(const T &k, const unordered_set<T> &v) {
return find(all(v), k) != v.end();
}
template <class T> inline T min(const set<T> &v) {
return *min_element(all(v));
}
template <class T> inline T min(const unordered_set<T> &v) {
return *min_element(all(v));
}
template <class T> inline T max(const set<T> &v) {
return *max_element(all(v));
}
template <class T> inline T max(const unordered_set<T> &v) {
return *max_element(all(v));
}
template <class T> inline T gcd(const set<T> &v) {
T r = 0;
for (T x : v)
r = (r == 0) ? x : gcd(r, x);
return r;
}
template <class T> inline T gcd(const unordered_set<T> &v) {
T r = 0;
for (T x : v)
r = (r == 0) ? x : gcd(r, x);
return r;
}
template <class T> inline T lcm(const set<T> &v) {
T r = 0;
for (T x : v)
r = (r == 0) ? x : lcm(r, x);
return r;
}
template <class T> inline T lcm(const unordered_set<T> &v) {
T r = 0;
for (T x : v)
r = (r == 0) ? x : lcm(r, x);
return r;
}
template <class T> inline void print(const set<T> &v) {
cout << "[ ";
for (T &x : v)
cout << x << ' ';
cout << "]\n";
}
template <class T> inline void print(const unordered_set<T> &v) {
cout << "[ ";
for (T &x : v)
cout << x << ' ';
cout << "]\n";
}
template <class S, class T> inline void print(const map<S, T> &m) {
cout << "[ ";
for (auto &x : m)
cout << "{ " << x.fi << ", " << x.se << " } ";
cout << "]\n";
}
template <class S, class T> inline void print(const unordered_map<S, T> &m) {
cout << "[ ";
for (auto &x : m)
cout << "{ " << x.fi << ", " << x.se << " } ";
cout << "]\n";
}
#pragma endregion template
void solve(ll K, ll A, ll B) {
if (K < A - 3 || B - A <= 2) {
cout << 1 + K << endl;
} else {
cout << B + (B - A) * ((K - A - 1) / 2) + (K - A - 1) % 2 << endl;
}
}
int main() {
ll K;
ignore_ret(scanf("%lld", &K));
ll A;
ignore_ret(scanf("%lld", &A));
ll B;
ignore_ret(scanf("%lld", &B));
solve(K, A, B);
return 0;
}
| #pragma region template
#include <bits/stdc++.h>
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define sz(a) (int)(a).size()
#define last(a) (a).at((int)(a).size() - 1)
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; i++)
#define brep(i, a, b) for (int i = (a), i##_len = (b); i <= i##_len; i++)
#define rrep(i, n) \
int i = (n); \
int now = -1; \
while (i-- && (now++ || 1))
#define xrep(i, n) for (int i = 1, i##_len = (n); i <= i##_len; i++)
#define Yes(n) cout << ((n) ? YES : NO) << '\n'
#define co(n) cout << (n) << '\n'
#define Sort(v) sort(all(v))
#define rSort(v) sort(all(v), greater<typeof(v[0])>())
#define Rev(v) reverse(all(v))
#define Unique(v) (v).erase(unique(all(v)), (v).end())
#define eb emplace_back
#define fi first
#define se second
#ifdef ONLINE_JUDGE
#define here()
#define cprint(vec)
#define comment(msg)
#define observe(var)
#define local(x)
#define alter(x, y) y
#else
#define here() cerr << __func__ << '/' << __LINE__ << ": passed\n"
#define cprint(vec) print_e(vec)
#define comment(msg) cerr << "{ " << msg << " }\n"
#define observe(var) cerr << "{ " << #var << " : " << var << " }\n"
#define local(x) x
#define alter(x, y) x
#endif
using namespace std;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using vbl = vector<bool>;
using dqbl = deque<bool>;
using vint = vector<int>;
using vll = vector<long long>;
using vdbl = vector<double>;
using vstr = vector<string>;
using vvbl = vector<vector<bool>>;
using vdqbl = vector<deque<bool>>;
using vvint = vector<vector<int>>;
using vvll = vector<vector<long long>>;
constexpr int INF = 1e9;
constexpr long long LINF = 1e18;
constexpr double EPS = 1e-9;
constexpr long double LEPS = 1e-18;
// --- functions which take 1 argument --- //
inline void ignore_ret(int x) { x++; }
template <class T> inline int sgn(const T &x) { return (x > 0) - (x < 0); }
template <class T> inline int digit(T x) {
int r = 1;
while ((x /= 10) >= 1)
r++;
return r;
}
template <class T> inline double deg_to_rad(const T &a) {
return a / 180.0 * M_PI;
}
template <class T> inline double rad_to_deg(const T &a) {
return a / M_PI * 180.0;
}
template <class T> inline ll factorial(const T &n) {
if (n == 0)
return 1;
ll r = 1;
brep(i, 2, n) r *= i;
return r;
}
template <class T> inline map<T, T> factorize(T n) {
map<T, T> r;
for (T i = 2; i * i <= n; i++) {
while (n % i == 0) {
r[i]++;
n /= i;
}
}
if (n != 1)
r[n] = 1;
return r;
}
template <class T> inline vector<T> divisor(const T &n) {
vector<T> r;
for (T i = 1; i * i <= n; i++) {
if (!(n % i)) {
r.eb(i);
if (i * i != n)
r.eb(n / i);
}
}
Sort(r);
return r;
}
// --- functions which take 2 arguments --- //
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline T nPr(const T &n, const T &k) {
if (n < k || n < 0 || k < 0)
return 0;
T r = 1;
brep(i, n - k + 1, n) r *= i;
return r;
}
template <class T> inline T nCr(const T &n, const T &k) {
if (n < k || n < 0 || k < 0)
return 0;
T r = 1;
k = min(k, n - k);
brep(i, n - k + 1, n) r *= i;
return r / factorial(k);
}
// --- functions which take vector(s) as argument(s) --- //
template <class T> inline void print(const vector<T> &v) {
cout << "[ ";
for (auto &x : v)
cout << x << ' ';
cout << "]\n";
}
template <class T> inline void print(const vector<vector<T>> &v) {
for (auto &x : v)
print<T>(x);
}
template <class T> inline void print_d(const vector<T> &v, string d) {
rep(i, sz(v) - 1) cout << v[i] << d;
cout << last(v) << '\n';
}
template <class T> inline void print_d(const vector<vector<T>> &v, string d) {
for (auto &x : v)
print_d(x, d);
}
template <class T> inline void print_e(const vector<T> &v) {
cerr << "[ ";
for (auto &x : v)
cerr << x << ' ';
cerr << "]\n";
}
template <class T> inline void print_e(const vector<vector<T>> &v) {
for (auto &x : v)
print_e<T>(x);
}
template <class T> inline bool in(const T &k, const vector<T> &v) {
return find(all(v), k) != v.end();
}
inline bool in(const int &k, const vector<ll> &v) {
return find(all(v), k) != v.end();
}
inline bool in(const ll &k, const vector<int> &v) {
return find(all(v), k) != v.end();
}
inline bool in(const char &k, const string &v) {
return find(all(v), k) != v.end();
}
inline bool in(const char *&k, const vector<string> &v) {
return find(all(v), k) != v.end();
}
template <class T> inline T min(const vector<T> &v) {
return *min_element(all(v));
}
template <class T> inline T max(const vector<T> &v) {
return *max_element(all(v));
}
template <class T> inline T sum(const T &v) { return reduce(all(v), (T)0); }
template <class T> inline T gcd(const vector<T> &v) {
T r = v[0];
brep(i, 1, sz(v) - 1) r = gcd(r, v[i]);
return r;
}
template <class T> inline T lcm(const vector<T> &v) {
T r = v[0];
brep(i, 1, sz(v) - 1) r = lcm(r, v[i]);
return r;
}
template <class T> inline double abs(const vector<T> &v) {
return sqrt(reduce(all(v), 0.0, [](T s, T v) { return s += v * v; }));
}
template <class T> inline T vector_add(const T &u, const T &v) {
T r(u.size());
rep(i, u.size()) r[i] = u[i] + v[i];
return r;
}
template <class T> inline T vector_subtract(const T &u, const T &v) {
T r(u.size());
rep(i, u.size()) r[i] = u[i] - v[i];
return r;
}
template <class T> inline T vector_multiply(const T &u, const T &v) {
T r(u.size());
rep(i, u.size()) r[i] = u[i] * v[i];
return r;
}
template <class S, class T>
inline common_type<S, T> dot_product(const vector<S> &u, const vector<T> &v) {
T r = 0;
rep(i, u.size()) r += u[i] * v[i];
return r;
}
template <class S, class T> inline void sort_by_second(vector<pair<S, T>> &v) {
sort(all(v), [](auto &L, auto &R) { return L.second < R.second; });
}
// --- functions which take set/map as argument --- //
template <class T> inline bool in(const T &k, const set<T> &v) {
return find(all(v), k) != v.end();
}
template <class T> inline bool in(const T &k, const unordered_set<T> &v) {
return find(all(v), k) != v.end();
}
template <class T> inline T min(const set<T> &v) {
return *min_element(all(v));
}
template <class T> inline T min(const unordered_set<T> &v) {
return *min_element(all(v));
}
template <class T> inline T max(const set<T> &v) {
return *max_element(all(v));
}
template <class T> inline T max(const unordered_set<T> &v) {
return *max_element(all(v));
}
template <class T> inline T gcd(const set<T> &v) {
T r = 0;
for (T x : v)
r = (r == 0) ? x : gcd(r, x);
return r;
}
template <class T> inline T gcd(const unordered_set<T> &v) {
T r = 0;
for (T x : v)
r = (r == 0) ? x : gcd(r, x);
return r;
}
template <class T> inline T lcm(const set<T> &v) {
T r = 0;
for (T x : v)
r = (r == 0) ? x : lcm(r, x);
return r;
}
template <class T> inline T lcm(const unordered_set<T> &v) {
T r = 0;
for (T x : v)
r = (r == 0) ? x : lcm(r, x);
return r;
}
template <class T> inline void print(const set<T> &v) {
cout << "[ ";
for (T &x : v)
cout << x << ' ';
cout << "]\n";
}
template <class T> inline void print(const unordered_set<T> &v) {
cout << "[ ";
for (T &x : v)
cout << x << ' ';
cout << "]\n";
}
template <class S, class T> inline void print(const map<S, T> &m) {
cout << "[ ";
for (auto &x : m)
cout << "{ " << x.fi << ", " << x.se << " } ";
cout << "]\n";
}
template <class S, class T> inline void print(const unordered_map<S, T> &m) {
cout << "[ ";
for (auto &x : m)
cout << "{ " << x.fi << ", " << x.se << " } ";
cout << "]\n";
}
#pragma endregion template
void solve(ll K, ll A, ll B) {
if (K < A + 1 || B - A <= 2) {
cout << 1 + K << endl;
} else {
cout << B + (B - A) * ((K - A - 1) / 2) + (K - A - 1) % 2 << endl;
}
}
int main() {
ll K;
ignore_ret(scanf("%lld", &K));
ll A;
ignore_ret(scanf("%lld", &A));
ll B;
ignore_ret(scanf("%lld", &B));
solve(K, A, B);
return 0;
}
| [] | 932,679 | 932,680 | u368735320 | cpp |
p03131 | #pragma region template
#include <bits/stdc++.h>
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define sz(a) (int)(a).size()
#define last(a) (a).at((int)(a).size() - 1)
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; i++)
#define brep(i, a, b) for (int i = (a), i##_len = (b); i <= i##_len; i++)
#define rrep(i, n) \
int i = (n); \
int now = -1; \
while (i-- && (now++ || 1))
#define xrep(i, n) for (int i = 1, i##_len = (n); i <= i##_len; i++)
#define Yes(n) cout << ((n) ? YES : NO) << '\n'
#define co(n) cout << (n) << '\n'
#define Sort(v) sort(all(v))
#define rSort(v) sort(all(v), greater<typeof(v[0])>())
#define Rev(v) reverse(all(v))
#define Unique(v) (v).erase(unique(all(v)), (v).end())
#define eb emplace_back
#define fi first
#define se second
#ifdef ONLINE_JUDGE
#define here()
#define cprint(vec)
#define comment(msg)
#define observe(var)
#define local(x)
#define alter(x, y) y
#else
#define here() cerr << __func__ << '/' << __LINE__ << ": passed\n"
#define cprint(vec) print_e(vec)
#define comment(msg) cerr << "{ " << msg << " }\n"
#define observe(var) cerr << "{ " << #var << " : " << var << " }\n"
#define local(x) x
#define alter(x, y) x
#endif
using namespace std;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using vbl = vector<bool>;
using dqbl = deque<bool>;
using vint = vector<int>;
using vll = vector<long long>;
using vdbl = vector<double>;
using vstr = vector<string>;
using vvbl = vector<vector<bool>>;
using vdqbl = vector<deque<bool>>;
using vvint = vector<vector<int>>;
using vvll = vector<vector<long long>>;
constexpr int INF = 1e9;
constexpr long long LINF = 1e18;
constexpr double EPS = 1e-9;
constexpr long double LEPS = 1e-18;
// --- functions which take 1 argument --- //
inline void ignore_ret(int x) { x++; }
template <class T> inline int sgn(const T &x) { return (x > 0) - (x < 0); }
template <class T> inline int digit(T x) {
int r = 1;
while ((x /= 10) >= 1)
r++;
return r;
}
template <class T> inline double deg_to_rad(const T &a) {
return a / 180.0 * M_PI;
}
template <class T> inline double rad_to_deg(const T &a) {
return a / M_PI * 180.0;
}
template <class T> inline ll factorial(const T &n) {
if (n == 0)
return 1;
ll r = 1;
brep(i, 2, n) r *= i;
return r;
}
template <class T> inline map<T, T> factorize(T n) {
map<T, T> r;
for (T i = 2; i * i <= n; i++) {
while (n % i == 0) {
r[i]++;
n /= i;
}
}
if (n != 1)
r[n] = 1;
return r;
}
template <class T> inline vector<T> divisor(const T &n) {
vector<T> r;
for (T i = 1; i * i <= n; i++) {
if (!(n % i)) {
r.eb(i);
if (i * i != n)
r.eb(n / i);
}
}
Sort(r);
return r;
}
// --- functions which take 2 arguments --- //
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline T nPr(const T &n, const T &k) {
if (n < k || n < 0 || k < 0)
return 0;
T r = 1;
brep(i, n - k + 1, n) r *= i;
return r;
}
template <class T> inline T nCr(const T &n, const T &k) {
if (n < k || n < 0 || k < 0)
return 0;
T r = 1;
k = min(k, n - k);
brep(i, n - k + 1, n) r *= i;
return r / factorial(k);
}
// --- functions which take vector(s) as argument(s) --- //
template <class T> inline void print(const vector<T> &v) {
cout << "[ ";
for (auto &x : v)
cout << x << ' ';
cout << "]\n";
}
template <class T> inline void print(const vector<vector<T>> &v) {
for (auto &x : v)
print<T>(x);
}
template <class T> inline void print_d(const vector<T> &v, string d) {
rep(i, sz(v) - 1) cout << v[i] << d;
cout << last(v) << '\n';
}
template <class T> inline void print_d(const vector<vector<T>> &v, string d) {
for (auto &x : v)
print_d(x, d);
}
template <class T> inline void print_e(const vector<T> &v) {
cerr << "[ ";
for (auto &x : v)
cerr << x << ' ';
cerr << "]\n";
}
template <class T> inline void print_e(const vector<vector<T>> &v) {
for (auto &x : v)
print_e<T>(x);
}
template <class T> inline bool in(const T &k, const vector<T> &v) {
return find(all(v), k) != v.end();
}
inline bool in(const int &k, const vector<ll> &v) {
return find(all(v), k) != v.end();
}
inline bool in(const ll &k, const vector<int> &v) {
return find(all(v), k) != v.end();
}
inline bool in(const char &k, const string &v) {
return find(all(v), k) != v.end();
}
inline bool in(const char *&k, const vector<string> &v) {
return find(all(v), k) != v.end();
}
template <class T> inline T min(const vector<T> &v) {
return *min_element(all(v));
}
template <class T> inline T max(const vector<T> &v) {
return *max_element(all(v));
}
template <class T> inline T sum(const T &v) { return reduce(all(v), (T)0); }
template <class T> inline T gcd(const vector<T> &v) {
T r = v[0];
brep(i, 1, sz(v) - 1) r = gcd(r, v[i]);
return r;
}
template <class T> inline T lcm(const vector<T> &v) {
T r = v[0];
brep(i, 1, sz(v) - 1) r = lcm(r, v[i]);
return r;
}
template <class T> inline double abs(const vector<T> &v) {
return sqrt(reduce(all(v), 0.0, [](T s, T v) { return s += v * v; }));
}
template <class T> inline T vector_add(const T &u, const T &v) {
T r(u.size());
rep(i, u.size()) r[i] = u[i] + v[i];
return r;
}
template <class T> inline T vector_subtract(const T &u, const T &v) {
T r(u.size());
rep(i, u.size()) r[i] = u[i] - v[i];
return r;
}
template <class T> inline T vector_multiply(const T &u, const T &v) {
T r(u.size());
rep(i, u.size()) r[i] = u[i] * v[i];
return r;
}
template <class S, class T>
inline common_type<S, T> dot_product(const vector<S> &u, const vector<T> &v) {
T r = 0;
rep(i, u.size()) r += u[i] * v[i];
return r;
}
template <class S, class T> inline void sort_by_second(vector<pair<S, T>> &v) {
sort(all(v), [](auto &L, auto &R) { return L.second < R.second; });
}
// --- functions which take set/map as argument --- //
template <class T> inline bool in(const T &k, const set<T> &v) {
return find(all(v), k) != v.end();
}
template <class T> inline bool in(const T &k, const unordered_set<T> &v) {
return find(all(v), k) != v.end();
}
template <class T> inline T min(const set<T> &v) {
return *min_element(all(v));
}
template <class T> inline T min(const unordered_set<T> &v) {
return *min_element(all(v));
}
template <class T> inline T max(const set<T> &v) {
return *max_element(all(v));
}
template <class T> inline T max(const unordered_set<T> &v) {
return *max_element(all(v));
}
template <class T> inline T gcd(const set<T> &v) {
T r = 0;
for (T x : v)
r = (r == 0) ? x : gcd(r, x);
return r;
}
template <class T> inline T gcd(const unordered_set<T> &v) {
T r = 0;
for (T x : v)
r = (r == 0) ? x : gcd(r, x);
return r;
}
template <class T> inline T lcm(const set<T> &v) {
T r = 0;
for (T x : v)
r = (r == 0) ? x : lcm(r, x);
return r;
}
template <class T> inline T lcm(const unordered_set<T> &v) {
T r = 0;
for (T x : v)
r = (r == 0) ? x : lcm(r, x);
return r;
}
template <class T> inline void print(const set<T> &v) {
cout << "[ ";
for (T &x : v)
cout << x << ' ';
cout << "]\n";
}
template <class T> inline void print(const unordered_set<T> &v) {
cout << "[ ";
for (T &x : v)
cout << x << ' ';
cout << "]\n";
}
template <class S, class T> inline void print(const map<S, T> &m) {
cout << "[ ";
for (auto &x : m)
cout << "{ " << x.fi << ", " << x.se << " } ";
cout << "]\n";
}
template <class S, class T> inline void print(const unordered_map<S, T> &m) {
cout << "[ ";
for (auto &x : m)
cout << "{ " << x.fi << ", " << x.se << " } ";
cout << "]\n";
}
#pragma endregion template
void solve(ll K, ll A, ll B) {
if (K < A - 1 || B - A <= 2) {
cout << 1 + K << endl;
} else {
cout << B + (B - A) * ((K - A - 1) / 2) + (K - A - 1) % 2 << endl;
}
}
int main() {
ll K;
ignore_ret(scanf("%lld", &K));
ll A;
ignore_ret(scanf("%lld", &A));
ll B;
ignore_ret(scanf("%lld", &B));
solve(K, A, B);
return 0;
}
| #pragma region template
#include <bits/stdc++.h>
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define sz(a) (int)(a).size()
#define last(a) (a).at((int)(a).size() - 1)
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; i++)
#define brep(i, a, b) for (int i = (a), i##_len = (b); i <= i##_len; i++)
#define rrep(i, n) \
int i = (n); \
int now = -1; \
while (i-- && (now++ || 1))
#define xrep(i, n) for (int i = 1, i##_len = (n); i <= i##_len; i++)
#define Yes(n) cout << ((n) ? YES : NO) << '\n'
#define co(n) cout << (n) << '\n'
#define Sort(v) sort(all(v))
#define rSort(v) sort(all(v), greater<typeof(v[0])>())
#define Rev(v) reverse(all(v))
#define Unique(v) (v).erase(unique(all(v)), (v).end())
#define eb emplace_back
#define fi first
#define se second
#ifdef ONLINE_JUDGE
#define here()
#define cprint(vec)
#define comment(msg)
#define observe(var)
#define local(x)
#define alter(x, y) y
#else
#define here() cerr << __func__ << '/' << __LINE__ << ": passed\n"
#define cprint(vec) print_e(vec)
#define comment(msg) cerr << "{ " << msg << " }\n"
#define observe(var) cerr << "{ " << #var << " : " << var << " }\n"
#define local(x) x
#define alter(x, y) x
#endif
using namespace std;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using vbl = vector<bool>;
using dqbl = deque<bool>;
using vint = vector<int>;
using vll = vector<long long>;
using vdbl = vector<double>;
using vstr = vector<string>;
using vvbl = vector<vector<bool>>;
using vdqbl = vector<deque<bool>>;
using vvint = vector<vector<int>>;
using vvll = vector<vector<long long>>;
constexpr int INF = 1e9;
constexpr long long LINF = 1e18;
constexpr double EPS = 1e-9;
constexpr long double LEPS = 1e-18;
// --- functions which take 1 argument --- //
inline void ignore_ret(int x) { x++; }
template <class T> inline int sgn(const T &x) { return (x > 0) - (x < 0); }
template <class T> inline int digit(T x) {
int r = 1;
while ((x /= 10) >= 1)
r++;
return r;
}
template <class T> inline double deg_to_rad(const T &a) {
return a / 180.0 * M_PI;
}
template <class T> inline double rad_to_deg(const T &a) {
return a / M_PI * 180.0;
}
template <class T> inline ll factorial(const T &n) {
if (n == 0)
return 1;
ll r = 1;
brep(i, 2, n) r *= i;
return r;
}
template <class T> inline map<T, T> factorize(T n) {
map<T, T> r;
for (T i = 2; i * i <= n; i++) {
while (n % i == 0) {
r[i]++;
n /= i;
}
}
if (n != 1)
r[n] = 1;
return r;
}
template <class T> inline vector<T> divisor(const T &n) {
vector<T> r;
for (T i = 1; i * i <= n; i++) {
if (!(n % i)) {
r.eb(i);
if (i * i != n)
r.eb(n / i);
}
}
Sort(r);
return r;
}
// --- functions which take 2 arguments --- //
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline T nPr(const T &n, const T &k) {
if (n < k || n < 0 || k < 0)
return 0;
T r = 1;
brep(i, n - k + 1, n) r *= i;
return r;
}
template <class T> inline T nCr(const T &n, const T &k) {
if (n < k || n < 0 || k < 0)
return 0;
T r = 1;
k = min(k, n - k);
brep(i, n - k + 1, n) r *= i;
return r / factorial(k);
}
// --- functions which take vector(s) as argument(s) --- //
template <class T> inline void print(const vector<T> &v) {
cout << "[ ";
for (auto &x : v)
cout << x << ' ';
cout << "]\n";
}
template <class T> inline void print(const vector<vector<T>> &v) {
for (auto &x : v)
print<T>(x);
}
template <class T> inline void print_d(const vector<T> &v, string d) {
rep(i, sz(v) - 1) cout << v[i] << d;
cout << last(v) << '\n';
}
template <class T> inline void print_d(const vector<vector<T>> &v, string d) {
for (auto &x : v)
print_d(x, d);
}
template <class T> inline void print_e(const vector<T> &v) {
cerr << "[ ";
for (auto &x : v)
cerr << x << ' ';
cerr << "]\n";
}
template <class T> inline void print_e(const vector<vector<T>> &v) {
for (auto &x : v)
print_e<T>(x);
}
template <class T> inline bool in(const T &k, const vector<T> &v) {
return find(all(v), k) != v.end();
}
inline bool in(const int &k, const vector<ll> &v) {
return find(all(v), k) != v.end();
}
inline bool in(const ll &k, const vector<int> &v) {
return find(all(v), k) != v.end();
}
inline bool in(const char &k, const string &v) {
return find(all(v), k) != v.end();
}
inline bool in(const char *&k, const vector<string> &v) {
return find(all(v), k) != v.end();
}
template <class T> inline T min(const vector<T> &v) {
return *min_element(all(v));
}
template <class T> inline T max(const vector<T> &v) {
return *max_element(all(v));
}
template <class T> inline T sum(const T &v) { return reduce(all(v), (T)0); }
template <class T> inline T gcd(const vector<T> &v) {
T r = v[0];
brep(i, 1, sz(v) - 1) r = gcd(r, v[i]);
return r;
}
template <class T> inline T lcm(const vector<T> &v) {
T r = v[0];
brep(i, 1, sz(v) - 1) r = lcm(r, v[i]);
return r;
}
template <class T> inline double abs(const vector<T> &v) {
return sqrt(reduce(all(v), 0.0, [](T s, T v) { return s += v * v; }));
}
template <class T> inline T vector_add(const T &u, const T &v) {
T r(u.size());
rep(i, u.size()) r[i] = u[i] + v[i];
return r;
}
template <class T> inline T vector_subtract(const T &u, const T &v) {
T r(u.size());
rep(i, u.size()) r[i] = u[i] - v[i];
return r;
}
template <class T> inline T vector_multiply(const T &u, const T &v) {
T r(u.size());
rep(i, u.size()) r[i] = u[i] * v[i];
return r;
}
template <class S, class T>
inline common_type<S, T> dot_product(const vector<S> &u, const vector<T> &v) {
T r = 0;
rep(i, u.size()) r += u[i] * v[i];
return r;
}
template <class S, class T> inline void sort_by_second(vector<pair<S, T>> &v) {
sort(all(v), [](auto &L, auto &R) { return L.second < R.second; });
}
// --- functions which take set/map as argument --- //
template <class T> inline bool in(const T &k, const set<T> &v) {
return find(all(v), k) != v.end();
}
template <class T> inline bool in(const T &k, const unordered_set<T> &v) {
return find(all(v), k) != v.end();
}
template <class T> inline T min(const set<T> &v) {
return *min_element(all(v));
}
template <class T> inline T min(const unordered_set<T> &v) {
return *min_element(all(v));
}
template <class T> inline T max(const set<T> &v) {
return *max_element(all(v));
}
template <class T> inline T max(const unordered_set<T> &v) {
return *max_element(all(v));
}
template <class T> inline T gcd(const set<T> &v) {
T r = 0;
for (T x : v)
r = (r == 0) ? x : gcd(r, x);
return r;
}
template <class T> inline T gcd(const unordered_set<T> &v) {
T r = 0;
for (T x : v)
r = (r == 0) ? x : gcd(r, x);
return r;
}
template <class T> inline T lcm(const set<T> &v) {
T r = 0;
for (T x : v)
r = (r == 0) ? x : lcm(r, x);
return r;
}
template <class T> inline T lcm(const unordered_set<T> &v) {
T r = 0;
for (T x : v)
r = (r == 0) ? x : lcm(r, x);
return r;
}
template <class T> inline void print(const set<T> &v) {
cout << "[ ";
for (T &x : v)
cout << x << ' ';
cout << "]\n";
}
template <class T> inline void print(const unordered_set<T> &v) {
cout << "[ ";
for (T &x : v)
cout << x << ' ';
cout << "]\n";
}
template <class S, class T> inline void print(const map<S, T> &m) {
cout << "[ ";
for (auto &x : m)
cout << "{ " << x.fi << ", " << x.se << " } ";
cout << "]\n";
}
template <class S, class T> inline void print(const unordered_map<S, T> &m) {
cout << "[ ";
for (auto &x : m)
cout << "{ " << x.fi << ", " << x.se << " } ";
cout << "]\n";
}
#pragma endregion template
void solve(ll K, ll A, ll B) {
if (K < A + 1 || B - A <= 2) {
cout << 1 + K << endl;
} else {
cout << B + (B - A) * ((K - A - 1) / 2) + (K - A - 1) % 2 << endl;
}
}
int main() {
ll K;
ignore_ret(scanf("%lld", &K));
ll A;
ignore_ret(scanf("%lld", &A));
ll B;
ignore_ret(scanf("%lld", &B));
solve(K, A, B);
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 932,681 | 932,680 | u368735320 | cpp |
p03130 | #include <iostream>
using namespace std;
int main() {
int a[3], b[3], c[4] = {};
int cou3 = 0, cou2 = 0;
for (int i = 0; i < 3; i++) {
cin >> a[i] >> b[i];
c[a[i]]++;
c[b[i]]++;
}
for (int j = 0; j < 4; j++) {
if (c[j] == 2)
cou2++;
if (c[j] == 3)
cou3++;
}
if (!cou3) {
cout << "YES" << endl;
} else if (cou2 == 2) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int a[3], b[3], c[5] = {};
int cou3 = 0, cou2 = 0;
for (int i = 0; i < 3; i++) {
cin >> a[i] >> b[i];
c[a[i]]++;
c[b[i]]++;
}
for (int j = 0; j < 5; j++) {
if (c[j] == 2)
cou2++;
if (c[j] == 3)
cou3++;
}
if (!cou3) {
cout << "YES" << endl;
} else if (cou2 == 2) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 932,700 | 932,701 | u912533549 | cpp |
p03130 | #include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp> // Common file
//#include <ext/pb_ds/tree_policy.hpp> // Including
//tree_order_statistics_node_update
using namespace std;
// using namespace __gnu_pbds;
// typedef tree<
// pair<int, int>, // change type
// null_type,
// less<pair<int, int> >, // change type
// rb_tree_tag,
// tree_order_statistics_node_update>
// ordered_set;
typedef long long ll;
#define rep(i, start, end) for (int i = start; i < end; ++i)
#define sz(x) (int)(x).size()
#define pb push_back
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define clr(d, v) memset(d, v, sizeof(d))
#define pii pair<int, int>
const double PI = 3.14159265358979323846;
const double eps = (1e-8);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
#ifndef ONLINE_JUDGE
// freopen("input.txt", "r", stdin);
// freopen("facebook.txt", "w", stdout);
#endif
int a[4];
rep(i, 0, 3) {
int x, y;
cin >> x >> y;
--x;
--y;
a[x]++;
a[y]++;
}
int one = 0, two = 0;
rep(i, 0, 4) {
one += a[i] == 1;
two += a[i] == 2;
}
if (one == 2 && two == 2)
cout << "YES";
else
cout << "NO";
return 0;
} | #include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp> // Common file
//#include <ext/pb_ds/tree_policy.hpp> // Including
//tree_order_statistics_node_update
using namespace std;
// using namespace __gnu_pbds;
// typedef tree<
// pair<int, int>, // change type
// null_type,
// less<pair<int, int> >, // change type
// rb_tree_tag,
// tree_order_statistics_node_update>
// ordered_set;
typedef long long ll;
#define rep(i, start, end) for (int i = start; i < end; ++i)
#define sz(x) (int)(x).size()
#define pb push_back
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define clr(d, v) memset(d, v, sizeof(d))
#define pii pair<int, int>
const double PI = 3.14159265358979323846;
const double eps = (1e-8);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
#ifndef ONLINE_JUDGE
// freopen("input.txt", "r", stdin);
// freopen("facebook.txt", "w", stdout);
#endif
int a[4] = {0};
rep(i, 0, 3) {
int x, y;
cin >> x >> y;
--x;
--y;
a[x]++;
a[y]++;
}
int one = 0, two = 0;
rep(i, 0, 4) {
one += a[i] == 1;
two += a[i] == 2;
}
if (one == 2 && two == 2)
cout << "YES";
else
cout << "NO";
return 0;
} | [
"variable_declaration.value.change"
] | 932,708 | 932,709 | u611826259 | cpp |
p03130 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define llong long long
#define pb(a) push_back(a)
using namespace std;
typedef pair<int, int> pii;
typedef long long int ll;
typedef pair<ll, ll> pll;
int dx[4] = {1, 0, 0, -1};
int dy[4] = {0, 1, -1, 0};
#define MOD 1000000007
#define ARRAY_MAX 100005
const int INF = 1e9 + 7;
int mp[4][4];
int visited[4];
int main() {
for (int i = 0; i < 3; i++) {
int a, b;
cin >> a >> b;
visited[a - 1]++;
visited[b - 1]++;
}
int odd = 0;
for (int i = 0; i < 4; i++) {
if (visited[i] % 2 == 1) {
odd++;
}
}
if (odd == 2) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define llong long long
#define pb(a) push_back(a)
using namespace std;
typedef pair<int, int> pii;
typedef long long int ll;
typedef pair<ll, ll> pll;
int dx[4] = {1, 0, 0, -1};
int dy[4] = {0, 1, -1, 0};
#define MOD 1000000007
#define ARRAY_MAX 100005
const int INF = 1e9 + 7;
int mp[4][4];
int visited[4];
int main() {
for (int i = 0; i < 3; i++) {
int a, b;
cin >> a >> b;
visited[a - 1]++;
visited[b - 1]++;
}
int odd = 0;
for (int i = 0; i < 4; i++) {
if (visited[i] % 2 == 1) {
odd++;
}
}
if (odd == 2) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 932,713 | 932,714 | u504142483 | cpp |
p03130 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a[5] = {0}, i, k;
for (i = 0; i < 3; i++) {
cin >> k;
a[k]++;
cin >> k;
a[k]++;
}
if (a[1] <= 1 && a[2] <= 2 && a[3] <= 2 && a[4] <= 3)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a[5] = {0}, i, k;
for (i = 0; i < 3; i++) {
cin >> k;
a[k]++;
cin >> k;
a[k]++;
}
if (a[1] <= 2 && a[2] <= 2 && a[3] <= 2 && a[4] <= 2)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 932,721 | 932,722 | u409179445 | cpp |
p03130 | #include <bits/stdc++.h>
using namespace std;
int main() {
int arr[5];
for (int i = 0; i < 4; i++)
arr[i] = 0;
for (int i = 0; i < 6; i++) {
int x;
cin >> x;
arr[x]++;
}
if (arr[4] <= 2 and arr[1] <= 2 and arr[2] <= 2 and arr[3] <= 2) {
cout << "YES\n";
} else
cout << "NO\n";
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int arr[5];
for (int i = 1; i <= 4; i++)
arr[i] = 0;
for (int i = 0; i < 6; i++) {
int x;
cin >> x;
arr[x]++;
}
if (arr[4] <= 2 and arr[1] <= 2 and arr[2] <= 2 and arr[3] <= 2) {
cout << "YES\n";
} else
cout << "NO\n";
}
| [
"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"
] | 932,726 | 932,727 | u047442155 | cpp |
p03130 | #include <bits/stdc++.h>
using namespace std;
int main() {
int arr[5];
for (int i = 0; i < 4; i++)
arr[i] = 0;
for (int i = 0; i < 6; i++) {
int x;
cin >> x;
arr[x]++;
}
if (arr[0] <= 2 and arr[1] <= 2 and arr[2] <= 2 and arr[3] <= 2) {
cout << "YES\n";
} else
cout << "NO\n";
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int arr[5];
for (int i = 1; i <= 4; i++)
arr[i] = 0;
for (int i = 0; i < 6; i++) {
int x;
cin >> x;
arr[x]++;
}
if (arr[4] <= 2 and arr[1] <= 2 and arr[2] <= 2 and arr[3] <= 2) {
cout << "YES\n";
} else
cout << "NO\n";
}
| [
"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",
"variable_access.subscript.index.change",
"control_... | 932,728 | 932,727 | u047442155 | cpp |
p03130 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
#pragma warning(disable : 4996)
using namespace std;
int d[10];
int main() {
for (int i = 0; i < 3; i++) {
int u, v;
cin >> u >> v;
d[u]++;
d[v]++;
}
bool flag = true;
for (int i = 1; i <= 4; i++)
if (d[i] != 2)
flag = false;
if (flag)
cout << "YES";
else
cout << "NO";
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
#pragma warning(disable : 4996)
using namespace std;
int d[10];
int main() {
for (int i = 0; i < 3; i++) {
int u, v;
cin >> u >> v;
d[u]++;
d[v]++;
}
bool flag = true;
for (int i = 1; i <= 4; i++)
if (d[i] > 2)
flag = false;
if (flag)
cout << "YES";
else
cout << "NO";
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 932,729 | 932,730 | u275726913 | cpp |
p03130 | #include "bits/stdc++.h"
typedef long long ll;
#define int ll
#define fi first
#define se second
#define SORT(a) sort(a.begin(), a.end())
#define rep(i, n) for (int i = 0; i < (n); i++)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define MP(a, b) make_pair(a, b)
#define pb(a) push_back(a)
#define INF LLONG_MAX / 2
using namespace std;
int MOD = 1000000007;
signed main() {
int u[4];
rep(i, 3) {
int a, b;
cin >> a >> b;
u[a - 1]++;
u[b - 1]++;
}
sort(u, u + 4);
if (u[0] == 1 && u[1] == 1 && u[2] == 2 && u[3] == 2)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
// g++ -std=c++14 code1.cpp
// rm -r -f test;oj dl
// https://ddcc2019-final.contest.atcoder.jp/tasks/ddcc2019_final_a rm -r -f
// test;oj dl http://arc060.contest.atcoder.jp/tasks/arc060_a | #include "bits/stdc++.h"
typedef long long ll;
#define int ll
#define fi first
#define se second
#define SORT(a) sort(a.begin(), a.end())
#define rep(i, n) for (int i = 0; i < (n); i++)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define MP(a, b) make_pair(a, b)
#define pb(a) push_back(a)
#define INF LLONG_MAX / 2
using namespace std;
int MOD = 1000000007;
signed main() {
int u[4] = {0};
rep(i, 3) {
int a, b;
cin >> a >> b;
u[a - 1]++;
u[b - 1]++;
}
sort(u, u + 4);
if (u[0] == 1 && u[1] == 1 && u[2] == 2 && u[3] == 2)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
// g++ -std=c++14 code1.cpp
// rm -r -f test;oj dl
// https://ddcc2019-final.contest.atcoder.jp/tasks/ddcc2019_final_a rm -r -f
// test;oj dl http://arc060.contest.atcoder.jp/tasks/arc060_a | [
"variable_declaration.value.change"
] | 932,731 | 932,732 | u548768105 | cpp |
p03130 | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int d[10];
for (int i = 1; i <= 4; i++)
d[i] = 0;
for (int i = 0; i < 6; i++) {
int z;
scanf("%d", &z);
d[z]++;
}
if (d[1] >= 3 && d[2] >= 3 && d[3] >= 3 && d[4] >= 3)
printf("NO\n");
else
printf("YES\n");
} | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int d[10];
for (int i = 1; i <= 4; i++)
d[i] = 0;
for (int i = 0; i < 6; i++) {
int z;
scanf("%d", &z);
d[z]++;
}
if (d[1] >= 3 || d[2] >= 3 || d[3] >= 3 || d[4] >= 3)
printf("NO\n");
else
printf("YES\n");
} | [
"misc.opposites",
"control_flow.branch.if.condition.change"
] | 932,735 | 932,736 | u346834985 | cpp |
p03130 | #include <cstring>
#include <iostream>
using namespace std;
int main() {
int element;
int vertex[4];
memset(vertex, 0, sizeof(vertex));
for (int i = 0; i < 6; i++) {
cin >> element;
vertex[element]++;
}
for (int i = 0; i < 4; i++) {
if (vertex[i] > 2) {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
| #include <cstring>
#include <iostream>
using namespace std;
int main() {
int element;
int vertex[5];
memset(vertex, 0, sizeof(vertex));
for (int i = 0; i < 6; i++) {
cin >> element;
vertex[element]++;
}
for (int i = 1; i <= 4; i++) {
if (vertex[i] > 2) {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.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"
] | 932,745 | 932,746 | u387480576 | cpp |
p03130 | #include <cstring>
#include <iostream>
using namespace std;
int main() {
int element;
int vertex[4];
memset(vertex, 0, sizeof(vertex));
for (int i = 0; i < 6; i++) {
cin >> element;
vertex[element]++;
}
for (int i = 1; i <= 4; i++) {
if (vertex[i] > 2) {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
| #include <cstring>
#include <iostream>
using namespace std;
int main() {
int element;
int vertex[5];
memset(vertex, 0, sizeof(vertex));
for (int i = 0; i < 6; i++) {
cin >> element;
vertex[element]++;
}
for (int i = 1; i <= 4; i++) {
if (vertex[i] > 2) {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 932,747 | 932,746 | u387480576 | cpp |
p03130 | #include <cstring>
#include <iostream>
using namespace std;
int main() {
int element;
int vertex[5];
memset(vertex, 0, 5);
for (int i = 0; i < 6; i++) {
cin >> element;
vertex[element]++;
}
for (int i = 1; i <= 4; i++) {
if (vertex[i] > 2) {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
| #include <cstring>
#include <iostream>
using namespace std;
int main() {
int element;
int vertex[5];
memset(vertex, 0, sizeof(vertex));
for (int i = 0; i < 6; i++) {
cin >> element;
vertex[element]++;
}
for (int i = 1; i <= 4; i++) {
if (vertex[i] > 2) {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
| [
"call.arguments.change"
] | 932,748 | 932,746 | u387480576 | cpp |
p03130 | #include <iostream>
using namespace std;
bool print(int *Path) {
for (int i = 0; i < 4; i++) {
if (Path[i] >= 3) {
return false;
}
}
return true;
}
int main() {
int Path[4];
int x, y;
for (int i = 0; i < 3; i++) {
cin >> x >> y;
Path[x - 1] += 1;
Path[y - 1] += 1;
}
if (print(Path)) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
} | #include <iostream>
using namespace std;
bool print(int *Path) {
for (int i = 0; i < 4; i++) {
if (Path[i] >= 3) {
return false;
}
}
return true;
}
int main() {
int Path[4] = {};
int x, y;
for (int i = 0; i < 3; i++) {
cin >> x >> y;
Path[x - 1] += 1;
Path[y - 1] += 1;
}
if (print(Path)) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
} | [
"variable_declaration.value.change"
] | 932,754 | 932,755 | u168139048 | cpp |
p03130 | #include <iostream>
#include <vector>
int main() {
std::vector<std::pair<int, int>> list;
for (int i = 0; i < 3; ++i) {
int n, k;
std::cin >> n;
std::cin >> k;
list.emplace_back(n, k);
}
int a[4] = {0};
bool flg = false;
for (auto c : list) {
a[c.first]++;
a[c.second]++;
}
int cnt = 0;
for (int i = 0; i < 4; ++i) {
if (a[i] == 2)
cnt++;
}
if (cnt == 2)
flg = true;
if (flg)
std::cout << "YES" << std::endl;
else
std::cout << "NO" << std::endl;
return 0;
} | #include <iostream>
#include <vector>
int main() {
std::vector<std::pair<int, int>> list;
for (int i = 0; i < 3; ++i) {
int n, k;
std::cin >> n;
std::cin >> k;
list.emplace_back(n, k);
}
int a[4] = {0};
bool flg = false;
for (auto c : list) {
a[c.first - 1]++;
a[c.second - 1]++;
}
int cnt = 0;
for (int i = 0; i < 4; ++i) {
if (a[i] == 2)
cnt++;
}
if (cnt == 2)
flg = true;
if (flg)
std::cout << "YES" << std::endl;
else
std::cout << "NO" << std::endl;
return 0;
} | [
"expression.operation.binary.add"
] | 932,767 | 932,768 | u336096593 | cpp |
p03130 | #include <bits/stdc++.h>
using namespace std;
int a[7];
int main() {
for (int i = 0; i < 6; ++i)
cin >> a[i];
int N = 0;
for (int i = 0; i < 6; ++i) {
if (a[i] == 1)
N++;
}
int B = 0;
for (int i = 0; i < 6; ++i) {
if (a[i] == 2)
B++;
}
int V = 0;
for (int i = 0; i < 6; ++i) {
if (a[i] == 3)
V++;
}
int C = 0;
for (int i = 0; i < 6; ++i) {
if (a[i] == 4)
C++;
}
if (N >= 3 || B >= 3 || V >= 3 || V >= 3) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int a[7];
int main() {
for (int i = 0; i < 6; ++i)
cin >> a[i];
int N = 0;
for (int i = 0; i < 6; ++i) {
if (a[i] == 1)
N++;
}
int B = 0;
for (int i = 0; i < 6; ++i) {
if (a[i] == 2)
B++;
}
int V = 0;
for (int i = 0; i < 6; ++i) {
if (a[i] == 3)
V++;
}
int C = 0;
for (int i = 0; i < 6; ++i) {
if (a[i] == 4)
C++;
}
if (N >= 3 || B >= 3 || V >= 3 || C >= 3) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 932,769 | 932,770 | u297195722 | cpp |
p03130 | #include <iostream>
using namespace std;
int main() {
int a[5] = {0, 0, 0, 0, 0};
int N;
for (int i = 1; i <= 6; i++) {
cin >> N;
a[N]++;
}
for (int j = 1; j <= 3; j++) {
if (a[j] >= 3) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int a[5] = {0, 0, 0, 0, 0};
int N;
for (int i = 1; i <= 6; i++) {
cin >> N;
a[N]++;
}
for (int j = 1; j <= 4; j++) {
if (a[j] >= 3) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 932,771 | 932,772 | u537837642 | cpp |
p03130 | #include <iostream>
using namespace std;
int main(void) {
int a1, b1, a2, b2, a3, b3;
cin >> a1;
cin >> b1;
cin >> a2;
cin >> b2;
cin >> a3;
cin >> b3;
int node_list[] = {a1, b1, a2, b2, a3, b3};
int num_list[] = {0, 0, 0, 0};
int flg = 0;
for (int i = 0; i < 6; ++i) {
num_list[node_list[i]]++;
}
for (int i = 0; i < 4; ++i) {
if (num_list[i] > 2 || num_list[i] == 0)
flg = 1;
}
if (flg)
cout << "NO" << endl;
else
cout << "YES" << endl;
return 0;
} | #include <iostream>
using namespace std;
int main(void) {
int a1, b1, a2, b2, a3, b3;
cin >> a1;
cin >> b1;
cin >> a2;
cin >> b2;
cin >> a3;
cin >> b3;
int node_list[] = {a1, b1, a2, b2, a3, b3};
int num_list[] = {0, 0, 0, 0};
int flg = 0;
for (int i = 0; i < 6; ++i) {
num_list[node_list[i] - 1]++;
}
for (int i = 0; i < 4; ++i) {
if (num_list[i] > 2 || num_list[i] == 0)
flg = 1;
}
if (flg)
cout << "NO" << endl;
else
cout << "YES" << endl;
return 0;
} | [
"expression.operation.binary.add"
] | 932,773 | 932,774 | u636489589 | cpp |
p03130 | #include <stdio.h>
char str[10001];
int a[3];
int b[3];
void receive_input() {
for (size_t i = 0; i < 3; i++) {
fgets(str, sizeof(str), stdin);
sscanf(str, "%d %d", &a[i], &b[i]);
}
}
void initialize() {
// nop
}
int check() {
int flag[4] = {};
for (size_t i = 0; i < 3; i++) {
flag[a[i]]++;
flag[b[i]]++;
}
for (size_t i = 0; i < 4; i++) {
if (flag[i] == 0 || flag[i] > 2) {
return 0;
}
}
return 1;
}
int main(void) {
receive_input();
initialize();
printf("%s\n", check() ? "YES" : "NO");
return 0;
}
| #include <stdio.h>
char str[10001];
int a[3];
int b[3];
void receive_input() {
for (size_t i = 0; i < 3; i++) {
fgets(str, sizeof(str), stdin);
sscanf(str, "%d %d", &a[i], &b[i]);
}
}
void initialize() {
// nop
}
int check() {
int flag[5] = {};
for (size_t i = 0; i < 3; i++) {
flag[a[i]]++;
flag[b[i]]++;
}
for (size_t i = 1; i <= 4; i++) {
if (flag[i] == 0 || flag[i] > 2) {
return 0;
}
}
return 1;
}
int main(void) {
receive_input();
initialize();
printf("%s\n", check() ? "YES" : "NO");
return 0;
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.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"
] | 932,781 | 932,782 | u869153175 | cpp |
p03130 | #include <iostream>
int a[4], b[4], count[5], countmax = 0, countmin = 10;
int main() {
for (int i = 1; i < 4; i++) {
std::cin >> a[i] >> b[i];
for (int j = 1; j < 5; j++) {
if (a[i] == j) {
count[j]++;
}
if (b[i] == j) {
count[j]++;
}
}
}
for (int i = 1; i < 5; i++) {
if (countmax < count[i]) {
countmax = count[i];
}
if (count[i] < countmin) {
countmin = count[i];
}
}
// std::cout << countmax << " " << countmin;
if (countmax > 3) {
std::cout << "NO";
} else if (countmin == 0) {
std::cout << "NO";
} else {
std::cout << "YES";
}
} | #include <iostream>
int a[4], b[4], count[5], countmax = 0, countmin = 10;
int main() {
for (int i = 1; i < 4; i++) {
std::cin >> a[i] >> b[i];
for (int j = 1; j < 5; j++) {
if (a[i] == j) {
count[j]++;
}
if (b[i] == j) {
count[j]++;
}
}
}
for (int i = 1; i < 5; i++) {
if (countmax < count[i]) {
countmax = count[i];
}
if (count[i] < countmin) {
countmin = count[i];
}
}
// std::cout << countmax << " " << countmin;
if (countmax > 2) {
std::cout << "NO";
} else if (countmin == 0) {
std::cout << "NO";
} else {
std::cout << "YES";
}
} | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 932,783 | 932,784 | u165829448 | cpp |
p03130 | #include <iostream>
using namespace std;
int main() {
int a[3], b[3];
for (int i = 0; i < 3; ++i)
cin >> a[i] >> b[i];
int p[3] = {0};
for (int i = 0; i < 3; ++i)
p[a[i] - 1]++, p[b[i] - 1]++;
bool ok = true;
for (int i = 0; i < 3; ++i)
if (p[i] >= 3)
ok = false;
cout << (ok ? "YES" : "NO") << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int a[3], b[3];
for (int i = 0; i < 3; ++i)
cin >> a[i] >> b[i];
int p[4] = {0};
for (int i = 0; i < 3; ++i)
p[a[i] - 1]++, p[b[i] - 1]++;
bool ok = true;
for (int i = 0; i < 4; ++i)
if (p[i] >= 3)
ok = false;
cout << (ok ? "YES" : "NO") << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 932,787 | 932,788 | u799216831 | cpp |
p03130 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a[10];
int b[10] = {0};
for (int i = 0; i < 6; ++i) {
cin >> a[i];
++b[a[i]];
}
for (int i = 0; i < 6; ++i) {
if (b[i] == 3) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a[10];
int b[10] = {0};
for (int i = 0; i < 6; ++i) {
cin >> a[i];
++b[a[i]];
}
for (int i = 0; i < 6; ++i) {
if (b[i] == 3) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
| [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 932,795 | 932,796 | u634527561 | cpp |
p03130 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a[10];
int b[10] = {0};
for (int i = 0; i < 6; ++i) {
cin >> a[i];
++b[a[i]];
}
for (int i = 0; i < 6; ++i) {
if (b[i] == 3) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
/*
int a, b, c, d, e, f;
cin >> a >> b >> c >> d >> e >> f;
if ( a==3 || b==3 || c==3 || d==3 || e==3 || f==3) cout << "Yes" << endl;
else cout << "No" << endl;
*/
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a[10];
int b[10] = {0};
for (int i = 0; i < 6; ++i) {
cin >> a[i];
++b[a[i]];
}
for (int i = 0; i < 6; ++i) {
if (b[i] == 3) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
| [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 932,797 | 932,796 | u634527561 | cpp |
p03130 | #include <iostream>
#include <string>
#include <vector>
using namespace std;
int n[5];
int main() {
int a[10], b[10];
for (int i = 0; i < 3; i++) {
cin >> a[i] >> b[i];
n[a[i]]++;
n[b[i]]++;
}
for (int i = 0; i < 4; i++) {
if (n[i] > 2) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
} | #include <iostream>
#include <string>
#include <vector>
using namespace std;
int n[5];
int main() {
int a[10], b[10];
for (int i = 0; i < 3; i++) {
cin >> a[i] >> b[i];
n[a[i]]++;
n[b[i]]++;
}
for (int i = 1; i <= 4; i++) {
if (n[i] > 2) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << 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"
] | 932,810 | 932,811 | u100499821 | cpp |
p03131 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
using namespace std;
int main() {
ll k, a, b;
cin >> k >> a >> b;
ll ans = 0;
if (a >= b - 2)
ans = k + 1;
else {
k -= a + 1;
ans = b + k / 2 * (b - a) + k % 2;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
using namespace std;
int main() {
ll k, a, b;
cin >> k >> a >> b;
ll ans = 0;
if (a >= b - 1 || a >= k)
ans = k + 1;
else {
k -= a + 1;
ans = b + k / 2 * (b - a) + k % 2;
}
cout << ans << endl;
return 0;
}
| [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 932,822 | 932,821 | u907525511 | cpp |
p03131 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
using namespace std;
int main() {
ll k, a, b;
cin >> k >> a >> b;
ll ans = 0;
if (a >= b - 1)
ans = k + 1;
else {
k -= a + 1;
ans = b + k / 2 * (b - a) + k % 2;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
using namespace std;
int main() {
ll k, a, b;
cin >> k >> a >> b;
ll ans = 0;
if (a >= b - 1 || a >= k)
ans = k + 1;
else {
k -= a + 1;
ans = b + k / 2 * (b - a) + k % 2;
}
cout << ans << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 932,823 | 932,821 | u907525511 | cpp |
p03131 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
ll mod = 1e9 + 7;
#define rep(i, n) for (int i = 0; i < (n); ++i)
int main() {
ll k, a, b;
cin >> k >> a >> b;
if (k < a) {
cout << k + 1LL << endl;
return 0;
}
if (a >= b) {
cout << a + k << endl;
return 0;
}
ll ans = a;
k -= a - 1LL;
if (b - a == 1) {
cout << ans + k << endl;
return 0;
}
if (!(k & 1)) {
cout << ans + (b - a) * (k / 2LL) << endl;
return 0;
}
cout << ans + (b - a) * ((k - 1) / 2LL) + 1LL << endl;
return 0;
}
| #include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
ll mod = 1e9 + 7;
#define rep(i, n) for (int i = 0; i < (n); ++i)
int main() {
ll k, a, b;
cin >> k >> a >> b;
if (k < a) {
cout << k + 1LL << endl;
return 0;
}
if (a >= b) {
cout << k + 1LL << endl;
return 0;
}
ll ans = a;
k -= a - 1LL;
if (b - a == 1) {
cout << ans + k << endl;
return 0;
}
if (!(k & 1)) {
cout << ans + (b - a) * (k / 2LL) << endl;
return 0;
}
cout << ans + (b - a) * ((k - 1) / 2LL) + 1LL << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 932,824 | 932,825 | u596311864 | cpp |
p03131 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
ll K, A, B;
cin >> K >> A >> B;
if (K <= A) {
cout << K << endl;
return 0;
}
ll ans = A;
ans += (K - A + 1) / 2 * max(B - A, 2LL);
ans += (K - A + 1) % 2;
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
ll K, A, B;
cin >> K >> A >> B;
if (K <= A - 1) {
cout << K + 1 << endl;
return 0;
}
ll ans = A;
ans += (K - A + 1) / 2 * max(B - A, 2LL);
ans += (K - A + 1) % 2;
cout << ans << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 932,826 | 932,827 | u843522325 | cpp |
p03131 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repi(i, s, n) for (int i = (s); i < (n); i++)
#ifdef LOCAL
#define INPUT_FILE \
ifstream in("atcoder-problems/yahoo_procon2019_qual_c.txt"); \
cin.rdbuf(in.rdbuf());
#define print_vec(v) \
rep(l, v.size()) { cout << v[l] << " "; } \
cout << endl;
#else
#define INPUT_FILE
#define print_vec(v)
#endif
#define CIN_OPTIMIZE \
cin.tie(0); \
ios::sync_with_stdio(false);
typedef pair<int, int> P;
typedef long long ll;
typedef pair<ll, ll> pl;
const int INF = 100100100;
const ll LINF = 1e18 + 100;
const int MOD = 1e9 + 7;
int main() {
INPUT_FILE CIN_OPTIMIZE;
ll K, A, B;
cin >> K >> A >> B;
if (K < A || B <= A + 2) {
cout << K + 1 << endl;
return 0;
}
ll k = K - (A - 1);
k--;
ll cookie = B;
k--;
cookie += (k / 2) * (B - A);
cookie += k % 2;
cout << cookie << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repi(i, s, n) for (int i = (s); i < (n); i++)
#ifdef LOCAL
#define INPUT_FILE \
ifstream in("atcoder-problems/yahoo_procon2019_qual_c.txt"); \
cin.rdbuf(in.rdbuf());
#define print_vec(v) \
rep(l, v.size()) { cout << v[l] << " "; } \
cout << endl;
#else
#define INPUT_FILE
#define print_vec(v)
#endif
#define CIN_OPTIMIZE \
cin.tie(0); \
ios::sync_with_stdio(false);
typedef pair<int, int> P;
typedef long long ll;
typedef pair<ll, ll> pl;
const int INF = 100100100;
const ll LINF = 1e18 + 100;
const int MOD = 1e9 + 7;
int main() {
INPUT_FILE CIN_OPTIMIZE;
ll K, A, B;
cin >> K >> A >> B;
if (K < A + 1 || B <= A + 2) {
cout << K + 1 << endl;
return 0;
}
ll k = K - (A - 1);
k--;
ll cookie = B;
k--;
cookie += (k / 2) * (B - A);
cookie += k % 2;
cout << cookie << endl;
} | [
"control_flow.branch.if.condition.change"
] | 932,837 | 932,838 | u513083943 | cpp |
p03131 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
ll k, a, b;
cin >> k >> a >> b;
if (b - a <= 2 || k < a + 1)
cout << k + 1 << endl;
else
cout << a + (k - a + 1) / 2 * (b - a) + (k - a + 1) % 2 * a << endl;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
ll k, a, b;
cin >> k >> a >> b;
if (b - a <= 2 || k < a + 1)
cout << k + 1 << endl;
else
cout << a + (k - a + 1) / 2 * (b - a) + (k - a + 1) % 2 << endl;
}
| [
"expression.operation.binary.remove"
] | 932,842 | 932,843 | u641900703 | cpp |
p03131 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll K, A, B;
cin >> K >> A >> B;
ll res;
if (A + 1 < B) {
if (K > A) {
res = B + ((K - A - 1) / 2) * (B - A) + (K - A - 1) % 2;
}
} else
res = K + 1;
cout << res << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll K, A, B;
cin >> K >> A >> B;
ll res;
if (A + 1 < B && K > A) {
res = B + ((K - A - 1) / 2) * (B - A) + (K - A - 1) % 2;
} else
res = K + 1;
cout << res << endl;
}
| [
"control_flow.branch.if.condition.change"
] | 932,852 | 932,853 | u986480146 | cpp |
p03131 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll K, A, B;
cin >> K >> A >> B;
if (A - B + 2 >= 0 || K < A + 1)
cout << K + 1 << endl;
else {
ll N = K - (A + 1);
if (N % 2 == 0)
cout << B + (B - A) * (N / 2) << endl;
if (N % 2 == 1)
cout << B + (B - 1) * ((N - 1) / 2) + 1 << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll K, A, B;
cin >> K >> A >> B;
if (A - B + 2 >= 0 || K < A + 1)
cout << K + 1 << endl;
else {
ll N = K - (A + 1);
if (N % 2 == 0)
cout << B + (B - A) * (N / 2) << endl;
if (N % 2 == 1)
cout << B + (B - A) * ((N - 1) / 2) + 1 << endl;
}
} | [
"identifier.replace.add",
"literal.replace.remove",
"io.output.change"
] | 932,854 | 932,855 | u094654185 | cpp |
p03131 | #include <bits/stdc++.h>
using namespace std;
int main() {
int64_t K, A, B;
cin >> K >> A >> B;
if (B - A <= 1 || K <= A)
cout << K + 1 << endl;
else {
if ((K - A + 1) % 2 == 0) {
int ans = A + (B - A) * (K - A + 1) / 2;
cout << ans << endl;
} else {
int ans = 1 + A + (B - A) * ((K - A + 1) / 2);
cout << ans << endl;
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int64_t K, A, B;
cin >> K >> A >> B;
if (B - A <= 1 || K <= A)
cout << K + 1 << endl;
else {
if ((K - A + 1) % 2 == 0) {
int64_t ans = A + (B - A) * (K - A + 1) / 2;
cout << ans << endl;
} else {
int64_t ans = 1 + A + (B - A) * ((K - A + 1) / 2);
cout << ans << endl;
}
}
return 0;
} | [
"variable_declaration.type.primitive.change"
] | 932,871 | 932,872 | u101018317 | cpp |
p03131 | #include <bits/stdc++.h>
using ll = long long;
#define int ll
#define rep(i, n) for (int i = 0; i < n; i++)
#define loop(i, s, n) for (int i = s; i < n; i++)
#define erep(e, v) for (auto &&e : v)
#define all(in) in.begin(), in.end()
#define MP make_pair
#define INF (sizeof(int) == 4 ? (int)1e9 : (int)1e18)
#define EPS 0.0000000001
using namespace std;
template <class T, class S> void cmin(T &a, const S &b) {
if (a > b)
a = b;
}
template <class T, class S> void cmax(T &a, const S &b) {
if (a < b)
a = b;
}
template <typename Head, typename Value>
auto vectors(const Head &head, const Value &v) {
return vector<Value>(head, v);
}
template <typename Head, typename... Tail> auto vectors(Head x, Tail... tail) {
auto inner = vectors(tail...);
return vector<decltype(inner)>(x, inner);
}
template <class T> void join(T a) {
for (auto itr : a) {
if (itr != *a.begin())
cout << " ";
cout << itr;
}
}
using ld = long double;
using pii = pair<int, int>;
using piii = pair<int, pii>;
int W, H;
int dx[] = {0, 0, 1, -1}, dy[] = {1, -1, 0, 0};
bool valid(int x, int y) { return (0 <= x && x < W) && (0 <= y && y < H); }
signed main() {
int k, a, b;
cin >> k >> a >> b;
if (a + 2 >= b or k + 1 <= a) {
return cout << k + 1 << endl, 0;
}
int ans = 0;
k -= a + 1;
ans += b;
int dif = b - a;
cout << ans + dif * (k / 2) + (k % 2) << endl;
}
| #include <bits/stdc++.h>
using ll = long long;
#define int ll
#define rep(i, n) for (int i = 0; i < n; i++)
#define loop(i, s, n) for (int i = s; i < n; i++)
#define erep(e, v) for (auto &&e : v)
#define all(in) in.begin(), in.end()
#define MP make_pair
#define INF (sizeof(int) == 4 ? (int)1e9 : (int)1e18)
#define EPS 0.0000000001
using namespace std;
template <class T, class S> void cmin(T &a, const S &b) {
if (a > b)
a = b;
}
template <class T, class S> void cmax(T &a, const S &b) {
if (a < b)
a = b;
}
template <typename Head, typename Value>
auto vectors(const Head &head, const Value &v) {
return vector<Value>(head, v);
}
template <typename Head, typename... Tail> auto vectors(Head x, Tail... tail) {
auto inner = vectors(tail...);
return vector<decltype(inner)>(x, inner);
}
template <class T> void join(T a) {
for (auto itr : a) {
if (itr != *a.begin())
cout << " ";
cout << itr;
}
}
using ld = long double;
using pii = pair<int, int>;
using piii = pair<int, pii>;
int W, H;
int dx[] = {0, 0, 1, -1}, dy[] = {1, -1, 0, 0};
bool valid(int x, int y) { return (0 <= x && x < W) && (0 <= y && y < H); }
signed main() {
int k, a, b;
cin >> k >> a >> b;
if (a + 2 > b or k <= a) {
return cout << k + 1 << endl, 0;
}
int ans = 0;
k -= a + 1;
ans += b;
int dif = b - a;
cout << ans + dif * (k / 2) + (k % 2) << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 932,873 | 932,874 | u318334550 | cpp |
p03131 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll k, a, b, ans;
cin >> k >> a >> b;
if (b - a <= 2) {
cout << k + 1 << endl;
return 0;
}
ans += a - 1;
k -= a - 1;
ans += k % 2;
k -= k % 2;
ans += (b - a) * k / 2;
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll k, a, b, ans = 1;
cin >> k >> a >> b;
if (b - a <= 2) {
cout << k + 1 << endl;
return 0;
}
ans += a - 1;
k -= a - 1;
ans += k % 2;
k -= k % 2;
ans += (b - a) * k / 2;
cout << ans << endl;
}
| [
"variable_declaration.value.change"
] | 932,875 | 932,876 | u028906014 | cpp |
p03131 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long k, a, b, c;
cin >> k >> a >> b;
c = 1;
if (a >= b) {
cout << k + 1 << endl;
} else {
if (k < a) {
cout << k + 1 << endl;
} else if (b - a == 1) {
cout << k + 1 << endl;
} else {
if (k >= a - c + 2) {
k -= (a - c + 2);
c = b;
}
while (k > 1) {
c += (b - a);
k -= 2;
}
if (k == 1) {
c++;
k--;
}
cout << c << endl;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long k, a, b, c;
cin >> k >> a >> b;
c = 1;
if (a >= b) {
cout << k + 1 << endl;
} else {
if (k < a + 1) {
cout << k + 1 << endl;
} else if (b - a == 1) {
cout << k + 1 << endl;
} else {
if (k >= a - c + 2) {
k -= (a - c + 2);
c = b;
}
while (k > 1) {
c += (b - a);
k -= 2;
}
if (k == 1) {
c++;
k--;
}
cout << c << endl;
}
}
} | [
"control_flow.branch.if.condition.change"
] | 932,877 | 932,878 | u956675118 | cpp |
p03131 | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
//最大公約数
ll gcd(ll x, ll y) {
ll tmp = 0;
if (x < y) {
tmp = x;
x = y;
y = tmp;
}
while (y > 0) {
ll r = x % y;
x = y;
y = r;
}
return x;
}
//最大公倍数
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
const int MAX = 1e6 + 1;
const ll MOD = 1e9 + 7;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
//階乗
ll kaijo(ll k) {
ll sum = 1;
for (ll i = 1; i <= k; ++i) {
sum *= i;
sum %= 1000000000 + 7;
}
return sum;
}
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
// sieve(MAX);でベクトルIsPrimeに「MAXまでの数値の素数の真偽」を格納する。
vector<bool> IsPrime;
void sieve(size_t max) {
if (max + 1 > IsPrime.size()) { // resizeで要素数が減らないように
IsPrime.resize(max + 1, true); // IsPrimeに必要な要素数を確保
}
IsPrime[0] = false; // 0は素数ではない
IsPrime[1] = false; // 1は素数ではない
for (size_t i = 2; i * i <= max; ++i) // 0からsqrt(max)まで調べる
if (IsPrime[i]) // iが素数ならば
for (size_t j = 2; i * j <= max; ++j) // (max以下の)iの倍数は
IsPrime[i * j] = false; // 素数ではない
}
struct UnionFind {
vector<int> par;
UnionFind(int n) : par(n, -1) {}
int root(int x) {
if (par[x] < 0)
return x;
else
return par[x] = root(par[x]);
}
bool issame(int x, int y) { return root(x) == root(y); }
bool merge(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (par[x] > par[y])
swap(x, y); // merge technique
par[x] += par[y];
par[y] = x;
return true;
}
int size(int x) { return -par[root(x)]; }
};
ll count(int n, int a) {
ll bunshi = 1;
for (int i = 0; i < a; i++) {
bunshi *= (n - i);
bunshi %= MOD;
}
ll bunbo = 1;
for (int i = 1; i < a + 1; i++) {
bunbo *= i;
bunbo %= MOD;
}
bunbo = modpow(bunbo, MOD - 2, MOD);
// cout<<(bunshi*bunbo)%MOD<<endl;
return (bunshi * bunbo) % MOD;
}
// 約数列挙。約数をvector<ll>で返す。計算量はsqrt(n)。
vector<ll> divisor(ll n) {
vector<ll> ret;
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(begin(ret), end(ret));
return (ret);
}
// ここから開始
const ll INF = 1e18;
int main() {
int K, A, B;
cin >> K >> A >> B;
if (B - A - 2 <= 0 || K < A - 1)
cout << K + 1 << endl;
else {
ll ans = A;
K -= (A - 1);
if (K % 2 == 1)
++ans, --K;
ans += (B - A) * (K / 2);
cout << ans << endl;
}
return 0;
} | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
//最大公約数
ll gcd(ll x, ll y) {
ll tmp = 0;
if (x < y) {
tmp = x;
x = y;
y = tmp;
}
while (y > 0) {
ll r = x % y;
x = y;
y = r;
}
return x;
}
//最大公倍数
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
const int MAX = 1e6 + 1;
const ll MOD = 1e9 + 7;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
//階乗
ll kaijo(ll k) {
ll sum = 1;
for (ll i = 1; i <= k; ++i) {
sum *= i;
sum %= 1000000000 + 7;
}
return sum;
}
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
// sieve(MAX);でベクトルIsPrimeに「MAXまでの数値の素数の真偽」を格納する。
vector<bool> IsPrime;
void sieve(size_t max) {
if (max + 1 > IsPrime.size()) { // resizeで要素数が減らないように
IsPrime.resize(max + 1, true); // IsPrimeに必要な要素数を確保
}
IsPrime[0] = false; // 0は素数ではない
IsPrime[1] = false; // 1は素数ではない
for (size_t i = 2; i * i <= max; ++i) // 0からsqrt(max)まで調べる
if (IsPrime[i]) // iが素数ならば
for (size_t j = 2; i * j <= max; ++j) // (max以下の)iの倍数は
IsPrime[i * j] = false; // 素数ではない
}
struct UnionFind {
vector<int> par;
UnionFind(int n) : par(n, -1) {}
int root(int x) {
if (par[x] < 0)
return x;
else
return par[x] = root(par[x]);
}
bool issame(int x, int y) { return root(x) == root(y); }
bool merge(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (par[x] > par[y])
swap(x, y); // merge technique
par[x] += par[y];
par[y] = x;
return true;
}
int size(int x) { return -par[root(x)]; }
};
ll count(int n, int a) {
ll bunshi = 1;
for (int i = 0; i < a; i++) {
bunshi *= (n - i);
bunshi %= MOD;
}
ll bunbo = 1;
for (int i = 1; i < a + 1; i++) {
bunbo *= i;
bunbo %= MOD;
}
bunbo = modpow(bunbo, MOD - 2, MOD);
// cout<<(bunshi*bunbo)%MOD<<endl;
return (bunshi * bunbo) % MOD;
}
// 約数列挙。約数をvector<ll>で返す。計算量はsqrt(n)。
vector<ll> divisor(ll n) {
vector<ll> ret;
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(begin(ret), end(ret));
return (ret);
}
// ここから開始
const ll INF = 1e18;
int main() {
ll K, A, B;
cin >> K >> A >> B;
if (B - A - 2 <= 0 || K < A - 1)
cout << K + 1 << endl;
else {
ll ans = A;
K -= (A - 1);
if (K % 2 == 1)
++ans, --K;
ans += (B - A) * (K / 2);
cout << ans << endl;
}
return 0;
} | [
"variable_declaration.type.change"
] | 932,888 | 932,889 | u622585907 | cpp |
p03131 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define PI 3.14159265358979323846
constexpr int INF = numeric_limits<int>::max() / 2;
constexpr long long INFL = numeric_limits<long long>::max() / 2;
constexpr int MOD = 1000000007;
using Graph = vector<vector<int>>;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
long long K, A, B;
cin >> K >> A >> B;
long long cou = 1;
long long y = 0;
long long ans = 0;
if (B - A <= 2)
ans = K + 1;
else {
long long y = (K - (A - 1)) / 2;
ans = (K - (A - 1)) % 2 + y * B;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define PI 3.14159265358979323846
constexpr int INF = numeric_limits<int>::max() / 2;
constexpr long long INFL = numeric_limits<long long>::max() / 2;
constexpr int MOD = 1000000007;
using Graph = vector<vector<int>>;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
long long K, A, B;
cin >> K >> A >> B;
long long cou = 1;
long long y = 0;
long long ans = 0;
if (B - A <= 2)
ans = K + 1;
else {
long long y = (K - (A - 1)) / 2;
ans = (K - (A - 1)) % 2 + y * (B - A) + A;
}
cout << ans << endl;
}
| [
"assignment.change"
] | 932,894 | 932,895 | u093973314 | cpp |
p03131 | #include "bits/stdc++.h"
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII> VPII;
typedef long long LL;
typedef priority_queue<int> PQ_DESC;
typedef priority_queue<int, vector<int>, greater<int>> PQ_ASC;
typedef priority_queue<PII> PQ_DESC_PII;
typedef priority_queue<PII, vector<PII>, greater<PII>> PQ_ASC_PII;
#define ALL(c) (c).begin(), (c).end()
#define PB push_back
#define MP make_pair
#define SORT_ASC(c) sort(ALL(c))
#define SORT_DESC(c) sort(ALL(c), greater<typeof(*((c).begin()))>())
#define SIZE(a) int((a).size())
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define ROF(i, a, b) for (int i = (b - 1); i >= (a); --i)
#define REP(i, n) FOR(i, 0, n)
#define PER(i, n) ROF(i, 0, n)
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int LARGE_INT = 1e9 + 100;
const int INF = 2e9 + 100;
const LL INF_LL = (LL)INF * 300 * 300;
const int MOD = 1e9 + 7;
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
LL modpow(LL a, LL n) {
LL res = 1;
while (n > 0) {
if (n & 1)
res = res * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return res;
}
void Main() {
LL k, a, b;
cin >> k >> a >> b;
if (a + 2 >= b) {
cout << k + 1 << endl;
return;
}
if (k <= a) {
cout << k + 1 << endl;
}
LL result = 0;
k -= a + 1;
result += b;
result += (k / 2) * (b - a);
result += k % 2;
cout << result << endl;
return;
}
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(15);
Main();
return 0;
} | #include "bits/stdc++.h"
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII> VPII;
typedef long long LL;
typedef priority_queue<int> PQ_DESC;
typedef priority_queue<int, vector<int>, greater<int>> PQ_ASC;
typedef priority_queue<PII> PQ_DESC_PII;
typedef priority_queue<PII, vector<PII>, greater<PII>> PQ_ASC_PII;
#define ALL(c) (c).begin(), (c).end()
#define PB push_back
#define MP make_pair
#define SORT_ASC(c) sort(ALL(c))
#define SORT_DESC(c) sort(ALL(c), greater<typeof(*((c).begin()))>())
#define SIZE(a) int((a).size())
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define ROF(i, a, b) for (int i = (b - 1); i >= (a); --i)
#define REP(i, n) FOR(i, 0, n)
#define PER(i, n) ROF(i, 0, n)
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int LARGE_INT = 1e9 + 100;
const int INF = 2e9 + 100;
const LL INF_LL = (LL)INF * 300 * 300;
const int MOD = 1e9 + 7;
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
LL modpow(LL a, LL n) {
LL res = 1;
while (n > 0) {
if (n & 1)
res = res * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return res;
}
void Main() {
LL k, a, b;
cin >> k >> a >> b;
if (a + 2 >= b) {
cout << k + 1 << endl;
return;
}
if (k <= a) {
cout << k + 1 << endl;
return;
}
LL result = 0;
k -= a + 1;
result += b;
result += (k / 2) * (b - a);
result += k % 2;
cout << result << endl;
return;
}
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(15);
Main();
return 0;
} | [
"control_flow.return.add"
] | 932,898 | 932,899 | u987591601 | cpp |
p03131 | #include <bits/stdc++.h>
using namespace std;
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
typedef long long ll;
typedef pair<ll, ll> P;
const ll INF = 1LL << 60;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
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;
}
ll modpow(ll a, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll K, A, B;
cin >> K >> A >> B;
K++;
ll ans = 0;
if (A + 2 >= B) {
ans = K;
} else {
if (K >= A + 1) {
ans += B;
K -= (A + 2);
ans += (B - A) * (K / 2);
K = K % 2;
ans += K;
} else {
ans = K;
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
typedef long long ll;
typedef pair<ll, ll> P;
const ll INF = 1LL << 60;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
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;
}
ll modpow(ll a, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll K, A, B;
cin >> K >> A >> B;
K++;
ll ans = 0;
if (A + 2 >= B) {
ans = K;
} else {
if (K >= A + 2) {
ans += B;
K -= (A + 2);
ans += (B - A) * (K / 2);
K = K % 2;
ans += K;
} else {
ans = K;
}
}
cout << ans << endl;
return 0;
}
| [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 932,916 | 932,917 | u187878098 | cpp |
p03131 | #include <bits/stdc++.h>
#define debug(x) \
cout << "DEBUG" \
<< " " << #x << ":" << x << '\n'
#define rep(i, n) for (int i = 0; i < ((int)(n)); i++) // 0-indexed昇順
#define rep1(i, n) for (int i = 1; i <= ((int)(n)); i++) // 1-indexed昇順
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--) // 0-indexed降順
#define rrep1(i, n) for (int i = ((int)(n)); i >= 1; i--) // 1-indexed降順
#define all(x) (x).begin(), (x).end()
using namespace std;
template <typename T> using vec = vector<T>;
using i32 = int_fast32_t;
using i64 = int_fast64_t;
using u32 = uint_fast32_t;
using u64 = uint_fast64_t;
using ll = long long;
using ld = long double;
using vi = vec<int_fast32_t>;
using vl = vec<int_fast64_t>;
using vld = vec<ld>;
using vii = vec<vi>; // 2次元配列
using PII = pair<int_fast32_t, int_fast32_t>;
template <class T> using maxheap = std::priority_queue<T>;
template <class T>
using minheap = std::priority_queue<T, std::vector<T>, std::greater<T>>;
template <class T, class U> inline bool chmax(T &a, const U &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T, class U> inline bool chmin(T &a, const U &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const ld Pi = std::acos(-1.0L);
constexpr ll infll = (1LL << 62) - 1;
constexpr int inf = (1 << 30) - 1;
const int mod = 1000000007;
// const int mod = 998244353;
/*FUNCs=================================================*/
/*MAIN==================================================*/
signed main() {
int START_TIME = clock();
cin.tie(nullptr);
ios::sync_with_stdio(false); // cin cout 高速化
// cout << fixed << setprecision(15);
i64 k, a, b;
cin >> k >> a >> b;
if (a + 2 < b) {
if (k < a + 2 + 1) {
cout << k + 1 << '\n';
} else {
i32 ans = (b - a) * ((k - a + 1) / 2) + a;
if ((k - a + 1) % 2)
ans += 1;
cout << ans << '\n';
}
} else
cout << k + 1 << '\n';
// printf("ExecutionTime: %d
// /ms\n",1000*(int)((clock()-START_TIME)/CLOCKS_PER_SEC));
}
| #include <bits/stdc++.h>
#define debug(x) \
cout << "DEBUG" \
<< " " << #x << ":" << x << '\n'
#define rep(i, n) for (int i = 0; i < ((int)(n)); i++) // 0-indexed昇順
#define rep1(i, n) for (int i = 1; i <= ((int)(n)); i++) // 1-indexed昇順
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--) // 0-indexed降順
#define rrep1(i, n) for (int i = ((int)(n)); i >= 1; i--) // 1-indexed降順
#define all(x) (x).begin(), (x).end()
using namespace std;
template <typename T> using vec = vector<T>;
using i32 = int_fast32_t;
using i64 = int_fast64_t;
using u32 = uint_fast32_t;
using u64 = uint_fast64_t;
using ll = long long;
using ld = long double;
using vi = vec<int_fast32_t>;
using vl = vec<int_fast64_t>;
using vld = vec<ld>;
using vii = vec<vi>; // 2次元配列
using PII = pair<int_fast32_t, int_fast32_t>;
template <class T> using maxheap = std::priority_queue<T>;
template <class T>
using minheap = std::priority_queue<T, std::vector<T>, std::greater<T>>;
template <class T, class U> inline bool chmax(T &a, const U &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T, class U> inline bool chmin(T &a, const U &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const ld Pi = std::acos(-1.0L);
constexpr ll infll = (1LL << 62) - 1;
constexpr int inf = (1 << 30) - 1;
const int mod = 1000000007;
// const int mod = 998244353;
/*FUNCs=================================================*/
/*MAIN==================================================*/
signed main() {
int START_TIME = clock();
cin.tie(nullptr);
ios::sync_with_stdio(false); // cin cout 高速化
// cout << fixed << setprecision(15);
i64 k, a, b;
cin >> k >> a >> b;
if (a + 2 < b) {
if (k < a + 1) {
cout << k + 1 << '\n';
} else {
i32 ans = (b - a) * ((k - a + 1) / 2) + a;
if ((k - a + 1) % 2)
ans += 1;
cout << ans << '\n';
}
} else
cout << k + 1 << '\n';
// printf("ExecutionTime: %d
// /ms\n",1000*(int)((clock()-START_TIME)/CLOCKS_PER_SEC));
}
| [
"expression.operation.binary.remove"
] | 932,918 | 932,919 | u457985479 | cpp |
p03131 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <utility>
#include <vector>
using namespace std;
typedef unsigned long long ll;
typedef pair<int, int> P;
int main() {
ll K, A, B;
cin >> K >> A >> B;
if (K >= (A + 1) && B - A > 1) {
ll fc = K - (A - 1);
ll cnt = fc / 2;
ll c = B + (cnt - 1) * (B - A);
ll cc = fc % 2;
cout << c + cc << endl;
} else {
cout << K + 1 << endl;
}
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main() {
ll K, A, B;
cin >> K >> A >> B;
if (K >= (A + 1) && B - A > 1) {
ll fc = K - (A - 1);
ll cnt = fc / 2;
ll c = B + (cnt - 1) * (B - A);
ll cc = fc % 2;
cout << c + cc << endl;
} else {
cout << K + 1 << endl;
}
} | [
"variable_declaration.type.narrow.change"
] | 932,924 | 932,925 | u723550619 | cpp |
p03131 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef pair<ll, ll> pll;
typedef vector<pii> vii;
typedef vector<pll> vll;
typedef vector<pdd> vdd;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define mem(a, b) memset(a, b, sizeof(a))
#define all(x) (x).begin(), (x).end()
#define INF 1000000000000
#define MOD 1000000007
#define PB push_back
#define MP make_pair
#define F first
#define S second
inline void normal(ll &a) {
a %= MOD;
(a < 0) && (a += MOD);
}
inline ll modMul(ll a, ll b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
return (a * b) % MOD;
}
inline ll modAdd(ll a, ll b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
return (a + b) % MOD;
}
inline ll modSub(ll a, ll b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline ll modPow(ll b, ll p) {
ll r = 1;
while (p) {
if (p & 1)
r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline ll modInverse(ll a) { return modPow(a, MOD - 2); }
inline ll modDiv(ll a, ll b) { return modMul(a, modInverse(b)); }
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
int ctoi(char c) {
if (c >= '0' && c <= '9') {
return c - '0';
}
return 0;
}
int main() {
ll k, a, b, m;
cin >> k >> a >> b;
m = k;
if (a >= b) {
cout << k + 1 << endl;
return 0;
} else {
if (k < a) {
cout << k + 1 << endl;
return 0;
} else {
ll ans = b;
k = k - a - 1;
int n = k / 2;
ans += n * (b - a);
if (k % 2 == 1)
ans++;
cout << max(ans, m + 1) << endl;
}
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef pair<ll, ll> pll;
typedef vector<pii> vii;
typedef vector<pll> vll;
typedef vector<pdd> vdd;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define mem(a, b) memset(a, b, sizeof(a))
#define all(x) (x).begin(), (x).end()
#define INF 1000000000000
#define MOD 1000000007
#define PB push_back
#define MP make_pair
#define F first
#define S second
inline void normal(ll &a) {
a %= MOD;
(a < 0) && (a += MOD);
}
inline ll modMul(ll a, ll b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
return (a * b) % MOD;
}
inline ll modAdd(ll a, ll b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
return (a + b) % MOD;
}
inline ll modSub(ll a, ll b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline ll modPow(ll b, ll p) {
ll r = 1;
while (p) {
if (p & 1)
r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline ll modInverse(ll a) { return modPow(a, MOD - 2); }
inline ll modDiv(ll a, ll b) { return modMul(a, modInverse(b)); }
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
int ctoi(char c) {
if (c >= '0' && c <= '9') {
return c - '0';
}
return 0;
}
int main() {
ll k, a, b, m;
cin >> k >> a >> b;
m = k;
if (a >= b) {
cout << k + 1 << endl;
return 0;
} else {
if (k < a + 1) {
cout << k + 1 << endl;
return 0;
} else {
ll ans = b;
k = k - a - 1;
int n = k / 2;
ans += n * (b - a);
if (k % 2 == 1)
ans++;
cout << max(ans, m + 1) << endl;
}
}
}
| [
"control_flow.branch.if.condition.change"
] | 932,939 | 932,940 | u789323170 | cpp |
p03131 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long K, A, B;
cin >> K >> A >> B;
if (B - A <= 2) {
cout << K + 1 << endl;
} else {
long long t = max(0LL, (K - (A - 1)) / 2);
cout << A + (B - A) * t + (K - t) % 2 << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long K, A, B;
cin >> K >> A >> B;
if (B - A <= 2) {
cout << K + 1 << endl;
} else {
long long t = max(0LL, (K - (A - 1)) / 2);
cout << A + (B - A) * t + (K - (A - 1)) % 2 << endl;
}
return 0;
}
| [
"io.output.change"
] | 932,941 | 932,942 | u519194615 | cpp |
p03131 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define REP(i, d, n) for (int i = (d); i < (n); ++i)
#define all(v) v.begin(), v.end()
using ll = long long;
using P = pair<int, int>;
int main() {
ll k, a, b;
cin >> k >> a >> b;
if (b - a <= 2) {
cout << k + 1 << endl;
} else {
ll ans = a; // aまでビスケット叩く
int t = (k - a) / 2;
ans += (b - a) * t;
if ((k - a) & 1)
ans++; //最後奇数なら
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define REP(i, d, n) for (int i = (d); i < (n); ++i)
#define all(v) v.begin(), v.end()
using ll = long long;
using P = pair<int, int>;
int main() {
ll k, a, b;
cin >> k >> a >> b;
if (b - a <= 2) {
cout << k + 1 << endl;
} else {
ll ans = a; // aまでビスケット叩く
int t = (k - a + 1) / 2;
ans += (b - a) * t;
if ((k - a + 1) & 1)
ans++; //最後奇数なら
cout << ans << endl;
}
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 932,943 | 932,944 | u561143568 | cpp |
p03131 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define ALL(v) v.begin(), v.end()
typedef long long ll;
typedef pair<int, int> P;
const int INF = 1000000005;
int main() {
ll k, a, b;
cin >> k >> a >> b;
ll ans = 1;
if (b - a > 2) {
ans += a - 1;
k -= a - 1;
if (k >= 2) {
ans += (b - a) * (k / 2);
k %= 2;
ans += k;
cout << ans << endl;
} else {
cout << k + 1 << endl;
}
} else {
cout << k + 1 << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define ALL(v) v.begin(), v.end()
typedef long long ll;
typedef pair<int, int> P;
const int INF = 1000000005;
int main() {
ll k, a, b;
cin >> k >> a >> b;
ll K = k;
ll ans = 1;
if (b - a > 2) {
ans += a - 1;
k -= a - 1;
if (k >= 2) {
ans += (b - a) * (k / 2);
k %= 2;
ans += k;
cout << ans << endl;
} else {
cout << K + 1 << endl;
}
} else {
cout << k + 1 << endl;
}
return 0;
} | [
"variable_declaration.add",
"identifier.change",
"io.output.change"
] | 932,952 | 932,953 | u184929210 | cpp |
p03131 | #include <bits/stdc++.h>
using namespace std;
using Graph = vector<vector<int>>;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define brep(n) for (int bit = 0; bit < (1 << n); bit++)
#define erep(i, container) for (auto i : container)
#define irep(i, n) for (int i = n - 1; i >= (int)0; i--)
#define rrep(i, m, n) for (int i = m; i < (int)(n); i++)
#define reprep(i, j, h, w) rep(i, h) rep(j, w)
#define all(x) (x).begin(), (x).end()
#define aall(x, n) (x).begin(), (x).begin() + (n)
#define VEC(type, name, n) \
std::vector<type> name(n); \
rep(i, n) std::cin >> name[i];
#define pb push_back
#define pf push_front
#define lb lower_bound
#define ub upper_bound
#define fi first
#define se second
#define itn int
#define mp make_pair
#define sum accumulate
#define keta fixed << setprecision
#define vvector(name, typ, m, n, a) \
vector<vector<typ>> name(m, vector<typ>(n, a))
#define vvvector(name, t, l, m, n, a) \
vector<vector<vector<t>>> name(l, vector<vector<t>>(m, vector<t>(n, a)));
#define vvvvector(name, t, k, l, m, n, a) \
vector<vector<vector<vector<t>>>> name( \
k, vector<vector<vector<t>>>(l, vector<vector<t>>(m, vector<t>(n, a))));
typedef long long ll;
const int INF = 2000000000;
const ll INF64 = 9223372036854775806ll;
const int mod = 1000000007ll;
const ll MOD = 1000000007LL;
/*メモ
*/
int main() {
ll k, a, b;
std::cin >> k >> a >> b;
if (k == 1) {
std::cout << 2 << std::endl;
} else {
ll a1 = 1ll, a2 = 1ll;
a1 += k;
k -= (a - 1);
if (k > 0) {
a2 = 0;
k -= 2;
a2 += (b);
a2 += (k / 2) * (b - a);
if (k % 2)
a2++;
}
std::cout << max(a1, a2) << std::endl;
}
} | #include <bits/stdc++.h>
using namespace std;
using Graph = vector<vector<int>>;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define brep(n) for (int bit = 0; bit < (1 << n); bit++)
#define erep(i, container) for (auto i : container)
#define irep(i, n) for (int i = n - 1; i >= (int)0; i--)
#define rrep(i, m, n) for (int i = m; i < (int)(n); i++)
#define reprep(i, j, h, w) rep(i, h) rep(j, w)
#define all(x) (x).begin(), (x).end()
#define aall(x, n) (x).begin(), (x).begin() + (n)
#define VEC(type, name, n) \
std::vector<type> name(n); \
rep(i, n) std::cin >> name[i];
#define pb push_back
#define pf push_front
#define lb lower_bound
#define ub upper_bound
#define fi first
#define se second
#define itn int
#define mp make_pair
#define sum accumulate
#define keta fixed << setprecision
#define vvector(name, typ, m, n, a) \
vector<vector<typ>> name(m, vector<typ>(n, a))
#define vvvector(name, t, l, m, n, a) \
vector<vector<vector<t>>> name(l, vector<vector<t>>(m, vector<t>(n, a)));
#define vvvvector(name, t, k, l, m, n, a) \
vector<vector<vector<vector<t>>>> name( \
k, vector<vector<vector<t>>>(l, vector<vector<t>>(m, vector<t>(n, a))));
typedef long long ll;
const int INF = 2000000000;
const ll INF64 = 9223372036854775806ll;
const int mod = 1000000007ll;
const ll MOD = 1000000007LL;
/*メモ
*/
int main() {
ll k, a, b;
std::cin >> k >> a >> b;
if (k == 1) {
std::cout << 2 << std::endl;
} else {
ll a1 = 1ll, a2 = 1ll;
a1 += k;
k -= (a - 1);
k--;
if (k > 0) {
a2 = 0;
k--;
a2 += (b);
a2 += (k / 2) * (b - a);
if (k % 2)
a2++;
}
std::cout << max(a1, a2) << std::endl;
}
} | [
"expression.unary.arithmetic.add"
] | 932,954 | 932,955 | u539011156 | cpp |
p03131 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
const int INF = 1 << 29;
const ll MOD = 1000000007;
const int MAX = 100000;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
// 法mでのaの逆元を計算
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
//最大公約数
int gcd(int x, int y) { return (x % y) ? gcd(y, x % y) : y; }
//最小公倍数
int lcm(int x, int y) { return x / gcd(x, y) * y; }
int main() {
ll K, A, B;
cin >> K >> A >> B;
ll cnt = 0;
//お金にしてからビスケットにするには2手かかる
if (B - A <= 2) {
cnt = K + 1; //叩き続ける
} else {
if (K < A + 1)
cnt = K + 1;
else {
K = K - (A - 1); //最初は1枚持っているからA枚まで叩き続ける
cnt = A; // A枚持っている
if (K % 2 == 1)
cnt++;
K--; //奇数なら最後に1回叩ける
cnt += (B - A) * (K / 2); // 2手で(B-A)枚増やせる．K/2回動ける
}
}
cout << cnt << endl;
return 0;
}
| #include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
const int INF = 1 << 29;
const ll MOD = 1000000007;
const int MAX = 100000;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
// 法mでのaの逆元を計算
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
//最大公約数
int gcd(int x, int y) { return (x % y) ? gcd(y, x % y) : y; }
//最小公倍数
int lcm(int x, int y) { return x / gcd(x, y) * y; }
int main() {
ll K, A, B;
cin >> K >> A >> B;
ll cnt = 0;
//お金にしてからビスケットにするには2手かかる
if (B - A <= 2) {
cnt = K + 1; //叩き続ける
} else {
if (K < A - 1)
cnt = K + 1;
else {
K = K - (A - 1); //最初は1枚持っているからA枚まで叩き続ける
cnt = A; // A枚持っている
if (K % 2 == 1) { //奇数なら最後に1回叩ける
cnt++;
K--;
}
cnt += (B - A) * (K / 2); // 2手で(B-A)枚増やせる．K/2回動ける
}
}
cout << cnt << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 932,958 | 932,959 | u024764559 | cpp |
p03131 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
const int INF = 1 << 29;
const ll MOD = 1000000007;
const int MAX = 100000;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
// 法mでのaの逆元を計算
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
//最大公約数
int gcd(int x, int y) { return (x % y) ? gcd(y, x % y) : y; }
//最小公倍数
int lcm(int x, int y) { return x / gcd(x, y) * y; }
int main() {
ll K, A, B;
cin >> K >> A >> B;
ll cnt = 0;
//お金にしてからビスケットにするには2手かかる
if (B - A <= 2) {
cnt = K + 1; //叩き続ける
} else {
if (K < A + 1)
cnt = K + 1;
else {
K = K - (A - 1); //最初は1枚持っているからA枚まで叩き続ける
cnt = A; // A枚持っている
if (K % 2 == 0)
cnt++;
K--; //奇数なら最後に1回叩ける
cnt += (B - A) * (K / 2); // 2手で(B-A)枚増やせる．K/2回動ける
}
}
cout << cnt << endl;
return 0;
}
| #include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
const int INF = 1 << 29;
const ll MOD = 1000000007;
const int MAX = 100000;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
// 法mでのaの逆元を計算
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
//最大公約数
int gcd(int x, int y) { return (x % y) ? gcd(y, x % y) : y; }
//最小公倍数
int lcm(int x, int y) { return x / gcd(x, y) * y; }
int main() {
ll K, A, B;
cin >> K >> A >> B;
ll cnt = 0;
//お金にしてからビスケットにするには2手かかる
if (B - A <= 2) {
cnt = K + 1; //叩き続ける
} else {
if (K < A - 1)
cnt = K + 1;
else {
K = K - (A - 1); //最初は1枚持っているからA枚まで叩き続ける
cnt = A; // A枚持っている
if (K % 2 == 1) { //奇数なら最後に1回叩ける
cnt++;
K--;
}
cnt += (B - A) * (K / 2); // 2手で(B-A)枚増やせる．K/2回動ける
}
}
cout << cnt << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change",
"literal.number.change"
] | 932,960 | 932,959 | u024764559 | cpp |
p03131 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define double long double
#define fo(a, b) for (int a = 0; a < b; a++)
#define Sort(a) sort(a.begin(), a.end())
#define rev(a) reverse(a.begin(), a.end())
#define fi first
#define se second
#define sz size()
#define bgn begin()
#define en end()
#define pb push_back
#define pp() pop_back()
#define V vector
#define P pair
#define yuko(a) setprecision(a)
#define uni(a) a.erase(unique(a.begin(), a.end()), a.end())
#define Q queue
#define pri priority_queue
#define Pri priority_queue<int, vector<int>, greater<int>>
#define PriP \
priority_queue<P<int, int>, vector<P<int, int>>, greater<P<int, int>>>
#define ff first.first
#define fs first.second
#define sf second.first
#define ss second.second
#define all(a) (a).begin(), (a).end()
#define elif else if
int low(V<int> a, int b) {
decltype(a)::iterator c = lower_bound(a.begin(), a.end(), b);
int d = c - a.bgn;
return d;
}
int upp(V<int> a, int b) {
decltype(a)::iterator c = upper_bound(a.begin(), a.end(), b);
int d = c - a.bgn;
return d;
}
template <class T> void cou(vector<vector<T>> a) {
int b = a.size();
int c = a[0].size();
fo(i, b) {
fo(j, c) {
cout << a[i][j];
if (j == c - 1)
cout << endl;
else
cout << ' ';
}
}
}
int wari(int a, int b) {
if (a % b == 0)
return a / b;
else
return a / b + 1;
}
int keta(int a) {
double b = a;
b = log10(b);
int c = b;
return c + 1;
}
int souwa(int a) { return a * (a + 1) / 2; }
int gcm(int a, int b) {
if (a % b == 0)
return b;
return gcm(b, a % b);
}
bool prime(int a) {
if (a < 2)
return false;
else if (a == 2)
return true;
else if (a % 2 == 0)
return false;
for (int i = 3; i <= sqrt(a) + 1; i += 2) {
if (a % i == 0)
return false;
}
return true;
}
struct Union {
vector<int> par;
Union(int a) { par = vector<int>(a, -1); }
int find(int a) {
if (par[a] < 0)
return a;
else
return par[a] = find(par[a]);
}
bool same(int a, int b) { return find(a) == find(b); }
int Size(int a) { return -par[find(a)]; }
void unite(int a, int b) {
a = find(a);
b = find(b);
if (a == b)
return;
if (Size(b) > Size(a))
swap<int>(a, b);
par[a] += par[b];
par[b] = a;
}
};
int ketas(int a) {
string b = to_string(a);
int c = 0;
fo(i, keta(a)) { c += b[i] - '0'; }
return c;
}
bool fe(int a, int b) {
a %= 10;
b %= 10;
if (a == 0)
a = 10;
if (b == 0)
b = 10;
if (a > b)
return true;
else
return false;
}
int INF = 1000000007;
struct edge {
int s, t, d;
};
V<int> mojisyu(string a) {
V<int> b(26, 0);
fo(i, a.sz) { b[a[i] - 'a']++; }
return b;
}
int wa2(int a) {
if (a % 2 == 1)
return a / 2;
return a / 2 - 1;
}
/*signed main(){
int a,b,c;
cin>>a>>b>>c;
V<V<edge>> d(a);
fo(i,b){
edge e;
cin>>e.s>>e.t>>e.d;
d[e.s].pb(e);
}
V<int> e(a,INF);
e[c]=0;
priority_queue<P<int,int>,V<P<int,int>>,greater<P<int,int>>> f;
f.push({0,c});
int h=INF;
while(!f.empty()){
P<int,int> g;
g=f.top();
f.pop();
int v = g.second, i = g.first;
for(edge l : d[v]){
if(e[l.t] > i + l.d){
e[l.t] = i + l.d;
f.push({i+l.d , l.t});
}
}
}
fo(i,a){
if(e[i]==INF)
cout<<"INF"<<endl;
else
cout<<e[i]<<endl;
}
}
?*/
int nCr(int n, int r) {
if (n < r)
return 0;
int a = 1;
r = min(r, n - r);
for (int i = n; i > n - r; i--) {
a *= i;
a /= n - i + 1;
}
return a;
}
/*void sea(int x,int y){
if(x<0||a<=x||y<0||b<=y||c[x][y]=='#')
return;
if(d[x][y])
return;
d[x][y]++;
sea(x+1,y);
sea(x-1,y);
sea(x,y+1);
sea(x,y-1);
}*/
int kaijou(int a) {
int b = 1;
fo(i, a) b *= i + 1;
return b;
}
int nPr(int a, int b) {
if (a < b)
return 0;
if (b == 0)
return 1;
int c = 1;
for (int i = a; i > a - b; i--) {
c *= i;
c %= INF;
}
return c;
}
int modinv(int a, int m) {
int b = m, u = 1, v = 0;
while (b) {
int t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
int lcm(int a, int b) {
int c = modinv(gcm(a, b), INF);
return ((a * c) % INF) * (b % INF) % INF;
}
int MOD = INF;
int fac[1000010], finv[1000010], inv[1000010];
// テーブルを作る前処理
//先にCOMinit()で前処理をする
// ABC145D
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < 1000010; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
int COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
bool naka(int a, int b, V<V<char>> c) {
return (a >= 0 && b >= 0 && a < c.sz && b < c[0].sz);
}
V<P<int, int>> mawari8 = {{0, -1}, {0, 1}, {1, 0}, {-1, 0},
{-1, -1}, {1, 1}, {1, -1}, {-1, -1}};
int inf = 1000000000000000007;
/*
signed main(){
int a,b,c;
cin>>a>>b>>c;
V<V<edge>> d(a);
fo(i,b){
edge e;
cin>>e.s>>e.t>>e.d;
d[e.s].pb(e);
}
V<int> e(a,INF);
e[c]=0;
priority_queue<P<int,int>,V<P<int,int>>,greater<P<int,int>>> f;
f.push({0,c});
int h=INF;
while(!f.empty()){
P<int,int> g;
g=f.top();
f.pop();
int v = g.second, i = g.first;
for(edge l : d[v]){
if(e[l.t] > i + l.d){
e[l.t] = i + l.d;
f.push({i+l.d , l.t});
}
}
}
fo(i,a){
if(e[i]==INF)
cout<<"INF"<<endl;
else
cout<<e[i]<<endl;
}
}*/
V<P<int, int>> mawari4 = {{0, -1}, {0, 1}, {1, 0}, {-1, 0}};
//最短経路の表 a(全部INFで初期化)
//縦横 x,y
//迷路 f
//スタートsx,sy
//ゴールgx,gy
//文字はgから使おうね
/*int bfs_haba(){
Q<P<int,int>> b;
a[sx][sy]=0;
b.push({sx,sy});
while(!b.empty()){
P<int,int> c=b.front();
b.pop();
if(c.fi==gx&&c.se==gy){
break;
}
fo(i,4){
int d=c.fi+mawari4[i].fi;
int e=c.se+mawari4[i].se;
if(0<=d&&0<=e&&d<x&&e<y&&f[d][e]!='#'&&a[d][e]==INF){
b.push({d,e});
a[d][e]=1+a[c.fi][c.se];
}
}
}
return a[gx][gy];
}*/
V<int> onajibubun(string a) {
V<int> b(a.sz);
for (int i = 1, j = 0; i < a.sz; i++) {
if (i + b[i - j] < j + b[j])
b[i] = b[i - j];
else {
int c = max<int>(0, j + b[j] - i);
while (i + c < a.sz && a[c] == a[i + c])
c++;
b[i] = c;
j = i;
}
}
b[0] = a.sz;
return b;
}
//各頂点ごとにどこに辺が出てるかの表がc
//各頂点ごとの色を表すV<int>(頂点数max)のcolorを用意する
// aはどこ塗るか、bは何で塗るかなので、(0,1,c)でよぶとおけ
V<int> color(205);
bool nibu_hantei(int a, int b, V<V<int>> c) {
color[a] = b;
fo(i, c[a].sz) {
if (b == color[c[a][i]])
return false;
if (color[c[a][i]] == 0 && !nibu_hantei(c[a][i], -b, c))
return false;
}
return true;
}
// aは頂点数
// nibu_hanteiの上にcolorを用意する
//各頂点ごとにどこに辺が出てるかの表がc
bool renketujanai_nibu_hantei(int a, V<V<int>> c) {
fo(i, a) {
if (color[i] == 0) {
if (!nibu_hantei(i, 1, c))
return false;
}
}
return true;
}
signed main() {
int a, b, c;
cin >> a >> b >> c;
if (b + 2 >= c)
cout << 1 + a << endl;
else {
if (a < b)
cout << 1 + a << endl;
else {
a -= b + 1;
cout << c + a % 2 + a / 2 * (c - b) << endl;
}
}
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define double long double
#define fo(a, b) for (int a = 0; a < b; a++)
#define Sort(a) sort(a.begin(), a.end())
#define rev(a) reverse(a.begin(), a.end())
#define fi first
#define se second
#define sz size()
#define bgn begin()
#define en end()
#define pb push_back
#define pp() pop_back()
#define V vector
#define P pair
#define yuko(a) setprecision(a)
#define uni(a) a.erase(unique(a.begin(), a.end()), a.end())
#define Q queue
#define pri priority_queue
#define Pri priority_queue<int, vector<int>, greater<int>>
#define PriP \
priority_queue<P<int, int>, vector<P<int, int>>, greater<P<int, int>>>
#define ff first.first
#define fs first.second
#define sf second.first
#define ss second.second
#define all(a) (a).begin(), (a).end()
#define elif else if
int low(V<int> a, int b) {
decltype(a)::iterator c = lower_bound(a.begin(), a.end(), b);
int d = c - a.bgn;
return d;
}
int upp(V<int> a, int b) {
decltype(a)::iterator c = upper_bound(a.begin(), a.end(), b);
int d = c - a.bgn;
return d;
}
template <class T> void cou(vector<vector<T>> a) {
int b = a.size();
int c = a[0].size();
fo(i, b) {
fo(j, c) {
cout << a[i][j];
if (j == c - 1)
cout << endl;
else
cout << ' ';
}
}
}
int wari(int a, int b) {
if (a % b == 0)
return a / b;
else
return a / b + 1;
}
int keta(int a) {
double b = a;
b = log10(b);
int c = b;
return c + 1;
}
int souwa(int a) { return a * (a + 1) / 2; }
int gcm(int a, int b) {
if (a % b == 0)
return b;
return gcm(b, a % b);
}
bool prime(int a) {
if (a < 2)
return false;
else if (a == 2)
return true;
else if (a % 2 == 0)
return false;
for (int i = 3; i <= sqrt(a) + 1; i += 2) {
if (a % i == 0)
return false;
}
return true;
}
struct Union {
vector<int> par;
Union(int a) { par = vector<int>(a, -1); }
int find(int a) {
if (par[a] < 0)
return a;
else
return par[a] = find(par[a]);
}
bool same(int a, int b) { return find(a) == find(b); }
int Size(int a) { return -par[find(a)]; }
void unite(int a, int b) {
a = find(a);
b = find(b);
if (a == b)
return;
if (Size(b) > Size(a))
swap<int>(a, b);
par[a] += par[b];
par[b] = a;
}
};
int ketas(int a) {
string b = to_string(a);
int c = 0;
fo(i, keta(a)) { c += b[i] - '0'; }
return c;
}
bool fe(int a, int b) {
a %= 10;
b %= 10;
if (a == 0)
a = 10;
if (b == 0)
b = 10;
if (a > b)
return true;
else
return false;
}
int INF = 1000000007;
struct edge {
int s, t, d;
};
V<int> mojisyu(string a) {
V<int> b(26, 0);
fo(i, a.sz) { b[a[i] - 'a']++; }
return b;
}
int wa2(int a) {
if (a % 2 == 1)
return a / 2;
return a / 2 - 1;
}
/*signed main(){
int a,b,c;
cin>>a>>b>>c;
V<V<edge>> d(a);
fo(i,b){
edge e;
cin>>e.s>>e.t>>e.d;
d[e.s].pb(e);
}
V<int> e(a,INF);
e[c]=0;
priority_queue<P<int,int>,V<P<int,int>>,greater<P<int,int>>> f;
f.push({0,c});
int h=INF;
while(!f.empty()){
P<int,int> g;
g=f.top();
f.pop();
int v = g.second, i = g.first;
for(edge l : d[v]){
if(e[l.t] > i + l.d){
e[l.t] = i + l.d;
f.push({i+l.d , l.t});
}
}
}
fo(i,a){
if(e[i]==INF)
cout<<"INF"<<endl;
else
cout<<e[i]<<endl;
}
}
?*/
int nCr(int n, int r) {
if (n < r)
return 0;
int a = 1;
r = min(r, n - r);
for (int i = n; i > n - r; i--) {
a *= i;
a /= n - i + 1;
}
return a;
}
/*void sea(int x,int y){
if(x<0||a<=x||y<0||b<=y||c[x][y]=='#')
return;
if(d[x][y])
return;
d[x][y]++;
sea(x+1,y);
sea(x-1,y);
sea(x,y+1);
sea(x,y-1);
}*/
int kaijou(int a) {
int b = 1;
fo(i, a) b *= i + 1;
return b;
}
int nPr(int a, int b) {
if (a < b)
return 0;
if (b == 0)
return 1;
int c = 1;
for (int i = a; i > a - b; i--) {
c *= i;
c %= INF;
}
return c;
}
int modinv(int a, int m) {
int b = m, u = 1, v = 0;
while (b) {
int t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
int lcm(int a, int b) {
int c = modinv(gcm(a, b), INF);
return ((a * c) % INF) * (b % INF) % INF;
}
int MOD = INF;
int fac[1000010], finv[1000010], inv[1000010];
// テーブルを作る前処理
//先にCOMinit()で前処理をする
// ABC145D
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < 1000010; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
int COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
bool naka(int a, int b, V<V<char>> c) {
return (a >= 0 && b >= 0 && a < c.sz && b < c[0].sz);
}
V<P<int, int>> mawari8 = {{0, -1}, {0, 1}, {1, 0}, {-1, 0},
{-1, -1}, {1, 1}, {1, -1}, {-1, -1}};
int inf = 1000000000000000007;
/*
signed main(){
int a,b,c;
cin>>a>>b>>c;
V<V<edge>> d(a);
fo(i,b){
edge e;
cin>>e.s>>e.t>>e.d;
d[e.s].pb(e);
}
V<int> e(a,INF);
e[c]=0;
priority_queue<P<int,int>,V<P<int,int>>,greater<P<int,int>>> f;
f.push({0,c});
int h=INF;
while(!f.empty()){
P<int,int> g;
g=f.top();
f.pop();
int v = g.second, i = g.first;
for(edge l : d[v]){
if(e[l.t] > i + l.d){
e[l.t] = i + l.d;
f.push({i+l.d , l.t});
}
}
}
fo(i,a){
if(e[i]==INF)
cout<<"INF"<<endl;
else
cout<<e[i]<<endl;
}
}*/
V<P<int, int>> mawari4 = {{0, -1}, {0, 1}, {1, 0}, {-1, 0}};
//最短経路の表 a(全部INFで初期化)
//縦横 x,y
//迷路 f
//スタートsx,sy
//ゴールgx,gy
//文字はgから使おうね
/*int bfs_haba(){
Q<P<int,int>> b;
a[sx][sy]=0;
b.push({sx,sy});
while(!b.empty()){
P<int,int> c=b.front();
b.pop();
if(c.fi==gx&&c.se==gy){
break;
}
fo(i,4){
int d=c.fi+mawari4[i].fi;
int e=c.se+mawari4[i].se;
if(0<=d&&0<=e&&d<x&&e<y&&f[d][e]!='#'&&a[d][e]==INF){
b.push({d,e});
a[d][e]=1+a[c.fi][c.se];
}
}
}
return a[gx][gy];
}*/
V<int> onajibubun(string a) {
V<int> b(a.sz);
for (int i = 1, j = 0; i < a.sz; i++) {
if (i + b[i - j] < j + b[j])
b[i] = b[i - j];
else {
int c = max<int>(0, j + b[j] - i);
while (i + c < a.sz && a[c] == a[i + c])
c++;
b[i] = c;
j = i;
}
}
b[0] = a.sz;
return b;
}
//各頂点ごとにどこに辺が出てるかの表がc
//各頂点ごとの色を表すV<int>(頂点数max)のcolorを用意する
// aはどこ塗るか、bは何で塗るかなので、(0,1,c)でよぶとおけ
V<int> color(205);
bool nibu_hantei(int a, int b, V<V<int>> c) {
color[a] = b;
fo(i, c[a].sz) {
if (b == color[c[a][i]])
return false;
if (color[c[a][i]] == 0 && !nibu_hantei(c[a][i], -b, c))
return false;
}
return true;
}
// aは頂点数
// nibu_hanteiの上にcolorを用意する
//各頂点ごとにどこに辺が出てるかの表がc
bool renketujanai_nibu_hantei(int a, V<V<int>> c) {
fo(i, a) {
if (color[i] == 0) {
if (!nibu_hantei(i, 1, c))
return false;
}
}
return true;
}
signed main() {
int a, b, c;
cin >> a >> b >> c;
if (b + 2 >= c)
cout << 1 + a << endl;
else {
if (a < b + 1)
cout << 1 + a << endl;
else {
a -= b + 1;
cout << c + a % 2 + a / 2 * (c - b) << endl;
}
}
} | [
"control_flow.branch.if.condition.change"
] | 932,961 | 932,962 | u322177979 | cpp |
p03131 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define double long double
#define fo(a, b) for (int a = 0; a < b; a++)
#define Sort(a) sort(a.begin(), a.end())
#define rev(a) reverse(a.begin(), a.end())
#define fi first
#define se second
#define sz size()
#define bgn begin()
#define en end()
#define pb push_back
#define pp() pop_back()
#define V vector
#define P pair
#define yuko(a) setprecision(a)
#define uni(a) a.erase(unique(a.begin(), a.end()), a.end())
#define Q queue
#define pri priority_queue
#define Pri priority_queue<int, vector<int>, greater<int>>
#define PriP \
priority_queue<P<int, int>, vector<P<int, int>>, greater<P<int, int>>>
#define ff first.first
#define fs first.second
#define sf second.first
#define ss second.second
#define all(a) (a).begin(), (a).end()
#define elif else if
int low(V<int> a, int b) {
decltype(a)::iterator c = lower_bound(a.begin(), a.end(), b);
int d = c - a.bgn;
return d;
}
int upp(V<int> a, int b) {
decltype(a)::iterator c = upper_bound(a.begin(), a.end(), b);
int d = c - a.bgn;
return d;
}
template <class T> void cou(vector<vector<T>> a) {
int b = a.size();
int c = a[0].size();
fo(i, b) {
fo(j, c) {
cout << a[i][j];
if (j == c - 1)
cout << endl;
else
cout << ' ';
}
}
}
int wari(int a, int b) {
if (a % b == 0)
return a / b;
else
return a / b + 1;
}
int keta(int a) {
double b = a;
b = log10(b);
int c = b;
return c + 1;
}
int souwa(int a) { return a * (a + 1) / 2; }
int gcm(int a, int b) {
if (a % b == 0)
return b;
return gcm(b, a % b);
}
bool prime(int a) {
if (a < 2)
return false;
else if (a == 2)
return true;
else if (a % 2 == 0)
return false;
for (int i = 3; i <= sqrt(a) + 1; i += 2) {
if (a % i == 0)
return false;
}
return true;
}
struct Union {
vector<int> par;
Union(int a) { par = vector<int>(a, -1); }
int find(int a) {
if (par[a] < 0)
return a;
else
return par[a] = find(par[a]);
}
bool same(int a, int b) { return find(a) == find(b); }
int Size(int a) { return -par[find(a)]; }
void unite(int a, int b) {
a = find(a);
b = find(b);
if (a == b)
return;
if (Size(b) > Size(a))
swap<int>(a, b);
par[a] += par[b];
par[b] = a;
}
};
int ketas(int a) {
string b = to_string(a);
int c = 0;
fo(i, keta(a)) { c += b[i] - '0'; }
return c;
}
bool fe(int a, int b) {
a %= 10;
b %= 10;
if (a == 0)
a = 10;
if (b == 0)
b = 10;
if (a > b)
return true;
else
return false;
}
int INF = 1000000007;
struct edge {
int s, t, d;
};
V<int> mojisyu(string a) {
V<int> b(26, 0);
fo(i, a.sz) { b[a[i] - 'a']++; }
return b;
}
int wa2(int a) {
if (a % 2 == 1)
return a / 2;
return a / 2 - 1;
}
/*signed main(){
int a,b,c;
cin>>a>>b>>c;
V<V<edge>> d(a);
fo(i,b){
edge e;
cin>>e.s>>e.t>>e.d;
d[e.s].pb(e);
}
V<int> e(a,INF);
e[c]=0;
priority_queue<P<int,int>,V<P<int,int>>,greater<P<int,int>>> f;
f.push({0,c});
int h=INF;
while(!f.empty()){
P<int,int> g;
g=f.top();
f.pop();
int v = g.second, i = g.first;
for(edge l : d[v]){
if(e[l.t] > i + l.d){
e[l.t] = i + l.d;
f.push({i+l.d , l.t});
}
}
}
fo(i,a){
if(e[i]==INF)
cout<<"INF"<<endl;
else
cout<<e[i]<<endl;
}
}
?*/
int nCr(int n, int r) {
if (n < r)
return 0;
int a = 1;
r = min(r, n - r);
for (int i = n; i > n - r; i--) {
a *= i;
a /= n - i + 1;
}
return a;
}
/*void sea(int x,int y){
if(x<0||a<=x||y<0||b<=y||c[x][y]=='#')
return;
if(d[x][y])
return;
d[x][y]++;
sea(x+1,y);
sea(x-1,y);
sea(x,y+1);
sea(x,y-1);
}*/
int kaijou(int a) {
int b = 1;
fo(i, a) b *= i + 1;
return b;
}
int nPr(int a, int b) {
if (a < b)
return 0;
if (b == 0)
return 1;
int c = 1;
for (int i = a; i > a - b; i--) {
c *= i;
c %= INF;
}
return c;
}
int modinv(int a, int m) {
int b = m, u = 1, v = 0;
while (b) {
int t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
int lcm(int a, int b) {
int c = modinv(gcm(a, b), INF);
return ((a * c) % INF) * (b % INF) % INF;
}
int MOD = INF;
int fac[1000010], finv[1000010], inv[1000010];
// テーブルを作る前処理
//先にCOMinit()で前処理をする
// ABC145D
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < 1000010; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
int COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
bool naka(int a, int b, V<V<char>> c) {
return (a >= 0 && b >= 0 && a < c.sz && b < c[0].sz);
}
V<P<int, int>> mawari8 = {{0, -1}, {0, 1}, {1, 0}, {-1, 0},
{-1, -1}, {1, 1}, {1, -1}, {-1, -1}};
int inf = 1000000000000000007;
/*
signed main(){
int a,b,c;
cin>>a>>b>>c;
V<V<edge>> d(a);
fo(i,b){
edge e;
cin>>e.s>>e.t>>e.d;
d[e.s].pb(e);
}
V<int> e(a,INF);
e[c]=0;
priority_queue<P<int,int>,V<P<int,int>>,greater<P<int,int>>> f;
f.push({0,c});
int h=INF;
while(!f.empty()){
P<int,int> g;
g=f.top();
f.pop();
int v = g.second, i = g.first;
for(edge l : d[v]){
if(e[l.t] > i + l.d){
e[l.t] = i + l.d;
f.push({i+l.d , l.t});
}
}
}
fo(i,a){
if(e[i]==INF)
cout<<"INF"<<endl;
else
cout<<e[i]<<endl;
}
}*/
V<P<int, int>> mawari4 = {{0, -1}, {0, 1}, {1, 0}, {-1, 0}};
//最短経路の表 a(全部INFで初期化)
//縦横 x,y
//迷路 f
//スタートsx,sy
//ゴールgx,gy
//文字はgから使おうね
/*int bfs_haba(){
Q<P<int,int>> b;
a[sx][sy]=0;
b.push({sx,sy});
while(!b.empty()){
P<int,int> c=b.front();
b.pop();
if(c.fi==gx&&c.se==gy){
break;
}
fo(i,4){
int d=c.fi+mawari4[i].fi;
int e=c.se+mawari4[i].se;
if(0<=d&&0<=e&&d<x&&e<y&&f[d][e]!='#'&&a[d][e]==INF){
b.push({d,e});
a[d][e]=1+a[c.fi][c.se];
}
}
}
return a[gx][gy];
}*/
V<int> onajibubun(string a) {
V<int> b(a.sz);
for (int i = 1, j = 0; i < a.sz; i++) {
if (i + b[i - j] < j + b[j])
b[i] = b[i - j];
else {
int c = max<int>(0, j + b[j] - i);
while (i + c < a.sz && a[c] == a[i + c])
c++;
b[i] = c;
j = i;
}
}
b[0] = a.sz;
return b;
}
//各頂点ごとにどこに辺が出てるかの表がc
//各頂点ごとの色を表すV<int>(頂点数max)のcolorを用意する
// aはどこ塗るか、bは何で塗るかなので、(0,1,c)でよぶとおけ
V<int> color(205);
bool nibu_hantei(int a, int b, V<V<int>> c) {
color[a] = b;
fo(i, c[a].sz) {
if (b == color[c[a][i]])
return false;
if (color[c[a][i]] == 0 && !nibu_hantei(c[a][i], -b, c))
return false;
}
return true;
}
// aは頂点数
// nibu_hanteiの上にcolorを用意する
//各頂点ごとにどこに辺が出てるかの表がc
bool renketujanai_nibu_hantei(int a, V<V<int>> c) {
fo(i, a) {
if (color[i] == 0) {
if (!nibu_hantei(i, 1, c))
return false;
}
}
return true;
}
signed main() {
int a, b, c;
cin >> a >> b >> c;
if (b + 1 >= c)
cout << 1 + a << endl;
else {
if (a < b)
cout << 1 + a << endl;
else {
a -= b + 1;
cout << c + a % 2 + a / 2 * (c - b) << endl;
}
}
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define double long double
#define fo(a, b) for (int a = 0; a < b; a++)
#define Sort(a) sort(a.begin(), a.end())
#define rev(a) reverse(a.begin(), a.end())
#define fi first
#define se second
#define sz size()
#define bgn begin()
#define en end()
#define pb push_back
#define pp() pop_back()
#define V vector
#define P pair
#define yuko(a) setprecision(a)
#define uni(a) a.erase(unique(a.begin(), a.end()), a.end())
#define Q queue
#define pri priority_queue
#define Pri priority_queue<int, vector<int>, greater<int>>
#define PriP \
priority_queue<P<int, int>, vector<P<int, int>>, greater<P<int, int>>>
#define ff first.first
#define fs first.second
#define sf second.first
#define ss second.second
#define all(a) (a).begin(), (a).end()
#define elif else if
int low(V<int> a, int b) {
decltype(a)::iterator c = lower_bound(a.begin(), a.end(), b);
int d = c - a.bgn;
return d;
}
int upp(V<int> a, int b) {
decltype(a)::iterator c = upper_bound(a.begin(), a.end(), b);
int d = c - a.bgn;
return d;
}
template <class T> void cou(vector<vector<T>> a) {
int b = a.size();
int c = a[0].size();
fo(i, b) {
fo(j, c) {
cout << a[i][j];
if (j == c - 1)
cout << endl;
else
cout << ' ';
}
}
}
int wari(int a, int b) {
if (a % b == 0)
return a / b;
else
return a / b + 1;
}
int keta(int a) {
double b = a;
b = log10(b);
int c = b;
return c + 1;
}
int souwa(int a) { return a * (a + 1) / 2; }
int gcm(int a, int b) {
if (a % b == 0)
return b;
return gcm(b, a % b);
}
bool prime(int a) {
if (a < 2)
return false;
else if (a == 2)
return true;
else if (a % 2 == 0)
return false;
for (int i = 3; i <= sqrt(a) + 1; i += 2) {
if (a % i == 0)
return false;
}
return true;
}
struct Union {
vector<int> par;
Union(int a) { par = vector<int>(a, -1); }
int find(int a) {
if (par[a] < 0)
return a;
else
return par[a] = find(par[a]);
}
bool same(int a, int b) { return find(a) == find(b); }
int Size(int a) { return -par[find(a)]; }
void unite(int a, int b) {
a = find(a);
b = find(b);
if (a == b)
return;
if (Size(b) > Size(a))
swap<int>(a, b);
par[a] += par[b];
par[b] = a;
}
};
int ketas(int a) {
string b = to_string(a);
int c = 0;
fo(i, keta(a)) { c += b[i] - '0'; }
return c;
}
bool fe(int a, int b) {
a %= 10;
b %= 10;
if (a == 0)
a = 10;
if (b == 0)
b = 10;
if (a > b)
return true;
else
return false;
}
int INF = 1000000007;
struct edge {
int s, t, d;
};
V<int> mojisyu(string a) {
V<int> b(26, 0);
fo(i, a.sz) { b[a[i] - 'a']++; }
return b;
}
int wa2(int a) {
if (a % 2 == 1)
return a / 2;
return a / 2 - 1;
}
/*signed main(){
int a,b,c;
cin>>a>>b>>c;
V<V<edge>> d(a);
fo(i,b){
edge e;
cin>>e.s>>e.t>>e.d;
d[e.s].pb(e);
}
V<int> e(a,INF);
e[c]=0;
priority_queue<P<int,int>,V<P<int,int>>,greater<P<int,int>>> f;
f.push({0,c});
int h=INF;
while(!f.empty()){
P<int,int> g;
g=f.top();
f.pop();
int v = g.second, i = g.first;
for(edge l : d[v]){
if(e[l.t] > i + l.d){
e[l.t] = i + l.d;
f.push({i+l.d , l.t});
}
}
}
fo(i,a){
if(e[i]==INF)
cout<<"INF"<<endl;
else
cout<<e[i]<<endl;
}
}
?*/
int nCr(int n, int r) {
if (n < r)
return 0;
int a = 1;
r = min(r, n - r);
for (int i = n; i > n - r; i--) {
a *= i;
a /= n - i + 1;
}
return a;
}
/*void sea(int x,int y){
if(x<0||a<=x||y<0||b<=y||c[x][y]=='#')
return;
if(d[x][y])
return;
d[x][y]++;
sea(x+1,y);
sea(x-1,y);
sea(x,y+1);
sea(x,y-1);
}*/
int kaijou(int a) {
int b = 1;
fo(i, a) b *= i + 1;
return b;
}
int nPr(int a, int b) {
if (a < b)
return 0;
if (b == 0)
return 1;
int c = 1;
for (int i = a; i > a - b; i--) {
c *= i;
c %= INF;
}
return c;
}
int modinv(int a, int m) {
int b = m, u = 1, v = 0;
while (b) {
int t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
int lcm(int a, int b) {
int c = modinv(gcm(a, b), INF);
return ((a * c) % INF) * (b % INF) % INF;
}
int MOD = INF;
int fac[1000010], finv[1000010], inv[1000010];
// テーブルを作る前処理
//先にCOMinit()で前処理をする
// ABC145D
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < 1000010; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
int COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
bool naka(int a, int b, V<V<char>> c) {
return (a >= 0 && b >= 0 && a < c.sz && b < c[0].sz);
}
V<P<int, int>> mawari8 = {{0, -1}, {0, 1}, {1, 0}, {-1, 0},
{-1, -1}, {1, 1}, {1, -1}, {-1, -1}};
int inf = 1000000000000000007;
/*
signed main(){
int a,b,c;
cin>>a>>b>>c;
V<V<edge>> d(a);
fo(i,b){
edge e;
cin>>e.s>>e.t>>e.d;
d[e.s].pb(e);
}
V<int> e(a,INF);
e[c]=0;
priority_queue<P<int,int>,V<P<int,int>>,greater<P<int,int>>> f;
f.push({0,c});
int h=INF;
while(!f.empty()){
P<int,int> g;
g=f.top();
f.pop();
int v = g.second, i = g.first;
for(edge l : d[v]){
if(e[l.t] > i + l.d){
e[l.t] = i + l.d;
f.push({i+l.d , l.t});
}
}
}
fo(i,a){
if(e[i]==INF)
cout<<"INF"<<endl;
else
cout<<e[i]<<endl;
}
}*/
V<P<int, int>> mawari4 = {{0, -1}, {0, 1}, {1, 0}, {-1, 0}};
//最短経路の表 a(全部INFで初期化)
//縦横 x,y
//迷路 f
//スタートsx,sy
//ゴールgx,gy
//文字はgから使おうね
/*int bfs_haba(){
Q<P<int,int>> b;
a[sx][sy]=0;
b.push({sx,sy});
while(!b.empty()){
P<int,int> c=b.front();
b.pop();
if(c.fi==gx&&c.se==gy){
break;
}
fo(i,4){
int d=c.fi+mawari4[i].fi;
int e=c.se+mawari4[i].se;
if(0<=d&&0<=e&&d<x&&e<y&&f[d][e]!='#'&&a[d][e]==INF){
b.push({d,e});
a[d][e]=1+a[c.fi][c.se];
}
}
}
return a[gx][gy];
}*/
V<int> onajibubun(string a) {
V<int> b(a.sz);
for (int i = 1, j = 0; i < a.sz; i++) {
if (i + b[i - j] < j + b[j])
b[i] = b[i - j];
else {
int c = max<int>(0, j + b[j] - i);
while (i + c < a.sz && a[c] == a[i + c])
c++;
b[i] = c;
j = i;
}
}
b[0] = a.sz;
return b;
}
//各頂点ごとにどこに辺が出てるかの表がc
//各頂点ごとの色を表すV<int>(頂点数max)のcolorを用意する
// aはどこ塗るか、bは何で塗るかなので、(0,1,c)でよぶとおけ
V<int> color(205);
bool nibu_hantei(int a, int b, V<V<int>> c) {
color[a] = b;
fo(i, c[a].sz) {
if (b == color[c[a][i]])
return false;
if (color[c[a][i]] == 0 && !nibu_hantei(c[a][i], -b, c))
return false;
}
return true;
}
// aは頂点数
// nibu_hanteiの上にcolorを用意する
//各頂点ごとにどこに辺が出てるかの表がc
bool renketujanai_nibu_hantei(int a, V<V<int>> c) {
fo(i, a) {
if (color[i] == 0) {
if (!nibu_hantei(i, 1, c))
return false;
}
}
return true;
}
signed main() {
int a, b, c;
cin >> a >> b >> c;
if (b + 2 >= c)
cout << 1 + a << endl;
else {
if (a < b + 1)
cout << 1 + a << endl;
else {
a -= b + 1;
cout << c + a % 2 + a / 2 * (c - b) << endl;
}
}
} | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 932,963 | 932,962 | u322177979 | cpp |
p03131 | #include <iostream>
using namespace std;
typedef long long ll;
ll K, A, B;
ll biscuit;
int main() {
cin >> K >> A >> B;
if (A >= B) {
biscuit = 1 + 2 * K;
cout << biscuit << endl;
}
else {
if (B - A < 2) {
biscuit = K + 1;
}
else {
if (K == A + 1) {
biscuit = B;
}
else if (K < A + 1) {
biscuit = K + 1;
}
else {
ll time = (K - A - 1) / 2;
ll modify = (K - A - 1) % 2;
biscuit = B + time * (B - A);
biscuit += modify;
}
}
cout << biscuit << endl;
}
return 0;
}
| #include <iostream>
using namespace std;
typedef long long ll;
ll K, A, B;
ll biscuit;
int main() {
cin >> K >> A >> B;
if (A >= B) {
biscuit = K + 1;
cout << biscuit << endl;
}
else {
if (B - A < 2) {
biscuit = K + 1;
}
else {
if (K == A + 1) {
biscuit = B;
}
else if (K < A + 1) {
biscuit = K + 1;
}
else {
ll time = (K - A - 1) / 2;
ll modify = (K - A - 1) % 2;
biscuit = B + time * (B - A);
biscuit += modify;
}
}
cout << biscuit << endl;
}
return 0;
}
| [
"expression.operation.binary.remove",
"assignment.change"
] | 932,970 | 932,971 | u353919145 | cpp |
p03131 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; i++)
#define PER(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, l, r) for (int i = l; i <= r; i++)
#define ROF(i, l, r) for (int i = r; i >= l; i--)
#define DEBUG(x) cout << #x << "=" << x << endl;
#define SHOW1(A, n) \
{ REP(i, n) cout << A[i] << (i == n - 1 ? '\n' : ' '); }
#define SHOW2(A, m, n) \
{ REP(j, m) SHOW1(A[j], n) }
#define pb push_back
#define fi first
#define se second
#define ALL(x) x.begin(), x.end()
#define SZ(x) (int)((x).size())
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> pii;
typedef pair<LL, LL> pll;
const int INF = 0x3f3f3f3f, MOD = 1000000007;
const double PI = acos(-1), EPS = 1e-15;
const int MAXN = 5e5 + 9, MAXM = 2e5 + 9;
int main() {
#ifdef LOCAL
// freopen("i.txt", "r", stdin);
// freopen("o.txt", "w", stdout);
#endif // LOCAL
LL K, A, B;
while (cin >> K >> A >> B) {
LL ans = 1;
if (A < B) {
if (K > A - 1) {
K -= A - 1;
ans = A;
ans += K / 2 * (B - A);
if (K & 1)
ans++;
} else
ans += K;
} else
ans += K;
cout << ans << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; i++)
#define PER(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, l, r) for (int i = l; i <= r; i++)
#define ROF(i, l, r) for (int i = r; i >= l; i--)
#define DEBUG(x) cout << #x << "=" << x << endl;
#define SHOW1(A, n) \
{ REP(i, n) cout << A[i] << (i == n - 1 ? '\n' : ' '); }
#define SHOW2(A, m, n) \
{ REP(j, m) SHOW1(A[j], n) }
#define pb push_back
#define fi first
#define se second
#define ALL(x) x.begin(), x.end()
#define SZ(x) (int)((x).size())
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> pii;
typedef pair<LL, LL> pll;
const int INF = 0x3f3f3f3f, MOD = 1000000007;
const double PI = acos(-1), EPS = 1e-15;
const int MAXN = 5e5 + 9, MAXM = 2e5 + 9;
int main() {
#ifdef LOCAL
// freopen("i.txt", "r", stdin);
// freopen("o.txt", "w", stdout);
#endif // LOCAL
LL K, A, B;
while (cin >> K >> A >> B) {
LL ans = 1;
if (A + 1 < B) {
if (K > A - 1) {
K -= A - 1;
ans = A;
ans += K / 2 * (B - A);
if (K & 1)
ans++;
} else
ans += K;
} else
ans += K;
cout << ans << endl;
}
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 932,972 | 932,973 | u089230684 | cpp |
p03131 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using ll = long long;
#define REP(i, a) for (int i = 0; i < (a); ++i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORR(i, a, b) for (int i = (a)-1; i >= (b); --i)
#define ALL(obj) (obj).begin(), (obj).end()
#define SIZE(obj) (int)(obj).sizeT()
#define YESNO(cond, yes, no) \
{ cout << ((cond) ? (yes) : (no)) << endl; }
#define SORT(list) sort(ALL((list)));
#define RSORT(list) sort((list).rbegin(), (list).rend())
#define ASSERT(cond, mes) assert(cond &&mes)
constexpr int MOD = 1'000'000'007;
constexpr int INF = 1'050'000'000;
template <typename T> T round_up(const T &a, const T &b) {
return (a + (b - 1)) / b;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, pair<T1, T2> &p) {
os << p.first << p.second;
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
REP(i, (int)v.size())
is >> v[i];
return is;
}
template <typename T> T clamp(T &n, T a, T b) {
if (n < a)
n = a;
if (n > b)
n = b;
return n;
}
template <typename T> static T GCD(T u, T v) {
T r;
while (v != 0) {
r = u % v;
u = v;
v = r;
}
return u;
}
template <typename T> static T LCM(T u, T v) { return u / GCD(u, v) * v; }
std::vector<int> enum_div(int n) {
std::vector<int> ret;
for (int i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i != 1 && i * i != n) {
ret.push_back(n / i);
}
}
}
return ret;
}
template <typename T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
struct ToUpper {
char operator()(char c) { return toupper(c); }
};
struct ToLower {
char operator()(char c) { return tolower(c); }
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
ll K, A, B;
cin >> K >> A >> B;
auto solve = [&]() {
if (A < B) {
ll t = K - A - 1;
if (t < 0)
return K + 1;
ll n = A;
n += (B - A) * (t / 2);
if (t % 2 == 0)
n++;
return max(n, K + 1);
} else {
return K + 1;
}
};
cout << solve() << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using ll = long long;
#define REP(i, a) for (int i = 0; i < (a); ++i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORR(i, a, b) for (int i = (a)-1; i >= (b); --i)
#define ALL(obj) (obj).begin(), (obj).end()
#define SIZE(obj) (int)(obj).sizeT()
#define YESNO(cond, yes, no) \
{ cout << ((cond) ? (yes) : (no)) << endl; }
#define SORT(list) sort(ALL((list)));
#define RSORT(list) sort((list).rbegin(), (list).rend())
#define ASSERT(cond, mes) assert(cond &&mes)
constexpr int MOD = 1'000'000'007;
constexpr int INF = 1'050'000'000;
template <typename T> T round_up(const T &a, const T &b) {
return (a + (b - 1)) / b;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, pair<T1, T2> &p) {
os << p.first << p.second;
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
REP(i, (int)v.size())
is >> v[i];
return is;
}
template <typename T> T clamp(T &n, T a, T b) {
if (n < a)
n = a;
if (n > b)
n = b;
return n;
}
template <typename T> static T GCD(T u, T v) {
T r;
while (v != 0) {
r = u % v;
u = v;
v = r;
}
return u;
}
template <typename T> static T LCM(T u, T v) { return u / GCD(u, v) * v; }
std::vector<int> enum_div(int n) {
std::vector<int> ret;
for (int i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i != 1 && i * i != n) {
ret.push_back(n / i);
}
}
}
return ret;
}
template <typename T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
struct ToUpper {
char operator()(char c) { return toupper(c); }
};
struct ToLower {
char operator()(char c) { return tolower(c); }
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
ll K, A, B;
cin >> K >> A >> B;
auto solve = [&]() {
if (A < B) {
ll t = K - A + 1;
if (t < 0)
return K + 1;
ll n = A;
n += (B - A) * (t / 2);
if (t % 2 == 1)
n++;
return max(n, K + 1);
} else {
return K + 1;
}
};
cout << solve() << endl;
return 0;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"expression.operation.binary.change",
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 932,988 | 932,989 | u303039933 | cpp |
p03131 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<int64_t, int64_t> pll;
typedef vector<int64_t> vl;
int dx[] = {1, -1, 0, 0, 1, -1, 1, -1};
int dy[] = {0, 0, 1, -1, 1, -1, -1, 1};
const long double PI = acos(-1);
#define INF (2147483647)
#define mod (1000000007)
#define limit (7368791)
#define rep(i, a, b) for (int64_t i = (a); i < (b); i++)
#define REP(i, n) rep(i, 0, n)
#define sz(s) (s).size()
#define ALL(a) begin(a), end(a)
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
void solve() {
int k, a, b;
cin >> k >> a >> b;
if (b <= a || k <= a) {
cout << k + 1 << endl;
} else {
int kk = k - (a - 1);
int abs = b - a;
int ans = a + abs * (kk / 2);
if (kk % 2)
ans++;
ans = max(ans, k + 1);
cout << ans << endl;
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<int64_t, int64_t> pll;
typedef vector<int64_t> vl;
int dx[] = {1, -1, 0, 0, 1, -1, 1, -1};
int dy[] = {0, 0, 1, -1, 1, -1, -1, 1};
const long double PI = acos(-1);
#define INF (2147483647)
#define mod (1000000007)
#define limit (7368791)
#define rep(i, a, b) for (int64_t i = (a); i < (b); i++)
#define REP(i, n) rep(i, 0, n)
#define sz(s) (s).size()
#define ALL(a) begin(a), end(a)
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
void solve() {
ll k, a, b;
cin >> k >> a >> b;
if (b <= a || k <= a) {
cout << k + 1 << endl;
} else {
ll kk = k - (a - 1);
ll abs = b - a;
ll ans = a + abs * (kk / 2);
if (kk % 2)
ans++;
ans = max(ans, k + 1);
cout << ans << endl;
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
}
| [
"variable_declaration.type.change"
] | 932,992 | 932,993 | u973991908 | cpp |
p03131 | #include <iostream>
using namespace std;
int main() {
long long k, a, b;
cin >> k >> a >> b;
if (k <= a) {
cout << k << endl;
return 0;
}
long long delta = b - a;
long long acc = 0;
if (delta > 2) {
k -= a - 1;
acc += a;
if (k % 2 == 0) {
acc += delta * (k / 2);
} else {
acc++;
k--;
if (k != 0) {
acc += delta * (k / 2);
}
}
} else {
acc += k + 1;
}
cout << acc << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
long long k, a, b;
cin >> k >> a >> b;
if (k <= a) {
cout << k + 1 << endl;
return 0;
}
long long delta = b - a;
long long acc = 0;
if (delta > 2) {
k -= a - 1;
acc += a;
if (k % 2 == 0) {
acc += delta * (k / 2);
} else {
acc++;
k--;
if (k != 0) {
acc += delta * (k / 2);
}
}
} else {
acc += k + 1;
}
cout << acc << endl;
return 0;
} | [
"expression.operation.binary.add"
] | 932,994 | 932,995 | u629133942 | cpp |
p03131 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll K, A, B;
cin >> K >> A >> B;
if (A >= B || K <= A)
cout << K + 1 << endl;
else
cout << A + (K + 1 - A) / 2 * (B - A) + (K - A + 1) % 2 << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll K, A, B;
cin >> K >> A >> B;
if (A >= B - 1 || K <= A)
cout << K + 1 << endl;
else
cout << A + (K - A + 1) / 2 * (B - A) + (K - A + 1) % 2 << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 932,996 | 932,997 | u548834738 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.