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 |
|---|---|---|---|---|---|---|---|
p02990 | void solve();
int main() {
solve();
return 0;
}
//////////////////////////////////////////////////
//////////////////////////////////////////////////
#include <algorithm>
#include <assert.h>
#include <complex>
#include <functional>
#include <iostream>
#include <limits.h>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> pii;
typedef long double ld;
typedef long long ll;
typedef complex<ld> Point;
int N, K;
vector<vector<ll>> dp;
int MOD = 1e9 + 7;
// N!を求める(O(N))
long long stair(int N, int mod = 1000000007) {
long long temp = 1;
if (mod != -1) {
for (int i = 2; i <= N; i++) {
temp = (temp * i) % mod;
}
} else {
for (int i = 2; i <= N; i++) {
temp = temp * i;
}
}
return temp;
}
// 0!,1!,...,N!を求める(O(N))
void stairs(int N, vector<long long> &vec, int mod = 1000000007) {
long long temp = 1;
vec.resize(N + 1);
vec[0] = 1;
vec[1] = 1;
for (int i = 2; i <= N; i++) {
if (mod != -1)
temp = (temp * i) % mod;
else
temp *= i;
vec[i] = temp;
}
return;
}
//繰り返し二乗法
//掛け算が定義されていることが必要
// O(log n)
template <class T> T pow(T base, int p, T mod = -1) {
if (p == 0)
return 1;
if (p == 1)
return mod == -1 ? base % mod : base;
int b = 1, c = 0;
while (b <= p) {
b *= 2;
c++;
}
T *arr2 = new T[c]; // T[n] = T^(2^n)
arr2[0] = mod == -1 ? base % mod : base;
for (int n = 1; n < c; n++) {
if (mod != -1)
arr2[n] = (arr2[n - 1] * arr2[n - 1]) % mod;
else
arr2[n] = arr2[n - 1] * arr2[n - 1];
}
c--;
T ans = arr2[c];
b /= 2;
p -= b;
while (p > 0) {
c--;
b /= 2;
if (p >= b) {
if (mod != -1)
ans = (ans * arr2[c]) % mod;
else
ans = ans * arr2[c];
p -= b;
}
}
return ans;
}
// 0!,1!,...,N!の逆元(mod剰余)を求める
// O(log(mod)+N)
void stairInv(int N, vector<long long> &vect, int mod = 1000000007) {
vect.resize(N + 1);
long long temp = stair(N, mod);
temp = pow(temp, mod - 2, (long long)mod);
vect[N] = temp;
for (long long n = N - 1; n >= 1; n--) {
temp = (vect[n + 1] * (n + 1)) % mod;
vect[n] = temp;
}
return;
}
// nCkを求める(mod剰余)
// O(N+log(mod)+max(n-k,k))
long long C(int n, int k, int mod = 1000000007) {
if (n == k)
return 1;
if (k == 0)
return 1;
long long temp = stair(n, mod);
vector<long long> *vect = new vector<long long>;
stairInv(max(n - k, k), *vect, mod);
temp = (temp * vect->at(n - k)) % mod;
temp = (temp * vect->at(k)) % mod;
delete vect;
return temp;
}
void solve() {
C(3, 3);
cin >> N >> K;
dp.resize(K + 1);
for (int k = 0; k <= K; k++) {
dp[k].resize(K + 1, 0);
}
for (int k = 1; k <= K; k++)
dp[k][1] = 1;
dp[1][1] = 1;
for (int k = 2; k <= K; k++) {
for (int i = 2; i <= k; i++) {
dp[k][i] = dp[k - 1][i] + dp[k - 1][i - 1];
dp[k][i] %= MOD;
}
}
for (int i = 1; i <= K; i++) {
if (i >= N - K + 1)
cout << 0 << endl;
else
cout << (C(N - K + 1, i) * dp[K][i]) % MOD << endl;
}
return;
} | void solve();
int main() {
solve();
return 0;
}
//////////////////////////////////////////////////
//////////////////////////////////////////////////
#include <algorithm>
#include <assert.h>
#include <complex>
#include <functional>
#include <iostream>
#include <limits.h>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> pii;
typedef long double ld;
typedef long long ll;
typedef complex<ld> Point;
int N, K;
vector<vector<ll>> dp;
int MOD = 1e9 + 7;
// N!を求める(O(N))
long long stair(int N, int mod = 1000000007) {
long long temp = 1;
if (mod != -1) {
for (int i = 2; i <= N; i++) {
temp = (temp * i) % mod;
}
} else {
for (int i = 2; i <= N; i++) {
temp = temp * i;
}
}
return temp;
}
// 0!,1!,...,N!を求める(O(N))
void stairs(int N, vector<long long> &vec, int mod = 1000000007) {
long long temp = 1;
vec.resize(N + 1);
vec[0] = 1;
vec[1] = 1;
for (int i = 2; i <= N; i++) {
if (mod != -1)
temp = (temp * i) % mod;
else
temp *= i;
vec[i] = temp;
}
return;
}
//繰り返し二乗法
//掛け算が定義されていることが必要
// O(log n)
template <class T> T pow(T base, int p, T mod = -1) {
if (p == 0)
return 1;
if (p == 1)
return mod == -1 ? base % mod : base;
int b = 1, c = 0;
while (b <= p) {
b *= 2;
c++;
}
T *arr2 = new T[c]; // T[n] = T^(2^n)
arr2[0] = mod == -1 ? base % mod : base;
for (int n = 1; n < c; n++) {
if (mod != -1)
arr2[n] = (arr2[n - 1] * arr2[n - 1]) % mod;
else
arr2[n] = arr2[n - 1] * arr2[n - 1];
}
c--;
T ans = arr2[c];
b /= 2;
p -= b;
while (p > 0) {
c--;
b /= 2;
if (p >= b) {
if (mod != -1)
ans = (ans * arr2[c]) % mod;
else
ans = ans * arr2[c];
p -= b;
}
}
return ans;
}
// 0!,1!,...,N!の逆元(mod剰余)を求める
// O(log(mod)+N)
void stairInv(int N, vector<long long> &vect, int mod = 1000000007) {
vect.resize(N + 1);
long long temp = stair(N, mod);
temp = pow(temp, mod - 2, (long long)mod);
vect[N] = temp;
for (long long n = N - 1; n >= 1; n--) {
temp = (vect[n + 1] * (n + 1)) % mod;
vect[n] = temp;
}
return;
}
// nCkを求める(mod剰余)
// O(N+log(mod)+max(n-k,k))
long long C(int n, int k, int mod = 1000000007) {
if (n == k)
return 1;
if (k == 0)
return 1;
long long temp = stair(n, mod);
vector<long long> *vect = new vector<long long>;
stairInv(max(n - k, k), *vect, mod);
temp = (temp * vect->at(n - k)) % mod;
temp = (temp * vect->at(k)) % mod;
delete vect;
return temp;
}
void solve() {
C(3, 3);
cin >> N >> K;
dp.resize(K + 1);
for (int k = 0; k <= K; k++) {
dp[k].resize(K + 1, 0);
}
for (int k = 1; k <= K; k++)
dp[k][1] = 1;
dp[1][1] = 1;
for (int k = 2; k <= K; k++) {
for (int i = 2; i <= k; i++) {
dp[k][i] = dp[k - 1][i] + dp[k - 1][i - 1];
dp[k][i] %= MOD;
}
}
for (int i = 1; i <= K; i++) {
if (i > N - K + 1)
cout << 0 << endl;
else
cout << (C(N - K + 1, i) * dp[K][i]) % MOD << endl;
}
return;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 799,027 | 799,028 | u457790148 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MAX = 200005;
const ll MOD = 1000000007;
ll fac[MAX], finv[MAX], inv[MAX];
ll ans;
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;
}
}
ll COM(ll i, ll j) {
if (i < j)
return 1;
if (i < 0 || j < 0)
return 1;
return fac[i] * (finv[j] * finv[i - j] % MOD) % MOD;
}
int main(void) {
COMinit();
ll N, K;
cin >> N >> K;
ll R = N - K;
for (int i = 2; i < 2 + K; i++) {
// cout<<COM(R+1,i-1)<<" "<<COM(K-1,i-2)<<" ";
ans = COM(R + 1, i - 1) * COM(K - 1, i - 2) % MOD;
cout << ans << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MAX = 2005;
const ll MOD = 1000000007;
ll fac[MAX], finv[MAX], inv[MAX];
ll ans;
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;
}
}
ll COM(ll i, ll j) {
if (i < j)
return 0;
if (i < 0 || j < 0)
return 0;
return fac[i] * (finv[j] * finv[i - j] % MOD) % MOD;
}
int main(void) {
COMinit();
ll N, K;
cin >> N >> K;
ll R = N - K;
for (int i = 2; i < 2 + K; i++) {
// cout<<COM(R+1,i-1)<<" "<<COM(K-1,i-2)<<" ";
ans = COM(R + 1, i - 1) * COM(K - 1, i - 2) % MOD;
cout << ans << endl;
}
}
| [
"literal.number.change",
"variable_declaration.value.change",
"function.return_value.change"
] | 799,032 | 799,033 | u045547337 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
#define rep(i, x, y) \
for (i64 i = i64(x), i##_max_for_repmacro = i64(y); \
i < i##_max_for_repmacro; ++i)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define print(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define print(x)
#endif
const int inf = 1.01e9;
const i64 inf64 = 4.01e18;
const double eps = 1e-9;
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
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;
}
template <typename T, size_t size> void fill(T (&ary)[size], const T &val) {
fill_n((T *)ary, size, val);
}
//漸化式を利用してコンビネーションを表を作る.O(nk)
vector<vector<i64>> comb;
void init_mod_comb(int n, int k, i64 mod) {
comb.resize(n + 1);
for (int i = 0; i <= n; ++i) {
comb[i].resize(i + 1);
comb[i][0] = 1;
if (i <= k)
comb[i][i] = 1;
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= min(i - 1, k); ++j) {
comb[i][j] = (comb[i - 1][j] + comb[i - 1][j - 1]) % mod;
}
}
}
void solve() {
const i64 mod = 1'000'000'007;
init_mod_comb(3010, 3010, mod);
i64 N, K;
cin >> N >> K;
rep(i, 1, K + 1) {
i64 tmp = comb[N - K + 1][i];
i64 r = K - i;
tmp *= comb[r + i - 1][i - 1];
tmp %= mod;
cout << tmp << endl;
}
}
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(16);
solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
#define rep(i, x, y) \
for (i64 i = i64(x), i##_max_for_repmacro = i64(y); \
i < i##_max_for_repmacro; ++i)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define print(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define print(x)
#endif
const int inf = 1.01e9;
const i64 inf64 = 4.01e18;
const double eps = 1e-9;
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
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;
}
template <typename T, size_t size> void fill(T (&ary)[size], const T &val) {
fill_n((T *)ary, size, val);
}
//漸化式を利用してコンビネーションを表を作る.O(nk)
vector<vector<i64>> comb;
void init_mod_comb(int n, int k, i64 mod) {
comb.resize(n + 1);
for (int i = 0; i <= n; ++i) {
comb[i].resize(k + 1);
comb[i][0] = 1;
if (i <= k)
comb[i][i] = 1;
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= min(i - 1, k); ++j) {
comb[i][j] = (comb[i - 1][j] + comb[i - 1][j - 1]) % mod;
}
}
}
void solve() {
const i64 mod = 1'000'000'007;
init_mod_comb(3010, 3010, mod);
i64 N, K;
cin >> N >> K;
rep(i, 1, K + 1) {
i64 tmp = comb[N - K + 1][i];
i64 r = K - i;
tmp *= comb[r + i - 1][i - 1];
tmp %= mod;
cout << tmp << endl;
}
}
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(16);
solve();
return 0;
}
| [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 799,034 | 799,035 | u759266806 | cpp |
p02990 | #include <bits/stdc++.h>
const int INF = 1e9;
const int MOD = 1e9 + 7;
// const int MOD=998244353;
const long long LINF = 1e18;
using namespace std;
#define int long long
#define fin \
{ \
cout << "No" << endl; \
return 0; \
}
// template
int pw(int n, int k) {
if (k < 0)
return pw(n, k + MOD - 1);
int res = 1;
while (k) {
if (k & 1)
res *= n;
res %= MOD;
n *= n;
n %= MOD;
k >>= 1;
}
return res;
}
std::vector<int> Factorial(1e6), Finverse(1e6);
void Cinit() {
Factorial[0] = 1;
for (int i = 1; i < 1e6; i++)
Factorial[i] = Factorial[i - 1] * i % MOD;
for (int i = 0; i < 1e6; i++)
Finverse[i] = pw(Factorial[i], MOD - 2);
}
int nCk(int n, int k) {
if (n < k)
return 1;
if (k < 0)
return 0;
int res = Factorial[n];
res *= Finverse[k];
res %= MOD;
res *= Finverse[n - k];
res %= MOD;
return res;
}
// main
signed main() {
int N, K;
cin >> N >> K;
Cinit();
for (int i = 1; i <= K; i++) {
if (N - K - (i - 1) < 0)
cout << 0 << endl;
else
cout << nCk(K - 1, i - 1) * nCk(N - K + 1, i) << endl;
}
}
| #include <bits/stdc++.h>
const int INF = 1e9;
const int MOD = 1e9 + 7;
// const int MOD=998244353;
const long long LINF = 1e18;
using namespace std;
#define int long long
#define fin \
{ \
cout << "No" << endl; \
return 0; \
}
// template
int pw(int n, int k) {
if (k < 0)
return pw(n, k + MOD - 1);
int res = 1;
while (k) {
if (k & 1)
res *= n;
res %= MOD;
n *= n;
n %= MOD;
k >>= 1;
}
return res;
}
std::vector<int> Factorial(1e6), Finverse(1e6);
void Cinit() {
Factorial[0] = 1;
for (int i = 1; i < 1e6; i++)
Factorial[i] = Factorial[i - 1] * i % MOD;
for (int i = 0; i < 1e6; i++)
Finverse[i] = pw(Factorial[i], MOD - 2);
}
int nCk(int n, int k) {
if (n < k)
return 1;
if (k < 0)
return 0;
int res = Factorial[n];
res *= Finverse[k];
res %= MOD;
res *= Finverse[n - k];
res %= MOD;
return res;
}
// main
signed main() {
int N, K;
cin >> N >> K;
Cinit();
for (int i = 1; i <= K; i++) {
if (N - K - (i - 1) < 0)
cout << 0 << endl;
else
cout << nCk(K - 1, i - 1) * nCk(N - K + 1, i) % MOD << endl;
}
}
| [
"expression.operation.binary.add"
] | 799,043 | 799,044 | u942774736 | cpp |
p02990 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 2e3 + 5, mod = 1e9 + 7;
int CC[maxn][maxn];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
for (int i = 0; i < maxn; ++i) {
CC[i][0] = CC[i][i] = 1;
for (int j = 1; j < i; ++j) {
CC[i][j] = (CC[i - 1][j] + CC[i - 1][j - 1]) % mod;
}
}
int n, k;
cin >> n >> k;
for (int i = 1; i <= k; ++i) {
cout << CC[n - k + 1][i] * CC[k - 1][i - 1] % mod << '\n';
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 2e3 + 5, mod = 1e9 + 7;
ll CC[maxn][maxn];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
for (int i = 0; i < maxn; ++i) {
CC[i][0] = CC[i][i] = 1;
for (int j = 1; j < i; ++j) {
CC[i][j] = (CC[i - 1][j] + CC[i - 1][j - 1]) % mod;
}
}
int n, k;
cin >> n >> k;
for (int i = 1; i <= k; ++i) {
cout << (ll)CC[n - k + 1][i] * CC[k - 1][i - 1] % mod << '\n';
}
return 0;
}
| [
"variable_declaration.type.change"
] | 799,045 | 799,046 | u187582424 | cpp |
p02990 | #include <bits/stdc++.h>
#define LL long long
#define M 1000005
using namespace std;
const int P = 1e9 + 7;
int C[2005][2005];
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= i; j++) {
if (j == 0 || j == i)
C[i][j] = 1;
else
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % P;
}
for (int i = 1; i <= k; i++) {
int ans = 1LL * C[k - 1][i - 1] * C[n - k + 1][i] % P;
printf("%d\n", ans);
}
return 0;
} | #include <bits/stdc++.h>
#define LL long long
#define M 1000005
using namespace std;
const int P = 1e9 + 7;
int C[2005][2005];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= i; j++) {
if (j == 0 || j == i)
C[i][j] = 1;
else
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % P;
}
for (int i = 1; i <= k; i++) {
int ans = 1LL * C[k - 1][i - 1] * C[n - k + 1][i] % P;
printf("%d\n", ans);
}
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 799,047 | 799,048 | u837479063 | cpp |
p02990 | //#define NDEBUG
#include <cstddef>
#include <cstdint>
#include <vector>
namespace n91 {
using i8 = std::int_fast8_t;
using i32 = std::int_fast32_t;
using i64 = std::int_fast64_t;
using u8 = std::uint_fast8_t;
using u32 = std::uint_fast32_t;
using u64 = std::uint_fast64_t;
using isize = std::ptrdiff_t;
using usize = std::size_t;
constexpr usize operator"" _z(unsigned long long x) noexcept {
return static_cast<usize>(x);
}
class rep {
const usize f, l;
public:
class itr {
friend rep;
usize i;
constexpr itr(const usize x) noexcept : i(x) {}
public:
void operator++() noexcept { ++i; }
constexpr usize operator*() const noexcept { return i; }
constexpr bool operator!=(const itr x) const noexcept { return i != x.i; }
};
constexpr rep(const usize first, const usize last) noexcept
: f(first), l(last) {}
constexpr itr begin() const noexcept { return itr(f); }
constexpr itr end() const noexcept { return itr(l); }
};
class revrep {
const usize f, l;
public:
class itr {
friend revrep;
usize i;
constexpr itr(usize x) noexcept : i(x) {}
public:
void operator++() noexcept { --i; }
constexpr usize operator*() const noexcept { return i; }
constexpr bool operator!=(const itr x) const noexcept { return i != x.i; }
};
constexpr revrep(usize first, usize last) noexcept : f(--first), l(--last) {}
constexpr itr begin() const noexcept { return itr(l); }
constexpr itr end() const noexcept { return itr(f); }
};
template <class T> using vec_alias = std::vector<T>;
template <class T> auto md_vec(const usize n, const T &value) {
return std::vector<T>(n, value);
}
template <class... Args> auto md_vec(const usize n, Args... args) {
return std::vector<decltype(md_vec(args...))>(n, md_vec(args...));
}
template <class T> constexpr T difference(const T &a, const T &b) {
return a < b ? b - a : a - b;
}
} // namespace n91
#include <cstdint>
namespace n91 {
constexpr std::uint_fast64_t totient(std::uint_fast64_t x) noexcept {
using u64 = std::uint_fast64_t;
u64 ret = x;
for (u64 i = static_cast<u64>(2); i * i <= x; ++i) {
if (x % i == static_cast<u64>(0)) {
ret -= ret / i;
x /= i;
while (x % i == static_cast<u64>(0)) {
x /= i;
}
}
}
if (x != static_cast<u64>(1)) {
ret -= ret / x;
}
return ret;
}
template <std::uint_fast64_t Modulus,
std::uint_fast64_t InverseExp =
totient(Modulus) - static_cast<u64>(1)>
class modint {
using u64 = std::uint_fast64_t;
static_assert(Modulus < static_cast<u64>(1) << static_cast<u64>(32),
"Modulus must be less than 2**32");
u64 a;
constexpr modint &negate() noexcept {
if (a != static_cast<u64>(0)) {
a = Modulus - a;
}
return *this;
}
public:
constexpr modint(const u64 x = static_cast<u64>(0)) noexcept
: a(x % Modulus) {}
constexpr u64 &value() noexcept { return a; }
constexpr const u64 &value() const noexcept { return a; }
constexpr modint operator+() const noexcept { return modint(*this); }
constexpr modint operator-() const noexcept { return modint(*this).negate(); }
constexpr modint operator+(const modint rhs) const noexcept {
return modint(*this) += rhs;
}
constexpr modint operator-(const modint rhs) const noexcept {
return modint(*this) -= rhs;
}
constexpr modint operator*(const modint rhs) const noexcept {
return modint(*this) *= rhs;
}
constexpr modint operator/(const modint rhs) const noexcept {
return modint(*this) /= rhs;
}
constexpr modint &operator+=(const modint rhs) noexcept {
a += rhs.a;
if (a >= Modulus) {
a -= Modulus;
}
return *this;
}
constexpr modint &operator-=(const modint rhs) noexcept {
if (a < rhs.a) {
a += Modulus;
}
a -= rhs.a;
return *this;
}
constexpr modint &operator*=(const modint rhs) noexcept {
a = a * rhs.a % Modulus;
return *this;
}
constexpr modint &operator/=(modint rhs) noexcept {
u64 exp = InverseExp;
while (exp) {
if (exp % static_cast<u64>(2) != static_cast<u64>(0)) {
*this *= rhs;
}
rhs *= rhs;
exp /= static_cast<u64>(2);
}
return *this;
}
constexpr bool operator==(const modint rhs) const noexcept {
return a == rhs.a;
}
constexpr bool operator!=(const modint rhs) const noexcept {
return a != rhs.a;
}
};
} // namespace n91
#include <vector>
namespace n91 {
template <class T> class fact_binom {
public:
using value_type = T;
using container_type = std::vector<value_type>;
using size_type = typename container_type::size_type;
private:
container_type factrial, inv_fact;
public:
fact_binom() : factrial(), inv_fact() {}
explicit fact_binom(const size_type n) : factrial(n + 1), inv_fact(n + 1) {
factrial[0] = static_cast<value_type>(1);
for (size_type i = 0; i != n; ++i) {
factrial[i + 1] = static_cast<value_type>(i + 1) * factrial[i];
}
inv_fact[n] = static_cast<value_type>(1) / factrial[n];
for (size_type i = n; i != 0; --i) {
inv_fact[i - 1] = inv_fact[i] * static_cast<value_type>(i);
}
}
value_type operator()(const size_type n, const size_type r) const {
return factrial[n] * inv_fact[r] * inv_fact[n - r];
}
};
} // namespace n91
#include <algorithm>
#include <array>
#include <iostream>
#include <string>
#include <utility>
namespace n91 {
void main_() {
using mint = modint<1000000007_z>;
usize n, k;
std::cin >> n >> k;
const fact_binom<mint> binom(n);
for (const auto i : rep(1_z, k + 1_z)) {
if (n - k - 1_z < i) {
std::cout << 0 << std::endl;
} else {
std::cout << (binom(k - 1_z, i - 1_z) * binom(n - k + 1_z, i)).value()
<< std::endl;
}
}
}
} // namespace n91
int main() {
n91::main_();
return 0;
}
| //#define NDEBUG
#include <cstddef>
#include <cstdint>
#include <vector>
namespace n91 {
using i8 = std::int_fast8_t;
using i32 = std::int_fast32_t;
using i64 = std::int_fast64_t;
using u8 = std::uint_fast8_t;
using u32 = std::uint_fast32_t;
using u64 = std::uint_fast64_t;
using isize = std::ptrdiff_t;
using usize = std::size_t;
constexpr usize operator"" _z(unsigned long long x) noexcept {
return static_cast<usize>(x);
}
class rep {
const usize f, l;
public:
class itr {
friend rep;
usize i;
constexpr itr(const usize x) noexcept : i(x) {}
public:
void operator++() noexcept { ++i; }
constexpr usize operator*() const noexcept { return i; }
constexpr bool operator!=(const itr x) const noexcept { return i != x.i; }
};
constexpr rep(const usize first, const usize last) noexcept
: f(first), l(last) {}
constexpr itr begin() const noexcept { return itr(f); }
constexpr itr end() const noexcept { return itr(l); }
};
class revrep {
const usize f, l;
public:
class itr {
friend revrep;
usize i;
constexpr itr(usize x) noexcept : i(x) {}
public:
void operator++() noexcept { --i; }
constexpr usize operator*() const noexcept { return i; }
constexpr bool operator!=(const itr x) const noexcept { return i != x.i; }
};
constexpr revrep(usize first, usize last) noexcept : f(--first), l(--last) {}
constexpr itr begin() const noexcept { return itr(l); }
constexpr itr end() const noexcept { return itr(f); }
};
template <class T> using vec_alias = std::vector<T>;
template <class T> auto md_vec(const usize n, const T &value) {
return std::vector<T>(n, value);
}
template <class... Args> auto md_vec(const usize n, Args... args) {
return std::vector<decltype(md_vec(args...))>(n, md_vec(args...));
}
template <class T> constexpr T difference(const T &a, const T &b) {
return a < b ? b - a : a - b;
}
} // namespace n91
#include <cstdint>
namespace n91 {
constexpr std::uint_fast64_t totient(std::uint_fast64_t x) noexcept {
using u64 = std::uint_fast64_t;
u64 ret = x;
for (u64 i = static_cast<u64>(2); i * i <= x; ++i) {
if (x % i == static_cast<u64>(0)) {
ret -= ret / i;
x /= i;
while (x % i == static_cast<u64>(0)) {
x /= i;
}
}
}
if (x != static_cast<u64>(1)) {
ret -= ret / x;
}
return ret;
}
template <std::uint_fast64_t Modulus,
std::uint_fast64_t InverseExp =
totient(Modulus) - static_cast<u64>(1)>
class modint {
using u64 = std::uint_fast64_t;
static_assert(Modulus < static_cast<u64>(1) << static_cast<u64>(32),
"Modulus must be less than 2**32");
u64 a;
constexpr modint &negate() noexcept {
if (a != static_cast<u64>(0)) {
a = Modulus - a;
}
return *this;
}
public:
constexpr modint(const u64 x = static_cast<u64>(0)) noexcept
: a(x % Modulus) {}
constexpr u64 &value() noexcept { return a; }
constexpr const u64 &value() const noexcept { return a; }
constexpr modint operator+() const noexcept { return modint(*this); }
constexpr modint operator-() const noexcept { return modint(*this).negate(); }
constexpr modint operator+(const modint rhs) const noexcept {
return modint(*this) += rhs;
}
constexpr modint operator-(const modint rhs) const noexcept {
return modint(*this) -= rhs;
}
constexpr modint operator*(const modint rhs) const noexcept {
return modint(*this) *= rhs;
}
constexpr modint operator/(const modint rhs) const noexcept {
return modint(*this) /= rhs;
}
constexpr modint &operator+=(const modint rhs) noexcept {
a += rhs.a;
if (a >= Modulus) {
a -= Modulus;
}
return *this;
}
constexpr modint &operator-=(const modint rhs) noexcept {
if (a < rhs.a) {
a += Modulus;
}
a -= rhs.a;
return *this;
}
constexpr modint &operator*=(const modint rhs) noexcept {
a = a * rhs.a % Modulus;
return *this;
}
constexpr modint &operator/=(modint rhs) noexcept {
u64 exp = InverseExp;
while (exp) {
if (exp % static_cast<u64>(2) != static_cast<u64>(0)) {
*this *= rhs;
}
rhs *= rhs;
exp /= static_cast<u64>(2);
}
return *this;
}
constexpr bool operator==(const modint rhs) const noexcept {
return a == rhs.a;
}
constexpr bool operator!=(const modint rhs) const noexcept {
return a != rhs.a;
}
};
} // namespace n91
#include <vector>
namespace n91 {
template <class T> class fact_binom {
public:
using value_type = T;
using container_type = std::vector<value_type>;
using size_type = typename container_type::size_type;
private:
container_type factrial, inv_fact;
public:
fact_binom() : factrial(), inv_fact() {}
explicit fact_binom(const size_type n) : factrial(n + 1), inv_fact(n + 1) {
factrial[0] = static_cast<value_type>(1);
for (size_type i = 0; i != n; ++i) {
factrial[i + 1] = static_cast<value_type>(i + 1) * factrial[i];
}
inv_fact[n] = static_cast<value_type>(1) / factrial[n];
for (size_type i = n; i != 0; --i) {
inv_fact[i - 1] = inv_fact[i] * static_cast<value_type>(i);
}
}
value_type operator()(const size_type n, const size_type r) const {
return factrial[n] * inv_fact[r] * inv_fact[n - r];
}
};
} // namespace n91
#include <algorithm>
#include <array>
#include <iostream>
#include <string>
#include <utility>
namespace n91 {
void main_() {
using mint = modint<1000000007_z>;
usize n, k;
std::cin >> n >> k;
const fact_binom<mint> binom(n);
for (const auto i : rep(1_z, k + 1_z)) {
if (n - k + 1_z < i) {
std::cout << 0 << std::endl;
} else {
std::cout << (binom(k - 1_z, i - 1_z) * binom(n - k + 1_z, i)).value()
<< std::endl;
}
}
}
} // namespace n91
int main() {
n91::main_();
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 799,049 | 799,050 | u708618797 | cpp |
p02991 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
bool f[314514];
int main() {
ll n, m;
cin >> n >> m;
vector<vector<ll>> v(314514);
vector<ll> dis(314514, 1e9);
ll p = 100000;
for (int i = 0; i < m; i++) {
ll a, b;
cin >> a >> b;
v[a].push_back(b + p);
v[a + p].push_back(b + 2 * p);
v[a + 2 * p].push_back(b);
}
ll s, t;
cin >> s >> t;
dis[s] = 0;
f[s] = 1;
queue<P> que;
que.push({s, 0});
while (!que.empty()) {
P x = que.front();
que.pop();
for (ll num : v[x.first]) {
if (f[num])
continue;
f[num] = 1;
que.push({num, x.second + 1});
dis[num] = x.second;
}
}
if (dis[t] == 1e9)
cout << -1;
else
cout << dis[t] / 3;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
bool f[314514];
int main() {
ll n, m;
cin >> n >> m;
vector<vector<ll>> v(314514);
vector<ll> dis(314514, 1e9);
ll p = 100000;
for (int i = 0; i < m; i++) {
ll a, b;
cin >> a >> b;
v[a].push_back(b + p);
v[a + p].push_back(b + 2 * p);
v[a + 2 * p].push_back(b);
}
ll s, t;
cin >> s >> t;
dis[s] = 0;
f[s] = 1;
queue<P> que;
que.push({s, 0});
while (!que.empty()) {
P x = que.front();
que.pop();
for (ll num : v[x.first]) {
if (f[num])
continue;
f[num] = 1;
que.push({num, x.second + 1});
dis[num] = x.second + 1;
}
}
if (dis[t] == 1e9)
cout << -1;
else
cout << dis[t] / 3;
return 0;
}
| [
"assignment.change"
] | 799,056 | 799,057 | u774202056 | cpp |
p02991 | #include <algorithm>
#include <array>
#include <bitset>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdint.h>
#include <string>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using uint = unsigned int;
using ldouble = long double;
// BDD,ZDD,kdtree, bdtree,bicalc, bolonoy, doloney, tree,
// chinesemod,segmenttree,daikusutora, saidairyuu, 2bugurahu, heirokenshutu,
// topologicalsort, kyourenketuseibun
#define REP(i, a, b) for (ll i = a; i < b; ++i)
#define PRI(s) cout << s << endl
#define PRIY PRI("Yes")
#define PRIN PRI("No")
ll N, M;
struct node {
ll d;
bool done;
vector<int> link;
};
vector<node> nod;
ll inf = (ll)1e18;
int main() {
cin >> N >> M;
nod.resize(3 * N);
for (node &n : nod) {
n.d = inf;
n.done = false;
}
REP(i, 0, M) {
int u, v;
cin >> u >> v;
--u;
--v;
nod[3 * u + 0].link.push_back(3 * v + 1);
nod[3 * u + 1].link.push_back(3 * v + 2);
nod[3 * u + 2].link.push_back(3 * v + 0);
}
int S, T;
cin >> S >> T;
--S;
--T;
nod[3 * S].d = 0;
auto cmp = [&](int a, int b) { return nod[a].d > nod[b].d; };
priority_queue<int, vector<int>, decltype(cmp)> q(cmp);
q.push(3 * S);
while (!q.empty()) {
int i = q.top();
q.pop();
if (nod[i].done)
continue;
nod[i].done = true;
for (int c : nod[i].link) {
if (!nod[c].done && nod[c].d > nod[i].d + 1) {
q.push(c);
nod[c].d = nod[i].d + 1;
}
}
}
if (nod[3 * T + 2].d == inf)
PRI(-1);
else
PRI(nod[3 * T + 2].d);
return 0;
}
| #include <algorithm>
#include <array>
#include <bitset>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdint.h>
#include <string>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using uint = unsigned int;
using ldouble = long double;
// BDD,ZDD,kdtree, bdtree,bicalc, bolonoy, doloney, tree,
// chinesemod,segmenttree,daikusutora, saidairyuu, 2bugurahu, heirokenshutu,
// topologicalsort, kyourenketuseibun
#define REP(i, a, b) for (ll i = a; i < b; ++i)
#define PRI(s) cout << s << endl
#define PRIY PRI("Yes")
#define PRIN PRI("No")
ll N, M;
struct node {
ll d;
bool done;
vector<int> link;
};
vector<node> nod;
ll inf = (ll)1e18;
int main() {
cin >> N >> M;
nod.resize(3 * N);
for (node &n : nod) {
n.d = inf;
n.done = false;
}
REP(i, 0, M) {
int u, v;
cin >> u >> v;
--u;
--v;
nod[3 * u + 0].link.push_back(3 * v + 1);
nod[3 * u + 1].link.push_back(3 * v + 2);
nod[3 * u + 2].link.push_back(3 * v + 0);
}
int S, T;
cin >> S >> T;
--S;
--T;
nod[3 * S].d = 0;
auto cmp = [&](int a, int b) { return nod[a].d > nod[b].d; };
priority_queue<int, vector<int>, decltype(cmp)> q(cmp);
q.push(3 * S);
while (!q.empty()) {
int i = q.top();
q.pop();
if (nod[i].done)
continue;
nod[i].done = true;
for (int c : nod[i].link) {
if (!nod[c].done && nod[c].d > nod[i].d + 1) {
q.push(c);
nod[c].d = nod[i].d + 1;
}
}
}
if (nod[3 * T].d == inf)
PRI(-1);
else
PRI(nod[3 * T].d / 3);
return 0;
}
| [
"expression.operation.binary.remove"
] | 799,066 | 799,067 | u539145601 | cpp |
p02991 | #pragma region header
#include <bits/stdc++.h>
#define int long long
#define all(a) begin(a), end(a)
#define rall(a) rbegin(a), rend(a)
#define mp make_pair
#define mt make_tuple
#define rep1(i, n) for (decltype(+n) i = 0; i < (n); i++)
#define rrep1(i, n) for (auto i = n - 1; i > static_cast<decltype(i)>(-1); i--)
#define rep2(i, a, b) for (auto i = (a); i < (b); i++)
#define rrep2(i, a, b) for (auto i = b - 1; i >= a; i--)
#define GET_MACRO(_1, _2, _3, NAME, ...) NAME
#define rep(...) GET_MACRO(__VA_ARGS__, rep2, rep1)(__VA_ARGS__)
#define rrep(...) GET_MACRO(__VA_ARGS__, rrep2, rrep1)(__VA_ARGS__)
#define each(i, a) for (auto &&i : (a))
using namespace std;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;
using vs = vector<string>;
using vvs = vector<vs>;
using vd = vector<ld>;
using vvd = vector<vd>;
using vb = vector<bool>;
using vvb = vector<vb>;
using pii = pair<int, int>;
using vp = vector<pii>;
using vvp = vector<vp>;
using mii = map<int, int>;
using vm = vector<mii>;
using vvm = vector<vm>;
template <class T, class U> using umap = unordered_map<T, U>;
using umii = umap<int, int>;
using seti = set<int>;
template <class T> using uset = unordered_set<T>;
using useti = uset<int>;
template <class T> using less_queue = priority_queue<T>;
template <class T>
using greater_queue = priority_queue<T, vector<T>, greater<T>>;
constexpr int INF = 1e18;
template <class T> void SORT(T &a) { stable_sort(all(a)); }
template <class T> void RSORT(T &a) { stable_sort(rall(a)); }
template <class T> void rev(T &a) { reverse(rall(a)); }
template <class T> void uniq(T &a) { a.erase(unique(all(a)), end(a)); }
template <class T> auto min_of(T a) { return *min_element(all(a)); }
template <class T> auto max_of(T a) { return *max_element(all(a)); }
template <class T> int sum_of(T a) { return accumulate(all(a), 0ll); }
template <class T, class U> auto sum_of(T a, U init) {
return accumulate(all(a), init);
}
template <class T, class U> int count_of(T a, U i) { return count(all(a), i); }
template <class T, class U> bool has(T a, U i) {
return find(all(a), i) != end(a);
}
template <class T> int sz(T a) { return a.size(); };
template <class T> void COUT(T x) { cout << x << endl; }
template <class T, class U> void COUT(T x, U y) {
cout << x << ' ' << y << endl;
}
template <class T, class U, class V> void COUT(T x, U y, V z) {
cout << x << ' ' << y << ' ' << z << endl;
}
template <class T> void CSP(T x) { cout << x << ' '; }
template <class T> void CVEC(T v) {
int c = v.size() - 1;
for (size_t i = 0; i < c; i++)
cout << v[i] << ' ';
if (c > -1)
cout << v[c];
cout << endl;
}
template <class T> bool amin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> bool amax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
constexpr int lshift(int x) noexcept { return 1ll << x; }
constexpr int popcount(unsigned int x) noexcept {
return __builtin_popcountll(x);
}
constexpr int least1(unsigned int x) noexcept { return __builtin_ffsll(x); }
constexpr int ceil_div(int x, int y) noexcept { return (x - 1) / y + 1; }
#pragma endregion header
void solve(int N, int M, vi u, vi v, int S, int T) {
vvi adj(N * 3);
rep(i, M) {
adj[u[i]].push_back(v[i] + N);
adj[u[i] + N].push_back(v[i] + N * 2);
adj[u[i] + N * 2].push_back(v[i]);
}
vi costs(N * 3, -1);
costs[0] = 0;
queue<int> q;
q.push(S);
while (!q.empty()) {
int now = q.front();
q.pop();
each(ni, adj[now]) {
if (costs[ni] == -1) {
costs[ni] = costs[now] + 1;
q.push(ni);
}
}
}
COUT(costs[T] == -1 ? -1 : costs[T] / 3);
}
#pragma region main
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(15);
int N;
cin >> N;
int M;
cin >> M;
vi u(M);
vi v(M);
for (int i = 0; i < M; i++) {
cin >> u[i];
cin >> v[i];
u[i]--;
v[i]--;
}
int S;
cin >> S;
int T;
cin >> T;
S--;
T--;
solve(N, M, move(u), move(v), S, T);
}
#pragma endregion main
| #pragma region header
#include <bits/stdc++.h>
#define int long long
#define all(a) begin(a), end(a)
#define rall(a) rbegin(a), rend(a)
#define mp make_pair
#define mt make_tuple
#define rep1(i, n) for (decltype(+n) i = 0; i < (n); i++)
#define rrep1(i, n) for (auto i = n - 1; i > static_cast<decltype(i)>(-1); i--)
#define rep2(i, a, b) for (auto i = (a); i < (b); i++)
#define rrep2(i, a, b) for (auto i = b - 1; i >= a; i--)
#define GET_MACRO(_1, _2, _3, NAME, ...) NAME
#define rep(...) GET_MACRO(__VA_ARGS__, rep2, rep1)(__VA_ARGS__)
#define rrep(...) GET_MACRO(__VA_ARGS__, rrep2, rrep1)(__VA_ARGS__)
#define each(i, a) for (auto &&i : (a))
using namespace std;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;
using vs = vector<string>;
using vvs = vector<vs>;
using vd = vector<ld>;
using vvd = vector<vd>;
using vb = vector<bool>;
using vvb = vector<vb>;
using pii = pair<int, int>;
using vp = vector<pii>;
using vvp = vector<vp>;
using mii = map<int, int>;
using vm = vector<mii>;
using vvm = vector<vm>;
template <class T, class U> using umap = unordered_map<T, U>;
using umii = umap<int, int>;
using seti = set<int>;
template <class T> using uset = unordered_set<T>;
using useti = uset<int>;
template <class T> using less_queue = priority_queue<T>;
template <class T>
using greater_queue = priority_queue<T, vector<T>, greater<T>>;
constexpr int INF = 1e18;
template <class T> void SORT(T &a) { stable_sort(all(a)); }
template <class T> void RSORT(T &a) { stable_sort(rall(a)); }
template <class T> void rev(T &a) { reverse(rall(a)); }
template <class T> void uniq(T &a) { a.erase(unique(all(a)), end(a)); }
template <class T> auto min_of(T a) { return *min_element(all(a)); }
template <class T> auto max_of(T a) { return *max_element(all(a)); }
template <class T> int sum_of(T a) { return accumulate(all(a), 0ll); }
template <class T, class U> auto sum_of(T a, U init) {
return accumulate(all(a), init);
}
template <class T, class U> int count_of(T a, U i) { return count(all(a), i); }
template <class T, class U> bool has(T a, U i) {
return find(all(a), i) != end(a);
}
template <class T> int sz(T a) { return a.size(); };
template <class T> void COUT(T x) { cout << x << endl; }
template <class T, class U> void COUT(T x, U y) {
cout << x << ' ' << y << endl;
}
template <class T, class U, class V> void COUT(T x, U y, V z) {
cout << x << ' ' << y << ' ' << z << endl;
}
template <class T> void CSP(T x) { cout << x << ' '; }
template <class T> void CVEC(T v) {
int c = v.size() - 1;
for (size_t i = 0; i < c; i++)
cout << v[i] << ' ';
if (c > -1)
cout << v[c];
cout << endl;
}
template <class T> bool amin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> bool amax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
constexpr int lshift(int x) noexcept { return 1ll << x; }
constexpr int popcount(unsigned int x) noexcept {
return __builtin_popcountll(x);
}
constexpr int least1(unsigned int x) noexcept { return __builtin_ffsll(x); }
constexpr int ceil_div(int x, int y) noexcept { return (x - 1) / y + 1; }
#pragma endregion header
void solve(int N, int M, vi u, vi v, int S, int T) {
vvi adj(N * 3);
rep(i, M) {
adj[u[i]].push_back(v[i] + N);
adj[u[i] + N].push_back(v[i] + N * 2);
adj[u[i] + N * 2].push_back(v[i]);
}
vi costs(N * 3, -1);
costs[S] = 0;
queue<int> q;
q.push(S);
while (!q.empty()) {
int now = q.front();
q.pop();
each(ni, adj[now]) {
if (costs[ni] == -1) {
costs[ni] = costs[now] + 1;
q.push(ni);
}
}
}
COUT(costs[T] == -1 ? -1 : costs[T] / 3);
}
#pragma region main
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(15);
int N;
cin >> N;
int M;
cin >> M;
vi u(M);
vi v(M);
for (int i = 0; i < M; i++) {
cin >> u[i];
cin >> v[i];
u[i]--;
v[i]--;
}
int S;
cin >> S;
int T;
cin >> T;
S--;
T--;
solve(N, M, move(u), move(v), S, T);
}
#pragma endregion main
| [
"assignment.variable.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change"
] | 799,076 | 799,077 | u048773461 | cpp |
p02991 | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <numeric>
#include <queue>
#include <string>
#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 INF 2e9
#define ALL(v) v.begin(), v.end()
using namespace std;
using ll = long long;
using P = pair<int, int>;
using pll = pair<ll, ll>;
using vvii = vector<vector<int>>;
using vvll = vector<vector<ll>>;
const ll inf = 1LL << 60;
struct Hop {
int N, M;
vvii G;
vector<vector<int>> done;
int S, T;
queue<P> que;
Hop() {
cin >> N >> M;
G.resize(N);
done.resize(3, vector<int>(N, -1));
REP(i, M) {
int u, v;
cin >> u >> v;
u--;
v--;
G[u].push_back(v);
}
cin >> S >> T;
S--;
T--;
}
int bfs() {
que.push(P(0, S));
while (!que.empty()) {
P now = que.front();
que.pop();
bfs3(now.first, now.second);
}
return done[0][T];
}
void bfs3(int turn, int s) {
queue<P> que3;
que3.push(P(0, s));
while (!que3.empty()) {
P nownow = que3.front();
que3.pop();
int ken = nownow.first;
int v = nownow.second;
if (ken == 3 && done[0][v] == -1) {
// done[0][v] = turn+1;
Hop::que.push(P(turn + 1, v));
// return;
}
else if (done[ken][v] == -1) {
done[ken][v] = turn;
REP(k, G[v].size()) {
int next = G[v][k];
que3.push(P(ken + 1, next));
}
}
}
}
};
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
// cout << fixed << setprecision(15);
Hop hop;
int ans = hop.bfs();
cout << ans << endl;
} | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <numeric>
#include <queue>
#include <string>
#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 INF 2e9
#define ALL(v) v.begin(), v.end()
using namespace std;
using ll = long long;
using P = pair<int, int>;
using pll = pair<ll, ll>;
using vvii = vector<vector<int>>;
using vvll = vector<vector<ll>>;
const ll inf = 1LL << 60;
struct Hop {
int N, M;
vvii G;
vector<vector<int>> done;
int S, T;
queue<P> que;
Hop() {
cin >> N >> M;
G.resize(N);
done.resize(3, vector<int>(N, -1));
REP(i, M) {
int u, v;
cin >> u >> v;
u--;
v--;
G[u].push_back(v);
}
cin >> S >> T;
S--;
T--;
}
int bfs() {
que.push(P(0, S));
while (!que.empty()) {
P now = que.front();
que.pop();
bfs3(now.first, now.second);
}
return done[0][T];
}
void bfs3(int turn, int s) {
queue<P> que3;
que3.push(P(0, s));
while (!que3.empty()) {
P nownow = que3.front();
que3.pop();
int ken = nownow.first; //何歩めか
int v = nownow.second; //どの街か
if (ken == 3) {
if (done[0][v] == -1) {
// done[0][v] = turn+1;
Hop::que.push(P(turn + 1, v));
// return;
}
}
else if (done[ken][v] == -1) {
done[ken][v] = turn;
REP(k, G[v].size()) {
int next = G[v][k];
que3.push(P(ken + 1, next));
}
}
}
}
};
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
// cout << fixed << setprecision(15);
Hop hop;
int ans = hop.bfs();
cout << ans << endl;
} | [
"control_flow.branch.if.condition.change",
"control_flow.branch.if.add"
] | 799,097 | 799,098 | u211259428 | cpp |
p02991 | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <numeric>
#include <queue>
#include <string>
#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 INF 2e9
#define ALL(v) v.begin(), v.end()
using namespace std;
using ll = long long;
using P = pair<int, int>;
using pll = pair<ll, ll>;
using vvii = vector<vector<int>>;
using vvll = vector<vector<ll>>;
const ll inf = 1LL << 60;
struct Hop {
int N, M;
vvii G;
vector<vector<int>> done;
int S, T;
queue<P> que;
Hop() {
cin >> N >> M;
G.resize(N);
done.resize(3, vector<int>(N, -1));
REP(i, N) {
int u, v;
cin >> u >> v;
u--;
v--;
G[u].push_back(v);
}
cin >> S >> T;
S--;
T--;
}
int bfs() {
que.push(P(0, S));
while (!que.empty()) {
P now = que.front();
que.pop();
bfs3(now.first, now.second);
}
return done[0][T];
}
void bfs3(int turn, int s) {
queue<P> que3;
que3.push(P(0, s));
while (!que3.empty()) {
P nownow = que3.front();
que3.pop();
int ken = nownow.first;
int v = nownow.second;
if (ken == 3 && done[0][v] == -1) {
// done[0][v] = turn+1;
Hop::que.push(P(turn + 1, v));
// return;
}
else if (done[ken][v] == -1) {
done[ken][v] = turn;
REP(k, G[v].size()) {
int next = G[v][k];
que3.push(P(ken + 1, next));
}
}
}
}
};
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
// cout << fixed << setprecision(15);
Hop hop;
int ans = hop.bfs();
cout << ans << endl;
} | #include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <numeric>
#include <queue>
#include <string>
#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 INF 2e9
#define ALL(v) v.begin(), v.end()
using namespace std;
using ll = long long;
using P = pair<int, int>;
using pll = pair<ll, ll>;
using vvii = vector<vector<int>>;
using vvll = vector<vector<ll>>;
const ll inf = 1LL << 60;
struct Hop {
int N, M;
vvii G;
vector<vector<int>> done;
int S, T;
queue<P> que;
Hop() {
cin >> N >> M;
G.resize(N);
done.resize(3, vector<int>(N, -1));
REP(i, M) {
int u, v;
cin >> u >> v;
u--;
v--;
G[u].push_back(v);
}
cin >> S >> T;
S--;
T--;
}
int bfs() {
que.push(P(0, S));
while (!que.empty()) {
P now = que.front();
que.pop();
bfs3(now.first, now.second);
}
return done[0][T];
}
void bfs3(int turn, int s) {
queue<P> que3;
que3.push(P(0, s));
while (!que3.empty()) {
P nownow = que3.front();
que3.pop();
int ken = nownow.first; //何歩めか
int v = nownow.second; //どの街か
if (ken == 3) {
if (done[0][v] == -1) {
// done[0][v] = turn+1;
Hop::que.push(P(turn + 1, v));
// return;
}
}
else if (done[ken][v] == -1) {
done[ken][v] = turn;
REP(k, G[v].size()) {
int next = G[v][k];
que3.push(P(ken + 1, next));
}
}
}
}
};
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
// cout << fixed << setprecision(15);
Hop hop;
int ans = hop.bfs();
cout << ans << endl;
} | [
"control_flow.branch.if.condition.change",
"control_flow.branch.if.add"
] | 799,099 | 799,098 | u211259428 | cpp |
p02991 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, m, n) for (int i = (m); i < (int)(n); i++)
#define RREP(i, m, n) for (int i = (int)(n - 1); i >= m; i--)
#define rep(i, n) REP(i, 0, n)
#define rrep(i, n) RREP(i, 0, n)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define fi first
#define se second
#define debug(...) \
{ \
cerr << "[L" << __LINE__ << "] "; \
_debug(__VA_ARGS__); \
}
template <typename T> string join(const vector<T> &v, string del = ", ") {
stringstream s;
for (auto x : v)
s << del << x;
return s.str().substr(del.size());
}
template <typename T> ostream &operator<<(ostream &o, const vector<T> &v) {
if (v.size())
o << "[" << join(v) << "]";
return o;
}
template <typename T>
ostream &operator<<(ostream &o, const vector<vector<T>> &vv) {
int l = vv.size();
if (l) {
o << endl;
rep(i, l) o << (i == 0 ? "[ " : ",\n ") << vv[i]
<< (i == l - 1 ? " ]" : "");
}
return o;
}
inline void _debug() { cerr << endl; }
template <class First, class... Rest>
void _debug(const First &first, const Rest &...rest) {
cerr << first << " ";
_debug(rest...);
}
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
const double PI = (1 * acos(0.0));
const double EPS = 1e-9;
const int INF = 0x3f3f3f3f;
const ll INFL = 0x3f3f3f3f3f3f3f3fLL;
const ll mod = 1e9 + 7;
inline void finput(string filename) { freopen(filename.c_str(), "r", stdin); }
vi g[100010];
int main() {
ios_base::sync_with_stdio(0);
// finput("./input");
int n, m;
cin >> n >> m;
rep(i, m) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
}
int s, t;
cin >> s >> t;
vvi d(n + 1, vi(3, INF));
queue<pii> Q;
Q.emplace(s, 0);
d[s][0] = 0;
while (!Q.empty()) {
pii p = Q.front();
Q.pop();
int v = p.fi, c = p.se;
int nc = (c + 1) % 3;
for (auto u : g[v]) {
if (d[u][nc] == INF) {
d[u][nc] = d[v][c] + 1;
Q.emplace(u, nc);
}
}
}
if (d[t][2] == INF)
cout << -1 << endl;
else
cout << d[t][2] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, m, n) for (int i = (m); i < (int)(n); i++)
#define RREP(i, m, n) for (int i = (int)(n - 1); i >= m; i--)
#define rep(i, n) REP(i, 0, n)
#define rrep(i, n) RREP(i, 0, n)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define fi first
#define se second
#define debug(...) \
{ \
cerr << "[L" << __LINE__ << "] "; \
_debug(__VA_ARGS__); \
}
template <typename T> string join(const vector<T> &v, string del = ", ") {
stringstream s;
for (auto x : v)
s << del << x;
return s.str().substr(del.size());
}
template <typename T> ostream &operator<<(ostream &o, const vector<T> &v) {
if (v.size())
o << "[" << join(v) << "]";
return o;
}
template <typename T>
ostream &operator<<(ostream &o, const vector<vector<T>> &vv) {
int l = vv.size();
if (l) {
o << endl;
rep(i, l) o << (i == 0 ? "[ " : ",\n ") << vv[i]
<< (i == l - 1 ? " ]" : "");
}
return o;
}
inline void _debug() { cerr << endl; }
template <class First, class... Rest>
void _debug(const First &first, const Rest &...rest) {
cerr << first << " ";
_debug(rest...);
}
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
const double PI = (1 * acos(0.0));
const double EPS = 1e-9;
const int INF = 0x3f3f3f3f;
const ll INFL = 0x3f3f3f3f3f3f3f3fLL;
const ll mod = 1e9 + 7;
inline void finput(string filename) { freopen(filename.c_str(), "r", stdin); }
vi g[100010];
int main() {
ios_base::sync_with_stdio(0);
// finput("./input");
ll n, m;
cin >> n >> m;
rep(i, m) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
}
int s, t;
cin >> s >> t;
vvi d(n + 1, vi(3, INF));
queue<pii> Q;
Q.emplace(s, 0);
d[s][0] = 0;
while (!Q.empty()) {
pii p = Q.front();
Q.pop();
int v = p.fi, c = p.se;
int nc = (c + 1) % 3;
for (auto u : g[v]) {
if (d[u][nc] == INF) {
d[u][nc] = d[v][c] + 1;
Q.emplace(u, nc);
}
}
}
if (d[t][0] == INF)
cout << -1 << endl;
else
cout << d[t][0] / 3 << endl;
return 0;
} | [
"variable_declaration.type.change",
"literal.number.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"io.output.change"
] | 799,100 | 799,101 | u382423941 | cpp |
p02991 |
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include <prettyprint.hpp>
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]: ", d_err(__VA_ARGS__);
#else
#define debug(...) 83;
#endif
void d_err() { cerr << endl; }
template <typename H, typename... T> void d_err(H h, T... t) {
cerr << h << " ";
d_err(t...);
}
template <typename T> void print(T x) { cout << x << endl; }
#define ALL(x) (x).begin(), (x).end()
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define REVFOR(i, m, n) for (int i = (n - 1); i >= (m); --i)
#define REP(i, n) FOR(i, 0, n)
#define REVREP(i, n) REVFOR(i, 0, n)
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define bcnt __builtin_popcountll
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<ll, ll> Pll;
typedef pair<int, int> Pin;
ll INF = 1e18;
int inf = 1e9;
ll MOD = 1e9 + 7;
struct Dijkstra {
struct Edge {
ll to;
ll c;
};
int V;
vector<vector<Edge>> e;
vector<ll> d;
Dijkstra(int V) : V(V) {
e.resize(V);
d.resize(V);
}
void add_edge(int from, int to, ll cost) { e[from].pb({to, cost}); }
void operator()(ll s) {
priority_queue<Pll, vector<Pll>, greater<>> q;
REP(i, V) d[i] = INF;
d[s] = 0;
q.push({0, s});
while (!q.empty()) {
Pll n = q.top();
q.pop();
ll v = n.se;
if (d[v] < n.fi)
continue;
REP(i, e[v].size()) {
Edge cur = e[v][i];
ll cost = d[v] + cur.c;
if (d[cur.to] > cost) {
d[cur.to] = cost;
q.push({cost, cur.to});
}
}
}
}
};
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(20);
int N, M;
cin >> N >> M;
Dijkstra graph(3 * N);
REP(i, M) {
int u, v;
cin >> u >> v;
--u;
--v;
graph.add_edge(3 * u, 3 * v + 1, 1);
graph.add_edge(3 * u + 1, 3 * v + 2, 1);
graph.add_edge(3 * u + 2, 3 * v, 1);
}
int s, t;
cin >> s >> t;
--s;
--t;
graph(s);
print(graph.d[3 * t] == INF ? -1 : graph.d[3 * t] / 3);
}
|
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include <prettyprint.hpp>
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]: ", d_err(__VA_ARGS__);
#else
#define debug(...) 83;
#endif
void d_err() { cerr << endl; }
template <typename H, typename... T> void d_err(H h, T... t) {
cerr << h << " ";
d_err(t...);
}
template <typename T> void print(T x) { cout << x << endl; }
#define ALL(x) (x).begin(), (x).end()
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define REVFOR(i, m, n) for (int i = (n - 1); i >= (m); --i)
#define REP(i, n) FOR(i, 0, n)
#define REVREP(i, n) REVFOR(i, 0, n)
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define bcnt __builtin_popcountll
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<ll, ll> Pll;
typedef pair<int, int> Pin;
ll INF = 1e18;
int inf = 1e9;
ll MOD = 1e9 + 7;
struct Dijkstra {
struct Edge {
ll to;
ll c;
};
int V;
vector<vector<Edge>> e;
vector<ll> d;
Dijkstra(int V) : V(V) {
e.resize(V);
d.resize(V);
}
void add_edge(int from, int to, ll cost) { e[from].pb({to, cost}); }
void operator()(ll s) {
priority_queue<Pll, vector<Pll>, greater<>> q;
REP(i, V) d[i] = INF;
d[s] = 0;
q.push({0, s});
while (!q.empty()) {
Pll n = q.top();
q.pop();
ll v = n.se;
if (d[v] < n.fi)
continue;
REP(i, e[v].size()) {
Edge cur = e[v][i];
ll cost = d[v] + cur.c;
if (d[cur.to] > cost) {
d[cur.to] = cost;
q.push({cost, cur.to});
}
}
}
}
};
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(20);
int N, M;
cin >> N >> M;
Dijkstra graph(3 * N);
REP(i, M) {
int u, v;
cin >> u >> v;
--u;
--v;
graph.add_edge(3 * u, 3 * v + 1, 1);
graph.add_edge(3 * u + 1, 3 * v + 2, 1);
graph.add_edge(3 * u + 2, 3 * v, 1);
}
int s, t;
cin >> s >> t;
--s;
--t;
graph(s * 3);
print(graph.d[3 * t] == INF ? -1 : graph.d[3 * t] / 3);
}
| [
"expression.operation.binary.add"
] | 799,104 | 799,105 | u089177147 | cpp |
p02991 |
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include <prettyprint.hpp>
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]: ", d_err(__VA_ARGS__);
#else
#define debug(...) 83;
#endif
void d_err() { cerr << endl; }
template <typename H, typename... T> void d_err(H h, T... t) {
cerr << h << " ";
d_err(t...);
}
template <typename T> void print(T x) { cout << x << endl; }
#define ALL(x) (x).begin(), (x).end()
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define REVFOR(i, m, n) for (int i = (n - 1); i >= (m); --i)
#define REP(i, n) FOR(i, 0, n)
#define REVREP(i, n) REVFOR(i, 0, n)
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define bcnt __builtin_popcountll
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<ll, ll> Pll;
typedef pair<int, int> Pin;
ll INF = 1e16;
int inf = 1e9;
ll MOD = 1e9 + 7;
struct Dijkstra {
struct Edge {
ll to;
ll c;
};
int V;
vector<vector<Edge>> e;
vector<ll> d;
Dijkstra(int V) : V(V) {
e.resize(V);
d.resize(V);
}
void add_edge(int from, int to, ll cost) { e[from].pb({to, cost}); }
void operator()(ll s) {
priority_queue<Pll, vector<Pll>, greater<>> q;
REP(i, V) d[i] = INF;
d[s] = 0;
q.push({0, s});
while (!q.empty()) {
Pll n = q.top();
q.pop();
ll v = n.se;
if (d[v] < n.fi)
continue;
REP(i, e[v].size()) {
Edge cur = e[v][i];
ll cost = d[v] + cur.c;
if (d[cur.to] > cost) {
d[cur.to] = cost;
q.push({cost, cur.to});
}
}
}
}
};
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(20);
int N, M;
cin >> N >> M;
Dijkstra graph(3 * N);
REP(i, M) {
int u, v;
cin >> u >> v;
--u;
--v;
graph.add_edge(3 * u, 3 * v + 1, 1);
graph.add_edge(3 * u + 1, 3 * v + 2, 1);
graph.add_edge(3 * u + 2, 3 * v, 1);
}
int s, t;
cin >> s >> t;
--s;
--t;
graph(s);
print(graph.d[3 * t] == INF ? -1 : graph.d[3 * t] / 3);
}
|
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include <prettyprint.hpp>
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]: ", d_err(__VA_ARGS__);
#else
#define debug(...) 83;
#endif
void d_err() { cerr << endl; }
template <typename H, typename... T> void d_err(H h, T... t) {
cerr << h << " ";
d_err(t...);
}
template <typename T> void print(T x) { cout << x << endl; }
#define ALL(x) (x).begin(), (x).end()
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define REVFOR(i, m, n) for (int i = (n - 1); i >= (m); --i)
#define REP(i, n) FOR(i, 0, n)
#define REVREP(i, n) REVFOR(i, 0, n)
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define bcnt __builtin_popcountll
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<ll, ll> Pll;
typedef pair<int, int> Pin;
ll INF = 1e18;
int inf = 1e9;
ll MOD = 1e9 + 7;
struct Dijkstra {
struct Edge {
ll to;
ll c;
};
int V;
vector<vector<Edge>> e;
vector<ll> d;
Dijkstra(int V) : V(V) {
e.resize(V);
d.resize(V);
}
void add_edge(int from, int to, ll cost) { e[from].pb({to, cost}); }
void operator()(ll s) {
priority_queue<Pll, vector<Pll>, greater<>> q;
REP(i, V) d[i] = INF;
d[s] = 0;
q.push({0, s});
while (!q.empty()) {
Pll n = q.top();
q.pop();
ll v = n.se;
if (d[v] < n.fi)
continue;
REP(i, e[v].size()) {
Edge cur = e[v][i];
ll cost = d[v] + cur.c;
if (d[cur.to] > cost) {
d[cur.to] = cost;
q.push({cost, cur.to});
}
}
}
}
};
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(20);
int N, M;
cin >> N >> M;
Dijkstra graph(3 * N);
REP(i, M) {
int u, v;
cin >> u >> v;
--u;
--v;
graph.add_edge(3 * u, 3 * v + 1, 1);
graph.add_edge(3 * u + 1, 3 * v + 2, 1);
graph.add_edge(3 * u + 2, 3 * v, 1);
}
int s, t;
cin >> s >> t;
--s;
--t;
graph(s * 3);
print(graph.d[3 * t] == INF ? -1 : graph.d[3 * t] / 3);
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 799,106 | 799,105 | u089177147 | cpp |
p02991 |
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include <prettyprint.hpp>
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]: ", d_err(__VA_ARGS__);
#else
#define debug(...) 83;
#endif
void d_err() { cerr << endl; }
template <typename H, typename... T> void d_err(H h, T... t) {
cerr << h << " ";
d_err(t...);
}
template <typename T> void print(T x) { cout << x << endl; }
#define ALL(x) (x).begin(), (x).end()
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define REVFOR(i, m, n) for (int i = (n - 1); i >= (m); --i)
#define REP(i, n) FOR(i, 0, n)
#define REVREP(i, n) REVFOR(i, 0, n)
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define bcnt __builtin_popcountll
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<ll, ll> Pll;
typedef pair<int, int> Pin;
ll INF = 1e16;
int inf = 1e9;
ll MOD = 1e9 + 7;
struct Dijkstra {
struct Edge {
ll to;
ll c;
};
int V;
vector<vector<Edge>> e;
vector<ll> d;
Dijkstra(int V) : V(V) {
e.resize(V);
d.resize(V);
}
void add_edge(int from, int to, ll cost) { e[from].pb({to, cost}); }
void operator()(ll s) {
priority_queue<Pll, vector<Pll>, greater<>> q;
REP(i, V) d[i] = INF;
d[s] = 0;
q.push({0, s});
while (!q.empty()) {
Pll n = q.top();
q.pop();
ll v = n.se;
if (d[v] < n.fi)
continue;
REP(i, e[v].size()) {
Edge cur = e[v][i];
ll cost = d[v] + cur.c;
if (d[cur.to] > cost) {
d[cur.to] = cost;
q.push({cost, cur.to});
}
}
}
}
};
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(20);
int N, M;
cin >> N >> M;
Dijkstra graph(3 * N);
REP(i, M) {
int u, v;
cin >> u >> v;
--u;
--v;
graph.add_edge(3 * u, 3 * v + 1, 1);
graph.add_edge(3 * u + 1, 3 * v + 2, 1);
graph.add_edge(3 * u + 2, 3 * v, 1);
}
int s, t;
cin >> s >> t;
--s;
--t;
graph(s);
print(graph.d[t] == INF ? -1 : graph.d[3 * t] / 3);
}
|
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include <prettyprint.hpp>
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]: ", d_err(__VA_ARGS__);
#else
#define debug(...) 83;
#endif
void d_err() { cerr << endl; }
template <typename H, typename... T> void d_err(H h, T... t) {
cerr << h << " ";
d_err(t...);
}
template <typename T> void print(T x) { cout << x << endl; }
#define ALL(x) (x).begin(), (x).end()
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define REVFOR(i, m, n) for (int i = (n - 1); i >= (m); --i)
#define REP(i, n) FOR(i, 0, n)
#define REVREP(i, n) REVFOR(i, 0, n)
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define bcnt __builtin_popcountll
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<ll, ll> Pll;
typedef pair<int, int> Pin;
ll INF = 1e18;
int inf = 1e9;
ll MOD = 1e9 + 7;
struct Dijkstra {
struct Edge {
ll to;
ll c;
};
int V;
vector<vector<Edge>> e;
vector<ll> d;
Dijkstra(int V) : V(V) {
e.resize(V);
d.resize(V);
}
void add_edge(int from, int to, ll cost) { e[from].pb({to, cost}); }
void operator()(ll s) {
priority_queue<Pll, vector<Pll>, greater<>> q;
REP(i, V) d[i] = INF;
d[s] = 0;
q.push({0, s});
while (!q.empty()) {
Pll n = q.top();
q.pop();
ll v = n.se;
if (d[v] < n.fi)
continue;
REP(i, e[v].size()) {
Edge cur = e[v][i];
ll cost = d[v] + cur.c;
if (d[cur.to] > cost) {
d[cur.to] = cost;
q.push({cost, cur.to});
}
}
}
}
};
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(20);
int N, M;
cin >> N >> M;
Dijkstra graph(3 * N);
REP(i, M) {
int u, v;
cin >> u >> v;
--u;
--v;
graph.add_edge(3 * u, 3 * v + 1, 1);
graph.add_edge(3 * u + 1, 3 * v + 2, 1);
graph.add_edge(3 * u + 2, 3 * v, 1);
}
int s, t;
cin >> s >> t;
--s;
--t;
graph(s * 3);
print(graph.d[3 * t] == INF ? -1 : graph.d[3 * t] / 3);
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 799,107 | 799,105 | u089177147 | cpp |
p02991 | #include <algorithm>
#include <array>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdint>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
#ifdef _DEBUG
#define DUMP(x) std::cerr << (#x) << " = " << (x) << "\n"
#else
#define DUMP(x)
#endif
#define REP(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define EREP(i, a, b) for (int i = (int)(a); i <= (int)(b); ++i)
#define RREP(i, a, b) for (int i = (int)(a)-1; i >= (int)(b); --i)
#define rep(i, n) REP(i, 0, n)
#define erep(i, n) EREP(i, 0, n)
#define rrep(i, n) RREP(i, n, 0)
#define ALL(r) (r).begin(), (r).end()
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
template <typename T> ostream &operator<<(ostream &os, vector<T> &v) {
os << "{";
rep(i, v.size()) os << v[i] << (i == (int)v.size() - 1 ? "" : ", ");
os << "}";
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, pair<T, U> &p) {
return (os << "(" << p.first << ", " << p.second << ")");
}
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &m) {
bool first = true;
os << "{";
for (const auto &e : m) {
if (!first)
os << ", ";
os << "{" << e.first << ": " << e.second << "}";
first = false;
}
os << "}";
return os;
}
template <typename T> ostream &operator<<(ostream &os, set<T> &s) {
os << "{";
bool first = true;
for (const auto &e : s) {
if (!first)
os << ", ";
os << e;
first = false;
}
os << "}";
return os;
}
template <typename T> T dup(T x, T y) { return (x + y - 1) / y; };
template <typename A, size_t N, typename T>
inline void arrayFill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
struct in {
const size_t n = 0;
in() = default;
in(size_t n) : n(n){};
template <typename T> operator T() {
T ret;
cin >> ret;
return ret;
}
template <typename T> operator vector<T>() {
assert(n != 0);
vector<T> ret(n);
for (T &x : ret) {
T tmp = in();
x = tmp;
}
return ret;
}
template <typename T, typename U> operator pair<T, U>() {
pair<T, U> ret;
ret.first = in();
ret.second = in();
return ret;
}
};
namespace fiore::impl {
template <typename T> inline void out_impl(const T &x, char end_char) {
std::cout << x << end_char;
}
template <typename T> inline void out_impl(const vector<T> &x, char end_char) {
bool first = true;
for (const auto &e : x) {
if (!first)
std::cout << ' ';
std::cout << e;
first = false;
}
std::cout << end_char;
}
} // namespace fiore::impl
template <typename T> inline void out(const T &x) {
fiore::impl::out_impl(x, '\n');
};
template <typename T, typename U, typename... Args>
inline void out(const T &x, const U &y, const Args &...args) {
fiore::impl::out_impl(x, ' ');
out(y, args...);
}
using ll = int64_t;
using vint = vector<int32_t>;
using vvint = vector<vint>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vstr = vector<string>;
using pint = pair<int32_t, int32_t>;
using vpint = vector<pint>;
using pll = pair<ll, ll>;
using vpll = vector<pll>;
using setint = set<int32_t>;
using qint = queue<int32_t>;
using qpint = queue<pint>;
constexpr std::int32_t INF = 1001001001;
constexpr std::int64_t LINF = 1001001001001001001;
void Main() {
int n = in(), m = in();
vvint g(n * 3);
rep(i, m) {
int u = in(), v = in();
--u, --v;
g[u * 3].pb(v * 3 + 1);
g[u * 3 + 1].pb(v * 3 + 2);
g[u * 3 + 2].pb(v * 3);
}
int s = in(), t = in();
--s, --t;
vint dist(n * 3, -1);
dist[s] = 0;
qint q;
q.push(s);
while (!q.empty()) {
int v = q.front();
q.pop();
for (const auto nv : g[v]) {
if (dist[nv] != -1)
continue;
dist[nv] = dist[v] + 1;
q.push(nv);
}
}
DUMP(dist);
if (dist[t * 3] == -1)
out(-1);
else
out(dist[t * 3] / 3);
}
signed main() {
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
std::cout << std::fixed << std::setprecision(15);
Main();
return 0;
} | #include <algorithm>
#include <array>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdint>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
#ifdef _DEBUG
#define DUMP(x) std::cerr << (#x) << " = " << (x) << "\n"
#else
#define DUMP(x)
#endif
#define REP(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define EREP(i, a, b) for (int i = (int)(a); i <= (int)(b); ++i)
#define RREP(i, a, b) for (int i = (int)(a)-1; i >= (int)(b); --i)
#define rep(i, n) REP(i, 0, n)
#define erep(i, n) EREP(i, 0, n)
#define rrep(i, n) RREP(i, n, 0)
#define ALL(r) (r).begin(), (r).end()
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
template <typename T> ostream &operator<<(ostream &os, vector<T> &v) {
os << "{";
rep(i, v.size()) os << v[i] << (i == (int)v.size() - 1 ? "" : ", ");
os << "}";
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, pair<T, U> &p) {
return (os << "(" << p.first << ", " << p.second << ")");
}
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &m) {
bool first = true;
os << "{";
for (const auto &e : m) {
if (!first)
os << ", ";
os << "{" << e.first << ": " << e.second << "}";
first = false;
}
os << "}";
return os;
}
template <typename T> ostream &operator<<(ostream &os, set<T> &s) {
os << "{";
bool first = true;
for (const auto &e : s) {
if (!first)
os << ", ";
os << e;
first = false;
}
os << "}";
return os;
}
template <typename T> T dup(T x, T y) { return (x + y - 1) / y; };
template <typename A, size_t N, typename T>
inline void arrayFill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
struct in {
const size_t n = 0;
in() = default;
in(size_t n) : n(n){};
template <typename T> operator T() {
T ret;
cin >> ret;
return ret;
}
template <typename T> operator vector<T>() {
assert(n != 0);
vector<T> ret(n);
for (T &x : ret) {
T tmp = in();
x = tmp;
}
return ret;
}
template <typename T, typename U> operator pair<T, U>() {
pair<T, U> ret;
ret.first = in();
ret.second = in();
return ret;
}
};
namespace fiore::impl {
template <typename T> inline void out_impl(const T &x, char end_char) {
std::cout << x << end_char;
}
template <typename T> inline void out_impl(const vector<T> &x, char end_char) {
bool first = true;
for (const auto &e : x) {
if (!first)
std::cout << ' ';
std::cout << e;
first = false;
}
std::cout << end_char;
}
} // namespace fiore::impl
template <typename T> inline void out(const T &x) {
fiore::impl::out_impl(x, '\n');
};
template <typename T, typename U, typename... Args>
inline void out(const T &x, const U &y, const Args &...args) {
fiore::impl::out_impl(x, ' ');
out(y, args...);
}
using ll = int64_t;
using vint = vector<int32_t>;
using vvint = vector<vint>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vstr = vector<string>;
using pint = pair<int32_t, int32_t>;
using vpint = vector<pint>;
using pll = pair<ll, ll>;
using vpll = vector<pll>;
using setint = set<int32_t>;
using qint = queue<int32_t>;
using qpint = queue<pint>;
constexpr std::int32_t INF = 1001001001;
constexpr std::int64_t LINF = 1001001001001001001;
void Main() {
int n = in(), m = in();
vvint g(n * 3);
rep(i, m) {
int u = in(), v = in();
--u, --v;
g[u * 3].pb(v * 3 + 1);
g[u * 3 + 1].pb(v * 3 + 2);
g[u * 3 + 2].pb(v * 3);
}
int s = in(), t = in();
--s, --t;
vint dist(n * 3, -1);
dist[s * 3] = 0;
qint q;
q.push(s * 3);
while (!q.empty()) {
int v = q.front();
q.pop();
for (const auto nv : g[v]) {
if (dist[nv] != -1)
continue;
dist[nv] = dist[v] + 1;
q.push(nv);
}
}
DUMP(dist);
if (dist[t * 3] == -1)
out(-1);
else
out(dist[t * 3] / 3);
}
signed main() {
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
std::cout << std::fixed << std::setprecision(15);
Main();
return 0;
} | [
"assignment.change"
] | 799,110 | 799,111 | u664394831 | cpp |
p02991 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <tuple>
#include <utility>
#include <vector>
#define ll long long
#define itn int
#define endl '\n'
#define co(ans) cout << ans << endl
#define COYE cout << "YES" << endl
#define COYe cout << "Yes" << endl
#define COye cout << "yes" << endl
#define CONO cout << "NO" << endl
#define CONo cout << "No" << endl
#define COno cout << "no" << endl
#define FORE(i, a) for (auto &i : a)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FFOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) FFOR(i, 1, n)
#define PB push_back
#define MP make_pair
#define ALL(V) (V).begin(), (V).end()
#define SORT(V) sort((V).begin(), (V).end())
#define REVERSE(V) reverse((V).begin(), (V).end())
#define EACH(V, i) \
for (typeof((V).begin()) i = (V).begin(); i != (V).end(); ++i)
#define equals(a, b) (fabs((a) - (b)) < EPS)
#define INF ((1LL << 62) - (1LL << 31))
#define EPS 1e-10
#define PI 3.141592653589793238
#define MOD 1000000007
#define MAX 5100000
using namespace std;
using Edge = pair<int, int>;
using Graph = vector<vector<int>>;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
const int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
ll N, M, S, T;
cin >> N >> M;
Graph G(N + 200010);
REP(i, M) {
ll U, V;
cin >> U >> V;
G[U].PB(V + 100000);
G[U + 100000].PB(V + 200000);
G[U + 200000].PB(V);
}
cin >> S >> T;
ll ans = -1, dist[N + 200010];
bool SEEN[N + 200010], EXIST = false;
RREP(i, N + 200009) {
dist[i] = INF;
SEEN[i] = false;
}
queue<ll> Q;
Q.push(S);
dist[S] = 0;
while (!Q.empty()) {
ll v = Q.front();
Q.pop();
if (v == T) {
ans = dist[T];
EXIST = true;
break;
}
FORE(nv, G[v]) {
if (SEEN[nv])
continue;
SEEN[nv] = true;
Q.push(nv);
chmin(dist[nv], dist[v] + 1);
}
}
if (EXIST)
co(ans);
else
co(-1);
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <tuple>
#include <utility>
#include <vector>
#define ll long long
#define itn int
#define endl '\n'
#define co(ans) cout << ans << endl
#define COYE cout << "YES" << endl
#define COYe cout << "Yes" << endl
#define COye cout << "yes" << endl
#define CONO cout << "NO" << endl
#define CONo cout << "No" << endl
#define COno cout << "no" << endl
#define FORE(i, a) for (auto &i : a)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FFOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) FFOR(i, 1, n)
#define PB push_back
#define MP make_pair
#define ALL(V) (V).begin(), (V).end()
#define SORT(V) sort((V).begin(), (V).end())
#define REVERSE(V) reverse((V).begin(), (V).end())
#define EACH(V, i) \
for (typeof((V).begin()) i = (V).begin(); i != (V).end(); ++i)
#define equals(a, b) (fabs((a) - (b)) < EPS)
#define INF ((1LL << 62) - (1LL << 31))
#define EPS 1e-10
#define PI 3.141592653589793238
#define MOD 1000000007
#define MAX 5100000
using namespace std;
using Edge = pair<int, int>;
using Graph = vector<vector<int>>;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
const int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
ll N, M, S, T;
cin >> N >> M;
Graph G(N + 200010);
REP(i, M) {
ll U, V;
cin >> U >> V;
G[U].PB(V + 100000);
G[U + 100000].PB(V + 200000);
G[U + 200000].PB(V);
}
cin >> S >> T;
ll ans = -1, dist[N + 200010];
bool SEEN[N + 200010], EXIST = false;
RREP(i, N + 200009) {
dist[i] = INF;
SEEN[i] = false;
}
queue<ll> Q;
Q.push(S);
dist[S] = 0;
while (!Q.empty()) {
ll v = Q.front();
Q.pop();
if (v == T) {
ans = dist[T];
EXIST = true;
break;
}
FORE(nv, G[v]) {
if (SEEN[nv])
continue;
SEEN[nv] = true;
Q.push(nv);
chmin(dist[nv], dist[v] + 1);
}
}
if (EXIST)
co(ans / 3);
else
co(-1);
return 0;
} | [
"expression.operation.binary.add"
] | 799,112 | 799,113 | u673211643 | cpp |
p02991 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <tuple>
#include <utility>
#include <vector>
#define ll long long
#define itn int
#define endl '\n'
#define co(ans) cout << ans << endl
#define COYE cout << "YES" << endl
#define COYe cout << "Yes" << endl
#define COye cout << "yes" << endl
#define CONO cout << "NO" << endl
#define CONo cout << "No" << endl
#define COno cout << "no" << endl
#define FORE(i, a) for (auto &i : a)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FFOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) FFOR(i, 1, n)
#define PB push_back
#define MP make_pair
#define ALL(V) (V).begin(), (V).end()
#define SORT(V) sort((V).begin(), (V).end())
#define REVERSE(V) reverse((V).begin(), (V).end())
#define EACH(V, i) \
for (typeof((V).begin()) i = (V).begin(); i != (V).end(); ++i)
#define equals(a, b) (fabs((a) - (b)) < EPS)
#define INF ((1LL << 62) - (1LL << 31))
#define EPS 1e-10
#define PI 3.141592653589793238
#define MOD 1000000007
#define MAX 5100000
using namespace std;
using Edge = pair<int, int>;
using Graph = vector<vector<int>>;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
const int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
ll N, M, S, T;
cin >> N >> M;
Graph G(N + 200010);
REP(i, M) {
ll U, V;
cin >> U >> V;
G[U].PB(V + 100000);
G[U + 100000].PB(V + 200000);
G[U + 200000].PB(V);
}
cin >> S >> T;
ll ans = -1, dist[N + 200010];
bool SEEN[N + 200010], EXIST = false;
RREP(i, N + 20009) {
dist[i] = INF;
SEEN[i] = false;
}
queue<ll> Q;
Q.push(S);
dist[S] = 0;
while (!Q.empty()) {
ll v = Q.front();
Q.pop();
if (v == T) {
ans = dist[T];
EXIST = true;
break;
}
FORE(nv, G[v]) {
if (SEEN[nv])
continue;
SEEN[nv] = true;
Q.push(nv);
chmin(dist[nv], dist[v] + 1);
}
}
if (EXIST)
co(ans);
else
co(-1);
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <tuple>
#include <utility>
#include <vector>
#define ll long long
#define itn int
#define endl '\n'
#define co(ans) cout << ans << endl
#define COYE cout << "YES" << endl
#define COYe cout << "Yes" << endl
#define COye cout << "yes" << endl
#define CONO cout << "NO" << endl
#define CONo cout << "No" << endl
#define COno cout << "no" << endl
#define FORE(i, a) for (auto &i : a)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FFOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) FFOR(i, 1, n)
#define PB push_back
#define MP make_pair
#define ALL(V) (V).begin(), (V).end()
#define SORT(V) sort((V).begin(), (V).end())
#define REVERSE(V) reverse((V).begin(), (V).end())
#define EACH(V, i) \
for (typeof((V).begin()) i = (V).begin(); i != (V).end(); ++i)
#define equals(a, b) (fabs((a) - (b)) < EPS)
#define INF ((1LL << 62) - (1LL << 31))
#define EPS 1e-10
#define PI 3.141592653589793238
#define MOD 1000000007
#define MAX 5100000
using namespace std;
using Edge = pair<int, int>;
using Graph = vector<vector<int>>;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
const int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
ll N, M, S, T;
cin >> N >> M;
Graph G(N + 200010);
REP(i, M) {
ll U, V;
cin >> U >> V;
G[U].PB(V + 100000);
G[U + 100000].PB(V + 200000);
G[U + 200000].PB(V);
}
cin >> S >> T;
ll ans = -1, dist[N + 200010];
bool SEEN[N + 200010], EXIST = false;
RREP(i, N + 200009) {
dist[i] = INF;
SEEN[i] = false;
}
queue<ll> Q;
Q.push(S);
dist[S] = 0;
while (!Q.empty()) {
ll v = Q.front();
Q.pop();
if (v == T) {
ans = dist[T];
EXIST = true;
break;
}
FORE(nv, G[v]) {
if (SEEN[nv])
continue;
SEEN[nv] = true;
Q.push(nv);
chmin(dist[nv], dist[v] + 1);
}
}
if (EXIST)
co(ans / 3);
else
co(-1);
return 0;
} | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 799,114 | 799,113 | u673211643 | cpp |
p02991 | #include "bits/stdc++.h"
using namespace std;
typedef long long int lint;
typedef pair<lint, lint> plint;
typedef pair<double long, double long> pld;
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((lint)(x).size())
#define POW2(n) (1LL << (n))
#define FOR(i, begin, end) \
for (lint i = (begin), i##_end_ = (end); i < i##_end_; i++)
#define IFOR(i, begin, end) \
for (lint i = (end)-1, i##_begin_ = (begin); i >= i##_begin_; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(const pair<T1, T2> &l, const pair<T1, T2> &r) {
return make_pair(l.first + r.first, l.second + r.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(const pair<T1, T2> &l, const pair<T1, T2> &r) {
return make_pair(l.first - r.first, l.second - r.second);
}
const lint MOD = 1e9 + 7, INF = 1e18;
lint N, M, S, T, u, v;
vector<lint> to[300000];
lint dp[100000];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cin >> N >> M;
REP(i, M) {
cin >> u >> v;
u--;
v--;
to[u].push_back(v + N);
to[u + N].push_back(v + N * 2);
to[u + N * 2].push_back(v);
}
cin >> S >> T;
S--;
T--;
REP(i, N * 3) { dp[i] = INF; }
queue<lint> que;
que.push(S);
dp[S] = 0;
while (!que.empty()) {
lint curr = que.front();
que.pop();
REP(i, SZ(to[curr])) {
lint next = to[curr][i];
if (dp[curr] + 1 < dp[next]) {
dp[next] = dp[curr] + 1;
que.push(next);
}
}
}
cout << (dp[T] != INF ? dp[T] : -1) << endl;
}
| #include "bits/stdc++.h"
using namespace std;
typedef long long int lint;
typedef pair<lint, lint> plint;
typedef pair<double long, double long> pld;
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((lint)(x).size())
#define POW2(n) (1LL << (n))
#define FOR(i, begin, end) \
for (lint i = (begin), i##_end_ = (end); i < i##_end_; i++)
#define IFOR(i, begin, end) \
for (lint i = (end)-1, i##_begin_ = (begin); i >= i##_begin_; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(const pair<T1, T2> &l, const pair<T1, T2> &r) {
return make_pair(l.first + r.first, l.second + r.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(const pair<T1, T2> &l, const pair<T1, T2> &r) {
return make_pair(l.first - r.first, l.second - r.second);
}
const lint MOD = 1e9 + 7, INF = 1e18;
lint N, M, S, T, u, v;
vector<lint> to[300000];
lint dp[300000];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cin >> N >> M;
REP(i, M) {
cin >> u >> v;
u--;
v--;
to[u].push_back(v + N);
to[u + N].push_back(v + N * 2);
to[u + N * 2].push_back(v);
}
cin >> S >> T;
S--;
T--;
REP(i, N * 3) { dp[i] = INF; }
queue<lint> que;
que.push(S);
dp[S] = 0;
while (!que.empty()) {
lint curr = que.front();
que.pop();
REP(i, SZ(to[curr])) {
lint next = to[curr][i];
if (dp[curr] + 1 < dp[next]) {
dp[next] = dp[curr] + 1;
que.push(next);
}
}
}
cout << (dp[T] != INF ? dp[T] / 3 : -1) << endl;
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 799,119 | 799,120 | u554988565 | cpp |
p02991 | #include "bits/stdc++.h"
using namespace std;
typedef long long int lint;
typedef pair<lint, lint> plint;
typedef pair<double long, double long> pld;
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((lint)(x).size())
#define POW2(n) (1LL << (n))
#define FOR(i, begin, end) \
for (lint i = (begin), i##_end_ = (end); i < i##_end_; i++)
#define IFOR(i, begin, end) \
for (lint i = (end)-1, i##_begin_ = (begin); i >= i##_begin_; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(const pair<T1, T2> &l, const pair<T1, T2> &r) {
return make_pair(l.first + r.first, l.second + r.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(const pair<T1, T2> &l, const pair<T1, T2> &r) {
return make_pair(l.first - r.first, l.second - r.second);
}
const lint MOD = 1e9 + 7, INF = 1e18;
lint N, M, S, T, u, v;
vector<lint> to[300000];
lint dp[300000];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cin >> N >> M;
REP(i, M) {
cin >> u >> v;
u--;
v--;
to[u].push_back(v * N);
to[u * N].push_back(v * N * 2);
to[u * N * 2].push_back(v);
}
cin >> S >> T;
S--;
T--;
REP(i, N * 3) { dp[i] = INF; }
queue<lint> que;
que.push(S);
dp[S] = 0;
while (!que.empty()) {
lint curr = que.front();
que.pop();
REP(i, SZ(to[curr])) {
lint next = to[curr][i];
if (dp[curr] + 1 < dp[next]) {
dp[next] = dp[curr] + 1;
que.push(next);
}
}
}
cout << (dp[T] != INF ? dp[T] : -1) << endl;
}
| #include "bits/stdc++.h"
using namespace std;
typedef long long int lint;
typedef pair<lint, lint> plint;
typedef pair<double long, double long> pld;
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((lint)(x).size())
#define POW2(n) (1LL << (n))
#define FOR(i, begin, end) \
for (lint i = (begin), i##_end_ = (end); i < i##_end_; i++)
#define IFOR(i, begin, end) \
for (lint i = (end)-1, i##_begin_ = (begin); i >= i##_begin_; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(const pair<T1, T2> &l, const pair<T1, T2> &r) {
return make_pair(l.first + r.first, l.second + r.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(const pair<T1, T2> &l, const pair<T1, T2> &r) {
return make_pair(l.first - r.first, l.second - r.second);
}
const lint MOD = 1e9 + 7, INF = 1e18;
lint N, M, S, T, u, v;
vector<lint> to[300000];
lint dp[300000];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cin >> N >> M;
REP(i, M) {
cin >> u >> v;
u--;
v--;
to[u].push_back(v + N);
to[u + N].push_back(v + N * 2);
to[u + N * 2].push_back(v);
}
cin >> S >> T;
S--;
T--;
REP(i, N * 3) { dp[i] = INF; }
queue<lint> que;
que.push(S);
dp[S] = 0;
while (!que.empty()) {
lint curr = que.front();
que.pop();
REP(i, SZ(to[curr])) {
lint next = to[curr][i];
if (dp[curr] + 1 < dp[next]) {
dp[next] = dp[curr] + 1;
que.push(next);
}
}
}
cout << (dp[T] != INF ? dp[T] / 3 : -1) << endl;
}
| [
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change",
"variable_access.subscript.index.change"
] | 799,121 | 799,120 | u554988565 | cpp |
p02991 | /*!enjoy karo yaar!*/
// CF,CC,AtC,SPOJ: hp1999
// HE: hemant269
// HR: hemant2132
#include <bits/stdc++.h>
using namespace std;
#define int long long int
#define fast() \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define all(x) begin(x), end(x)
#define rz(x) resize(x)
#define asn(x, y) assign(x, y)
#define mem(a, b) memset(a, b, sizeof(a))
#define sz(x) ((int)size(x))
#define eb emplace_back
#define pb push_back
#define pf push_front
#define pob pop_back
#define pof pop_front
#define ins insert
#define vi vector<int>
#define pii pair<int, int>
#define mii map<int, int>
#define F first
#define S second
#define remax(a, b) a = max(a, b)
#define remin(a, b) a = min(a, b)
#define bitcount(x) __builtin_popcountll(x)
#define iceil(n, x) (((n)-1) / (x) + 1)
#define dbug(x) cout << #x << ": " << (x) << "\n"
#define flush fflush(stdout)
#define show(x) \
for (auto zz : x) \
cout << zz << " "; \
cout << "\n";
#define show2(x) \
for (auto zz : x) \
cout << zz.F << " " << zz.S << "\n";
typedef unsigned long long ull;
typedef long long ll;
typedef long double ld;
const ld pi = acos(-1);
const ll inf = 1e9, M = 1e9 + 7;
const int N = 1e5 + 5;
vi v[N];
int dp[N][3];
void solve() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
v[a].pb(b);
}
int s, t;
cin >> s >> t;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 3; ++j)
dp[i][j] = inf;
}
priority_queue<pii> pq;
dp[1][0] = 0;
pq.push({0, 1});
while (!pq.empty()) {
auto p = pq.top();
pq.pop();
int dist = -p.F, x = p.S;
int a = dist % 3, b = (dist + 1) % 3;
for (auto c : v[x]) {
if (dp[c][b] > dp[x][a] + 1) {
dp[c][b] = dp[x][a] + 1;
pq.push({-dp[c][b], c});
}
}
}
if (dp[t][0] == inf)
cout << -1;
else
cout << dp[t][0] / 3;
}
int32_t main() {
fast();
int t = 1;
// cin>>t;
for (int z = 1; z <= t; ++z) {
solve();
// cout<<"\n";
}
return 0;
}
| /*!enjoy karo yaar!*/
// CF,CC,AtC,SPOJ: hp1999
// HE: hemant269
// HR: hemant2132
#include <bits/stdc++.h>
using namespace std;
#define int long long int
#define fast() \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define all(x) begin(x), end(x)
#define rz(x) resize(x)
#define asn(x, y) assign(x, y)
#define mem(a, b) memset(a, b, sizeof(a))
#define sz(x) ((int)size(x))
#define eb emplace_back
#define pb push_back
#define pf push_front
#define pob pop_back
#define pof pop_front
#define ins insert
#define vi vector<int>
#define pii pair<int, int>
#define mii map<int, int>
#define F first
#define S second
#define remax(a, b) a = max(a, b)
#define remin(a, b) a = min(a, b)
#define bitcount(x) __builtin_popcountll(x)
#define iceil(n, x) (((n)-1) / (x) + 1)
#define dbug(x) cout << #x << ": " << (x) << "\n"
#define flush fflush(stdout)
#define show(x) \
for (auto zz : x) \
cout << zz << " "; \
cout << "\n";
#define show2(x) \
for (auto zz : x) \
cout << zz.F << " " << zz.S << "\n";
typedef unsigned long long ull;
typedef long long ll;
typedef long double ld;
const ld pi = acos(-1);
const ll inf = 1e9, M = 1e9 + 7;
const int N = 1e5 + 5;
vi v[N];
int dp[N][3];
void solve() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
v[a].pb(b);
}
int s, t;
cin >> s >> t;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 3; ++j)
dp[i][j] = inf;
}
priority_queue<pii> pq;
dp[s][0] = 0;
pq.push({0, s});
while (!pq.empty()) {
auto p = pq.top();
pq.pop();
int dist = -p.F, x = p.S;
int a = dist % 3, b = (dist + 1) % 3;
for (auto c : v[x]) {
if (dp[c][b] > dp[x][a] + 1) {
dp[c][b] = dp[x][a] + 1;
pq.push({-dp[c][b], c});
}
}
}
if (dp[t][0] == inf)
cout << -1;
else
cout << dp[t][0] / 3;
}
int32_t main() {
fast();
int t = 1;
// cin>>t;
for (int z = 1; z <= t; ++z) {
solve();
// cout<<"\n";
}
return 0;
}
| [
"assignment.variable.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 799,122 | 799,123 | u579670739 | cpp |
p02991 | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7, INF = 1e9 + 7;
int n, m, s, t;
vector<int> g[N];
int dist[N][3];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
while (m--) {
int u, v;
cin >> u >> v;
u--;
v--;
g[u].push_back(v);
}
cin >> s >> t;
s--;
t--;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++)
dist[i][j] = INF;
}
dist[0][0] = 0;
deque<pair<int, int>> q{{0, 0}};
while (!q.empty()) {
int u = q.front().first, kek = q.front().second;
q.pop_front();
for (auto v : g[u]) {
if (dist[u][kek] + 1 < dist[v][(kek + 1) % 3]) {
dist[v][(kek + 1) % 3] = dist[u][kek] + 1;
q.emplace_back(v, (kek + 1) % 3);
}
}
}
cout << (dist[t][0] == INF ? -1 : dist[t][0] / 3);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7, INF = 1e9 + 7;
int n, m, s, t;
vector<int> g[N];
int dist[N][3];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
while (m--) {
int u, v;
cin >> u >> v;
u--;
v--;
g[u].push_back(v);
}
cin >> s >> t;
s--;
t--;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++)
dist[i][j] = INF;
}
dist[s][0] = 0;
deque<pair<int, int>> q{{s, 0}};
while (!q.empty()) {
int u = q.front().first, kek = q.front().second;
q.pop_front();
for (auto v : g[u]) {
if (dist[u][kek] + 1 < dist[v][(kek + 1) % 3]) {
dist[v][(kek + 1) % 3] = dist[u][kek] + 1;
q.emplace_back(v, (kek + 1) % 3);
}
}
}
cout << (dist[t][0] == INF ? -1 : dist[t][0] / 3);
return 0;
}
| [
"assignment.variable.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change"
] | 799,128 | 799,129 | u408861977 | cpp |
p02991 | #include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
#define flush fflush(stdout)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> Pl;
const int mod = (int)1e9 + 7, INF = (int)1e9;
const int di[4] = {1, 0, -1, 0}, dj[4] = {0, 1, 0, -1};
int main(void) {
int n, m, i, j, a, b, s, t, d[100003][3] = {};
vector<int> g[100003];
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
g[a - 1].push_back(b - 1);
}
scanf("%d%d", &s, &t);
s--;
t--;
for (i = 0; i < n; i++)
for (j = 0; j < 3; j++) {
d[i][j] = INF;
}
P p;
int ds, pv, pr, nv, nr;
priority_queue<P, vector<P>, greater<P>> pq;
pq.push(P(0, s));
d[s][0] = 0;
while (!pq.empty()) {
p = pq.top();
pq.pop();
ds = p.first;
pv = p.second / 3;
pr = p.second % 3;
if (d[pv][pr] < ds) {
continue;
}
for (i = 0; i < g[pv].size(); i++) {
nv = g[pv][i];
nr = (pr + 1) % 3;
if (d[nv][nr] > ds + 1) {
d[nv][nr] = ds + 1;
pq.push(P(ds + 1, nv * 3 + nr));
}
}
}
if (d[t][0] == INF) {
printf("-1\n");
} else {
printf("%d\n", d[t][0] / 3);
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
#define flush fflush(stdout)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> Pl;
const int mod = (int)1e9 + 7, INF = (int)1e9;
const int di[4] = {1, 0, -1, 0}, dj[4] = {0, 1, 0, -1};
int main(void) {
int n, m, i, j, a, b, s, t, d[100003][3] = {};
vector<int> g[100003];
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
g[a - 1].push_back(b - 1);
}
scanf("%d%d", &s, &t);
s--;
t--;
for (i = 0; i < n; i++)
for (j = 0; j < 3; j++) {
d[i][j] = INF;
}
P p;
int ds, pv, pr, nv, nr;
priority_queue<P, vector<P>, greater<P>> pq;
pq.push(P(0, s * 3));
d[s][0] = 0;
while (!pq.empty()) {
p = pq.top();
pq.pop();
ds = p.first;
pv = p.second / 3;
pr = p.second % 3;
if (d[pv][pr] < ds) {
continue;
}
for (i = 0; i < g[pv].size(); i++) {
nv = g[pv][i];
nr = (pr + 1) % 3;
if (d[nv][nr] > ds + 1) {
d[nv][nr] = ds + 1;
pq.push(P(ds + 1, nv * 3 + nr));
}
}
}
if (d[t][0] == INF) {
printf("-1\n");
} else {
printf("%d\n", d[t][0] / 3);
}
return 0;
} | [
"expression.operation.binary.add"
] | 799,158 | 799,159 | u088895504 | cpp |
p02991 | // #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i, x) for (ll i = 0; i < (ll)(x); i++)
#define rrep(i, x) for (ll i = (ll)(x)-1; 0 <= i; i--)
#define reps(i, x) for (ll i = 1; i < (ll)(x) + 1; i++)
#define rreps(i, x) for (ll i = (ll)(x); 1 <= i; i--)
#define debug(x) cerr << #x << ": " << (x) << "\n";
#define all(x) (x).begin(), (x).end()
typedef long long ll;
typedef long double ld;
typedef pair<int, int> P;
typedef pair<ll, ll> Pll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef vector<vector<vector<ll>>> vvvl;
const ll INF = numeric_limits<ll>::max() / 4;
const int n_max = 1e5 + 10;
#define int ll
void print() { cout << endl; }
// template <class Head, class... Tail>
// void print(Head&& head, Tail&&... tail) {
// cout << head;
// if (sizeof...(tail) != 0) cout << " ";
// print(forward<Tail>(tail)...);
// }
template <class T> void print(vector<T> &vec) {
for (auto &a : vec) {
cout << a;
if (&a != &vec.back())
cout << " ";
}
cout << endl;
}
template <class T> void print(vector<T> &vec, ll k) {
ll n = vec.size();
k = min(k, n);
rep(i, k - 1) cout << vec[i] << " ";
cout << vec[k - 1] << endl;
}
template <class T> void print(vector<vector<T>> &df) {
for (auto &vec : df) {
print(vec);
}
}
template <class T, class U> void print(pair<T, U> &p) {
cout << p.first << " " << p.second << "\n";
}
template <typename T> struct edge {
int f, t;
T c;
int id;
edge(){};
edge(int f, int t, T c, int id = 0) : f(f), t(t), c(c), id(id){};
bool operator<(const edge &rhs) const { return (*this).c < rhs.c; }
bool operator>(const edge &rhs) const { return (*this).c > rhs.c; }
};
template <typename T> struct graph {
std::vector<std::vector<edge<T>>> data;
graph(int v) : data(v){};
void add_edge(edge<T> &e) { data[e.f].push_back(e); }
void add_edge(int f, int t, T c) { data[f].emplace_back(f, t, c); }
size_t size() { return data.size(); }
vector<edge<T>> operator[](int n) { return data[n]; }
std::vector<edge<T>> make_edges() {
std::vector<edge<T>> r;
for (auto &i : data)
std::copy(i.begin(), i.end(), std::back_inserter(r));
return r;
}
};
signed main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
// ifstream in("killer_01.in");
// cin.rdbuf(in.rdbuf());
// ofstream ofstr("out.txt");
// streambuf* strbuf;
// strbuf = std::cout.rdbuf( ofstr.rdbuf() );
ll n, m;
cin >> n >> m;
graph<ll> g(n);
rep(i, m) {
ll f, t;
cin >> f >> t;
f--;
t--;
g.add_edge(f, t, 1);
}
ll s, t;
cin >> s >> t;
s--;
t--;
vvl data(3, vl(n, INF));
data[0][s] = 0;
using state = pair<ll, Pll>;
priority_queue<state, vector<state>, greater<state>> pq;
pq.emplace(0, Pll(0, s));
while (!pq.empty()) {
state t = pq.top();
pq.pop();
ll c = t.first;
ll dim = t.second.first, pos = t.second.second;
ll n_dim = (dim + 1) % 3;
if (data[dim][pos] < c)
continue;
for (auto &e : g[pos]) {
if (data[n_dim][e.t] <= c + 1)
continue;
data[n_dim][e.t] = c + 1;
pq.emplace(c + 1, Pll(n_dim, e.t));
}
}
print(data);
cout << (data[0][t] == INF ? -1 : data[0][t] / 3) << endl;
} | // #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i, x) for (ll i = 0; i < (ll)(x); i++)
#define rrep(i, x) for (ll i = (ll)(x)-1; 0 <= i; i--)
#define reps(i, x) for (ll i = 1; i < (ll)(x) + 1; i++)
#define rreps(i, x) for (ll i = (ll)(x); 1 <= i; i--)
#define debug(x) cerr << #x << ": " << (x) << "\n";
#define all(x) (x).begin(), (x).end()
typedef long long ll;
typedef long double ld;
typedef pair<int, int> P;
typedef pair<ll, ll> Pll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef vector<vector<vector<ll>>> vvvl;
const ll INF = numeric_limits<ll>::max() / 4;
const int n_max = 1e5 + 10;
#define int ll
void print() { cout << endl; }
// template <class Head, class... Tail>
// void print(Head&& head, Tail&&... tail) {
// cout << head;
// if (sizeof...(tail) != 0) cout << " ";
// print(forward<Tail>(tail)...);
// }
template <class T> void print(vector<T> &vec) {
for (auto &a : vec) {
cout << a;
if (&a != &vec.back())
cout << " ";
}
cout << endl;
}
template <class T> void print(vector<T> &vec, ll k) {
ll n = vec.size();
k = min(k, n);
rep(i, k - 1) cout << vec[i] << " ";
cout << vec[k - 1] << endl;
}
template <class T> void print(vector<vector<T>> &df) {
for (auto &vec : df) {
print(vec);
}
}
template <class T, class U> void print(pair<T, U> &p) {
cout << p.first << " " << p.second << "\n";
}
template <typename T> struct edge {
int f, t;
T c;
int id;
edge(){};
edge(int f, int t, T c, int id = 0) : f(f), t(t), c(c), id(id){};
bool operator<(const edge &rhs) const { return (*this).c < rhs.c; }
bool operator>(const edge &rhs) const { return (*this).c > rhs.c; }
};
template <typename T> struct graph {
std::vector<std::vector<edge<T>>> data;
graph(int v) : data(v){};
void add_edge(edge<T> &e) { data[e.f].push_back(e); }
void add_edge(int f, int t, T c) { data[f].emplace_back(f, t, c); }
size_t size() { return data.size(); }
vector<edge<T>> operator[](int n) { return data[n]; }
std::vector<edge<T>> make_edges() {
std::vector<edge<T>> r;
for (auto &i : data)
std::copy(i.begin(), i.end(), std::back_inserter(r));
return r;
}
};
signed main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
// ifstream in("killer_01.in");
// cin.rdbuf(in.rdbuf());
// ofstream ofstr("out.txt");
// streambuf* strbuf;
// strbuf = std::cout.rdbuf( ofstr.rdbuf() );
ll n, m;
cin >> n >> m;
graph<ll> g(n);
rep(i, m) {
ll f, t;
cin >> f >> t;
f--;
t--;
g.add_edge(f, t, 1);
}
ll s, t;
cin >> s >> t;
s--;
t--;
vvl data(3, vl(n, INF));
data[0][s] = 0;
using state = pair<ll, Pll>;
priority_queue<state, vector<state>, greater<state>> pq;
pq.emplace(0, Pll(0, s));
while (!pq.empty()) {
state t = pq.top();
pq.pop();
ll c = t.first;
ll dim = t.second.first, pos = t.second.second;
ll n_dim = (dim + 1) % 3;
if (data[dim][pos] < c)
continue;
for (auto &e : g[pos]) {
if (data[n_dim][e.t] <= c + 1)
continue;
data[n_dim][e.t] = c + 1;
pq.emplace(c + 1, Pll(n_dim, e.t));
}
}
// print(data);
cout << (data[0][t] == INF ? -1 : data[0][t] / 3) << endl;
} | [
"call.remove"
] | 799,162 | 799,163 | u899645116 | cpp |
p02991 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M, S, T;
cin >> N >> M;
vector<vector<int>> graph(N);
vector<long long int> len(3 * N, -1);
for (int i = 0; i < M; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
graph[u].push_back(v);
}
cin >> S >> T;
S--;
T--;
queue<int> Q;
Q.push(S);
len[3 * S] = 0;
while (!Q.empty()) {
int now = Q.front();
Q.pop();
for (int i = 0; i < graph[now / 3].size(); i++) {
if (len[3 * graph[now / 3][i] + (now % 3 + 1) % 3] == -1) {
len[3 * graph[now / 3][i] + (now % 3 + 1) % 3] = len[now] + 1;
Q.push(3 * graph[now / 3][i] + (now % 3 + 1) % 3);
}
}
}
if (len[3 * T] == -1) {
cout << -1 << endl;
} else {
cout << len[3 * T] / 3 << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M, S, T;
cin >> N >> M;
vector<vector<int>> graph(N);
vector<long long int> len(3 * N, -1);
for (int i = 0; i < M; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
graph[u].push_back(v);
}
cin >> S >> T;
S--;
T--;
queue<int> Q;
Q.push(3 * S);
len[3 * S] = 0;
while (!Q.empty()) {
int now = Q.front();
Q.pop();
for (int i = 0; i < graph[now / 3].size(); i++) {
if (len[3 * graph[now / 3][i] + (now % 3 + 1) % 3] == -1) {
len[3 * graph[now / 3][i] + (now % 3 + 1) % 3] = len[now] + 1;
Q.push(3 * graph[now / 3][i] + (now % 3 + 1) % 3);
}
}
}
if (len[3 * T] == -1) {
cout << -1 << endl;
} else {
cout << len[3 * T] / 3 << endl;
}
} | [
"expression.operation.binary.add"
] | 799,164 | 799,165 | u926416331 | cpp |
p02991 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M, S, T;
cin >> N >> M;
vector<vector<int>> graph(N);
vector<int> len(3 * N, -1);
for (int i = 0; i < M; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
graph[u].push_back(v);
}
cin >> S >> T;
S--;
T--;
queue<int> Q;
Q.push(S);
len[3 * S] = 0;
while (!Q.empty()) {
int now = Q.front();
Q.pop();
for (int i = 0; i < graph[now / 3].size(); i++) {
if (len[3 * graph[now / 3][i] + (now % 3 + 1) % 3] == -1) {
len[3 * graph[now / 3][i] + (now % 3 + 1) % 3] = len[now] + 1;
Q.push(3 * graph[now / 3][i] + (now % 3 + 1) % 3);
}
}
}
if (len[3 * T] == -1) {
cout << -1 << endl;
} else {
cout << len[3 * T] / 3 << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M, S, T;
cin >> N >> M;
vector<vector<int>> graph(N);
vector<long long int> len(3 * N, -1);
for (int i = 0; i < M; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
graph[u].push_back(v);
}
cin >> S >> T;
S--;
T--;
queue<int> Q;
Q.push(3 * S);
len[3 * S] = 0;
while (!Q.empty()) {
int now = Q.front();
Q.pop();
for (int i = 0; i < graph[now / 3].size(); i++) {
if (len[3 * graph[now / 3][i] + (now % 3 + 1) % 3] == -1) {
len[3 * graph[now / 3][i] + (now % 3 + 1) % 3] = len[now] + 1;
Q.push(3 * graph[now / 3][i] + (now % 3 + 1) % 3);
}
}
}
if (len[3 * T] == -1) {
cout << -1 << endl;
} else {
cout << len[3 * T] / 3 << endl;
}
} | [
"variable_declaration.type.widen.change",
"expression.operation.binary.add"
] | 799,166 | 799,165 | u926416331 | cpp |
p02991 | #include "bits/stdc++.h"
using namespace std;
const int N = 1e5 + 20;
int n, m, u, v, dp[N][3], source, dest;
queue<pair<int, int>> q;
bool vis[N][3];
vector<int> adj[N];
void add(int node, int mod, int dist) {
q.push({node, mod});
dp[node][mod] = dist;
vis[node][mod] = true;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
adj[u].push_back(v);
}
scanf("%d%d", &source, &dest);
add(source, 0, 0);
while (not q.empty()) {
auto p = q.front();
q.pop();
int node = p.first, mod = p.second;
for (auto child : adj[node])
if (not vis[child][(mod + 1) % 3])
add(child, (mod + 1) % 3, dp[node][mod] + (mod == 2 ? 0 : 1));
}
if (not vis[dest][0])
dp[dest][0] = -1;
printf("%d", dp[dest][0]);
} | #include "bits/stdc++.h"
using namespace std;
const int N = 1e5 + 20;
int n, m, u, v, dp[N][3], source, dest;
queue<pair<int, int>> q;
bool vis[N][3];
vector<int> adj[N];
void add(int node, int mod, int dist) {
q.push({node, mod});
dp[node][mod] = dist;
vis[node][mod] = true;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
adj[u].push_back(v);
}
scanf("%d%d", &source, &dest);
add(source, 0, 0);
while (not q.empty()) {
auto p = q.front();
q.pop();
int node = p.first, mod = p.second;
for (auto child : adj[node])
if (not vis[child][(mod + 1) % 3])
add(child, (mod + 1) % 3, dp[node][mod] + (mod != 2 ? 0 : 1));
}
if (not vis[dest][0])
dp[dest][0] = -1;
printf("%d", dp[dest][0]);
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 799,174 | 799,175 | u325959156 | cpp |
p02991 | #include "bits/stdc++.h"
using namespace std;
const int N = 1e5 + 20;
int n, m, u, v, dp[N][3], source, dest;
queue<pair<int, int>> q;
bool vis[N][3];
vector<int> adj[N];
void add(int node, int mod, int dist) {
q.push({node, mod});
dp[node][mod] = dist;
vis[node][mod] = true;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
adj[u].push_back(v);
}
scanf("%d%d", &source, &dest);
add(source, 0, 0);
while (not q.empty()) {
auto p = q.front();
q.pop();
int node = p.first, mod = p.second;
for (auto child : adj[node])
if (not vis[child][(mod + 1) % 3])
add(child, (mod + 1) % 3, dp[node][mod] + mod == 1 ? 0 : 1);
}
if (not vis[dest][0])
dp[dest][0] = -1;
printf("%d", dp[dest][0]);
} | #include "bits/stdc++.h"
using namespace std;
const int N = 1e5 + 20;
int n, m, u, v, dp[N][3], source, dest;
queue<pair<int, int>> q;
bool vis[N][3];
vector<int> adj[N];
void add(int node, int mod, int dist) {
q.push({node, mod});
dp[node][mod] = dist;
vis[node][mod] = true;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
adj[u].push_back(v);
}
scanf("%d%d", &source, &dest);
add(source, 0, 0);
while (not q.empty()) {
auto p = q.front();
q.pop();
int node = p.first, mod = p.second;
for (auto child : adj[node])
if (not vis[child][(mod + 1) % 3])
add(child, (mod + 1) % 3, dp[node][mod] + (mod != 2 ? 0 : 1));
}
if (not vis[dest][0])
dp[dest][0] = -1;
printf("%d", dp[dest][0]);
} | [
"control_flow.branch.if.condition.change"
] | 799,176 | 799,175 | u325959156 | cpp |
p02991 | #include "bits/stdc++.h"
using namespace std;
const int N = 1e5 + 20;
int n, m, u, v, dp[N][3], source, dest;
queue<pair<int, int>> q;
bool vis[N][3];
vector<int> adj[N];
void add(int node, int mod, int dist) {
q.push({node, mod});
dp[node][mod] = dist;
vis[node][mod] = true;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
adj[u].push_back(v);
}
scanf("%d%d", &source, &dest);
add(source, 0, 0);
while (not q.empty()) {
auto p = q.front();
q.pop();
int node = p.first, mod = p.second;
for (auto child : adj[node])
if (not vis[child][(mod + 1) % 3])
add(child, (mod + 1) % 3, dp[node][mod] + mod ? 0 : 1);
}
if (not vis[dest][0])
dp[dest][0] = -1;
printf("%d", dp[dest][0]);
} | #include "bits/stdc++.h"
using namespace std;
const int N = 1e5 + 20;
int n, m, u, v, dp[N][3], source, dest;
queue<pair<int, int>> q;
bool vis[N][3];
vector<int> adj[N];
void add(int node, int mod, int dist) {
q.push({node, mod});
dp[node][mod] = dist;
vis[node][mod] = true;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
adj[u].push_back(v);
}
scanf("%d%d", &source, &dest);
add(source, 0, 0);
while (not q.empty()) {
auto p = q.front();
q.pop();
int node = p.first, mod = p.second;
for (auto child : adj[node])
if (not vis[child][(mod + 1) % 3])
add(child, (mod + 1) % 3, dp[node][mod] + (mod != 2 ? 0 : 1));
}
if (not vis[dest][0])
dp[dest][0] = -1;
printf("%d", dp[dest][0]);
} | [
"control_flow.branch.if.condition.change"
] | 799,177 | 799,175 | u325959156 | cpp |
p02991 | #include <iostream>
#include <math.h>
#include <queue>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> cnt(n, 0);
vector<vector<int>> g0(n);
// vector<vector<int> > g1(n);
// vector<vector<int> > g2(n);
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
g0[v].push_back(v);
}
int dist[n][3];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
dist[i][j] = 1e9;
}
}
queue<pair<int, int>> Q;
int s, t;
cin >> s >> t;
s--, t--;
Q.push({s, 0});
dist[s][0] = 0;
while (!Q.empty()) {
int a = Q.front().first;
int b = Q.front().second;
Q.pop();
for (int i = 0; i < g0[a].size(); i++) {
if (dist[g0[a][i]][(b + 1) % 3] == 1e9)
Q.push({g0[a][i], (b + 1) % 3});
else
continue;
dist[g0[a][i]][(b + 1) % 3] = dist[a][b] + 1;
}
}
if (dist[t][0] == 1e9)
cout << -1 << endl;
else
cout << dist[t][0] / 3 << endl;
} | #include <iostream>
#include <math.h>
#include <queue>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> cnt(n, 0);
vector<vector<int>> g0(n);
// vector<vector<int> > g1(n);
// vector<vector<int> > g2(n);
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
g0[u].push_back(v);
}
int dist[n][3];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
dist[i][j] = 1e9;
}
}
queue<pair<int, int>> Q;
int s, t;
cin >> s >> t;
s--, t--;
Q.push({s, 0});
dist[s][0] = 0;
while (!Q.empty()) {
int a = Q.front().first;
int b = Q.front().second;
Q.pop();
for (int i = 0; i < g0[a].size(); i++) {
if (dist[g0[a][i]][(b + 1) % 3] == 1e9)
Q.push({g0[a][i], (b + 1) % 3});
else
continue;
dist[g0[a][i]][(b + 1) % 3] = dist[a][b] + 1;
}
}
if (dist[t][0] == 1e9)
cout << -1 << endl;
else
cout << dist[t][0] / 3 << endl;
} | [
"identifier.change",
"variable_access.subscript.index.change"
] | 799,182 | 799,183 | u303059352 | cpp |
p02991 | #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
#define MAX 100000
#define INF -1
int n;
vector<ll> g[3 * MAX];
ll d[3 * MAX];
void bfs(int s) {
queue<int> q;
fill(d, d + 3 * MAX, INF);
q.push(s);
d[s] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < g[u].size(); i++) {
if (d[g[u][i]] == INF) {
q.push(g[u][i]);
d[g[u][i]] = d[u] + 1;
}
}
}
return;
}
int main() {
int m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
for (int j = 0; j < 3; j++) {
g[j * MAX + u].push_back(((j + 1) % 3) * MAX + v);
}
}
int s, t;
cin >> s >> t;
s--;
t--;
bfs(0);
if (d[t] != INF && d[t] % 3 == 0)
cout << d[t] / 3 << endl;
else
cout << -1 << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
#define MAX 100000
#define INF -1
int n;
vector<int> g[4 * MAX];
int d[4 * MAX];
void bfs(int s) {
queue<int> q;
fill(d, d + 4 * MAX, INF);
q.push(s);
d[s] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < g[u].size(); i++) {
if (d[g[u][i]] == INF) {
q.push(g[u][i]);
d[g[u][i]] = d[u] + 1;
}
}
}
return;
}
int main() {
int m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
for (int j = 0; j < 3; j++) {
g[j * MAX + u].push_back(((j + 1) % 3) * MAX + v);
}
}
int s, t;
cin >> s >> t;
s--;
t--;
bfs(s);
if (d[t] != INF && d[t] % 3 == 0)
cout << d[t] / 3 << endl;
else
cout << -1 << endl;
return 0;
} | [
"literal.number.change",
"expression.operation.binary.change",
"variable_declaration.type.change",
"call.arguments.change",
"identifier.replace.add",
"literal.replace.remove"
] | 799,184 | 799,185 | u348670055 | cpp |
p02991 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < n; i++)
typedef long long ll;
typedef long long unsigned int llu;
ll MOD = 1000000007;
ll INF = 1000000009;
/*
sからtへの3の倍数の経路のうち最小のものを出力する
1 -> 2 を
1 -> 5
2 -> 6
3 -> 4
深さ優先探索
進められる辺がなくなるまで、以下を繰り返す
1.
スタート地点から伸びる辺を選択し、sを訪問済みにセットして、辺の先の頂点をスタックに追加
2.
以後、スタックの上にある頂点が未到達なら到達済みに変更した上で辺の先の頂点をスタックに追加
なお、未到達の管理は配列に整数値を格納することで行う.
デフォルトでは-1、到達したら最短距離を格納
*/
void solve() {
ll n, m;
cin >> n >> m;
vector<ll> g[n * 3 + 10];
rep(i, m) {
ll a, b;
cin >> a >> b;
g[3 * a - 2].emplace_back(3 * b - 1);
g[3 * a - 1].emplace_back(3 * b);
g[3 * a].emplace_back(3 * b - 2);
}
ll s, t;
cin >> s >> t;
ll visited[3 * n + 10];
rep(i, 3 * n + 1) { visited[i] = -1; }
stack<ll> st;
st.push(s * 3 - 2);
visited[s * 3 - 2] = 0;
while (!st.empty()) {
ll tmp = st.top();
st.pop();
for (auto i : g[tmp]) {
if (visited[i] == -1) {
visited[i] = visited[tmp] + 1;
st.push(i);
}
}
}
if (visited[t * 3 - 2] != -1)
cout << visited[t * 3 - 2] / 3 << endl;
else
cout << -1 << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < n; i++)
typedef long long ll;
typedef long long unsigned int llu;
ll MOD = 1000000007;
ll INF = 1000000009;
/*
sからtへの3の倍数の経路のうち最小のものを出力する
1 -> 2 を
1 -> 5
2 -> 6
3 -> 4
深さ優先探索
進められる辺がなくなるまで、以下を繰り返す
1.
スタート地点から伸びる辺を選択し、sを訪問済みにセットして、辺の先の頂点をスタックに追加
2.
以後、スタックの上にある頂点が未到達なら到達済みに変更した上で辺の先の頂点をスタックに追加
なお、未到達の管理は配列に整数値を格納することで行う.
デフォルトでは-1、到達したら最短距離を格納
*/
void solve() {
ll n, m;
cin >> n >> m;
vector<ll> g[n * 3 + 10];
rep(i, m) {
ll a, b;
cin >> a >> b;
g[3 * a - 2].emplace_back(3 * b - 1);
g[3 * a - 1].emplace_back(3 * b);
g[3 * a].emplace_back(3 * b - 2);
}
ll s, t;
cin >> s >> t;
ll visited[3 * n + 10];
rep(i, 3 * n + 1) { visited[i] = -1; }
/*
stack<ll> st;
st.push(s*3-2);
visited[s*3-2]=0;
while(!st.empty()){
ll tmp = st.top();
st.pop();
for(auto i:g[tmp]){
if(visited[i]==-1){
visited[i]=visited[tmp]+1;
st.push(i);
}
}
}
*/
queue<ll> st;
st.push(s * 3 - 2);
visited[s * 3 - 2] = 0;
while (!st.empty()) {
ll tmp = st.front();
st.pop();
for (auto i : g[tmp]) {
if (visited[i] == -1) {
visited[i] = visited[tmp] + 1;
st.push(i);
}
}
}
if (visited[t * 3 - 2] != -1)
cout << visited[t * 3 - 2] / 3 << endl;
else
cout << -1 << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
} | [
"variable_declaration.type.change",
"call.function.change"
] | 799,186 | 799,187 | u272496669 | cpp |
p02991 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
const int INF = 1 << 29;
int main() {
int n, m;
scanf("%d%d", &n, &m);
vector<int> G[100000];
rep(i, m) {
int u, v;
scanf("%d%d", &u, &v);
u--;
v--;
G[u].emplace_back(v);
}
int s, t;
scanf("%d%d", &s, &t);
s--;
t--;
int d[100000][3];
rep(u, n) rep(k, 3) d[u][k] = INF;
d[s][0] = 0;
queue<pair<int, int>> Q;
Q.emplace(s, 0);
while (!Q.empty()) {
auto a = Q.front();
Q.pop();
int u = a.first, k = a.second;
if (u == t && k == 0) {
printf("%d\n", d[u][k] / 3);
return 0;
}
for (int v : G[u])
if (d[v][(k + 1) % 3] < INF) {
d[v][(k + 1) % 3] = d[u][k] + 1;
Q.emplace(v, (k + 1) % 3);
}
}
puts("-1");
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
const int INF = 1 << 29;
int main() {
int n, m;
scanf("%d%d", &n, &m);
vector<int> G[100000];
rep(i, m) {
int u, v;
scanf("%d%d", &u, &v);
u--;
v--;
G[u].emplace_back(v);
}
int s, t;
scanf("%d%d", &s, &t);
s--;
t--;
int d[100000][3];
rep(u, n) rep(k, 3) d[u][k] = INF;
d[s][0] = 0;
queue<pair<int, int>> Q;
Q.emplace(s, 0);
while (!Q.empty()) {
auto a = Q.front();
Q.pop();
int u = a.first, k = a.second;
if (u == t && k == 0) {
printf("%d\n", d[u][k] / 3);
return 0;
}
for (int v : G[u])
if (d[v][(k + 1) % 3] == INF) {
d[v][(k + 1) % 3] = d[u][k] + 1;
Q.emplace(v, (k + 1) % 3);
}
}
puts("-1");
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 799,188 | 799,189 | u781095600 | cpp |
p02991 | #include <bits/stdc++.h>
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define rep(i, s, N) for (ll i{s}; i < (N); i++)
#define rem(i, N, s) for (ll i{N}; i > (s); i--)
#define debug(x) cerr << #x << ": " << x << '\n'
#define debugv(v) \
cerr << #v << ": "; \
for (auto &&i : v) \
cerr << i << " "; \
cerr << '\n'
const int MOD = (int)1e9 + 7;
const long double pi = 3.141592653589793238462643383279L;
using namespace std;
using ll = long long;
using ld = long double;
using str = string;
using wstr = wstring;
const string rt = "\n", sp = " ";
const wstring wrt = L"\n", wsp = L" ";
/* GCD */
template <typename M, typename N> constexpr common_type_t<M, N> gcd(M a, N b) {
return b != 0 ? gcd(b, a % b) : a;
}
/* LCM */
template <typename M, typename N> constexpr common_type_t<M, N> lcm(M a, N b) {
return a * b / gcd(a, b);
}
/* UNIONFIND */
template <typename T> struct UnionFind {
vector<T> par;
UnionFind(T n) : par(n, -1) {}
void init(T n) { par.assign(n, -1); }
T root(T x) {
if (par[x] < 0)
return x;
else
return par[x] = root(par[x]);
}
bool issame(T x, T y) { return root(x) == root(y); }
bool merge(T x, T y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (par[x] > par[y])
swap(x, y);
par[x] += par[y];
par[y] = x;
return true;
}
int size(int x) { return -par[root(x)]; }
};
/* COMB */
auto comb(ll N) {
vector<vector<ll>> v(N + 1, vector<ll>(N + 1));
for (int i = 0; i < v.size(); i++) {
v[i][0] = 1;
v[i][i] = 1;
}
for (int k = 1; k < v.size(); k++) {
for (int j = 1; j < k; j++) {
v[k][j] = (v[k - 1][j - 1] + v[k - 1][j]);
}
}
return v;
}
auto comb(ll N, ll n) {
vector<vector<ll>> v(max(N + 1, n + 1), vector<ll>(max(N + 1, n + 1)));
for (int i = 0; i < v.size(); i++) {
v[i][0] = 1;
v[i][i] = 1;
}
for (int k = 1; k < v.size(); k++) {
for (int j = 1; j < k; j++) {
v[k][j] = (v[k - 1][j - 1] + v[k - 1][j]);
}
}
return v[N][n];
}
/* COMB % MOD */
template <typename T> ll combpm(T N_, T C_) {
const int NUM_ = 400001;
static ll fact[NUM_ + 1], factr[NUM_ + 1], inv[NUM_ + 1];
if (fact[0] == 0) {
inv[1] = fact[0] = factr[0] = 1;
for (int i = 2; i <= NUM_; ++i)
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
for (int i = 1; i <= NUM_; ++i)
fact[i] = fact[i - 1] * i % MOD, factr[i] = factr[i - 1] * inv[i] % MOD;
}
if (C_ < 0 || C_ > N_)
return 0;
return factr[C_] * fact[N_] % MOD * factr[N_ - C_] % MOD;
}
/* MAKE VECTOR */
template <class T> constexpr vector<T> mvec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto mvec(size_t a, Ts... ts) {
return vector<decltype(mvec<T>(ts...))>(a, mvec<T>(ts...));
}
/* MAKE DEQUE */
template <class T> constexpr deque<T> mdeq(size_t a) { return deque<T>(a); }
template <class T, class... Ts> auto mdeq(size_t a, Ts... ts) {
return deque<decltype(mdeq<T>(ts...))>(a, mdeq<T>(ts...));
}
/* TEST */
void test(ll n) { cout << "test" << n << endl; }
/* PRECISION */
void fixsp(ll n) { cout << fixed << setprecision(n); }
void defsp(ll n) { cout << defaultfloat << setprecision(n); }
/* WEIGHTENED UNIONFIND */
struct WUnionFind {
vector<int> par;
vector<int> rank;
WUnionFind(int n = 1) { init(n); }
void init(int n = 1) {
par.resize(n);
rank.resize(n);
for (int i = 0; i < n; ++i)
par[i] = i, rank[i] = 0;
}
int root(int x) {
if (par[x] == x) {
return x;
} else {
int r = root(par[x]);
return par[x] = r;
}
}
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 (rank[x] < rank[y])
swap(x, y);
if (rank[x] == rank[y])
++rank[x];
par[y] = x;
return true;
}
};
/* DIVISOR */
deque<ll> divisor(ll n) {
deque<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);
}
/* MODE */
template <typename T> auto mode(T data) {
if (data.size() == 1)
return *begin(data);
sort(begin(data), end(data));
typename decltype(data)::value_type mode{};
size_t n{}, count{1};
for (auto iter = adjacent_find(begin(data), end(data)), last = end(data),
next = end(data);
iter != last;) {
next = upper_bound(iter, last, *iter);
count = distance(iter, next);
if (n < count)
n = count, mode = *iter;
iter = adjacent_find(next, last);
}
return mode;
}
/* MEDIAN */
template <typename T> auto median(T data) {
sort(begin(data), end(data));
size_t median_index = data.size() / 2;
return (
data.size() % 2 == 0
? static_cast<double>(data[median_index] + data[median_index - 1]) / 2
: data[median_index]);
}
/* INT POW */
template <typename T> T multi(T a, ll b) {
T ans{1};
for (int i{}; i < b; i++)
ans *= a;
return ans;
}
/* INF */
template <typename T> constexpr T inf() { return numeric_limits<T>::max(); }
/* FASTER IO */
void fastio(ll a) {
ios::sync_with_stdio(false);
cin.tie(NULL);
if (a)
fixsp(a);
}
/* MIN COST FLOW */
template <typename flow_t, typename cost_t> struct PrimalDual {
const cost_t INF;
struct edge {
int to;
flow_t cap;
cost_t cost;
int rev;
bool isrev;
};
vector<vector<edge>> graph;
vector<cost_t> potential, min_cost;
vector<int> prevv, preve;
PrimalDual(int V) : graph(V), INF(numeric_limits<cost_t>::max()) {}
void add_edge(int from, int to, flow_t cap, cost_t cost) {
graph[from].emplace_back(
(edge){to, cap, cost, (int)graph[to].size(), false});
graph[to].emplace_back(
(edge){from, 0, -cost, (int)graph[from].size() - 1, true});
}
cost_t min_cost_flow(int s, int t, flow_t f) {
int V = (int)graph.size();
cost_t ret = 0;
using Pi = pair<cost_t, int>;
priority_queue<Pi, vector<Pi>, greater<Pi>> que;
potential.assign(V, 0);
preve.assign(V, -1);
prevv.assign(V, -1);
while (f > 0) {
min_cost.assign(V, INF);
que.emplace(0, s);
min_cost[s] = 0;
while (!que.empty()) {
Pi p = que.top();
que.pop();
if (min_cost[p.second] < p.first)
continue;
for (int i = 0; i < graph[p.second].size(); i++) {
edge &e = graph[p.second][i];
cost_t nextCost = min_cost[p.second] + e.cost + potential[p.second] -
potential[e.to];
if (e.cap > 0 && min_cost[e.to] > nextCost) {
min_cost[e.to] = nextCost;
prevv[e.to] = p.second, preve[e.to] = i;
que.emplace(min_cost[e.to], e.to);
}
}
}
if (min_cost[t] == INF)
return -1;
for (int v = 0; v < V; v++)
potential[v] += min_cost[v];
flow_t addflow = f;
for (int v = t; v != s; v = prevv[v]) {
addflow = min(addflow, graph[prevv[v]][preve[v]].cap);
}
f -= addflow;
ret += addflow * potential[t];
for (int v = t; v != s; v = prevv[v]) {
edge &e = graph[prevv[v]][preve[v]];
e.cap -= addflow;
graph[v][e.rev].cap += addflow;
}
}
return ret;
}
void output() {
for (int i = 0; i < graph.size(); i++) {
for (auto &e : graph[i]) {
if (e.isrev)
continue;
auto &rev_e = graph[e.to][e.rev];
cout << i << "->" << e.to << " (flow: " << rev_e.cap << "/"
<< rev_e.cap + e.cap << ")" << endl;
}
}
}
};
/* BELLMANFORD */
template <typename T> struct edge {
int from, to;
T cost;
edge(int to, T cost) : from(-1), to(to), cost(cost) {}
edge(int from, int to, T cost) : from(from), to(to), cost(cost) {}
explicit operator int() const { return to; }
};
template <typename T> vector<T> BellmanFord(int s, int V, vector<edge<T>> &G) {
vector<T> d(V, inf<T>());
vector<bool> neg(V);
d[s] = 0;
for (int i = 0; i < V - 1; ++i) {
for (auto &&e : G) {
if (d[e.from] == inf<T>())
continue;
d[e.to] = min(d[e.to], d[e.from] + e.cost);
}
}
for (int i = 0; i < V; ++i) {
for (auto &&e : G) {
if (d[e.from] == inf<T>())
continue;
if (d[e.to] > d[e.from] + e.cost) {
d[e.to] = d[e.from] + e.cost;
neg[e.to] = 1;
}
if (neg[e.from])
neg[e.to] = 1;
}
}
for (int i = 0; i < V; i++) {
if (neg[i])
d[i] = -inf<ll>();
}
return d;
}
/* DIJKSTRA */
vector<ll> Dijkstra(int s, int V, vector<tuple<ll, ll, ll>> &G) {
// uv [from] = (to, length)
vector<vector<pair<ll, ll>>> uv(V);
for (auto &&i : G)
uv[get<0>(i)].emplace_back(get<1>(i), get<2>(i));
vector<ll> d(V, inf<ll>() / 2);
vector<ll> prev(V, -1);
d[s] = 0;
priority_queue<pair<ll, ll>, vector<pair<ll, ll>>, greater<pair<ll, ll>>> Q;
rep(i, 0, V) Q.emplace(d[i], i);
while (!Q.empty()) {
ll u = Q.top().second;
Q.pop();
for (auto &&v : uv[u]) {
ll alt = d[u] + v.second;
if (d[v.first] > alt) {
d[v.first] = alt;
if (d[v.first] > inf<ll>() / 4)
d[v.first] = inf<ll>() / 2;
else if (d[v.first] < -inf<ll>() / 4)
d[v.first] = -inf<ll>() / 2;
prev[v.first] = u;
Q.emplace(alt, v.first);
}
}
// debugv(d);
}
for (auto &&i : d) {
if (abs(i) > inf<ll>() / 4)
(i *= 2)++;
}
return d;
}
/* BFS */
vector<ll> BFS(ll s, ll V, vector<pair<ll, ll>> &G) {
stack<ll> Q;
vector<vector<ll>> uv(V);
for (auto &&i : G)
uv[i.first].emplace_back(i.second);
vector<ll> dist(V, inf<ll>());
dist[s] = 0;
Q.emplace(s);
while (!Q.empty()) {
ll v = Q.top();
Q.pop();
for (auto &&i : uv[v]) {
if (dist[i] == inf<ll>()) {
dist[i] = dist[v] + 1;
Q.emplace(i);
}
}
}
return dist;
}
/* NUITA.INC & KYOTO UNIVERSITY */
/* LAST EDITED ON 8.18.2019 */
/* CODE STARTS FROM HERE */
int main() {
fastio(0);
ll N, M;
cin >> N >> M;
vector<pair<ll, ll>> utov;
rep(i, 0, M) {
ll u, v;
cin >> u >> v;
u--;
v--;
utov.emplace_back(u * 3, v * 3 + 1);
utov.emplace_back(u * 3 + 1, v * 3 + 2);
utov.emplace_back(u * 3 + 2, v * 3);
}
ll S, T;
cin >> S >> T;
S--;
T--;
auto ans = BFS(3 * S, 3 * N, utov);
if (abs(ans[3 * T]) == inf<ll>())
ans[3 * T] = -3;
cout << ans[3 * T] / 3;
} | #include <bits/stdc++.h>
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define rep(i, s, N) for (ll i{s}; i < (N); i++)
#define rem(i, N, s) for (ll i{N}; i > (s); i--)
#define debug(x) cerr << #x << ": " << x << '\n'
#define debugv(v) \
cerr << #v << ": "; \
for (auto &&i : v) \
cerr << i << " "; \
cerr << '\n'
const int MOD = (int)1e9 + 7;
const long double pi = 3.141592653589793238462643383279L;
using namespace std;
using ll = long long;
using ld = long double;
using str = string;
using wstr = wstring;
const string rt = "\n", sp = " ";
const wstring wrt = L"\n", wsp = L" ";
/* GCD */
template <typename M, typename N> constexpr common_type_t<M, N> gcd(M a, N b) {
return b != 0 ? gcd(b, a % b) : a;
}
/* LCM */
template <typename M, typename N> constexpr common_type_t<M, N> lcm(M a, N b) {
return a * b / gcd(a, b);
}
/* UNIONFIND */
template <typename T> struct UnionFind {
vector<T> par;
UnionFind(T n) : par(n, -1) {}
void init(T n) { par.assign(n, -1); }
T root(T x) {
if (par[x] < 0)
return x;
else
return par[x] = root(par[x]);
}
bool issame(T x, T y) { return root(x) == root(y); }
bool merge(T x, T y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (par[x] > par[y])
swap(x, y);
par[x] += par[y];
par[y] = x;
return true;
}
int size(int x) { return -par[root(x)]; }
};
/* COMB */
auto comb(ll N) {
vector<vector<ll>> v(N + 1, vector<ll>(N + 1));
for (int i = 0; i < v.size(); i++) {
v[i][0] = 1;
v[i][i] = 1;
}
for (int k = 1; k < v.size(); k++) {
for (int j = 1; j < k; j++) {
v[k][j] = (v[k - 1][j - 1] + v[k - 1][j]);
}
}
return v;
}
auto comb(ll N, ll n) {
vector<vector<ll>> v(max(N + 1, n + 1), vector<ll>(max(N + 1, n + 1)));
for (int i = 0; i < v.size(); i++) {
v[i][0] = 1;
v[i][i] = 1;
}
for (int k = 1; k < v.size(); k++) {
for (int j = 1; j < k; j++) {
v[k][j] = (v[k - 1][j - 1] + v[k - 1][j]);
}
}
return v[N][n];
}
/* COMB % MOD */
template <typename T> ll combpm(T N_, T C_) {
const int NUM_ = 400001;
static ll fact[NUM_ + 1], factr[NUM_ + 1], inv[NUM_ + 1];
if (fact[0] == 0) {
inv[1] = fact[0] = factr[0] = 1;
for (int i = 2; i <= NUM_; ++i)
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
for (int i = 1; i <= NUM_; ++i)
fact[i] = fact[i - 1] * i % MOD, factr[i] = factr[i - 1] * inv[i] % MOD;
}
if (C_ < 0 || C_ > N_)
return 0;
return factr[C_] * fact[N_] % MOD * factr[N_ - C_] % MOD;
}
/* MAKE VECTOR */
template <class T> constexpr vector<T> mvec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto mvec(size_t a, Ts... ts) {
return vector<decltype(mvec<T>(ts...))>(a, mvec<T>(ts...));
}
/* MAKE DEQUE */
template <class T> constexpr deque<T> mdeq(size_t a) { return deque<T>(a); }
template <class T, class... Ts> auto mdeq(size_t a, Ts... ts) {
return deque<decltype(mdeq<T>(ts...))>(a, mdeq<T>(ts...));
}
/* TEST */
void test(ll n) { cout << "test" << n << endl; }
/* PRECISION */
void fixsp(ll n) { cout << fixed << setprecision(n); }
void defsp(ll n) { cout << defaultfloat << setprecision(n); }
/* WEIGHTENED UNIONFIND */
struct WUnionFind {
vector<int> par;
vector<int> rank;
WUnionFind(int n = 1) { init(n); }
void init(int n = 1) {
par.resize(n);
rank.resize(n);
for (int i = 0; i < n; ++i)
par[i] = i, rank[i] = 0;
}
int root(int x) {
if (par[x] == x) {
return x;
} else {
int r = root(par[x]);
return par[x] = r;
}
}
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 (rank[x] < rank[y])
swap(x, y);
if (rank[x] == rank[y])
++rank[x];
par[y] = x;
return true;
}
};
/* DIVISOR */
deque<ll> divisor(ll n) {
deque<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);
}
/* MODE */
template <typename T> auto mode(T data) {
if (data.size() == 1)
return *begin(data);
sort(begin(data), end(data));
typename decltype(data)::value_type mode{};
size_t n{}, count{1};
for (auto iter = adjacent_find(begin(data), end(data)), last = end(data),
next = end(data);
iter != last;) {
next = upper_bound(iter, last, *iter);
count = distance(iter, next);
if (n < count)
n = count, mode = *iter;
iter = adjacent_find(next, last);
}
return mode;
}
/* MEDIAN */
template <typename T> auto median(T data) {
sort(begin(data), end(data));
size_t median_index = data.size() / 2;
return (
data.size() % 2 == 0
? static_cast<double>(data[median_index] + data[median_index - 1]) / 2
: data[median_index]);
}
/* INT POW */
template <typename T> T multi(T a, ll b) {
T ans{1};
for (int i{}; i < b; i++)
ans *= a;
return ans;
}
/* INF */
template <typename T> constexpr T inf() { return numeric_limits<T>::max(); }
/* FASTER IO */
void fastio(ll a) {
ios::sync_with_stdio(false);
cin.tie(NULL);
if (a)
fixsp(a);
}
/* MIN COST FLOW */
template <typename flow_t, typename cost_t> struct PrimalDual {
const cost_t INF;
struct edge {
int to;
flow_t cap;
cost_t cost;
int rev;
bool isrev;
};
vector<vector<edge>> graph;
vector<cost_t> potential, min_cost;
vector<int> prevv, preve;
PrimalDual(int V) : graph(V), INF(numeric_limits<cost_t>::max()) {}
void add_edge(int from, int to, flow_t cap, cost_t cost) {
graph[from].emplace_back(
(edge){to, cap, cost, (int)graph[to].size(), false});
graph[to].emplace_back(
(edge){from, 0, -cost, (int)graph[from].size() - 1, true});
}
cost_t min_cost_flow(int s, int t, flow_t f) {
int V = (int)graph.size();
cost_t ret = 0;
using Pi = pair<cost_t, int>;
priority_queue<Pi, vector<Pi>, greater<Pi>> que;
potential.assign(V, 0);
preve.assign(V, -1);
prevv.assign(V, -1);
while (f > 0) {
min_cost.assign(V, INF);
que.emplace(0, s);
min_cost[s] = 0;
while (!que.empty()) {
Pi p = que.top();
que.pop();
if (min_cost[p.second] < p.first)
continue;
for (int i = 0; i < graph[p.second].size(); i++) {
edge &e = graph[p.second][i];
cost_t nextCost = min_cost[p.second] + e.cost + potential[p.second] -
potential[e.to];
if (e.cap > 0 && min_cost[e.to] > nextCost) {
min_cost[e.to] = nextCost;
prevv[e.to] = p.second, preve[e.to] = i;
que.emplace(min_cost[e.to], e.to);
}
}
}
if (min_cost[t] == INF)
return -1;
for (int v = 0; v < V; v++)
potential[v] += min_cost[v];
flow_t addflow = f;
for (int v = t; v != s; v = prevv[v]) {
addflow = min(addflow, graph[prevv[v]][preve[v]].cap);
}
f -= addflow;
ret += addflow * potential[t];
for (int v = t; v != s; v = prevv[v]) {
edge &e = graph[prevv[v]][preve[v]];
e.cap -= addflow;
graph[v][e.rev].cap += addflow;
}
}
return ret;
}
void output() {
for (int i = 0; i < graph.size(); i++) {
for (auto &e : graph[i]) {
if (e.isrev)
continue;
auto &rev_e = graph[e.to][e.rev];
cout << i << "->" << e.to << " (flow: " << rev_e.cap << "/"
<< rev_e.cap + e.cap << ")" << endl;
}
}
}
};
/* BELLMANFORD */
template <typename T> struct edge {
int from, to;
T cost;
edge(int to, T cost) : from(-1), to(to), cost(cost) {}
edge(int from, int to, T cost) : from(from), to(to), cost(cost) {}
explicit operator int() const { return to; }
};
template <typename T> vector<T> BellmanFord(int s, int V, vector<edge<T>> &G) {
vector<T> d(V, inf<T>());
vector<bool> neg(V);
d[s] = 0;
for (int i = 0; i < V - 1; ++i) {
for (auto &&e : G) {
if (d[e.from] == inf<T>())
continue;
d[e.to] = min(d[e.to], d[e.from] + e.cost);
}
}
for (int i = 0; i < V; ++i) {
for (auto &&e : G) {
if (d[e.from] == inf<T>())
continue;
if (d[e.to] > d[e.from] + e.cost) {
d[e.to] = d[e.from] + e.cost;
neg[e.to] = 1;
}
if (neg[e.from])
neg[e.to] = 1;
}
}
for (int i = 0; i < V; i++) {
if (neg[i])
d[i] = -inf<ll>();
}
return d;
}
/* DIJKSTRA */
vector<ll> Dijkstra(int s, int V, vector<tuple<ll, ll, ll>> &G) {
// uv [from] = (to, length)
vector<vector<pair<ll, ll>>> uv(V);
for (auto &&i : G)
uv[get<0>(i)].emplace_back(get<1>(i), get<2>(i));
vector<ll> d(V, inf<ll>() / 2);
vector<ll> prev(V, -1);
d[s] = 0;
priority_queue<pair<ll, ll>, vector<pair<ll, ll>>, greater<pair<ll, ll>>> Q;
rep(i, 0, V) Q.emplace(d[i], i);
while (!Q.empty()) {
ll u = Q.top().second;
Q.pop();
for (auto &&v : uv[u]) {
ll alt = d[u] + v.second;
if (d[v.first] > alt) {
d[v.first] = alt;
if (d[v.first] > inf<ll>() / 4)
d[v.first] = inf<ll>() / 2;
else if (d[v.first] < -inf<ll>() / 4)
d[v.first] = -inf<ll>() / 2;
prev[v.first] = u;
Q.emplace(alt, v.first);
}
}
// debugv(d);
}
for (auto &&i : d) {
if (abs(i) > inf<ll>() / 4)
(i *= 2)++;
}
return d;
}
/* BFS */
vector<ll> BFS(ll s, ll V, vector<pair<ll, ll>> &G) {
queue<ll> Q;
vector<vector<ll>> uv(V);
for (auto &&i : G)
uv[i.first].emplace_back(i.second);
vector<ll> dist(V, inf<ll>());
dist[s] = 0;
Q.emplace(s);
while (!Q.empty()) {
ll v = Q.front();
Q.pop();
for (auto &&i : uv[v]) {
if (dist[i] == inf<ll>()) {
dist[i] = dist[v] + 1;
Q.emplace(i);
}
}
}
return dist;
}
/* NUITA.INC & KYOTO UNIVERSITY */
/* LAST EDITED ON 8.18.2019 */
/* CODE STARTS FROM HERE */
int main() {
fastio(0);
ll N, M;
cin >> N >> M;
vector<pair<ll, ll>> utov;
rep(i, 0, M) {
ll u, v;
cin >> u >> v;
u--;
v--;
utov.emplace_back(u * 3, v * 3 + 1);
utov.emplace_back(u * 3 + 1, v * 3 + 2);
utov.emplace_back(u * 3 + 2, v * 3);
}
ll S, T;
cin >> S >> T;
S--;
T--;
vector<ll> ans = BFS(3 * S, 3 * N, utov);
if (abs(ans[3 * T]) == inf<ll>())
ans[3 * T] = -3;
cout << ans[3 * T] / 3;
} | [
"variable_declaration.type.change",
"call.function.change"
] | 799,212 | 799,213 | u936790121 | cpp |
p02991 | #include <bits/stdc++.h>
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define rep(i, s, N) for (ll i{s}; i < (N); i++)
#define rem(i, N, s) for (ll i{N}; i > (s); i--)
#define debug(x) cerr << #x << ": " << x << '\n'
#define debugv(v) \
cerr << #v << ": "; \
for (auto &&i : v) \
cerr << i << " "; \
cerr << '\n'
const int MOD = (int)1e9 + 7;
const long double pi = 3.141592653589793238462643383279L;
using namespace std;
using ll = long long;
using ld = long double;
using str = string;
using wstr = wstring;
const string rt = "\n", sp = " ";
const wstring wrt = L"\n", wsp = L" ";
/* GCD */
template <typename M, typename N> constexpr common_type_t<M, N> gcd(M a, N b) {
return b != 0 ? gcd(b, a % b) : a;
}
/* LCM */
template <typename M, typename N> constexpr common_type_t<M, N> lcm(M a, N b) {
return a * b / gcd(a, b);
}
/* UNIONFIND */
template <typename T> struct UnionFind {
vector<T> par;
UnionFind(T n) : par(n, -1) {}
void init(T n) { par.assign(n, -1); }
T root(T x) {
if (par[x] < 0)
return x;
else
return par[x] = root(par[x]);
}
bool issame(T x, T y) { return root(x) == root(y); }
bool merge(T x, T y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (par[x] > par[y])
swap(x, y);
par[x] += par[y];
par[y] = x;
return true;
}
int size(int x) { return -par[root(x)]; }
};
/* COMB */
auto comb(ll N) {
vector<vector<ll>> v(N + 1, vector<ll>(N + 1));
for (int i = 0; i < v.size(); i++) {
v[i][0] = 1;
v[i][i] = 1;
}
for (int k = 1; k < v.size(); k++) {
for (int j = 1; j < k; j++) {
v[k][j] = (v[k - 1][j - 1] + v[k - 1][j]);
}
}
return v;
}
auto comb(ll N, ll n) {
vector<vector<ll>> v(max(N + 1, n + 1), vector<ll>(max(N + 1, n + 1)));
for (int i = 0; i < v.size(); i++) {
v[i][0] = 1;
v[i][i] = 1;
}
for (int k = 1; k < v.size(); k++) {
for (int j = 1; j < k; j++) {
v[k][j] = (v[k - 1][j - 1] + v[k - 1][j]);
}
}
return v[N][n];
}
/* COMB % MOD */
template <typename T> ll combpm(T N_, T C_) {
const int NUM_ = 400001;
static ll fact[NUM_ + 1], factr[NUM_ + 1], inv[NUM_ + 1];
if (fact[0] == 0) {
inv[1] = fact[0] = factr[0] = 1;
for (int i = 2; i <= NUM_; ++i)
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
for (int i = 1; i <= NUM_; ++i)
fact[i] = fact[i - 1] * i % MOD, factr[i] = factr[i - 1] * inv[i] % MOD;
}
if (C_ < 0 || C_ > N_)
return 0;
return factr[C_] * fact[N_] % MOD * factr[N_ - C_] % MOD;
}
/* MAKE VECTOR */
template <class T> constexpr vector<T> mvec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto mvec(size_t a, Ts... ts) {
return vector<decltype(mvec<T>(ts...))>(a, mvec<T>(ts...));
}
/* MAKE DEQUE */
template <class T> constexpr deque<T> mdeq(size_t a) { return deque<T>(a); }
template <class T, class... Ts> auto mdeq(size_t a, Ts... ts) {
return deque<decltype(mdeq<T>(ts...))>(a, mdeq<T>(ts...));
}
/* TEST */
void test(ll n) { cout << "test" << n << endl; }
/* PRECISION */
void fixsp(ll n) { cout << fixed << setprecision(n); }
void defsp(ll n) { cout << defaultfloat << setprecision(n); }
/* WEIGHTENED UNIONFIND */
struct WUnionFind {
vector<int> par;
vector<int> rank;
WUnionFind(int n = 1) { init(n); }
void init(int n = 1) {
par.resize(n);
rank.resize(n);
for (int i = 0; i < n; ++i)
par[i] = i, rank[i] = 0;
}
int root(int x) {
if (par[x] == x) {
return x;
} else {
int r = root(par[x]);
return par[x] = r;
}
}
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 (rank[x] < rank[y])
swap(x, y);
if (rank[x] == rank[y])
++rank[x];
par[y] = x;
return true;
}
};
/* DIVISOR */
deque<ll> divisor(ll n) {
deque<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);
}
/* MODE */
template <typename T> auto mode(T data) {
if (data.size() == 1)
return *begin(data);
sort(begin(data), end(data));
typename decltype(data)::value_type mode{};
size_t n{}, count{1};
for (auto iter = adjacent_find(begin(data), end(data)), last = end(data),
next = end(data);
iter != last;) {
next = upper_bound(iter, last, *iter);
count = distance(iter, next);
if (n < count)
n = count, mode = *iter;
iter = adjacent_find(next, last);
}
return mode;
}
/* MEDIAN */
template <typename T> auto median(T data) {
sort(begin(data), end(data));
size_t median_index = data.size() / 2;
return (
data.size() % 2 == 0
? static_cast<double>(data[median_index] + data[median_index - 1]) / 2
: data[median_index]);
}
/* INT POW */
template <typename T> T multi(T a, ll b) {
T ans{1};
for (int i{}; i < b; i++)
ans *= a;
return ans;
}
/* INF */
template <typename T> constexpr T inf() { return numeric_limits<T>::max(); }
/* FASTER IO */
void fastio(ll a) {
ios::sync_with_stdio(false);
cin.tie(NULL);
if (a)
fixsp(a);
}
/* MIN COST FLOW */
template <typename flow_t, typename cost_t> struct PrimalDual {
const cost_t INF;
struct edge {
int to;
flow_t cap;
cost_t cost;
int rev;
bool isrev;
};
vector<vector<edge>> graph;
vector<cost_t> potential, min_cost;
vector<int> prevv, preve;
PrimalDual(int V) : graph(V), INF(numeric_limits<cost_t>::max()) {}
void add_edge(int from, int to, flow_t cap, cost_t cost) {
graph[from].emplace_back(
(edge){to, cap, cost, (int)graph[to].size(), false});
graph[to].emplace_back(
(edge){from, 0, -cost, (int)graph[from].size() - 1, true});
}
cost_t min_cost_flow(int s, int t, flow_t f) {
int V = (int)graph.size();
cost_t ret = 0;
using Pi = pair<cost_t, int>;
priority_queue<Pi, vector<Pi>, greater<Pi>> que;
potential.assign(V, 0);
preve.assign(V, -1);
prevv.assign(V, -1);
while (f > 0) {
min_cost.assign(V, INF);
que.emplace(0, s);
min_cost[s] = 0;
while (!que.empty()) {
Pi p = que.top();
que.pop();
if (min_cost[p.second] < p.first)
continue;
for (int i = 0; i < graph[p.second].size(); i++) {
edge &e = graph[p.second][i];
cost_t nextCost = min_cost[p.second] + e.cost + potential[p.second] -
potential[e.to];
if (e.cap > 0 && min_cost[e.to] > nextCost) {
min_cost[e.to] = nextCost;
prevv[e.to] = p.second, preve[e.to] = i;
que.emplace(min_cost[e.to], e.to);
}
}
}
if (min_cost[t] == INF)
return -1;
for (int v = 0; v < V; v++)
potential[v] += min_cost[v];
flow_t addflow = f;
for (int v = t; v != s; v = prevv[v]) {
addflow = min(addflow, graph[prevv[v]][preve[v]].cap);
}
f -= addflow;
ret += addflow * potential[t];
for (int v = t; v != s; v = prevv[v]) {
edge &e = graph[prevv[v]][preve[v]];
e.cap -= addflow;
graph[v][e.rev].cap += addflow;
}
}
return ret;
}
void output() {
for (int i = 0; i < graph.size(); i++) {
for (auto &e : graph[i]) {
if (e.isrev)
continue;
auto &rev_e = graph[e.to][e.rev];
cout << i << "->" << e.to << " (flow: " << rev_e.cap << "/"
<< rev_e.cap + e.cap << ")" << endl;
}
}
}
};
/* BELLMANFORD */
template <typename T> struct edge {
int from, to;
T cost;
edge(int to, T cost) : from(-1), to(to), cost(cost) {}
edge(int from, int to, T cost) : from(from), to(to), cost(cost) {}
explicit operator int() const { return to; }
};
template <typename T> vector<T> BellmanFord(int s, int V, vector<edge<T>> &G) {
vector<T> d(V, inf<T>());
vector<bool> neg(V);
d[s] = 0;
for (int i = 0; i < V - 1; ++i) {
for (auto &&e : G) {
if (d[e.from] == inf<T>())
continue;
d[e.to] = min(d[e.to], d[e.from] + e.cost);
}
}
for (int i = 0; i < V; ++i) {
for (auto &&e : G) {
if (d[e.from] == inf<T>())
continue;
if (d[e.to] > d[e.from] + e.cost) {
d[e.to] = d[e.from] + e.cost;
neg[e.to] = 1;
}
if (neg[e.from])
neg[e.to] = 1;
}
}
for (int i = 0; i < V; i++) {
if (neg[i])
d[i] = -inf<ll>();
}
return d;
}
/* DIJKSTRA */
vector<ll> Dijkstra(int s, int V, vector<tuple<ll, ll, ll>> &G) {
// uv [from] = (to, length)
vector<vector<pair<ll, ll>>> uv(V);
for (auto &&i : G)
uv[get<0>(i)].emplace_back(get<1>(i), get<2>(i));
vector<ll> d(V, inf<ll>() / 2);
vector<ll> prev(V, -1);
d[s] = 0;
priority_queue<pair<ll, ll>, vector<pair<ll, ll>>, greater<pair<ll, ll>>> Q;
rep(i, 0, V) Q.emplace(d[i], i);
while (!Q.empty()) {
ll u = Q.top().second;
Q.pop();
for (auto &&v : uv[u]) {
ll alt = d[u] + v.second;
if (d[v.first] > alt) {
d[v.first] = alt;
if (d[v.first] > inf<ll>() / 4)
d[v.first] = inf<ll>() / 2;
else if (d[v.first] < -inf<ll>() / 4)
d[v.first] = -inf<ll>() / 2;
prev[v.first] = u;
Q.emplace(alt, v.first);
}
}
// debugv(d);
}
for (auto &&i : d) {
if (abs(i) > inf<ll>() / 4)
(i *= 2)++;
}
return d;
}
/* BFS */
vector<ll> BFS(ll s, ll V, vector<pair<ll, ll>> &G) {
stack<ll> Q;
vector<vector<ll>> uv(V);
for (auto &&i : G)
uv[i.first].emplace_back(i.second);
vector<ll> dist(V, inf<ll>());
dist[s] = 0;
Q.emplace(s);
while (!Q.empty()) {
ll v = Q.top();
Q.pop();
for (auto &&i : uv[v]) {
if (dist[i] == inf<ll>()) {
dist[i] = dist[v] + 1;
Q.emplace(i);
}
}
}
return dist;
}
/* NUITA.INC & KYOTO UNIVERSITY */
/* LAST EDITED ON 8.18.2019 */
/* CODE STARTS FROM HERE */
int main() {
fastio(0);
ll N, M;
cin >> N >> M;
vector<pair<ll, ll>> utov;
rep(i, 0, M) {
ll u, v;
cin >> u >> v;
u--;
v--;
utov.emplace_back(u * 3, v * 3 + 1);
utov.emplace_back(u * 3 + 1, v * 3 + 2);
utov.emplace_back(u * 3 + 2, v * 3);
}
ll S, T;
cin >> S >> T;
S--;
T--;
auto ans = BFS(3 * S, 3 * N, utov);
if (abs(ans[3 * T]) == inf<ll>())
ans[3 * T] = -3;
cout << ans[3 * T] / 3;
} | #include <bits/stdc++.h>
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define rep(i, s, N) for (ll i{s}; i < (N); i++)
#define rem(i, N, s) for (ll i{N}; i > (s); i--)
#define debug(x) cerr << #x << ": " << x << '\n'
#define debugv(v) \
cerr << #v << ": "; \
for (auto &&i : v) \
cerr << i << " "; \
cerr << '\n'
const int MOD = (int)1e9 + 7;
const long double pi = 3.141592653589793238462643383279L;
using namespace std;
using ll = long long;
using ld = long double;
using str = string;
using wstr = wstring;
const string rt = "\n", sp = " ";
const wstring wrt = L"\n", wsp = L" ";
/* GCD */
template <typename M, typename N> constexpr common_type_t<M, N> gcd(M a, N b) {
return b != 0 ? gcd(b, a % b) : a;
}
/* LCM */
template <typename M, typename N> constexpr common_type_t<M, N> lcm(M a, N b) {
return a * b / gcd(a, b);
}
/* UNIONFIND */
template <typename T> struct UnionFind {
vector<T> par;
UnionFind(T n) : par(n, -1) {}
void init(T n) { par.assign(n, -1); }
T root(T x) {
if (par[x] < 0)
return x;
else
return par[x] = root(par[x]);
}
bool issame(T x, T y) { return root(x) == root(y); }
bool merge(T x, T y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (par[x] > par[y])
swap(x, y);
par[x] += par[y];
par[y] = x;
return true;
}
int size(int x) { return -par[root(x)]; }
};
/* COMB */
auto comb(ll N) {
vector<vector<ll>> v(N + 1, vector<ll>(N + 1));
for (int i = 0; i < v.size(); i++) {
v[i][0] = 1;
v[i][i] = 1;
}
for (int k = 1; k < v.size(); k++) {
for (int j = 1; j < k; j++) {
v[k][j] = (v[k - 1][j - 1] + v[k - 1][j]);
}
}
return v;
}
auto comb(ll N, ll n) {
vector<vector<ll>> v(max(N + 1, n + 1), vector<ll>(max(N + 1, n + 1)));
for (int i = 0; i < v.size(); i++) {
v[i][0] = 1;
v[i][i] = 1;
}
for (int k = 1; k < v.size(); k++) {
for (int j = 1; j < k; j++) {
v[k][j] = (v[k - 1][j - 1] + v[k - 1][j]);
}
}
return v[N][n];
}
/* COMB % MOD */
template <typename T> ll combpm(T N_, T C_) {
const int NUM_ = 400001;
static ll fact[NUM_ + 1], factr[NUM_ + 1], inv[NUM_ + 1];
if (fact[0] == 0) {
inv[1] = fact[0] = factr[0] = 1;
for (int i = 2; i <= NUM_; ++i)
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
for (int i = 1; i <= NUM_; ++i)
fact[i] = fact[i - 1] * i % MOD, factr[i] = factr[i - 1] * inv[i] % MOD;
}
if (C_ < 0 || C_ > N_)
return 0;
return factr[C_] * fact[N_] % MOD * factr[N_ - C_] % MOD;
}
/* MAKE VECTOR */
template <class T> constexpr vector<T> mvec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto mvec(size_t a, Ts... ts) {
return vector<decltype(mvec<T>(ts...))>(a, mvec<T>(ts...));
}
/* MAKE DEQUE */
template <class T> constexpr deque<T> mdeq(size_t a) { return deque<T>(a); }
template <class T, class... Ts> auto mdeq(size_t a, Ts... ts) {
return deque<decltype(mdeq<T>(ts...))>(a, mdeq<T>(ts...));
}
/* TEST */
void test(ll n) { cout << "test" << n << endl; }
/* PRECISION */
void fixsp(ll n) { cout << fixed << setprecision(n); }
void defsp(ll n) { cout << defaultfloat << setprecision(n); }
/* WEIGHTENED UNIONFIND */
struct WUnionFind {
vector<int> par;
vector<int> rank;
WUnionFind(int n = 1) { init(n); }
void init(int n = 1) {
par.resize(n);
rank.resize(n);
for (int i = 0; i < n; ++i)
par[i] = i, rank[i] = 0;
}
int root(int x) {
if (par[x] == x) {
return x;
} else {
int r = root(par[x]);
return par[x] = r;
}
}
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 (rank[x] < rank[y])
swap(x, y);
if (rank[x] == rank[y])
++rank[x];
par[y] = x;
return true;
}
};
/* DIVISOR */
deque<ll> divisor(ll n) {
deque<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);
}
/* MODE */
template <typename T> auto mode(T data) {
if (data.size() == 1)
return *begin(data);
sort(begin(data), end(data));
typename decltype(data)::value_type mode{};
size_t n{}, count{1};
for (auto iter = adjacent_find(begin(data), end(data)), last = end(data),
next = end(data);
iter != last;) {
next = upper_bound(iter, last, *iter);
count = distance(iter, next);
if (n < count)
n = count, mode = *iter;
iter = adjacent_find(next, last);
}
return mode;
}
/* MEDIAN */
template <typename T> auto median(T data) {
sort(begin(data), end(data));
size_t median_index = data.size() / 2;
return (
data.size() % 2 == 0
? static_cast<double>(data[median_index] + data[median_index - 1]) / 2
: data[median_index]);
}
/* INT POW */
template <typename T> T multi(T a, ll b) {
T ans{1};
for (int i{}; i < b; i++)
ans *= a;
return ans;
}
/* INF */
template <typename T> constexpr T inf() { return numeric_limits<T>::max(); }
/* FASTER IO */
void fastio(ll a) {
ios::sync_with_stdio(false);
cin.tie(NULL);
if (a)
fixsp(a);
}
/* MIN COST FLOW */
template <typename flow_t, typename cost_t> struct PrimalDual {
const cost_t INF;
struct edge {
int to;
flow_t cap;
cost_t cost;
int rev;
bool isrev;
};
vector<vector<edge>> graph;
vector<cost_t> potential, min_cost;
vector<int> prevv, preve;
PrimalDual(int V) : graph(V), INF(numeric_limits<cost_t>::max()) {}
void add_edge(int from, int to, flow_t cap, cost_t cost) {
graph[from].emplace_back(
(edge){to, cap, cost, (int)graph[to].size(), false});
graph[to].emplace_back(
(edge){from, 0, -cost, (int)graph[from].size() - 1, true});
}
cost_t min_cost_flow(int s, int t, flow_t f) {
int V = (int)graph.size();
cost_t ret = 0;
using Pi = pair<cost_t, int>;
priority_queue<Pi, vector<Pi>, greater<Pi>> que;
potential.assign(V, 0);
preve.assign(V, -1);
prevv.assign(V, -1);
while (f > 0) {
min_cost.assign(V, INF);
que.emplace(0, s);
min_cost[s] = 0;
while (!que.empty()) {
Pi p = que.top();
que.pop();
if (min_cost[p.second] < p.first)
continue;
for (int i = 0; i < graph[p.second].size(); i++) {
edge &e = graph[p.second][i];
cost_t nextCost = min_cost[p.second] + e.cost + potential[p.second] -
potential[e.to];
if (e.cap > 0 && min_cost[e.to] > nextCost) {
min_cost[e.to] = nextCost;
prevv[e.to] = p.second, preve[e.to] = i;
que.emplace(min_cost[e.to], e.to);
}
}
}
if (min_cost[t] == INF)
return -1;
for (int v = 0; v < V; v++)
potential[v] += min_cost[v];
flow_t addflow = f;
for (int v = t; v != s; v = prevv[v]) {
addflow = min(addflow, graph[prevv[v]][preve[v]].cap);
}
f -= addflow;
ret += addflow * potential[t];
for (int v = t; v != s; v = prevv[v]) {
edge &e = graph[prevv[v]][preve[v]];
e.cap -= addflow;
graph[v][e.rev].cap += addflow;
}
}
return ret;
}
void output() {
for (int i = 0; i < graph.size(); i++) {
for (auto &e : graph[i]) {
if (e.isrev)
continue;
auto &rev_e = graph[e.to][e.rev];
cout << i << "->" << e.to << " (flow: " << rev_e.cap << "/"
<< rev_e.cap + e.cap << ")" << endl;
}
}
}
};
/* BELLMANFORD */
template <typename T> struct edge {
int from, to;
T cost;
edge(int to, T cost) : from(-1), to(to), cost(cost) {}
edge(int from, int to, T cost) : from(from), to(to), cost(cost) {}
explicit operator int() const { return to; }
};
template <typename T> vector<T> BellmanFord(int s, int V, vector<edge<T>> &G) {
vector<T> d(V, inf<T>());
vector<bool> neg(V);
d[s] = 0;
for (int i = 0; i < V - 1; ++i) {
for (auto &&e : G) {
if (d[e.from] == inf<T>())
continue;
d[e.to] = min(d[e.to], d[e.from] + e.cost);
}
}
for (int i = 0; i < V; ++i) {
for (auto &&e : G) {
if (d[e.from] == inf<T>())
continue;
if (d[e.to] > d[e.from] + e.cost) {
d[e.to] = d[e.from] + e.cost;
neg[e.to] = 1;
}
if (neg[e.from])
neg[e.to] = 1;
}
}
for (int i = 0; i < V; i++) {
if (neg[i])
d[i] = -inf<ll>();
}
return d;
}
/* DIJKSTRA */
vector<ll> Dijkstra(int s, int V, vector<tuple<ll, ll, ll>> &G) {
// uv [from] = (to, length)
vector<vector<pair<ll, ll>>> uv(V);
for (auto &&i : G)
uv[get<0>(i)].emplace_back(get<1>(i), get<2>(i));
vector<ll> d(V, inf<ll>() / 2);
vector<ll> prev(V, -1);
d[s] = 0;
priority_queue<pair<ll, ll>, vector<pair<ll, ll>>, greater<pair<ll, ll>>> Q;
rep(i, 0, V) Q.emplace(d[i], i);
while (!Q.empty()) {
ll u = Q.top().second;
Q.pop();
for (auto &&v : uv[u]) {
ll alt = d[u] + v.second;
if (d[v.first] > alt) {
d[v.first] = alt;
if (d[v.first] > inf<ll>() / 4)
d[v.first] = inf<ll>() / 2;
else if (d[v.first] < -inf<ll>() / 4)
d[v.first] = -inf<ll>() / 2;
prev[v.first] = u;
Q.emplace(alt, v.first);
}
}
// debugv(d);
}
for (auto &&i : d) {
if (abs(i) > inf<ll>() / 4)
(i *= 2)++;
}
return d;
}
/* BFS */
vector<ll> BFS(ll s, ll V, vector<pair<ll, ll>> &G) {
queue<ll> Q;
vector<vector<ll>> uv(V);
for (auto &&i : G)
uv[i.first].emplace_back(i.second);
vector<ll> dist(V, inf<ll>());
dist[s] = 0;
Q.emplace(s);
while (!Q.empty()) {
ll v = Q.front();
Q.pop();
for (auto &&i : uv[v]) {
if (dist[i] == inf<ll>()) {
dist[i] = dist[v] + 1;
Q.emplace(i);
}
}
}
return dist;
}
/* NUITA.INC & KYOTO UNIVERSITY */
/* LAST EDITED ON 8.18.2019 */
/* CODE STARTS FROM HERE */
int main() {
fastio(0);
ll N, M;
cin >> N >> M;
vector<pair<ll, ll>> utov;
rep(i, 0, M) {
ll u, v;
cin >> u >> v;
u--;
v--;
utov.emplace_back(u * 3, v * 3 + 1);
utov.emplace_back(u * 3 + 1, v * 3 + 2);
utov.emplace_back(u * 3 + 2, v * 3);
}
ll S, T;
cin >> S >> T;
S--;
T--;
auto ans = BFS(3 * S, 3 * N, utov);
if (abs(ans[3 * T]) == inf<ll>())
ans[3 * T] = -3;
cout << ans[3 * T] / 3;
} | [
"variable_declaration.type.change",
"call.function.change"
] | 799,212 | 799,214 | u936790121 | cpp |
p02991 | #include <bits/stdc++.h>
using namespace std;
#define IO \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define forn(i, n) for (int i = 0; i < n; i++)
#define forse(i, s, e) for (int i = s; i < e; i++)
#define pb push_back
#define pf push_front
#define rb pop_back
#define rf pop_front
#define mp make_pair
#define all(vec) vec.begin(), vec.end()
#define getcurrtime() \
cerr << "Time = " << ((double)clock() / CLOCKS_PER_SEC) << endl
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<vector<ll>> Matrix;
const int sqr = 500;
const int P = 1e9 + 7;
const int arrn = 1e5 + 3;
const int arrn2 = 5e3 + 3;
int n, m, s, t;
int ans[arrn][3] = {};
vector<int> graph[arrn] = {};
void dijs() {
priority_queue<pair<int, pair<int, int>>> proc;
proc.push(mp(0, mp(0, s)));
int done[arrn][3] = {};
while (!proc.empty()) {
pair<int, pii> cur = proc.top();
proc.pop();
int dis = cur.first;
int ind = cur.second.first;
int ver = cur.second.second;
if (!done[ver][ind]) {
done[ver][ind] = 1;
ans[ver][ind] = dis;
if (ver == t && ind == 0) {
cout << ans[ver][ind] / 3;
return;
}
forn(i, (int)graph[ver].size()) {
if (!done[graph[ver][i]][(1 + ind) % 3])
proc.push(mp(1 + dis, mp((1 + ind) % 3, graph[ver][i])));
}
}
}
cout << -1;
}
void solve() {
cin >> n >> m;
forn(i, m) {
int u, v;
cin >> u >> v;
graph[u].pb(v);
}
cin >> s >> t;
dijs();
}
int main() {
IO;
int T;
T = 1;
while (T--) {
solve();
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define IO \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define forn(i, n) for (int i = 0; i < n; i++)
#define forse(i, s, e) for (int i = s; i < e; i++)
#define pb push_back
#define pf push_front
#define rb pop_back
#define rf pop_front
#define mp make_pair
#define all(vec) vec.begin(), vec.end()
#define getcurrtime() \
cerr << "Time = " << ((double)clock() / CLOCKS_PER_SEC) << endl
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<vector<ll>> Matrix;
const int sqr = 500;
const int P = 1e9 + 7;
const int arrn = 1e5 + 3;
const int arrn2 = 5e3 + 3;
int n, m, s, t;
int ans[arrn][3] = {};
vector<int> graph[arrn] = {};
void dijs() {
priority_queue<pair<int, pair<int, int>>> proc;
proc.push(mp(0, mp(0, s)));
int done[arrn][3] = {};
while (!proc.empty()) {
pair<int, pii> cur = proc.top();
proc.pop();
int dis = -cur.first;
int ind = cur.second.first;
int ver = cur.second.second;
if (!done[ver][ind]) {
done[ver][ind] = 1;
ans[ver][ind] = dis;
if (ver == t && ind == 0) {
cout << ans[ver][ind] / 3;
return;
}
forn(i, (int)graph[ver].size()) {
if (!done[graph[ver][i]][(1 + ind) % 3])
proc.push(mp(-(1 + dis), mp((1 + ind) % 3, graph[ver][i])));
}
}
}
cout << -1;
}
void solve() {
cin >> n >> m;
forn(i, m) {
int u, v;
cin >> u >> v;
graph[u].pb(v);
}
cin >> s >> t;
dijs();
}
int main() {
IO;
int T;
T = 1;
while (T--) {
solve();
}
return 0;
}
| [
"expression.operation.unary.add",
"call.arguments.change"
] | 799,224 | 799,225 | u339747464 | cpp |
p02991 | #include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
const int inf = 1e8;
int dist[100010][3];
int main() {
int N, M;
cin >> N >> M;
vector<vector<int>> to(N);
for (int i = 0; i < M; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
to[u].push_back(v);
}
for (int i = 0; i < 100010; i++) {
for (int j = 0; j < 3; j++) {
dist[i][j] = inf;
}
} // infは未到達
int start, terminate;
cin >> start >> terminate;
start--;
terminate--;
dist[start][0] = 0; // dist[terminate][0]を調べたい
queue<pair<int, int>> Q;
Q.push(make_pair(start, 0));
while (!Q.empty()) {
pair<int, int> p = Q.front();
Q.pop();
int s = p.first;
int t = p.second;
int nt = (t + 1) % 3;
// sノードに繋がるノーどを全て調べたい
for (int i = 0; i < to[s].size(); s++) {
int r = to[s][i];
if (dist[r][nt] != inf) {
continue;
} else {
dist[r][nt] = dist[s][t] + 1;
Q.push(make_pair(r, nt));
}
}
}
int answer = dist[terminate][0];
if (answer == inf) {
cout << -1 << endl;
} else {
cout << answer / 3 << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
const int inf = 1e8;
int dist[100010][3];
int main() {
int N, M;
cin >> N >> M;
vector<vector<int>> to(N);
for (int i = 0; i < M; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
to[u].push_back(v);
}
for (int i = 0; i < 100010; i++) {
for (int j = 0; j < 3; j++) {
dist[i][j] = inf;
}
} // infは未到達
int start, terminate;
cin >> start >> terminate;
start--;
terminate--;
dist[start][0] = 0; // dist[terminate][0]を調べたい
queue<pair<int, int>> Q;
Q.push(make_pair(start, 0));
while (!Q.empty()) {
pair<int, int> p = Q.front();
Q.pop();
int s = p.first;
int t = p.second;
int nt = (t + 1) % 3;
// sノードに繋がるノーどを全て調べたい
for (int i = 0; i < to[s].size(); i++) {
int r = to[s][i];
if (dist[r][nt] != inf) {
continue;
} else {
dist[r][nt] = dist[s][t] + 1;
Q.push(make_pair(r, nt));
}
}
}
int answer = dist[terminate][0];
if (answer == inf) {
cout << -1 << endl;
} else {
cout << answer / 3 << endl;
}
return 0;
}
| [
"identifier.change"
] | 799,226 | 799,227 | u904123392 | cpp |
p02991 | #include <bits/stdc++.h>
using namespace std;
struct element {
int node;
int step;
};
deque<element> que;
vector<int> edges[100001 + 1];
int n, m, s, t;
bool done[100001][3];
void extend(int node, int step) {
vector<int> next_nodes = edges[node];
int next_nstep = step + 1;
for (unsigned int i = 0; i < next_nodes.size(); i++) {
int n = next_nodes[i];
if (done[n][next_nstep % 3]) {
continue;
}
done[n][next_nstep] = true;
que.push_back(element{n, next_nstep});
}
return;
};
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int t1, t2;
cin >> t1 >> t2;
(edges[t1]).push_back(t2);
}
cin >> s >> t;
done[s][0] = true;
que.push_back(element{s, 0});
while (!que.empty()) {
element target = que.front();
que.pop_front();
if (target.step % 3 == 0 && target.node == t) {
cout << target.step / 3 << endl;
return 0;
}
extend(target.node, target.step);
}
cout << -1 << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
struct element {
int node;
int step;
};
deque<element> que;
vector<int> edges[100001 + 1];
int n, m, s, t;
bool done[100001][3];
void extend(int node, int step) {
vector<int> next_nodes = edges[node];
int next_nstep = step + 1;
for (unsigned int i = 0; i < next_nodes.size(); i++) {
int n = next_nodes[i];
if (done[n][next_nstep % 3]) {
continue;
}
done[n][next_nstep % 3] = true;
que.push_back(element{n, next_nstep});
}
return;
};
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int t1, t2;
cin >> t1 >> t2;
(edges[t1]).push_back(t2);
}
cin >> s >> t;
done[s][0] = true;
que.push_back(element{s, 0});
while (!que.empty()) {
element target = que.front();
que.pop_front();
if (target.step % 3 == 0 && target.node == t) {
cout << target.step / 3 << endl;
return 0;
}
extend(target.node, target.step);
}
cout << -1 << endl;
return 0;
} | [
"assignment.change"
] | 799,228 | 799,229 | u052546116 | cpp |
p02991 | #include "bits/stdc++.h"
#define rep(i, N) for (int(i) = 0; (i) < (N); (i)++)
#define debug(var) std::cout << #var << " : " << var;
using Graph = std::vector<std::vector<int>>;
int main() {
int N, M;
std::cin >> N >> M;
Graph G(N);
rep(i, N) {
int u, v;
std::cin >> u >> v;
G[u - 1].push_back(v - 1);
}
int S, T;
std::cin >> S >> T;
S--;
T--;
std::vector<std::array<int, 3>> memo(N, {-1, -1, -1});
memo[S][0] = 0;
std::queue<std::pair<int, int>> q;
q.push(std::make_pair(S, 0));
while (!q.empty()) {
auto cur = q.front();
q.pop();
for (auto &v : G[cur.first]) {
int tmp = ((cur.second) + 1) % 3;
if (memo[v][tmp] != -1)
continue;
memo[v][tmp] = memo[cur.first][cur.second] + 1;
q.push(std::make_pair(v, tmp));
}
}
int ans = memo[T][0];
if (ans != -1)
ans /= 3;
std::cout << ans;
return 0;
}
| #include "bits/stdc++.h"
#define rep(i, N) for (int(i) = 0; (i) < (N); (i)++)
#define debug(var) std::cout << #var << " : " << var;
using Graph = std::vector<std::vector<int>>;
int main() {
int N, M;
std::cin >> N >> M;
Graph G(N);
rep(i, M) {
int u, v;
std::cin >> u >> v;
G[u - 1].push_back(v - 1);
}
int S, T;
std::cin >> S >> T;
S--;
T--;
std::vector<std::array<int, 3>> memo(N, {-1, -1, -1});
memo[S][0] = 0;
std::queue<std::pair<int, int>> q;
q.push(std::make_pair(S, 0));
while (!q.empty()) {
auto cur = q.front();
q.pop();
for (auto &v : G[cur.first]) {
int tmp = ((cur.second) + 1) % 3;
if (memo[v][tmp] != -1)
continue;
memo[v][tmp] = memo[cur.first][cur.second] + 1;
q.push(std::make_pair(v, tmp));
}
}
int ans = memo[T][0];
if (ans != -1)
ans /= 3;
std::cout << ans;
return 0;
}
| [] | 799,256 | 799,257 | u575279726 | cpp |
p02991 | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef vector<int> vi;
typedef pair<int, ii> iii;
typedef pair<int, iii> iiii;
typedef pair<double, ii> dii;
typedef long long ll;
typedef pair<ll, ii> lii;
const int INF = 1000000000;
const double EPS = 1e-9;
#define LSOne(S) (S & (-S))
int mods(int a, int b) { return (b + (a % b)) % b; }
int n, m, a, b, s, t, dist[300005];
vector<vi> adjList;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
cin >> n >> m;
adjList.resize(3 * n);
for (int i = 0; i < 3 * n; i++)
dist[i] = INF;
for (int i = 0; i < m; i++) {
cin >> a >> b;
a--;
b--;
adjList[a].push_back(b + n);
adjList[a + n].push_back(b + 2 * n);
adjList[a + 2 * n].push_back(b);
}
cin >> s >> t;
s--;
t--;
queue<int> q;
q.push(s);
dist[s] = 0;
bool reached = 0;
while (!q.empty() && !reached) {
int u = q.front();
q.pop();
for (int i = 0; i < adjList[u].size() && !reached; i++) {
int v = adjList[u][i];
if (dist[v] == INF) {
dist[v] = dist[u] + 1;
if (v == t)
reached = 1;
q.push(v);
}
}
}
if (dist[t] == 1e18)
cout << "-1\n";
else
cout << dist[t] / 3 << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef vector<int> vi;
typedef pair<int, ii> iii;
typedef pair<int, iii> iiii;
typedef pair<double, ii> dii;
typedef long long ll;
typedef pair<ll, ii> lii;
const int INF = 1000000000;
const double EPS = 1e-9;
#define LSOne(S) (S & (-S))
int mods(int a, int b) { return (b + (a % b)) % b; }
int n, m, a, b, s, t, dist[300005];
vector<vi> adjList;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
cin >> n >> m;
adjList.resize(3 * n);
for (int i = 0; i < 3 * n; i++)
dist[i] = INF;
for (int i = 0; i < m; i++) {
cin >> a >> b;
a--;
b--;
adjList[a].push_back(b + n);
adjList[a + n].push_back(b + 2 * n);
adjList[a + 2 * n].push_back(b);
}
cin >> s >> t;
s--;
t--;
queue<int> q;
q.push(s);
dist[s] = 0;
bool reached = 0;
while (!q.empty() && !reached) {
int u = q.front();
q.pop();
for (int i = 0; i < adjList[u].size() && !reached; i++) {
int v = adjList[u][i];
if (dist[v] == INF) {
dist[v] = dist[u] + 1;
if (v == t)
reached = 1;
q.push(v);
}
}
}
if (dist[t] == INF)
cout << "-1\n";
else
cout << dist[t] / 3 << '\n';
return 0;
} | [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.branch.if.condition.change"
] | 799,265 | 799,266 | u514760660 | cpp |
p02991 | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef vector<int> vi;
typedef pair<int, ii> iii;
typedef pair<int, iii> iiii;
typedef pair<double, ii> dii;
typedef long long ll;
typedef pair<ll, ii> lii;
const int INF = 1000000000;
const double EPS = 1e-9;
#define LSOne(S) (S & (-S))
int mods(int a, int b) { return (b + (a % b)) % b; }
int n, m, a, b, s, t, dist[300005];
vector<vi> adjList;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
cin >> n >> m;
adjList.resize(3 * n);
for (int i = 0; i < 3 * n; i++)
dist[i] = INF;
for (int i = 0; i < m; i++) {
cin >> a >> b;
a--;
b--;
adjList[a].push_back(b + n);
adjList[a + n].push_back(b + 2 * n);
adjList[a + 2 * n].push_back(b);
}
cin >> s >> t;
s--;
t--;
queue<int> q;
q.push(s);
dist[0] = 0;
bool reached = 0;
while (!q.empty() && !reached) {
int u = q.front();
q.pop();
for (int i = 0; i < adjList[u].size() && !reached; i++) {
int v = adjList[u][i];
if (dist[v] == INF) {
dist[v] = dist[u] + 1;
if (v == t)
reached = 1;
q.push(v);
}
}
}
if (dist[t] == INF)
cout << "-1\n";
else
cout << dist[t] / 3 << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef vector<int> vi;
typedef pair<int, ii> iii;
typedef pair<int, iii> iiii;
typedef pair<double, ii> dii;
typedef long long ll;
typedef pair<ll, ii> lii;
const int INF = 1000000000;
const double EPS = 1e-9;
#define LSOne(S) (S & (-S))
int mods(int a, int b) { return (b + (a % b)) % b; }
int n, m, a, b, s, t, dist[300005];
vector<vi> adjList;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
cin >> n >> m;
adjList.resize(3 * n);
for (int i = 0; i < 3 * n; i++)
dist[i] = INF;
for (int i = 0; i < m; i++) {
cin >> a >> b;
a--;
b--;
adjList[a].push_back(b + n);
adjList[a + n].push_back(b + 2 * n);
adjList[a + 2 * n].push_back(b);
}
cin >> s >> t;
s--;
t--;
queue<int> q;
q.push(s);
dist[s] = 0;
bool reached = 0;
while (!q.empty() && !reached) {
int u = q.front();
q.pop();
for (int i = 0; i < adjList[u].size() && !reached; i++) {
int v = adjList[u][i];
if (dist[v] == INF) {
dist[v] = dist[u] + 1;
if (v == t)
reached = 1;
q.push(v);
}
}
}
if (dist[t] == INF)
cout << "-1\n";
else
cout << dist[t] / 3 << '\n';
return 0;
} | [
"assignment.variable.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change"
] | 799,267 | 799,266 | u514760660 | cpp |
p02991 | #include "bits/stdc++.h"
// Custom Header {{{
#define ALL(x) x.begin(), x.end()
#define rep(i, s, n) for (int i(s); i < int(n); ++i)
#define endl '\n'
#ifndef YDK
#define eprintf(...)
#endif
using namespace std;
using i64 = long long;
using pii = pair<i64, i64>;
template <class A, class B> inline bool chmax(A &a, const B &b) {
return b > a ? a = b, 1 : 0;
}
template <class A, class B> inline bool chmin(A &a, const B &b) {
return b < a ? a = b, 1 : 0;
}
constexpr const int INF = 0x3f3f3f3f;
constexpr const i64 LINF = 0x3f3f3f3f3f3f3f3fLL;
constexpr const int MOD = int(1e9) + 7;
// }}}
// Library {{{
// n の素因数を (素因数, 個数) のペアで列挙して返す。O(sqrt(N))
map<i64, int> getPrimeFactors(i64 n) {
map<i64, int> pf;
for (i64 i = 2; i * i <= n; ++i) {
while (n % i == 0) {
pf[i] += 1;
n /= i;
}
}
if (n != 1)
pf[n] = 1;
return pf;
}
// }}}
struct FastIO {
FastIO() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
}
} fastIO_ydk;
int N, M;
int s, t;
vector<int> G[100010];
int dist[100010][5];
signed main() {
cin >> N >> M;
for (int i = 0; i < M; ++i) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
}
cin >> s >> t;
queue<pii> que;
que.emplace(s, 0);
memset(dist, INF, sizeof(dist));
dist[s][0] = 0;
while (!que.empty()) {
const int u = que.front().first;
const int k = que.front().second;
const int nxtCost = dist[u][k] + 1;
const int nxtK = (k + 1) % 3;
que.pop();
for (int nxt : G[u]) {
if (chmin(dist[nxt][nxtK], nxtCost)) {
que.emplace(nxt, nxtK);
}
}
}
if (dist[t][2] >= INF) {
cout << (-1) << endl;
} else {
cout << (dist[t][2]) << endl;
}
return 0;
}
| #include "bits/stdc++.h"
// Custom Header {{{
#define ALL(x) x.begin(), x.end()
#define rep(i, s, n) for (int i(s); i < int(n); ++i)
#define endl '\n'
#ifndef YDK
#define eprintf(...)
#endif
using namespace std;
using i64 = long long;
using pii = pair<i64, i64>;
template <class A, class B> inline bool chmax(A &a, const B &b) {
return b > a ? a = b, 1 : 0;
}
template <class A, class B> inline bool chmin(A &a, const B &b) {
return b < a ? a = b, 1 : 0;
}
constexpr const int INF = 0x3f3f3f3f;
constexpr const i64 LINF = 0x3f3f3f3f3f3f3f3fLL;
constexpr const int MOD = int(1e9) + 7;
// }}}
// Library {{{
// n の素因数を (素因数, 個数) のペアで列挙して返す。O(sqrt(N))
map<i64, int> getPrimeFactors(i64 n) {
map<i64, int> pf;
for (i64 i = 2; i * i <= n; ++i) {
while (n % i == 0) {
pf[i] += 1;
n /= i;
}
}
if (n != 1)
pf[n] = 1;
return pf;
}
// }}}
struct FastIO {
FastIO() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
}
} fastIO_ydk;
int N, M;
int s, t;
vector<int> G[100010];
int dist[100010][5];
signed main() {
cin >> N >> M;
for (int i = 0; i < M; ++i) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
}
cin >> s >> t;
queue<pii> que;
que.emplace(s, 0);
memset(dist, INF, sizeof(dist));
dist[s][0] = 0;
while (!que.empty()) {
const int u = que.front().first;
const int k = que.front().second;
const int nxtCost = dist[u][k] + 1;
const int nxtK = (k + 1) % 3;
que.pop();
for (int nxt : G[u]) {
if (chmin(dist[nxt][nxtK], nxtCost)) {
que.emplace(nxt, nxtK);
}
}
}
if (dist[t][0] >= INF) {
cout << (-1) << endl;
} else {
cout << (dist[t][0] / 3) << endl;
}
return 0;
}
| [
"literal.number.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"io.output.change"
] | 799,277 | 799,278 | u897304429 | cpp |
p02991 | #include "bits/stdc++.h"
// Custom Header {{{
#define ALL(x) x.begin(), x.end()
#define rep(i, s, n) for (int i(s); i < int(n); ++i)
#define endl '\n'
#ifndef YDK
#define eprintf(...)
#endif
using namespace std;
using i64 = long long;
using pii = pair<i64, i64>;
template <class A, class B> inline bool chmax(A &a, const B &b) {
return b > a ? a = b, 1 : 0;
}
template <class A, class B> inline bool chmin(A &a, const B &b) {
return b < a ? a = b, 1 : 0;
}
constexpr const int INF = 0x3f3f3f3f;
constexpr const i64 LINF = 0x3f3f3f3f3f3f3f3fLL;
constexpr const int MOD = int(1e9) + 7;
// }}}
// Library {{{
// n の素因数を (素因数, 個数) のペアで列挙して返す。O(sqrt(N))
map<i64, int> getPrimeFactors(i64 n) {
map<i64, int> pf;
for (i64 i = 2; i * i <= n; ++i) {
while (n % i == 0) {
pf[i] += 1;
n /= i;
}
}
if (n != 1)
pf[n] = 1;
return pf;
}
// }}}
struct FastIO {
FastIO() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
}
} fastIO_ydk;
int N, M;
int s, t;
vector<int> G[10010];
int dist[100010][5];
signed main() {
cin >> N >> M;
for (int i = 0; i < M; ++i) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
}
cin >> s >> t;
queue<pii> que;
que.emplace(s, 0);
memset(dist, INF, sizeof(dist));
dist[s][0] = 0;
while (!que.empty()) {
const int u = que.front().first;
const int k = que.front().second;
const int nxtCost = dist[u][k] + 1;
const int nxtK = (k + 1) % 3;
que.pop();
for (int nxt : G[u]) {
if (chmin(dist[nxt][nxtK], nxtCost)) {
que.emplace(nxt, nxtK);
}
}
}
if (dist[t][2] >= INF) {
cout << (-1) << endl;
} else {
cout << (dist[t][2]) << endl;
}
return 0;
}
| #include "bits/stdc++.h"
// Custom Header {{{
#define ALL(x) x.begin(), x.end()
#define rep(i, s, n) for (int i(s); i < int(n); ++i)
#define endl '\n'
#ifndef YDK
#define eprintf(...)
#endif
using namespace std;
using i64 = long long;
using pii = pair<i64, i64>;
template <class A, class B> inline bool chmax(A &a, const B &b) {
return b > a ? a = b, 1 : 0;
}
template <class A, class B> inline bool chmin(A &a, const B &b) {
return b < a ? a = b, 1 : 0;
}
constexpr const int INF = 0x3f3f3f3f;
constexpr const i64 LINF = 0x3f3f3f3f3f3f3f3fLL;
constexpr const int MOD = int(1e9) + 7;
// }}}
// Library {{{
// n の素因数を (素因数, 個数) のペアで列挙して返す。O(sqrt(N))
map<i64, int> getPrimeFactors(i64 n) {
map<i64, int> pf;
for (i64 i = 2; i * i <= n; ++i) {
while (n % i == 0) {
pf[i] += 1;
n /= i;
}
}
if (n != 1)
pf[n] = 1;
return pf;
}
// }}}
struct FastIO {
FastIO() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
}
} fastIO_ydk;
int N, M;
int s, t;
vector<int> G[100010];
int dist[100010][5];
signed main() {
cin >> N >> M;
for (int i = 0; i < M; ++i) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
}
cin >> s >> t;
queue<pii> que;
que.emplace(s, 0);
memset(dist, INF, sizeof(dist));
dist[s][0] = 0;
while (!que.empty()) {
const int u = que.front().first;
const int k = que.front().second;
const int nxtCost = dist[u][k] + 1;
const int nxtK = (k + 1) % 3;
que.pop();
for (int nxt : G[u]) {
if (chmin(dist[nxt][nxtK], nxtCost)) {
que.emplace(nxt, nxtK);
}
}
}
if (dist[t][0] >= INF) {
cout << (-1) << endl;
} else {
cout << (dist[t][0] / 3) << endl;
}
return 0;
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"io.output.change"
] | 799,279 | 799,278 | u897304429 | cpp |
p02991 | #include <algorithm>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
int main() {
ll N, M;
cin >> N >> M;
vector<ll> s(M), e(M);
map<ll, set<ll>> G, G1;
REP(i, M) {
cin >> s[i] >> e[i];
G[s[i]].insert(e[i]);
G1[s[i] * 3].insert(e[i] * 3 + 1);
G1[s[i] * 3 + 1].insert(e[i] * 3 + 2);
G1[s[i] * 3 + 2].insert(e[i] * 3);
}
ll S, T;
cin >> S >> T;
std::vector<ll> val(3 * N + 4, 4 * N);
queue<ll> que;
que.push(S * 3);
ll tmp = S * 3;
val[tmp] = 0;
while (!que.empty()) {
tmp = que.front();
que.pop();
for (auto x : G1[tmp]) {
if (val[tmp] + 1 < val[x]) {
que.push(x);
val[x] = val[tmp] + 1;
}
}
}
if (val[T * 3] == 4 * N)
val[T * 3] = -1;
cout << (val[T * 3] / 3) << endl;
return 0;
}
| #include <algorithm>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
int main() {
ll N, M;
cin >> N >> M;
vector<ll> s(M), e(M);
map<ll, set<ll>> G, G1;
REP(i, M) {
cin >> s[i] >> e[i];
G[s[i]].insert(e[i]);
G1[s[i] * 3].insert(e[i] * 3 + 1);
G1[s[i] * 3 + 1].insert(e[i] * 3 + 2);
G1[s[i] * 3 + 2].insert(e[i] * 3);
}
ll S, T;
cin >> S >> T;
std::vector<ll> val(3 * N + 4, 4 * N);
queue<ll> que;
que.push(S * 3);
ll tmp = S * 3;
val[tmp] = 0;
while (!que.empty()) {
tmp = que.front();
que.pop();
for (auto x : G1[tmp]) {
if (val[tmp] + 1 < val[x]) {
que.push(x);
val[x] = val[tmp] + 1;
}
}
}
if (val[T * 3] == 4 * N)
val[T * 3] = -3;
cout << (val[T * 3] / 3) << endl;
return 0;
}
| [
"literal.number.change",
"assignment.value.change"
] | 799,287 | 799,288 | u716566635 | cpp |
p02991 | #include <algorithm>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
int main() {
ll N, M;
cin >> N >> M;
vector<ll> s(M), e(M);
map<ll, set<ll>> G, G1;
REP(i, M) {
cin >> s[i] >> e[i];
G[s[i]].insert(e[i]);
G1[s[i] * 3].insert(e[i] * 3 + 1);
G1[s[i] * 3 + 1].insert(e[i] * 3 + 2);
G1[s[i] * 3 + 2].insert(e[i] * 3);
}
ll S, T;
cin >> S >> T;
std::vector<ll> val(3 * N + 4, 4 * N);
queue<ll> que;
que.push(S * 3);
ll tmp = S * 3;
val[tmp] = 0;
while (!que.empty()) {
tmp = que.front();
que.pop();
for (auto x : G1[tmp]) {
if (val[tmp] + 1 <= val[x]) {
que.push(x);
val[x] = val[tmp] + 1;
}
}
}
if (val[T * 3] == 4 * N)
val[T * 3] = -1;
cout << (val[T * 3] / 3) << endl;
return 0;
}
| #include <algorithm>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
int main() {
ll N, M;
cin >> N >> M;
vector<ll> s(M), e(M);
map<ll, set<ll>> G, G1;
REP(i, M) {
cin >> s[i] >> e[i];
G[s[i]].insert(e[i]);
G1[s[i] * 3].insert(e[i] * 3 + 1);
G1[s[i] * 3 + 1].insert(e[i] * 3 + 2);
G1[s[i] * 3 + 2].insert(e[i] * 3);
}
ll S, T;
cin >> S >> T;
std::vector<ll> val(3 * N + 4, 4 * N);
queue<ll> que;
que.push(S * 3);
ll tmp = S * 3;
val[tmp] = 0;
while (!que.empty()) {
tmp = que.front();
que.pop();
for (auto x : G1[tmp]) {
if (val[tmp] + 1 < val[x]) {
que.push(x);
val[x] = val[tmp] + 1;
}
}
}
if (val[T * 3] == 4 * N)
val[T * 3] = -3;
cout << (val[T * 3] / 3) << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"literal.number.change",
"assignment.value.change"
] | 799,289 | 799,288 | u716566635 | cpp |
p02991 | #include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 15;
const int inf = 0x3f3f3f3f;
int head[maxn], n, m, u, v, s, t, cnt;
struct edge {
int to, nxt, w;
} e[maxn << 1];
inline void add(int u, int v, int _w) {
e[++cnt].to = v;
e[cnt].nxt = head[u];
e[cnt].w = _w;
head[u] = cnt;
}
int dp[maxn][3], vis[maxn][3];
struct node {
int x, dis, f;
bool friend operator<(node a, node b) { return a.dis < b.dis; }
};
void dijkstra() {
memset(dp, 0x3f, sizeof(dp));
dp[s][0] = 0;
priority_queue<node> q;
q.push(node{s, 0, 0});
while (!q.empty()) {
node now = q.top();
q.pop();
if (vis[now.x][now.f])
continue;
vis[now.x][now.f] = 1;
for (int i = head[now.x]; i; i = e[i].nxt) {
int v = e[i].to;
if (dp[v][(now.f + 1) % 3] > now.dis + 1) {
dp[v][(now.f + 1) % 3] = now.dis + 1;
q.push(node{v, now.dis + 1, (now.f + 1) % 3});
}
}
}
}
int main() {
scanf("%d %d", &n, &m);
while (m--) {
scanf("%d %d", &u, &v);
add(u, v, 1);
// add(v,u,1);
}
scanf("%d %d", &s, &t);
dijkstra();
if (dp[t][0] == inf)
puts("-1");
else
printf("%d\n", dp[t][0] / 3);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 15;
const int inf = 0x3f3f3f3f;
int head[maxn], n, m, u, v, s, t, cnt;
struct edge {
int to, nxt, w;
} e[maxn << 2];
inline void add(int u, int v, int _w) {
e[++cnt].to = v;
e[cnt].nxt = head[u];
e[cnt].w = _w;
head[u] = cnt;
}
int dp[maxn][3], vis[maxn][3];
struct node {
int x, dis, f;
bool friend operator<(node a, node b) { return a.dis > b.dis; }
};
void dijkstra() {
memset(dp, 0x3f, sizeof(dp));
dp[s][0] = 0;
priority_queue<node> q;
q.push(node{s, 0, 0});
while (!q.empty()) {
node now = q.top();
q.pop();
if (vis[now.x][now.f])
continue;
vis[now.x][now.f] = 1;
for (int i = head[now.x]; i; i = e[i].nxt) {
int v = e[i].to;
if (dp[v][(now.f + 1) % 3] > now.dis + 1) {
dp[v][(now.f + 1) % 3] = now.dis + 1;
q.push(node{v, now.dis + 1, (now.f + 1) % 3});
}
}
}
}
int main() {
scanf("%d %d", &n, &m);
while (m--) {
scanf("%d %d", &u, &v);
add(u, v, 1);
}
scanf("%d %d", &s, &t);
dijkstra();
if (dp[t][0] == inf)
puts("-1");
else
printf("%d\n", dp[t][0] / 3);
return 0;
} | [
"literal.number.change",
"expression.operation.binary.change",
"misc.opposites",
"expression.operator.compare.change",
"function.return_value.change"
] | 799,307 | 799,308 | u593546783 | cpp |
p02991 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <vector>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(a) (a).begin(), (a).end()
typedef long long lint;
using namespace std;
int main() {
int N, M, S, T;
cin >> N >> M;
vector<int> c[3 * N];
REP(i, M) {
int u, v;
cin >> u >> v;
u--;
v--;
c[u].push_back(v + N);
c[u + N].push_back(v + 2 * N);
c[u + 2 * N].push_back(v);
}
cin >> S >> T;
S--;
T--;
int d[3 * N];
REP(i, 3 * N) d[i] = -3;
d[S] = 0;
queue<int> q;
q.push(S);
while (!q.empty()) {
int p = q.front();
q.pop();
for (auto e : c[p]) {
if (d[e] > 0)
break;
q.push(e);
d[e] = d[p] + 1;
}
}
cout << d[T] / 3 << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <vector>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(a) (a).begin(), (a).end()
typedef long long lint;
using namespace std;
int main() {
int N, M, S, T;
cin >> N >> M;
vector<int> c[3 * N];
REP(i, M) {
int u, v;
cin >> u >> v;
u--;
v--;
c[u].push_back(v + N);
c[u + N].push_back(v + 2 * N);
c[u + 2 * N].push_back(v);
}
cin >> S >> T;
S--;
T--;
int d[3 * N];
REP(i, 3 * N) d[i] = -3;
d[S] = 0;
queue<int> q;
q.push(S);
while (!q.empty()) {
int p = q.front();
q.pop();
for (auto e : c[p]) {
if (d[e] > 0)
continue;
q.push(e);
d[e] = d[p] + 1;
}
}
cout << d[T] / 3 << endl;
return 0;
}
| [
"control_flow.break.remove",
"control_flow.continue.add"
] | 799,317 | 799,318 | u484460274 | cpp |
p02991 | #include <cstdio>
#include <iostream>
#include <list>
#include <map>
using namespace std;
int N, M;
int S, T;
int ans = -1;
int d[3][100001];
map<int, list<int>> e;
list<pair<int, int>> queue;
int f(int q, int steps, int count) {
for (auto i = e[q].begin(); i != e[q].end(); ++i) {
if (steps == 0 && d[1][*i] < 0) {
d[1][*i] = 1;
f(*i, 1, count);
} else if (steps == 1 && d[2][*i] < 0) {
d[2][*i] = 1;
f(*i, 2, count);
} else if (steps == 2) {
if (d[0][*i] < 0) {
queue.push_back(make_pair(*i, count + 1));
d[0][*i] = count + 1;
}
}
}
}
int main() {
scanf("%d %d", &N, &M);
for (int i = 0; i < N; i++)
for (int j = 0; j < 3; j++)
d[j][i] = -1;
for (int i = 0; i < M; i++) {
int u, v;
scanf("%d %d", &u, &v);
e[u - 1].push_back(v - 1);
}
scanf("%d %d", &S, &T);
S--, T--;
queue.push_back(make_pair(S, 0));
d[0][0] = 0;
for (auto itr = queue.begin(); itr != queue.end(); itr++) {
if (d[0][T] != -1)
break;
f(itr->first, 0, itr->second);
}
cout << d[0][T] << endl;
return 0;
} | #include <cstdio>
#include <iostream>
#include <list>
#include <map>
using namespace std;
int N, M;
int S, T;
int ans = -1;
int d[3][100001];
map<int, list<int>> e;
list<pair<int, int>> queue;
int f(int q, int steps, int count) {
for (auto i = e[q].begin(); i != e[q].end(); ++i) {
if (steps == 0 && d[1][*i] < 0) {
d[1][*i] = 1;
f(*i, 1, count);
} else if (steps == 1 && d[2][*i] < 0) {
d[2][*i] = 1;
f(*i, 2, count);
} else if (steps == 2) {
if (d[0][*i] < 0) {
queue.push_back(make_pair(*i, count + 1));
d[0][*i] = count + 1;
}
}
}
}
int main() {
scanf("%d %d", &N, &M);
for (int i = 0; i < N; i++)
for (int j = 0; j < 3; j++)
d[j][i] = -1;
for (int i = 0; i < M; i++) {
int u, v;
scanf("%d %d", &u, &v);
e[u - 1].push_back(v - 1);
}
scanf("%d %d", &S, &T);
S--, T--;
queue.push_back(make_pair(S, 0));
d[0][S] = 0;
for (auto itr = queue.begin(); itr != queue.end(); itr++) {
if (d[0][T] != -1)
break;
f(itr->first, 0, itr->second);
}
cout << d[0][T] << endl;
return 0;
}
| [
"assignment.variable.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change"
] | 799,321 | 799,322 | u426462442 | cpp |
p02991 | #include <iostream>
#include <queue>
using namespace std;
int n, m, S, T;
vector<vector<int>> graph(300010);
vector<int> dist(300010);
void BFS() {
queue<int> que;
dist[3 * S] = 0;
que.push(3 * S);
while (!que.empty()) {
int f = que.front();
que.pop();
for (auto t : graph[f]) {
if (dist[t] == -1) {
dist[t] = dist[f] + 1;
que.push(t);
}
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
for (int k = 0; k < 3; k++)
graph[3 * u + k].push_back(3 * v + ((k + 1) % 3));
}
cin >> S >> T;
S--;
T--;
BFS();
if (dist[3 * T] == -1)
cout << "-1" << endl;
else
cout << dist[3 * T] / 3 << endl;
return 0;
}
| #include <iostream>
#include <queue>
using namespace std;
int n, m, S, T;
vector<vector<int>> graph(333333);
vector<int> dist(333333, -1);
void BFS() {
queue<int> que;
dist[3 * S] = 0;
que.push(3 * S);
while (!que.empty()) {
int f = que.front();
que.pop();
for (auto t : graph[f]) {
if (dist[t] == -1) {
dist[t] = dist[f] + 1;
que.push(t);
}
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
for (int k = 0; k < 3; k++)
graph[3 * u + k].push_back(3 * v + ((k + 1) % 3));
}
cin >> S >> T;
S--;
T--;
BFS();
if (dist[3 * T] == -1)
cout << "-1" << endl;
else
cout << dist[3 * T] / 3 << endl;
return 0;
}
| [
"literal.number.change",
"call.arguments.change",
"call.arguments.add"
] | 799,350 | 799,351 | u957318593 | cpp |
p02991 | /* -*- coding: utf-8 -*-
*
* e.cc: E - Hopscotch Addict
*/
#include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
/* constant */
const int MAX_N = 100000;
const int K = 3;
const int MAX_GN = MAX_N * K;
/* typedef */
typedef vector<int> vi;
typedef queue<int> qi;
/* global variables */
vi nbrs[MAX_GN];
int ds[MAX_GN];
/* subroutines */
/* main */
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
u--, v--;
int uk = u * K, vk = v * K;
for (int j = 0; j < K; j++)
nbrs[uk + j].push_back(vk + (j + 1) % K);
}
int s, t;
scanf("%d%d", &s, &t);
s--, t--;
int st = s * K, gl = t * K;
memset(ds, -1, sizeof(ds));
ds[s] = 0;
qi q;
q.push(s);
while (!q.empty()) {
int u = q.front();
q.pop();
if (u == gl)
break;
int vd = ds[u] + 1;
vi &nbru = nbrs[u];
for (vi::iterator vit = nbru.begin(); vit != nbru.end(); vit++) {
int &v = *vit;
if (ds[v] < 0) {
ds[v] = vd;
q.push(v);
}
}
}
printf("%d\n", (ds[gl] < 0) ? -1 : ds[gl] / K);
return 0;
}
| /* -*- coding: utf-8 -*-
*
* e.cc: E - Hopscotch Addict
*/
#include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
/* constant */
const int MAX_N = 100000;
const int K = 3;
const int MAX_GN = MAX_N * K;
/* typedef */
typedef vector<int> vi;
typedef queue<int> qi;
/* global variables */
vi nbrs[MAX_GN];
int ds[MAX_GN];
/* subroutines */
/* main */
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
u--, v--;
int uk = u * K, vk = v * K;
for (int j = 0; j < K; j++)
nbrs[uk + j].push_back(vk + (j + 1) % K);
}
int s, t;
scanf("%d%d", &s, &t);
s--, t--;
int st = s * K, gl = t * K;
memset(ds, -1, sizeof(ds));
ds[st] = 0;
qi q;
q.push(st);
while (!q.empty()) {
int u = q.front();
q.pop();
if (u == gl)
break;
int vd = ds[u] + 1;
vi &nbru = nbrs[u];
for (vi::iterator vit = nbru.begin(); vit != nbru.end(); vit++) {
int &v = *vit;
if (ds[v] < 0) {
ds[v] = vd;
q.push(v);
}
}
}
printf("%d\n", (ds[gl] < 0) ? -1 : ds[gl] / K);
return 0;
}
| [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 799,360 | 799,361 | u744314647 | cpp |
p02991 | #include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define ll long long
#define ull unsigned long long
#define rep(i, N) for (ll i = 0; i < N; i++)
#define loop(i, N, M) for (ll i = N; i < M; i++)
#define MAX(v) *max_element(v.begin(), v.end())
#define MIN(v) *min_element(v.begin(), v.end())
#define SORTL2S(type, v) sort(v.begin(), v.end(), greater<type>())
#define SORTS2L(type, v) sort(v.begin(), v.end())
#define SORTMF(v, func) sort(v.begin(), v.end(), func)
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
ll N, M, S, T;
void solve() {
cin >> N >> M;
vector<vector<ll>> edge(3 * N, vector<ll>()); // edge[i]はiから移動できる頂点
rep(i, M) {
ll u, v;
cin >> u >> v;
u--;
v--;
edge[3 * u].emplace_back(3 * v + 1);
edge[3 * u + 1].emplace_back(3 * v + 2);
edge[3 * u + 2].emplace_back(3 * v);
}
cin >> S >> T;
S--;
T--;
queue<ll> Q;
Q.push(3 * S);
vector<ll> chk(3 * N, -1);
chk[3 * S] = 0;
bool end = false;
while (Q.size() != 0) {
ll pos = Q.front();
Q.pop();
rep(i, edge[pos].size()) {
if (chk[edge[pos][i]] == -1) {
Q.push(edge[pos][i]);
chk[edge[pos][i]] = chk[pos] + 1;
}
}
}
cout << (chk[3 * T] == -1 ? -1 : chk[3 * T] % 3);
}
int main() {
solve();
cout << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define ll long long
#define ull unsigned long long
#define rep(i, N) for (ll i = 0; i < N; i++)
#define loop(i, N, M) for (ll i = N; i < M; i++)
#define MAX(v) *max_element(v.begin(), v.end())
#define MIN(v) *min_element(v.begin(), v.end())
#define SORTL2S(type, v) sort(v.begin(), v.end(), greater<type>())
#define SORTS2L(type, v) sort(v.begin(), v.end())
#define SORTMF(v, func) sort(v.begin(), v.end(), func)
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
ll N, M, S, T;
void solve() {
cin >> N >> M;
vector<vector<ll>> edge(3 * N, vector<ll>()); // edge[i]はiから移動できる頂点
rep(i, M) {
ll u, v;
cin >> u >> v;
u--;
v--;
edge[3 * u].emplace_back(3 * v + 1);
edge[3 * u + 1].emplace_back(3 * v + 2);
edge[3 * u + 2].emplace_back(3 * v);
}
cin >> S >> T;
S--;
T--;
queue<ll> Q;
Q.push(3 * S);
vector<ll> chk(3 * N, -1);
chk[3 * S] = 0;
bool end = false;
while (Q.size() != 0) {
ll pos = Q.front();
Q.pop();
rep(i, edge[pos].size()) {
if (chk[edge[pos][i]] == -1) {
Q.push(edge[pos][i]);
chk[edge[pos][i]] = chk[pos] + 1;
}
}
}
cout << (chk[3 * T] == -1 ? -1 : chk[3 * T] / 3);
}
int main() {
solve();
cout << endl;
return 0;
}
| [
"expression.operator.arithmetic.change",
"io.output.change"
] | 799,362 | 799,363 | u426855695 | cpp |
p02991 | #include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define ll long long
#define ull unsigned long long
#define rep(i, N) for (ll i = 0; i < N; i++)
#define loop(i, N, M) for (ll i = N; i < M; i++)
#define MAX(v) *max_element(v.begin(), v.end())
#define MIN(v) *min_element(v.begin(), v.end())
#define SORTL2S(type, v) sort(v.begin(), v.end(), greater<type>())
#define SORTS2L(type, v) sort(v.begin(), v.end())
#define SORTMF(v, func) sort(v.begin(), v.end(), func)
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
ll N, M, S, T;
void solve() {
cin >> N >> M;
vector<vector<ll>> edge(3 * N, vector<ll>()); // edge[i]はiから移動できる頂点
rep(i, M) {
ll u, v;
cin >> u >> v;
u--;
v--;
edge[3 * u].emplace_back(3 * v + 1);
edge[3 * u + 1].emplace_back(3 * v + 2);
edge[3 * u + 2].emplace_back(3 * v);
}
cin >> S >> T;
S--;
T--;
queue<ll> Q;
Q.push(3 * S);
vector<ll> chk(3 * N, -1);
chk[3 * S] = 0;
bool end = false;
while (Q.size() != 0) {
ll pos = Q.front();
Q.pop();
rep(i, edge[pos].size()) {
if (chk[edge[pos][i]] == -1) {
Q.push(edge[pos][i]);
chk[edge[pos][i]] = chk[pos] + 1;
}
}
}
cout << (chk[3 * T] == -1 ? -1 : chk[3 * T + 2] % 3);
}
int main() {
solve();
cout << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define ll long long
#define ull unsigned long long
#define rep(i, N) for (ll i = 0; i < N; i++)
#define loop(i, N, M) for (ll i = N; i < M; i++)
#define MAX(v) *max_element(v.begin(), v.end())
#define MIN(v) *min_element(v.begin(), v.end())
#define SORTL2S(type, v) sort(v.begin(), v.end(), greater<type>())
#define SORTS2L(type, v) sort(v.begin(), v.end())
#define SORTMF(v, func) sort(v.begin(), v.end(), func)
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
ll N, M, S, T;
void solve() {
cin >> N >> M;
vector<vector<ll>> edge(3 * N, vector<ll>()); // edge[i]はiから移動できる頂点
rep(i, M) {
ll u, v;
cin >> u >> v;
u--;
v--;
edge[3 * u].emplace_back(3 * v + 1);
edge[3 * u + 1].emplace_back(3 * v + 2);
edge[3 * u + 2].emplace_back(3 * v);
}
cin >> S >> T;
S--;
T--;
queue<ll> Q;
Q.push(3 * S);
vector<ll> chk(3 * N, -1);
chk[3 * S] = 0;
bool end = false;
while (Q.size() != 0) {
ll pos = Q.front();
Q.pop();
rep(i, edge[pos].size()) {
if (chk[edge[pos][i]] == -1) {
Q.push(edge[pos][i]);
chk[edge[pos][i]] = chk[pos] + 1;
}
}
}
cout << (chk[3 * T] == -1 ? -1 : chk[3 * T] / 3);
}
int main() {
solve();
cout << endl;
return 0;
}
| [
"expression.operation.binary.remove",
"expression.operator.arithmetic.change",
"io.output.change"
] | 799,364 | 799,363 | u426855695 | cpp |
p02991 | #include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define ll long long
#define ull unsigned long long
#define rep(i, N) for (ll i = 0; i < N; i++)
#define loop(i, N, M) for (ll i = N; i < M; i++)
#define MAX(v) *max_element(v.begin(), v.end())
#define MIN(v) *min_element(v.begin(), v.end())
#define SORTL2S(type, v) sort(v.begin(), v.end(), greater<type>())
#define SORTS2L(type, v) sort(v.begin(), v.end())
#define SORTMF(v, func) sort(v.begin(), v.end(), func)
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
ll N, M, S, T;
void solve() {
cin >> N >> M;
vector<vector<ll>> edge(3 * N, vector<ll>()); // edge[i]はiから移動できる頂点
rep(i, M) {
ll u, v;
cin >> u >> v;
u--;
v--;
edge[3 * u].emplace_back(3 * v + 1);
edge[3 * u + 1].emplace_back(3 * v + 2);
edge[3 * u + 2].emplace_back(3 * v);
}
cin >> S >> T;
S--;
T--;
queue<ll> Q;
Q.push(3 * S);
vector<ll> chk(3 * N, -1);
chk[3 * S] = 0;
bool end = false;
while (Q.size() != 0) {
ll pos = Q.front();
Q.pop();
rep(i, edge[pos].size()) {
if (chk[edge[pos][i]] == -1) {
Q.push(edge[pos][i]);
chk[edge[pos][i]] = chk[pos] + 1;
}
}
}
cout << (chk[3 * T + 2] == -1 ? -1 : chk[3 * T + 2] % 3);
}
int main() {
solve();
cout << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define ll long long
#define ull unsigned long long
#define rep(i, N) for (ll i = 0; i < N; i++)
#define loop(i, N, M) for (ll i = N; i < M; i++)
#define MAX(v) *max_element(v.begin(), v.end())
#define MIN(v) *min_element(v.begin(), v.end())
#define SORTL2S(type, v) sort(v.begin(), v.end(), greater<type>())
#define SORTS2L(type, v) sort(v.begin(), v.end())
#define SORTMF(v, func) sort(v.begin(), v.end(), func)
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
ll N, M, S, T;
void solve() {
cin >> N >> M;
vector<vector<ll>> edge(3 * N, vector<ll>()); // edge[i]はiから移動できる頂点
rep(i, M) {
ll u, v;
cin >> u >> v;
u--;
v--;
edge[3 * u].emplace_back(3 * v + 1);
edge[3 * u + 1].emplace_back(3 * v + 2);
edge[3 * u + 2].emplace_back(3 * v);
}
cin >> S >> T;
S--;
T--;
queue<ll> Q;
Q.push(3 * S);
vector<ll> chk(3 * N, -1);
chk[3 * S] = 0;
bool end = false;
while (Q.size() != 0) {
ll pos = Q.front();
Q.pop();
rep(i, edge[pos].size()) {
if (chk[edge[pos][i]] == -1) {
Q.push(edge[pos][i]);
chk[edge[pos][i]] = chk[pos] + 1;
}
}
}
cout << (chk[3 * T] == -1 ? -1 : chk[3 * T] / 3);
}
int main() {
solve();
cout << endl;
return 0;
}
| [
"expression.operation.binary.remove",
"expression.operator.arithmetic.change",
"io.output.change"
] | 799,365 | 799,363 | u426855695 | cpp |
p02991 | #include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define ll long long
#define ull unsigned long long
#define rep(i, N) for (ll i = 0; i < N; i++)
#define loop(i, N, M) for (ll i = N; i < M; i++)
#define MAX(v) *max_element(v.begin(), v.end())
#define MIN(v) *min_element(v.begin(), v.end())
#define SORTL2S(type, v) sort(v.begin(), v.end(), greater<type>())
#define SORTS2L(type, v) sort(v.begin(), v.end())
#define SORTMF(v, func) sort(v.begin(), v.end(), func)
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
ll N, M, S, T;
void solve() {
cin >> N >> M;
vector<vector<ll>> edge(3 * N, vector<ll>()); // edge[i]はiから移動できる頂点
rep(i, M) {
ll u, v;
cin >> u >> v;
u--;
v--;
edge[3 * u].emplace_back(3 * v + 1);
edge[3 * u + 1].emplace_back(3 * v + 2);
edge[3 * u + 2].emplace_back(3 * v);
}
cin >> S >> T;
S--;
T--;
queue<ll> Q;
Q.push(3 * S);
vector<ll> chk(3 * N, -1);
chk[3 * S] = 0;
bool end = false;
while (Q.size() != 0) {
ll pos = Q.front();
Q.pop();
rep(i, edge[pos].size()) {
if (chk[edge[pos][i]] == -1) {
Q.push(edge[pos][i]);
chk[edge[pos][i]] = chk[pos] + 1;
}
}
}
cout << (chk[3 * T + 2] == -1 ? -1 : chk[3 * T + 2] / 3);
}
int main() {
solve();
cout << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define ll long long
#define ull unsigned long long
#define rep(i, N) for (ll i = 0; i < N; i++)
#define loop(i, N, M) for (ll i = N; i < M; i++)
#define MAX(v) *max_element(v.begin(), v.end())
#define MIN(v) *min_element(v.begin(), v.end())
#define SORTL2S(type, v) sort(v.begin(), v.end(), greater<type>())
#define SORTS2L(type, v) sort(v.begin(), v.end())
#define SORTMF(v, func) sort(v.begin(), v.end(), func)
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
ll N, M, S, T;
void solve() {
cin >> N >> M;
vector<vector<ll>> edge(3 * N, vector<ll>()); // edge[i]はiから移動できる頂点
rep(i, M) {
ll u, v;
cin >> u >> v;
u--;
v--;
edge[3 * u].emplace_back(3 * v + 1);
edge[3 * u + 1].emplace_back(3 * v + 2);
edge[3 * u + 2].emplace_back(3 * v);
}
cin >> S >> T;
S--;
T--;
queue<ll> Q;
Q.push(3 * S);
vector<ll> chk(3 * N, -1);
chk[3 * S] = 0;
bool end = false;
while (Q.size() != 0) {
ll pos = Q.front();
Q.pop();
rep(i, edge[pos].size()) {
if (chk[edge[pos][i]] == -1) {
Q.push(edge[pos][i]);
chk[edge[pos][i]] = chk[pos] + 1;
}
}
}
cout << (chk[3 * T] == -1 ? -1 : chk[3 * T] / 3);
}
int main() {
solve();
cout << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 799,366 | 799,363 | u426855695 | cpp |
p02991 | #include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 5;
int dist[100005][3];
int main() {
int n, m;
scanf("%d %d", &n, &m);
vector<vector<int>> to(n);
for (int i = 0; i < m; ++i) {
int a, b;
scanf("%d %d", &a, &b);
--a;
--b;
to[a].push_back(b);
}
int s, t;
scanf("%d %d", &s, &t);
--s;
--t;
for (int i = 0; i < n; ++i)
for (int j = 0; j < 3; ++j)
dist[i][j] = INF;
queue<pair<int, int>> q;
q.push(make_pair(s, 0));
dist[s][0] = 0;
while (!q.empty()) {
int v = q.front().first;
int l = q.front().second;
q.pop();
for (int u : to[v]) {
int nl = (l + 1) % 3;
if (dist[u][nl] != INF)
continue;
dist[u][nl] = dist[v][1] + 1;
q.push(make_pair(u, nl));
}
}
int ans = dist[t][0];
if (ans == INF)
ans = -1;
else
ans /= 3;
printf("%d\n", ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 5;
int dist[100005][3];
int main() {
int n, m;
scanf("%d %d", &n, &m);
vector<vector<int>> to(n);
for (int i = 0; i < m; ++i) {
int a, b;
scanf("%d %d", &a, &b);
--a;
--b;
to[a].push_back(b);
}
int s, t;
scanf("%d %d", &s, &t);
--s;
--t;
for (int i = 0; i < n; ++i)
for (int j = 0; j < 3; ++j)
dist[i][j] = INF;
queue<pair<int, int>> q;
q.push(make_pair(s, 0));
dist[s][0] = 0;
while (!q.empty()) {
int v = q.front().first;
int l = q.front().second;
q.pop();
for (int u : to[v]) {
int nl = (l + 1) % 3;
if (dist[u][nl] != INF)
continue;
dist[u][nl] = dist[v][l] + 1;
q.push(make_pair(u, nl));
}
}
int ans = dist[t][0];
if (ans == INF)
ans = -1;
else
ans /= 3;
printf("%d\n", ans);
return 0;
}
| [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 799,371 | 799,372 | u559765551 | cpp |
p02991 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef pair<int, int> P;
const int INF = 1001001001;
int dist[100005][3];
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> to(n);
rep(i, m) {
int a, b;
cin >> a >> b;
--a;
--b;
to[a].push_back(b);
}
int sv, tv;
cin >> sv >> tv;
--sv;
--tv;
rep(i, n) rep(j, 3) dist[i][j] = INF;
queue<P> q;
q.push(P(sv, 0));
dist[sv][0] = 0;
while (!q.empty()) {
int v = q.front().first;
int l = q.front().second;
q.pop();
for (int u : to[v]) {
int nl = (l + 1) % 3;
if (dist[u][nl] != INF)
continue;
dist[u][nl] = dist[v][l] + 1;
q.push(P(u, nl));
}
}
int ans = dist[tv][0];
if (ans == INF)
ans = -1;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef pair<int, int> P;
const int INF = 1001001001;
int dist[100005][3];
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> to(n);
rep(i, m) {
int a, b;
cin >> a >> b;
--a;
--b;
to[a].push_back(b);
}
int sv, tv;
cin >> sv >> tv;
--sv;
--tv;
rep(i, n) rep(j, 3) dist[i][j] = INF;
queue<P> q;
q.push(P(sv, 0));
dist[sv][0] = 0;
while (!q.empty()) {
int v = q.front().first;
int l = q.front().second;
q.pop();
for (int u : to[v]) {
int nl = (l + 1) % 3;
if (dist[u][nl] != INF)
continue;
dist[u][nl] = dist[v][l] + 1;
q.push(P(u, nl));
}
}
int ans = dist[tv][0];
if (ans == INF)
ans = -1;
else
ans /= 3;
cout << ans << endl;
return 0;
} | [
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add",
"assignment.add"
] | 799,378 | 799,379 | u457283867 | cpp |
p02991 | #include <bits/stdc++.h>
#include <unordered_set>
using namespace std;
#define ll long long
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define repeat(i, s, n) for (int(i) = s; (i) < (n); (i)++)
#define revrep(i, n) for (int(i) = (n)-1; i >= 0; i--)
template <typename W>
// example const ll inf=1e15;
void dijkstra(int s, map<int, map<int, W>> &g, vector<W> &dist, const W inf) {
vector<bool> visited(dist.size());
fill(dist.begin(), dist.end(), inf);
using P = pair<W, int>;
priority_queue<P, vector<P>, greater<P>> pq;
dist[s] = 0;
// visited[s]=true;
pq.push(make_pair(0, s));
while (!pq.empty()) {
int v;
W d;
tie(d, v) = pq.top();
pq.pop();
if (visited[v])
continue;
visited[v] = true;
for (auto &uw : g[v]) {
int u;
W w;
tie(u, w) = uw;
if (visited[u])
continue;
if (d + w < dist[u]) {
dist[u] = d + w;
pq.push(make_pair(dist[u], u));
}
}
}
}
using G = map<int, map<int, int>>;
G make_kg(int n, vector<vector<int>> g) {
G kg;
repeat(v, 1, n + 1) {
// move three times from s
for (auto &u : g[v]) {
kg[v][u + n] = 1;
kg[v + n][u + 2 * n] = 1;
kg[v + 2 * n][u] = 1;
}
}
return kg;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(std::numeric_limits<float>::max_digits10);
cout << fixed;
int n, m;
cin >> n >> m;
vector<vector<int>> g(n + 1);
rep(i, m) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
}
int s, t;
cin >> s >> t;
G kg = make_kg(n, g);
vector<int> dist(3 * n + 1);
const int inf = 1e8;
dijkstra<int>(s, kg, dist, inf);
if (dist[t] == inf) {
cout << -1 << endl;
} else {
cout << dist[t] << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#include <unordered_set>
using namespace std;
#define ll long long
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define repeat(i, s, n) for (int(i) = s; (i) < (n); (i)++)
#define revrep(i, n) for (int(i) = (n)-1; i >= 0; i--)
template <typename W>
// example const ll inf=1e15;
void dijkstra(int s, map<int, map<int, W>> &g, vector<W> &dist, const W inf) {
vector<bool> visited(dist.size());
fill(dist.begin(), dist.end(), inf);
using P = pair<W, int>;
priority_queue<P, vector<P>, greater<P>> pq;
dist[s] = 0;
// visited[s]=true;
pq.push(make_pair(0, s));
while (!pq.empty()) {
int v;
W d;
tie(d, v) = pq.top();
pq.pop();
if (visited[v])
continue;
visited[v] = true;
for (auto &uw : g[v]) {
int u;
W w;
tie(u, w) = uw;
if (visited[u])
continue;
if (d + w < dist[u]) {
dist[u] = d + w;
pq.push(make_pair(dist[u], u));
}
}
}
}
using G = map<int, map<int, int>>;
G make_kg(int n, vector<vector<int>> g) {
G kg;
repeat(v, 1, n + 1) {
// move three times from s
for (auto &u : g[v]) {
kg[v][u + n] = 1;
kg[v + n][u + 2 * n] = 1;
kg[v + 2 * n][u] = 1;
}
}
return kg;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(std::numeric_limits<float>::max_digits10);
cout << fixed;
int n, m;
cin >> n >> m;
vector<vector<int>> g(n + 1);
rep(i, m) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
}
int s, t;
cin >> s >> t;
G kg = make_kg(n, g);
vector<int> dist(3 * n + 1);
const int inf = 1e8;
dijkstra<int>(s, kg, dist, inf);
if (dist[t] == inf) {
cout << -1 << endl;
} else {
cout << dist[t] / 3 << endl;
}
return 0;
}
| [
"expression.operation.binary.add"
] | 799,380 | 799,381 | u817142576 | cpp |
p02991 | #include <bits/stdc++.h>
using namespace std;
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define MIN(a) *min_element(all(a))
#define MAX(a) *max_element(all(a))
#define SUM(a) accumulate(all(a), 0LL)
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define RREP(i, n) for (int(i) = (n)-1; (i) >= 0; (i)--)
#define FOR(i, m, n) for (int(i) = (m); (i) < (n); i++)
#define FORR(i, m, n) for (int(i) = (n)-1; (i) >= (m); i--)
#define debug(x) cerr << #x << " = " << x << endl
//#define int long long
typedef long long ll;
// ll const MOD = 998244353;
ll const MOD = 1e9 + 7;
int const inf = 1e9;
ll const INF = 1e18;
inline void ios_() {
cin.tie(0);
ios::sync_with_stdio(false);
}
template <typename T> int size(const T &a) { return (int)a.size(); }
template <typename T> T Div(T a, T b) { return (a + b - 1) / b; }
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;
}
// Graph in adjcency list
class Graph {
struct edge {
int from;
int to;
ll cost;
edge(int a, ll b) : to(a), cost(b) {}
edge(int a, int b, ll c) : from(a), to(b), cost(c) {}
};
public:
int N; //頂点数
vector<vector<edge>> adjlist; //隣接リスト
vector<ll> depth; //ノードの深さ
vector<bool> check; //訪問済みの頂点を記録
ll diam; //木の直径
vector<int> deg; //入次数
vector<int> tsort; //トポロジカルソートの結果
Graph(int n)
: N(n), adjlist(n), depth(n, INF), check(n, false), diam(INF), deg(n, 0) {
}
void setEdge(int a, int b, ll c) { //辺を追加
adjlist[a].push_back(edge(b, c));
deg[b]++;
}
void dfs(int p, int v, ll d) { //深さ優先探索
if (check[v])
return;
check[v] = true;
depth[v] = d;
for (auto i : adjlist[v]) {
if (i.to == p)
continue;
dfs(v, i.to, d + i.cost);
}
}
void bfs(int v) { //幅優先探索
queue<edge> que;
for (auto i : adjlist[v])
que.push(i);
check[v] = true;
while (!que.empty()) {
int u = que.front().to;
ll d = que.front().cost;
que.pop();
check[u] = true;
depth[u] = d;
for (auto i : adjlist[u]) {
if (!check[i.to]) {
que.push(edge(i.to, d + i.cost));
}
}
}
}
ll diameter() { //木の直径を求める
if (diam != INF)
return diam; //計算済みの場合
dfs(-1, 0, 0); //頂点0からの最遠頂点vを求める
int v = max_element(all(depth)) - depth.begin();
REP(i, N) {
check[i] = false;
depth[i] = 0;
}
dfs(-1, v, 0); // vからの最遠頂点を求める
return diam = MAX(depth); //この2頂点間の距離が直径
}
void dijkstra(int start) { //ダイクストラ法
depth[start] = 0;
auto fn = [](edge a, edge b) { return a.cost > b.cost; };
priority_queue<edge, vector<edge>, decltype(fn)> que(fn);
for (auto i : adjlist[start])
que.push(i);
while (!que.empty()) {
auto v = que.top().to;
auto d = que.top().cost;
que.pop();
if (depth[v] < INF)
continue;
else
depth[v] = d;
for (auto i : adjlist[v]) {
if (depth[i.to] == INF) {
que.push(edge(i.to, i.cost + d));
}
}
}
}
bool
BellmanFord(int start) { //ベルマンフォード法 (負の閉路がある場合はtrueを返す)
depth[start] = 0;
REP(i, N) {
REP(j, N) {
for (auto k : adjlist[j]) {
if (check[j] && depth[j] + k.cost < depth[k.to]) {
if (i == N - 1)
return true; // N回目にも更新があるなら負の閉路が存在
depth[k.to] = depth[j] + k.cost;
}
}
}
}
return false;
}
void topologicalSort() { //トポロジカルソート
deque<int> deq;
REP(i, N) {
if (deg[i] == 0)
deq.push_back(i);
}
while (!deq.empty()) {
auto v = deq.front();
deq.pop_front();
tsort.push_back(v);
for (auto i : adjlist[v]) {
deg[i.to]--;
if (deg[i.to] == 0)
deq.push_back(i.to);
}
}
}
};
signed main() {
ios_();
int n, m;
cin >> n >> m;
Graph G(3 * n);
REP(i, m) {
int a, b;
cin >> a >> b;
a--;
b--;
REP(j, 3) { G.setEdge(3 * a + j, 3 * b + (j + 1) % 3, 1); }
}
int start, goal;
cin >> start >> goal;
start--;
goal--;
G.bfs(start * 3);
ll ans = G.depth[3 * goal];
cout << (ans < INF ? ans / 3 : -1) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define MIN(a) *min_element(all(a))
#define MAX(a) *max_element(all(a))
#define SUM(a) accumulate(all(a), 0LL)
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define RREP(i, n) for (int(i) = (n)-1; (i) >= 0; (i)--)
#define FOR(i, m, n) for (int(i) = (m); (i) < (n); i++)
#define FORR(i, m, n) for (int(i) = (n)-1; (i) >= (m); i--)
#define debug(x) cerr << #x << " = " << x << endl
//#define int long long
typedef long long ll;
// ll const MOD = 998244353;
ll const MOD = 1e9 + 7;
int const inf = 1e9;
ll const INF = 1e18;
inline void ios_() {
cin.tie(0);
ios::sync_with_stdio(false);
}
template <typename T> int size(const T &a) { return (int)a.size(); }
template <typename T> T Div(T a, T b) { return (a + b - 1) / b; }
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;
}
// Graph in adjcency list
class Graph {
struct edge {
int from;
int to;
ll cost;
edge(int a, ll b) : to(a), cost(b) {}
edge(int a, int b, ll c) : from(a), to(b), cost(c) {}
};
public:
int N; //頂点数
vector<vector<edge>> adjlist; //隣接リスト
vector<ll> depth; //ノードの深さ
vector<bool> check; //訪問済みの頂点を記録
ll diam; //木の直径
vector<int> deg; //入次数
vector<int> tsort; //トポロジカルソートの結果
Graph(int n)
: N(n), adjlist(n), depth(n, INF), check(n, false), diam(INF), deg(n, 0) {
}
void setEdge(int a, int b, ll c) { //辺を追加
adjlist[a].push_back(edge(b, c));
deg[b]++;
}
void dfs(int p, int v, ll d) { //深さ優先探索
if (check[v])
return;
check[v] = true;
depth[v] = d;
for (auto i : adjlist[v]) {
if (i.to == p)
continue;
dfs(v, i.to, d + i.cost);
}
}
void bfs(int v) { //幅優先探索
queue<edge> que;
for (auto i : adjlist[v])
que.push(i);
check[v] = true;
while (!que.empty()) {
int u = que.front().to;
ll d = que.front().cost;
que.pop();
check[u] = true;
depth[u] = d;
for (auto i : adjlist[u]) {
if (!check[i.to]) {
que.push(edge(i.to, d + i.cost));
}
}
}
}
ll diameter() { //木の直径を求める
if (diam != INF)
return diam; //計算済みの場合
dfs(-1, 0, 0); //頂点0からの最遠頂点vを求める
int v = max_element(all(depth)) - depth.begin();
REP(i, N) {
check[i] = false;
depth[i] = 0;
}
dfs(-1, v, 0); // vからの最遠頂点を求める
return diam = MAX(depth); //この2頂点間の距離が直径
}
void dijkstra(int start) { //ダイクストラ法
depth[start] = 0;
auto fn = [](edge a, edge b) { return a.cost > b.cost; };
priority_queue<edge, vector<edge>, decltype(fn)> que(fn);
for (auto i : adjlist[start])
que.push(i);
while (!que.empty()) {
auto v = que.top().to;
auto d = que.top().cost;
que.pop();
if (depth[v] < INF)
continue;
else
depth[v] = d;
for (auto i : adjlist[v]) {
if (depth[i.to] == INF) {
que.push(edge(i.to, i.cost + d));
}
}
}
}
bool
BellmanFord(int start) { //ベルマンフォード法 (負の閉路がある場合はtrueを返す)
depth[start] = 0;
REP(i, N) {
REP(j, N) {
for (auto k : adjlist[j]) {
if (check[j] && depth[j] + k.cost < depth[k.to]) {
if (i == N - 1)
return true; // N回目にも更新があるなら負の閉路が存在
depth[k.to] = depth[j] + k.cost;
}
}
}
}
return false;
}
void topologicalSort() { //トポロジカルソート
deque<int> deq;
REP(i, N) {
if (deg[i] == 0)
deq.push_back(i);
}
while (!deq.empty()) {
auto v = deq.front();
deq.pop_front();
tsort.push_back(v);
for (auto i : adjlist[v]) {
deg[i.to]--;
if (deg[i.to] == 0)
deq.push_back(i.to);
}
}
}
};
signed main() {
ios_();
int n, m;
cin >> n >> m;
Graph G(3 * n);
REP(i, m) {
int a, b;
cin >> a >> b;
a--;
b--;
REP(j, 3) { G.setEdge(3 * a + j, 3 * b + (j + 1) % 3, 1); }
}
int start, goal;
cin >> start >> goal;
start--;
goal--;
G.dijkstra(start * 3);
ll ans = G.depth[3 * goal];
cout << (ans < INF ? ans / 3 : -1) << endl;
return 0;
}
| [
"call.function.change"
] | 799,383 | 799,384 | u994831328 | cpp |
p02991 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define reps(i, s, n) for (int(i) = (s); (i) < (n); (i)++)
#define repr(i, n) for (int(i) = (n)-1; (i) >= 0; (i)--)
#define all(v) (v).begin(), (v).end()
#define chmax(a, b) a = (((a) < (b)) ? (b) : (a))
#define chmin(a, b) a = (((a) > (b)) ? (b) : (a))
#define pb push_back
#define mp make_pair
#define mod 1000000007
#define inf 1000000000
#define llinf 1000000000000000
typedef long long ll;
typedef vector<int> vint;
typedef vector<ll> vll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pii> vpii;
int main() {
int n, m;
cin >> n >> m;
vint ps(m), pe(m);
vector<vector<int>> root(n);
vector<vector<int>> true_root(n);
vint minans0(n), minans1(n), minans2(n);
rep(i, m) {
int x, y;
cin >> x >> y;
root[x - 1].pb(y - 1);
// root[y-1].pb(x-1);
}
int s, t;
cin >> s >> t;
s--;
t--;
rep(i, n) {
minans0[i] = inf;
minans1[i] = inf;
minans2[i] = inf;
}
priority_queue<pii, vector<pii>, greater<pii>> que;
que.push(mp(0, s));
while (!que.empty()) {
pii q = que.top();
que.pop();
if (q.first % 3 == 0) {
if (minans0[q.second] <= q.first) {
continue;
}
minans0[q.second] = q.first;
}
if (q.first % 3 == 1) {
if (minans1[q.second] <= q.first) {
continue;
}
minans1[q.second] = q.first;
}
if (q.first % 3 == 2) {
if (minans2[q.second] <= q.first) {
continue;
}
minans2[q.second] = q.first;
}
for (auto x : root[q.second]) {
que.push(mp(q.first + 1, x));
}
}
if (minans0[t] == inf) {
cout << -1 << endl;
} else {
cout << minans0[t] << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define reps(i, s, n) for (int(i) = (s); (i) < (n); (i)++)
#define repr(i, n) for (int(i) = (n)-1; (i) >= 0; (i)--)
#define all(v) (v).begin(), (v).end()
#define chmax(a, b) a = (((a) < (b)) ? (b) : (a))
#define chmin(a, b) a = (((a) > (b)) ? (b) : (a))
#define pb push_back
#define mp make_pair
#define mod 1000000007
#define inf 1000000000
#define llinf 1000000000000000
typedef long long ll;
typedef vector<int> vint;
typedef vector<ll> vll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pii> vpii;
int main() {
int n, m;
cin >> n >> m;
vint ps(m), pe(m);
vector<vector<int>> root(n);
vector<vector<int>> true_root(n);
vint minans0(n), minans1(n), minans2(n);
rep(i, m) {
int x, y;
cin >> x >> y;
root[x - 1].pb(y - 1);
// root[y-1].pb(x-1);
}
int s, t;
cin >> s >> t;
s--;
t--;
rep(i, n) {
minans0[i] = inf;
minans1[i] = inf;
minans2[i] = inf;
}
priority_queue<pii, vector<pii>, greater<pii>> que;
que.push(mp(0, s));
while (!que.empty()) {
pii q = que.top();
que.pop();
if (q.first % 3 == 0) {
if (minans0[q.second] <= q.first) {
continue;
}
minans0[q.second] = q.first;
}
if (q.first % 3 == 1) {
if (minans1[q.second] <= q.first) {
continue;
}
minans1[q.second] = q.first;
}
if (q.first % 3 == 2) {
if (minans2[q.second] <= q.first) {
continue;
}
minans2[q.second] = q.first;
}
for (auto x : root[q.second]) {
que.push(mp(q.first + 1, x));
}
}
if (minans0[t] == inf) {
cout << -1 << endl;
} else {
cout << minans0[t] / 3 << endl;
}
} | [
"expression.operation.binary.add"
] | 799,487 | 799,488 | u943094398 | cpp |
p02991 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
vector<pair<int, int>> edges[100000][3];
int d[100000][3];
bool decided[100000][3];
void dijikstra(int S, int T, int N) {
for (int i = 0; i < N; i++) {
for (int j = 0; j < 3; j++) {
d[i][j] = INT_MAX;
}
}
priority_queue<pair<int, pair<int, int>>, vector<pair<int, pair<int, int>>>,
greater<pair<int, pair<int, int>>>>
pq;
d[S][0] = 0;
pq.push(make_pair(0, make_pair(S, 0)));
while (!pq.empty()) {
auto cur = pq.top();
auto cur_cost = cur.first;
auto cur_node = cur.second.first;
auto cur_mod = cur.second.second;
pq.pop();
if (d[cur_node][cur_mod] < cur_cost) {
continue;
}
for (int i = 0; i < edges[cur_node][cur_mod].size(); i++) {
auto nex = edges[cur_node][cur_mod][i];
auto next_node = nex.first;
auto next_mod = nex.second;
int next_d = d[cur_node][cur_mod] + 1;
if (d[next_node][next_mod] > next_d) {
d[next_node][next_mod] = next_d;
pq.push(make_pair(next_d, make_pair(next_node, next_mod)));
}
}
}
}
int main() {
int N;
int M;
cin >> N >> M;
for (int i = 0; i < M; i++) {
int u;
int v;
cin >> u >> v;
for (int i = 0; i < 3; i++) {
edges[u - 1][i].push_back(make_pair(v - 1, (i + 1) % 3));
// edges[v - 1][i].push_back(make_pair(u - 1, (i + 1) % 3));
}
}
int S;
int T;
cin >> S >> T;
dijikstra(S - 1, T - 1, N);
if (d[T - 1][0] == INT_MAX) {
cout << -1 << endl;
} else {
cout << d[T - 1][0] << endl;
}
/*
for(int i = 0; i < N; i++){
for(int j = 0; j < 3; j++){
cout << d[i][j] / 3 << " ";
}
cout << endl;
}
*/
return 0;
}
| #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
vector<pair<int, int>> edges[100000][3];
int d[100000][3];
bool decided[100000][3];
void dijikstra(int S, int T, int N) {
for (int i = 0; i < N; i++) {
for (int j = 0; j < 3; j++) {
d[i][j] = INT_MAX;
}
}
priority_queue<pair<int, pair<int, int>>, vector<pair<int, pair<int, int>>>,
greater<pair<int, pair<int, int>>>>
pq;
d[S][0] = 0;
pq.push(make_pair(0, make_pair(S, 0)));
while (!pq.empty()) {
auto cur = pq.top();
auto cur_cost = cur.first;
auto cur_node = cur.second.first;
auto cur_mod = cur.second.second;
pq.pop();
if (d[cur_node][cur_mod] < cur_cost) {
continue;
}
for (int i = 0; i < edges[cur_node][cur_mod].size(); i++) {
auto nex = edges[cur_node][cur_mod][i];
auto next_node = nex.first;
auto next_mod = nex.second;
int next_d = d[cur_node][cur_mod] + 1;
if (d[next_node][next_mod] > next_d) {
d[next_node][next_mod] = next_d;
pq.push(make_pair(next_d, make_pair(next_node, next_mod)));
}
}
}
}
int main() {
int N;
int M;
cin >> N >> M;
for (int i = 0; i < M; i++) {
int u;
int v;
cin >> u >> v;
for (int i = 0; i < 3; i++) {
edges[u - 1][i].push_back(make_pair(v - 1, (i + 1) % 3));
// edges[v - 1][i].push_back(make_pair(u - 1, (i + 1) % 3));
}
}
int S;
int T;
cin >> S >> T;
dijikstra(S - 1, T - 1, N);
if (d[T - 1][0] == INT_MAX) {
cout << -1 << endl;
} else {
cout << d[T - 1][0] / 3 << endl;
}
/*
for(int i = 0; i < N; i++){
for(int j = 0; j < 3; j++){
cout << d[i][j] / 3 << " ";
}
cout << endl;
}
*/
return 0;
}
| [
"expression.operation.binary.add"
] | 799,489 | 799,490 | u623349537 | cpp |
p02991 | #include <bits/stdc++.h>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
#define ll long long
#define faltu \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define binary(x) \
std::string binary = std::bitset<25>(x).to_string(); // to binary
#define inf 1000000007
#define mod 1000000007
#define pi pair<int, int>
#define lpi pair<int, int>
#define mp make_pair
#define pb push_back
#define vi vector<int>
#define lvi vector<long long int>
#define pie 3.14159265358979323846
ll int MMM = inf;
int pw(int x, int y) {
int z = 1;
for (; y; y >>= 1, x = 1ll * x * x % MMM)
if (y & 1)
z = 1ll * z * x % MMM;
return z;
}
using namespace std;
vi pm;
void prm(int n) {
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= n; i += p)
prime[i] = false;
}
}
for (int p = 2; p <= n; p++)
if (prime[p])
pm.pb(p);
}
bool sortbysecdesc(const pair<ll int, ll int> &a,
const pair<ll int, ll int> &b) {
return a.first > b.first;
}
bool cmp(int x, int y) { return x > y; }
int vis[100003][4];
int main() {
faltu;
int n, m, uu, vv, x, y;
cin >> n >> m;
vi v[n + 1];
for (int i = 0; i < m; i++) {
cin >> x >> y;
v[x].pb(y);
}
cin >> uu >> vv;
queue<pair<int, int>> q;
q.push(mp(1, 0));
int s;
vis[1][0] = 1;
while (!q.empty()) {
int f = q.front().first;
s = q.front().second;
q.pop();
if (f == vv && s % 3 == 0)
break;
s++;
for (int i = 0; i < v[f].size(); i++) {
if (vis[v[f][i]][s % 3])
continue;
q.push(mp(v[f][i], s));
vis[v[f][i]][s % 3] = 1;
}
}
if (!vis[vv][0])
cout << "-1" << endl;
else
cout << s / 3 << endl;
}
| #include <bits/stdc++.h>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
#define ll long long
#define faltu \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define binary(x) \
std::string binary = std::bitset<25>(x).to_string(); // to binary
#define inf 1000000007
#define mod 1000000007
#define pi pair<int, int>
#define lpi pair<int, int>
#define mp make_pair
#define pb push_back
#define vi vector<int>
#define lvi vector<long long int>
#define pie 3.14159265358979323846
ll int MMM = inf;
int pw(int x, int y) {
int z = 1;
for (; y; y >>= 1, x = 1ll * x * x % MMM)
if (y & 1)
z = 1ll * z * x % MMM;
return z;
}
using namespace std;
vi pm;
void prm(int n) {
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= n; i += p)
prime[i] = false;
}
}
for (int p = 2; p <= n; p++)
if (prime[p])
pm.pb(p);
}
bool sortbysecdesc(const pair<ll int, ll int> &a,
const pair<ll int, ll int> &b) {
return a.first > b.first;
}
bool cmp(int x, int y) { return x > y; }
int vis[100003][4];
int main() {
faltu;
int n, m, uu, vv, x, y;
cin >> n >> m;
vi v[n + 1];
for (int i = 0; i < m; i++) {
cin >> x >> y;
v[x].pb(y);
}
cin >> uu >> vv;
queue<pair<int, int>> q;
q.push(mp(uu, 0));
int s;
vis[uu][0] = 1;
while (!q.empty()) {
int f = q.front().first;
s = q.front().second;
q.pop();
if (f == vv && s % 3 == 0)
break;
s++;
for (int i = 0; i < v[f].size(); i++) {
if (vis[v[f][i]][s % 3])
continue;
q.push(mp(v[f][i], s));
vis[v[f][i]][s % 3] = 1;
}
}
if (!vis[vv][0])
cout << "-1" << endl;
else
cout << s / 3 << endl;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change",
"assignment.variable.change",
"variable_access.subscript.index.change"
] | 799,493 | 799,494 | u323491962 | cpp |
p02991 | #include <bits/stdc++.h>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
#define ll long long
#define faltu \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define binary(x) \
std::string binary = std::bitset<25>(x).to_string(); // to binary
#define inf 1000000007
#define mod 1000000007
#define pi pair<int, int>
#define lpi pair<int, int>
#define mp make_pair
#define pb push_back
#define vi vector<int>
#define lvi vector<long long int>
#define pie 3.14159265358979323846
ll int MMM = inf;
int pw(int x, int y) {
int z = 1;
for (; y; y >>= 1, x = 1ll * x * x % MMM)
if (y & 1)
z = 1ll * z * x % MMM;
return z;
}
using namespace std;
vi pm;
void prm(int n) {
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= n; i += p)
prime[i] = false;
}
}
for (int p = 2; p <= n; p++)
if (prime[p])
pm.pb(p);
}
bool sortbysecdesc(const pair<ll int, ll int> &a,
const pair<ll int, ll int> &b) {
return a.first > b.first;
}
bool cmp(int x, int y) { return x > y; }
int vis[300003][4];
int main() {
faltu;
int n, m, uu, vv, x, y;
cin >> n >> m;
vi v[n + 1];
for (int i = 0; i < m; i++) {
cin >> x >> y;
v[x].pb(y);
}
cin >> uu >> vv;
queue<pair<int, int>> q;
q.push(mp(1, 0));
int s;
vis[1][0] = 1;
while (!q.empty()) {
int f = q.front().first;
s = q.front().second;
q.pop();
if (f == vv && s % 3 == 0)
break;
s++;
for (int i = 0; i < v[f].size(); i++) {
if (vis[v[f][i]][s % 3])
continue;
q.push(mp(v[f][i], s));
vis[v[f][i]][s % 3] = 1;
}
}
if (!vis[vv][s % 3])
cout << "-1" << endl;
else
cout << s / 3 << endl;
}
| #include <bits/stdc++.h>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
#define ll long long
#define faltu \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define binary(x) \
std::string binary = std::bitset<25>(x).to_string(); // to binary
#define inf 1000000007
#define mod 1000000007
#define pi pair<int, int>
#define lpi pair<int, int>
#define mp make_pair
#define pb push_back
#define vi vector<int>
#define lvi vector<long long int>
#define pie 3.14159265358979323846
ll int MMM = inf;
int pw(int x, int y) {
int z = 1;
for (; y; y >>= 1, x = 1ll * x * x % MMM)
if (y & 1)
z = 1ll * z * x % MMM;
return z;
}
using namespace std;
vi pm;
void prm(int n) {
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= n; i += p)
prime[i] = false;
}
}
for (int p = 2; p <= n; p++)
if (prime[p])
pm.pb(p);
}
bool sortbysecdesc(const pair<ll int, ll int> &a,
const pair<ll int, ll int> &b) {
return a.first > b.first;
}
bool cmp(int x, int y) { return x > y; }
int vis[100003][4];
int main() {
faltu;
int n, m, uu, vv, x, y;
cin >> n >> m;
vi v[n + 1];
for (int i = 0; i < m; i++) {
cin >> x >> y;
v[x].pb(y);
}
cin >> uu >> vv;
queue<pair<int, int>> q;
q.push(mp(uu, 0));
int s;
vis[uu][0] = 1;
while (!q.empty()) {
int f = q.front().first;
s = q.front().second;
q.pop();
if (f == vv && s % 3 == 0)
break;
s++;
for (int i = 0; i < v[f].size(); i++) {
if (vis[v[f][i]][s % 3])
continue;
q.push(mp(v[f][i], s));
vis[v[f][i]][s % 3] = 1;
}
}
if (!vis[vv][0])
cout << "-1" << endl;
else
cout << s / 3 << endl;
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change",
"assignment.variable.change",
"variable_access.subscript.index.change",
"identifier.replace.remove",
"literal.replace.add",
"control_flow.branch.if.... | 799,495 | 799,494 | u323491962 | cpp |
p02991 | #include <bits/stdc++.h>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
#define ll long long
#define faltu \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define binary(x) \
std::string binary = std::bitset<25>(x).to_string(); // to binary
#define inf 1000000007
#define mod 1000000007
#define pi pair<int, int>
#define lpi pair<int, int>
#define mp make_pair
#define pb push_back
#define vi vector<int>
#define lvi vector<long long int>
#define pie 3.14159265358979323846
ll int MMM = inf;
int pw(int x, int y) {
int z = 1;
for (; y; y >>= 1, x = 1ll * x * x % MMM)
if (y & 1)
z = 1ll * z * x % MMM;
return z;
}
using namespace std;
vi pm;
void prm(int n) {
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= n; i += p)
prime[i] = false;
}
}
for (int p = 2; p <= n; p++)
if (prime[p])
pm.pb(p);
}
bool sortbysecdesc(const pair<ll int, ll int> &a,
const pair<ll int, ll int> &b) {
return a.first > b.first;
}
bool cmp(int x, int y) { return x > y; }
int vis[100003][4];
int main() {
faltu;
int n, m, uu, vv, x, y;
cin >> n >> m;
vi v[n + 1];
for (int i = 0; i < m; i++) {
cin >> x >> y;
v[x].pb(y);
}
cin >> uu >> vv;
queue<pair<int, int>> q;
q.push(mp(1, 0));
int s;
vis[1][0] = 1;
while (!q.empty()) {
int f = q.front().first;
s = q.front().second;
q.pop();
if (f == vv && s % 3 == 0)
break;
s++;
for (int i = 0; i < v[f].size(); i++) {
if (vis[v[f][i]][s % 3])
continue;
q.push(mp(v[f][i], s));
vis[v[f][i]][s % 3] = 1;
}
}
if (!vis[vv][s % 3])
cout << "-1" << endl;
else
cout << s / 3 << endl;
}
| #include <bits/stdc++.h>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
#define ll long long
#define faltu \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define binary(x) \
std::string binary = std::bitset<25>(x).to_string(); // to binary
#define inf 1000000007
#define mod 1000000007
#define pi pair<int, int>
#define lpi pair<int, int>
#define mp make_pair
#define pb push_back
#define vi vector<int>
#define lvi vector<long long int>
#define pie 3.14159265358979323846
ll int MMM = inf;
int pw(int x, int y) {
int z = 1;
for (; y; y >>= 1, x = 1ll * x * x % MMM)
if (y & 1)
z = 1ll * z * x % MMM;
return z;
}
using namespace std;
vi pm;
void prm(int n) {
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= n; i += p)
prime[i] = false;
}
}
for (int p = 2; p <= n; p++)
if (prime[p])
pm.pb(p);
}
bool sortbysecdesc(const pair<ll int, ll int> &a,
const pair<ll int, ll int> &b) {
return a.first > b.first;
}
bool cmp(int x, int y) { return x > y; }
int vis[100003][4];
int main() {
faltu;
int n, m, uu, vv, x, y;
cin >> n >> m;
vi v[n + 1];
for (int i = 0; i < m; i++) {
cin >> x >> y;
v[x].pb(y);
}
cin >> uu >> vv;
queue<pair<int, int>> q;
q.push(mp(uu, 0));
int s;
vis[uu][0] = 1;
while (!q.empty()) {
int f = q.front().first;
s = q.front().second;
q.pop();
if (f == vv && s % 3 == 0)
break;
s++;
for (int i = 0; i < v[f].size(); i++) {
if (vis[v[f][i]][s % 3])
continue;
q.push(mp(v[f][i], s));
vis[v[f][i]][s % 3] = 1;
}
}
if (!vis[vv][0])
cout << "-1" << endl;
else
cout << s / 3 << endl;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change",
"assignment.variable.change",
"variable_access.subscript.index.change",
"identifier.replace.remove",
"literal.replace.add",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 799,496 | 799,494 | u323491962 | cpp |
p02991 | #define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#include <algorithm>
#include <array>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
#define INF 0x3f3f3f3f
#define INFLL 0x3f3f3f3f3f3f3f3fLL
//#define mod 998244353
#define MOD 1000000007
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define eb emplace_back
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pint;
typedef pair<ll, ll> pll;
typedef tuple<int, int, int> tint;
typedef vector<int> vint;
typedef vector<ll> vll;
typedef vector<ull> vull;
typedef vector<pint> vpint;
int dx[8] = {0, 0, -1, 1, 1, 1, -1, -1};
int dy[8] = {-1, 1, 0, 0, 1, -1, 1, -1};
const int SIZE = 5050;
// templete
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
#define FOR(i, c) for (auto i = (c).begin(); i != (c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
typedef int Weight;
struct Edge {
int src, dst;
Weight weight;
Edge(int src, int dst, Weight weight) : src(src), dst(dst), weight(weight) {}
};
bool operator<(const Edge &e, const Edge &f) {
return e.weight != f.weight ? e.weight > f.weight : // !!INVERSE!!
e.src != f.src ? e.src < f.src
: e.dst < f.dst;
}
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
typedef vector<Weight> Array;
typedef vector<Array> Matrix;
void shortestPath(const Graph &g, int s, vector<Weight> &dist,
vector<int> &prev) {
int n = g.size();
dist.assign(n, INF);
dist[s] = 0;
prev.assign(n, -1);
priority_queue<Edge> Q; // "e < f" <=> "e.weight > f.weight"
for (Q.push(Edge(-2, s, 0)); !Q.empty();) {
Edge e = Q.top();
Q.pop();
if (prev[e.dst] != -1)
continue;
prev[e.dst] = e.src;
FOR(f, g[e.dst]) {
if (dist[f->dst] > e.weight + f->weight) {
dist[f->dst] = e.weight + f->weight;
Q.push(Edge(f->src, f->dst, e.weight + f->weight));
}
}
}
}
vector<int> buildPath(const vector<int> &prev, int t) {
vector<int> path;
for (int u = t; u >= 0; u = prev[u])
path.push_back(u);
reverse(path.begin(), path.end());
return path;
}
int N;
int num(int i, int a) { return i + N * a; }
int main() {
cin >> N;
int M;
cin >> M;
Graph G;
for (int i = 0; i < N * 3; i++) {
Edges E;
G.pb(E);
}
for (int i = 0; i < M; i++) {
int s, t;
cin >> s >> t;
s--;
t--;
for (int j = 0; j < 3; j++) {
G[num(s, j)].pb(Edge(num(s, j), num(t, (j + 1) % 3), 1));
}
}
int S, T;
cin >> S >> T;
S--;
T--;
vector<Weight> dist;
vector<int> prev;
shortestPath(G, num(S, 0), dist, prev);
if (dist[num(T, 2)] == INF)
cout << -1 << endl;
else
cout << dist[num(T, 2)] << endl;
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#include <algorithm>
#include <array>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
#define INF 0x3f3f3f3f
#define INFLL 0x3f3f3f3f3f3f3f3fLL
//#define mod 998244353
#define MOD 1000000007
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define eb emplace_back
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pint;
typedef pair<ll, ll> pll;
typedef tuple<int, int, int> tint;
typedef vector<int> vint;
typedef vector<ll> vll;
typedef vector<ull> vull;
typedef vector<pint> vpint;
int dx[8] = {0, 0, -1, 1, 1, 1, -1, -1};
int dy[8] = {-1, 1, 0, 0, 1, -1, 1, -1};
const int SIZE = 5050;
// templete
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
#define FOR(i, c) for (auto i = (c).begin(); i != (c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
typedef int Weight;
struct Edge {
int src, dst;
Weight weight;
Edge(int src, int dst, Weight weight) : src(src), dst(dst), weight(weight) {}
};
bool operator<(const Edge &e, const Edge &f) {
return e.weight != f.weight ? e.weight > f.weight : // !!INVERSE!!
e.src != f.src ? e.src < f.src
: e.dst < f.dst;
}
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
typedef vector<Weight> Array;
typedef vector<Array> Matrix;
void shortestPath(const Graph &g, int s, vector<Weight> &dist,
vector<int> &prev) {
int n = g.size();
dist.assign(n, INF);
dist[s] = 0;
prev.assign(n, -1);
priority_queue<Edge> Q; // "e < f" <=> "e.weight > f.weight"
for (Q.push(Edge(-2, s, 0)); !Q.empty();) {
Edge e = Q.top();
Q.pop();
if (prev[e.dst] != -1)
continue;
prev[e.dst] = e.src;
FOR(f, g[e.dst]) {
if (dist[f->dst] > e.weight + f->weight) {
dist[f->dst] = e.weight + f->weight;
Q.push(Edge(f->src, f->dst, e.weight + f->weight));
}
}
}
}
vector<int> buildPath(const vector<int> &prev, int t) {
vector<int> path;
for (int u = t; u >= 0; u = prev[u])
path.push_back(u);
reverse(path.begin(), path.end());
return path;
}
int N;
int num(int i, int a) { return i + N * a; }
int main() {
cin >> N;
int M;
cin >> M;
Graph G;
for (int i = 0; i < N * 3; i++) {
Edges E;
G.pb(E);
}
for (int i = 0; i < M; i++) {
int s, t;
cin >> s >> t;
s--;
t--;
for (int j = 0; j < 3; j++) {
G[num(s, j)].pb(Edge(num(s, j), num(t, (j + 1) % 3), 1));
}
}
int S, T;
cin >> S >> T;
S--;
T--;
vector<Weight> dist;
vector<int> prev;
shortestPath(G, num(S, 0), dist, prev);
if (dist[num(T, 0)] == INF)
cout << -1 << endl;
else
cout << dist[num(T, 0)] / 3 << endl;
return 0;
} | [
"literal.number.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"io.output.change"
] | 799,499 | 799,500 | u836644468 | cpp |
p02991 | #include <bits/stdc++.h>
using namespace std;
using pint = pair<int, int>;
using ll = long long;
using pll = pair<ll, ll>;
#define FOR(i, begin, end) \
for (int i = (begin), i##_end_ = (end); i < i##_end_; i++)
#define IFOR(i, begin, end) \
for (int i = (end)-1, i##_begin_ = (begin); i >= i##_begin_; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
#define FI first
#define SE second
#define endl "\n"
#define ciosup \
cin.tie(0); \
ios::sync_with_stdio(false);
#define eb emplace_back
#define vint vector<int>
constexpr ll INF = -1;
constexpr ll MOD = 1e9 + 7;
int d[100005];
int d2[100005];
int n, m;
int s, t;
vector<vector<int>> G(100005);
int bfs() {
queue<int> que;
REP(i, n + 3)
d[i] = INF;
que.push(s);
d[s] = 0;
while (que.size()) {
int p = que.front();
que.pop();
if (p == t)
break;
for (auto ite = G[p].begin(); ite != G[p].end(); ++ite) {
for (auto ite2 = G[*ite].begin(); ite2 != G[*ite].end(); ++ite2) {
if (d2[*ite2] != 0) {
for (auto ite3 = G[*ite2].begin(); ite3 != G[*ite2].end(); ++ite3) {
if (d[*ite3] == INF) {
que.push(*ite3);
d[*ite3] = d[p] + 1;
}
}
d2[*ite2] = 1;
}
}
}
if (d[t] != INF)
break;
}
return d[t];
}
int main() {
ciosup;
cin >> n >> m;
REP(i, m) {
int u, v;
cin >> u >> v;
G[u].eb(v);
// G[v].eb(u);
}
cin >> s >> t;
cout << bfs() << endl;
} | #include <bits/stdc++.h>
using namespace std;
using pint = pair<int, int>;
using ll = long long;
using pll = pair<ll, ll>;
#define FOR(i, begin, end) \
for (int i = (begin), i##_end_ = (end); i < i##_end_; i++)
#define IFOR(i, begin, end) \
for (int i = (end)-1, i##_begin_ = (begin); i >= i##_begin_; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
#define FI first
#define SE second
#define endl "\n"
#define ciosup \
cin.tie(0); \
ios::sync_with_stdio(false);
#define eb emplace_back
#define vint vector<int>
constexpr ll INF = -1;
constexpr ll MOD = 1e9 + 7;
int d[100005];
int d2[100005];
int n, m;
int s, t;
vector<vector<int>> G(100005);
int bfs() {
queue<int> que;
REP(i, n + 3)
d[i] = INF;
que.push(s);
d[s] = 0;
while (que.size()) {
int p = que.front();
que.pop();
if (p == t)
break;
for (auto ite = G[p].begin(); ite != G[p].end(); ++ite) {
for (auto ite2 = G[*ite].begin(); ite2 != G[*ite].end(); ++ite2) {
if (d2[*ite2] == 0) {
for (auto ite3 = G[*ite2].begin(); ite3 != G[*ite2].end(); ++ite3) {
if (d[*ite3] == INF) {
que.push(*ite3);
d[*ite3] = d[p] + 1;
}
}
d2[*ite2] = 1;
}
}
}
if (d[t] != INF)
break;
}
return d[t];
}
int main() {
ciosup;
cin >> n >> m;
REP(i, m) {
int u, v;
cin >> u >> v;
G[u].eb(v);
// G[v].eb(u);
}
cin >> s >> t;
cout << bfs() << endl;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 799,503 | 799,504 | u337054478 | cpp |
p02991 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < ((int)(n)); i++)
#define reg(i, a, b) for (int i = ((int)(a)); i <= ((int)(b)); i++)
#define irep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define ireg(i, a, b) for (int i = ((int)(b)); i >= ((int)(a)); i--)
typedef long long ll;
/*
*/
ll INF = 1e18;
ll n, m, s, t;
ll d[3][100010];
vector<ll> v[100010];
void dfs(int root) {
queue<pair<ll, ll>> Q;
rep(j, 3) rep(i, n) d[j][i] = INF;
d[root][0] = 0;
Q.push({root, 0});
while (!Q.empty()) {
pair<ll, ll> pf = Q.front();
Q.pop();
ll p = pf.first, state = pf.second;
// cerr<<p<<endl;
for (int i = 0; i < v[p].size(); i++) {
int q = v[p][i];
if (d[(state + 1) % 3][q] > d[state][p] + 1) {
d[(state + 1) % 3][q] = d[state][p] + 1;
Q.push({q, (state + 1) % 3});
}
}
}
}
void init() {
cin >> n >> m;
rep(i, m) {
ll a, b;
cin >> a >> b;
a--;
b--;
v[a].push_back(b);
// v[b].push_back(a);
}
cin >> s >> t;
s--;
t--;
dfs(s);
// rep(j,3){
// rep(i,n)cerr<<d[j][i]<<" ";
// cerr<<endl;
// }
}
int main(void) {
init();
if (d[0][t] == 1e18) {
cout << -1 << endl;
} else {
cout << d[0][t] / 3 << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < ((int)(n)); i++)
#define reg(i, a, b) for (int i = ((int)(a)); i <= ((int)(b)); i++)
#define irep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define ireg(i, a, b) for (int i = ((int)(b)); i >= ((int)(a)); i--)
typedef long long ll;
/*
*/
ll INF = 1e18;
ll n, m, s, t;
ll d[3][200010];
vector<ll> v[100010];
void dfs(int root) {
queue<pair<ll, ll>> Q;
rep(j, 3) rep(i, n) d[j][i] = INF;
d[0][root] = 0;
Q.push({root, 0});
while (!Q.empty()) {
pair<ll, ll> pf = Q.front();
Q.pop();
ll p = pf.first, state = pf.second;
// cerr<<p<<endl;
for (int i = 0; i < v[p].size(); i++) {
int q = v[p][i];
if (d[(state + 1) % 3][q] > d[state][p] + 1) {
d[(state + 1) % 3][q] = d[state][p] + 1;
Q.push({q, (state + 1) % 3});
}
}
}
}
void init() {
cin >> n >> m;
rep(i, m) {
ll a, b;
cin >> a >> b;
a--;
b--;
v[a].push_back(b);
}
cin >> s >> t;
s--;
t--;
dfs(s);
// rep(j,3){
// rep(i,n)cerr<<d[j][i]<<" ";
// cerr<<endl;
// }
}
int main(void) {
init();
if (d[0][t] == INF) {
cout << -1 << endl;
} else {
cout << d[0][t] / 3 << endl;
}
return 0;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"assignment.variable.change",
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.branch.if.condition.change"
] | 799,505 | 799,506 | u372786981 | cpp |
p02991 | #include <bits/stdc++.h>
using namespace std;
constexpr int maxn = 1e5 + 10, inf = 1e8;
int n, m;
vector<int> g[maxn];
int d[maxn][3];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0, u, v; i < m; ++i) {
scanf("%d%d", &u, &v);
g[u].push_back(v);
}
int s, t;
scanf("%d%d", &s, &t);
for (int i = 1; i <= n; ++i) {
d[i][0] = d[i][1] = d[i][2] = inf;
}
d[s][0] = 0;
queue<pair<int, int>> q;
q.emplace(s, 0);
while (q.size()) {
int x = q.front().first;
int t = q.front().first;
q.pop();
for (int y : g[x]) {
int &tmp = d[y][(t + 1) % 3];
if (tmp == inf) {
tmp = d[x][t] + 1;
q.emplace(y, (t + 1) % 3);
}
}
}
printf("%d\n", (d[t][0] != inf) ? d[t][0] / 3 : -1);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
constexpr int maxn = 1e5 + 10, inf = 1e8;
int n, m;
vector<int> g[maxn];
int d[maxn][3];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0, u, v; i < m; ++i) {
scanf("%d%d", &u, &v);
g[u].push_back(v);
}
int s, t;
scanf("%d%d", &s, &t);
for (int i = 1; i <= n; ++i) {
d[i][0] = d[i][1] = d[i][2] = inf;
}
d[s][0] = 0;
queue<pair<int, int>> q;
q.emplace(s, 0);
while (q.size()) {
int x = q.front().first;
int t = q.front().second;
q.pop();
for (int y : g[x]) {
int &tmp = d[y][(t + 1) % 3];
if (tmp == inf) {
tmp = d[x][t] + 1;
q.emplace(y, (t + 1) % 3);
}
}
}
printf("%d\n", (d[t][0] != inf) ? d[t][0] / 3 : -1);
return 0;
}
| [] | 799,516 | 799,517 | u129325320 | cpp |
p02991 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(a, b, c) for (int a = b, a##end = c; a <= a##end; ++a)
#define drep(a, b, c) for (int a = b, a##end = c; a >= a##end; --a)
char IO;
int rd() {
int s = 0, f = 0;
while (IO = getchar(), IO < '0' || IO > '9')
if (IO == '-')
f = 1;
do
s = (s << 1) + (s << 3) + (IO ^ '0');
while (IO = getchar(), IO >= '0' && IO <= '9');
return f ? -s : s;
}
const int N = 1e5 + 10, P = 1e9 + 7;
int n, m;
int dis[N][3];
struct Edge {
int to, nxt;
} e[N];
int head[N], ecnt;
void AddEdge(int u, int v) {
e[++ecnt] = (Edge){v, head[u]};
head[u] = ecnt;
}
int inq[N][3];
queue<pair<int, int>> Q;
void SPFA(int st) {
Q.push((pair<int, int>){st, 0});
dis[st][0] = 0;
while (!Q.empty()) {
int u = Q.front().first, k = Q.front().second;
Q.pop();
int nk = (k + 1) % 3;
inq[u][k] = 0;
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (dis[v][nk] > dis[u][k] + 1) {
dis[v][nk] = dis[u][k] + 1;
if (!inq[v][k])
Q.push((pair<int, int>){v, nk}), inq[v][nk] = 1;
}
}
}
}
int main() {
memset(dis, 127, sizeof dis);
n = rd(), m = rd();
rep(i, 1, m) {
int u = rd(), v = rd();
AddEdge(u, v);
}
int s = rd(), t = rd();
SPFA(s);
int ans = dis[t][0];
if (ans < 1e9)
printf("%d\n", ans / 3);
else
puts("-1");
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(a, b, c) for (int a = b, a##end = c; a <= a##end; ++a)
#define drep(a, b, c) for (int a = b, a##end = c; a >= a##end; --a)
char IO;
int rd() {
int s = 0, f = 0;
while (IO = getchar(), IO < '0' || IO > '9')
if (IO == '-')
f = 1;
do
s = (s << 1) + (s << 3) + (IO ^ '0');
while (IO = getchar(), IO >= '0' && IO <= '9');
return f ? -s : s;
}
const int N = 1e5 + 10, P = 1e9 + 7;
int n, m;
int dis[N][3];
struct Edge {
int to, nxt;
} e[N];
int head[N], ecnt;
void AddEdge(int u, int v) {
e[++ecnt] = (Edge){v, head[u]};
head[u] = ecnt;
}
int inq[N][3];
queue<pair<int, int>> Q;
void SPFA(int st) {
Q.push((pair<int, int>){st, 0});
dis[st][0] = 0;
while (!Q.empty()) {
int u = Q.front().first, k = Q.front().second;
Q.pop();
int nk = (k + 1) % 3;
inq[u][k] = 0;
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (dis[v][nk] > dis[u][k] + 1) {
dis[v][nk] = dis[u][k] + 1;
if (!inq[v][nk])
Q.push((pair<int, int>){v, nk}), inq[v][nk] = 1;
}
}
}
}
int main() {
memset(dis, 127, sizeof dis);
n = rd(), m = rd();
rep(i, 1, m) {
int u = rd(), v = rd();
AddEdge(u, v);
}
int s = rd(), t = rd();
SPFA(s);
int ans = dis[t][0];
if (ans < 1e9)
printf("%d\n", ans / 3);
else
puts("-1");
}
| [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 799,525 | 799,526 | u891465773 | cpp |
p02991 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < int(n); ++i)
const int INF = 1e9;
int main(void) {
int n, m;
cin >> n >> m;
vector<vector<int>> g(n);
g.resize(n);
rep(i, m) {
int u, v;
cin >> u >> v;
u--, v--;
g[u].push_back(v);
}
int s, t;
cin >> s >> t;
s--, t--;
vector<int> dp[3];
rep(i, 3) dp[i] = vector<int>(n, INF);
dp[0][s] = 0;
using P = pair<int, int>;
queue<P> qu;
qu.push({0, 0});
while (qu.size()) {
P front = qu.front();
qu.pop();
int v = front.first;
int cost = front.second + 1;
for (int to : g[v]) {
if (dp[cost % 3][to] > cost) {
dp[cost % 3][to] = cost;
qu.push({to, cost});
}
}
}
cout << (dp[0][t] < INF ? dp[0][t] / 3 : -1) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < int(n); ++i)
const int INF = 1e9;
int main(void) {
int n, m;
cin >> n >> m;
vector<vector<int>> g(n);
g.resize(n);
rep(i, m) {
int u, v;
cin >> u >> v;
u--, v--;
g[u].push_back(v);
}
int s, t;
cin >> s >> t;
s--, t--;
vector<int> dp[3];
rep(i, 3) dp[i] = vector<int>(n, INF);
dp[0][s] = 0;
using P = pair<int, int>;
queue<P> qu;
qu.push({s, 0});
while (qu.size()) {
P front = qu.front();
qu.pop();
int v = front.first;
int cost = front.second + 1;
for (int to : g[v]) {
if (dp[cost % 3][to] > cost) {
dp[cost % 3][to] = cost;
qu.push({to, cost});
}
}
}
cout << (dp[0][t] < INF ? dp[0][t] / 3 : -1) << endl;
return 0;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change"
] | 799,534 | 799,535 | u241615199 | cpp |
p02991 | /*
author: madhav_1999 aka orthodoxparadox
29-Jun-2019
17:51:15
*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define dbl long double
#define int ll
#define ll long long
#define sz(x) ((long long)x.size())
#define pii pair<int, int>
#define fup(i, begin, end) \
for (__typeof(end) i = (begin) - ((begin) > (end)); \
i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
#define len(x) sz(x)
#define fnu for (ll i = 0; i < n; i++)
#define trav(x, v) for (auto &x : v)
#define rev(Y) reverse(all(Y))
#define oiint ostream_iterator<int>(cout, " ")
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define endl '\n'
#define all(a) a.begin(), a.end()
#define initialise(a, x) memset(a, x, sizeof(a))
#define onlyunique(v) v.erase(unique(all(v)), v.end()); // only for sorted
// vector
#define inf 2e18
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define _CRT_SECURE_NO_WARNINGS
#ifdef __APPLE__
#define dbg(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " ";
__f(comma + 1, args...);
}
#else
#define dbg(...)
#endif
template <typename X> ostream &operator<<(ostream &x, const vector<X> &v) {
for (int i = 0; i < v.size(); ++i)
x << v[i] << " ";
return x;
}
template <typename X> ostream &operator<<(ostream &x, const set<X> &v) {
for (auto it : v)
x << it << " ";
return x;
}
template <typename X, typename Y>
ostream &operator<<(ostream &x, const pair<X, Y> &v) {
x << v.ff << " " << v.ss;
return x;
}
template <typename T, typename S>
ostream &operator<<(ostream &os, const map<T, S> &v) {
for (auto it : v)
os << it.first << "=>" << it.second << endl;
return os;
}
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
struct pair_hash {
inline std::size_t operator()(const std::pair<int, int> &v) const {
return v.first * 31 + v.second;
}
};
const int MOD = 1e9 + 7;
int takemod(int a, int mod = MOD) {
a %= mod;
if (a < 0)
a += mod;
return a;
}
int fast_exp(int base, int expo, int mod = MOD) {
int res = 1;
while (expo > 0) {
if (expo & 1)
res = (res * base) % mod;
base = (base * base) % mod;
expo >>= 1;
}
return res;
}
int modinv(int a, int mod = MOD) {
return takemod(fast_exp(takemod(a), mod - 2));
}
const int N = 1e5 + 10;
vector<int> graph[N];
int moves[3][N];
void dfs(int a, int cur, int streak = 0) {
moves[cur][a] = streak;
for (int &i : graph[a]) {
if (moves[(cur + 1) % 3][i] == -1) {
dfs(i, (cur + 1) % 3, streak + 1);
}
}
}
void bfs() {
queue<pii> q;
q.push(mp(1, 0));
while (!q.empty()) {
pii p = q.front();
q.pop();
for (auto &x : graph[p.ff]) {
if (moves[(p.ss + 1) % 3][x] == -1) {
moves[(p.ss + 1) % 3][x] = (moves[p.ss][p.ff] + 1);
q.push(mp(x, (p.ss + 1) % 3));
}
}
}
}
void solve() {
int n, m;
cin >> n >> m;
initialise(moves, -1);
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
graph[u].pb(v);
}
int s, t;
cin >> s >> t;
moves[0][s] = 0;
bfs();
int res = moves[0][t];
if (res != -1)
res /= 3;
cout << res;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
#ifdef __APPLE__
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
freopen("error.txt", "w", stderr);
#endif
clock_t t1, t2;
t1 = clock();
int t = 1;
// cin >> t;
while (t--) {
solve();
}
t2 = clock();
cerr << "time taken: " << (t2 - t1) / (dbl)CLOCKS_PER_SEC;
return 0;
} | /*
author: madhav_1999 aka orthodoxparadox
29-Jun-2019
17:51:15
*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define dbl long double
#define int ll
#define ll long long
#define sz(x) ((long long)x.size())
#define pii pair<int, int>
#define fup(i, begin, end) \
for (__typeof(end) i = (begin) - ((begin) > (end)); \
i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
#define len(x) sz(x)
#define fnu for (ll i = 0; i < n; i++)
#define trav(x, v) for (auto &x : v)
#define rev(Y) reverse(all(Y))
#define oiint ostream_iterator<int>(cout, " ")
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define endl '\n'
#define all(a) a.begin(), a.end()
#define initialise(a, x) memset(a, x, sizeof(a))
#define onlyunique(v) v.erase(unique(all(v)), v.end()); // only for sorted
// vector
#define inf 2e18
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define _CRT_SECURE_NO_WARNINGS
#ifdef __APPLE__
#define dbg(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " ";
__f(comma + 1, args...);
}
#else
#define dbg(...)
#endif
template <typename X> ostream &operator<<(ostream &x, const vector<X> &v) {
for (int i = 0; i < v.size(); ++i)
x << v[i] << " ";
return x;
}
template <typename X> ostream &operator<<(ostream &x, const set<X> &v) {
for (auto it : v)
x << it << " ";
return x;
}
template <typename X, typename Y>
ostream &operator<<(ostream &x, const pair<X, Y> &v) {
x << v.ff << " " << v.ss;
return x;
}
template <typename T, typename S>
ostream &operator<<(ostream &os, const map<T, S> &v) {
for (auto it : v)
os << it.first << "=>" << it.second << endl;
return os;
}
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
struct pair_hash {
inline std::size_t operator()(const std::pair<int, int> &v) const {
return v.first * 31 + v.second;
}
};
const int MOD = 1e9 + 7;
int takemod(int a, int mod = MOD) {
a %= mod;
if (a < 0)
a += mod;
return a;
}
int fast_exp(int base, int expo, int mod = MOD) {
int res = 1;
while (expo > 0) {
if (expo & 1)
res = (res * base) % mod;
base = (base * base) % mod;
expo >>= 1;
}
return res;
}
int modinv(int a, int mod = MOD) {
return takemod(fast_exp(takemod(a), mod - 2));
}
const int N = 1e5 + 10;
vector<int> graph[N];
int moves[3][N];
void dfs(int a, int cur, int streak = 0) {
moves[cur][a] = streak;
for (int &i : graph[a]) {
if (moves[(cur + 1) % 3][i] == -1) {
dfs(i, (cur + 1) % 3, streak + 1);
}
}
}
void bfs(int s) {
queue<pii> q;
q.push(mp(s, 0));
while (!q.empty()) {
pii p = q.front();
q.pop();
for (auto &x : graph[p.ff]) {
if (moves[(p.ss + 1) % 3][x] == -1) {
moves[(p.ss + 1) % 3][x] = (moves[p.ss][p.ff] + 1);
q.push(mp(x, (p.ss + 1) % 3));
}
}
}
}
void solve() {
int n, m;
cin >> n >> m;
initialise(moves, -1);
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
graph[u].pb(v);
}
int s, t;
cin >> s >> t;
moves[0][s] = 0;
bfs(s);
int res = moves[0][t];
if (res != -1)
res /= 3;
cout << res;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
#ifdef __APPLE__
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
freopen("error.txt", "w", stderr);
#endif
clock_t t1, t2;
t1 = clock();
int t = 1;
// cin >> t;
while (t--) {
solve();
}
t2 = clock();
cerr << "time taken: " << (t2 - t1) / (dbl)CLOCKS_PER_SEC;
return 0;
} | [
"function.parameters.parameter.add",
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change"
] | 799,536 | 799,537 | u202833686 | cpp |
p02993 | #define mod 1000000007
#define PI acos(-1)
#include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <vector>
using namespace std;
typedef long long ll;
const ll INF = 0x7fffffffffffffff;
const int inf = 0x7fffffff;
const int N = 4e5 + 5;
clock_t start, finish;
void time_in() { start = clock(); }
void time_out() {
finish = clock();
double tim = (double)(finish - start) / CLOCKS_PER_SEC;
printf("Running time is %lf\n", tim);
}
inline ll mul(ll a, ll b) {
ll s = 0;
while (b) {
if (b & 1)
s = (s + a) % mod;
a = (a << 1) % mod;
b >>= 1;
}
return s % mod;
}
inline ll pow_mul(ll a, ll b) {
ll s = 1;
while (b) {
if (b & 1)
s = mul(s, a);
a = mul(a, a);
b >>= 1;
}
return s;
}
inline ll poww(ll a, ll b) {
ll s = 1;
while (b) {
if (b & 1)
s = (s * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return s % mod;
}
inline bool read(int &ret) {
char c = getchar();
int sgn;
if (c == EOF)
return 0;
while (c != '-' && (c < '0' || c > '9'))
c = getchar();
sgn = ((c == '-') ? -1 : 1);
ret = ((c == '-') ? 0 : (c - '0'));
while (c = getchar(), c >= '0' && c <= '9')
ret = ret * 10 + (c - '0');
ret *= sgn;
return 1;
}
inline void write(int x) {
if (x > 9)
write(x / 10);
putchar(x % 10 + '0');
}
int fact[10] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880};
int st[4][2] = {1, 0, 0, 1, -1, 0, 0, -1};
int t, cas;
int n, m, k;
int main() {
char s[10];
while (~scanf("%s", s)) {
if (s[0] == s[1] || s[1] == s[2] || s[2] == s[3])
printf("Bad\n");
else
printf("Dood\n");
}
}
| #define mod 1000000007
#define PI acos(-1)
#include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <vector>
using namespace std;
typedef long long ll;
const ll INF = 0x7fffffffffffffff;
const int inf = 0x7fffffff;
const int N = 4e5 + 5;
clock_t start, finish;
void time_in() { start = clock(); }
void time_out() {
finish = clock();
double tim = (double)(finish - start) / CLOCKS_PER_SEC;
printf("Running time is %lf\n", tim);
}
inline ll mul(ll a, ll b) {
ll s = 0;
while (b) {
if (b & 1)
s = (s + a) % mod;
a = (a << 1) % mod;
b >>= 1;
}
return s % mod;
}
inline ll pow_mul(ll a, ll b) {
ll s = 1;
while (b) {
if (b & 1)
s = mul(s, a);
a = mul(a, a);
b >>= 1;
}
return s;
}
inline ll poww(ll a, ll b) {
ll s = 1;
while (b) {
if (b & 1)
s = (s * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return s % mod;
}
inline bool read(int &ret) {
char c = getchar();
int sgn;
if (c == EOF)
return 0;
while (c != '-' && (c < '0' || c > '9'))
c = getchar();
sgn = ((c == '-') ? -1 : 1);
ret = ((c == '-') ? 0 : (c - '0'));
while (c = getchar(), c >= '0' && c <= '9')
ret = ret * 10 + (c - '0');
ret *= sgn;
return 1;
}
inline void write(int x) {
if (x > 9)
write(x / 10);
putchar(x % 10 + '0');
}
int fact[10] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880};
int st[4][2] = {1, 0, 0, 1, -1, 0, 0, -1};
int t, cas;
int n, m, k;
int main() {
char s[10];
while (~scanf("%s", s)) {
if (s[0] == s[1] || s[1] == s[2] || s[2] == s[3])
printf("Bad\n");
else
printf("Good\n");
}
}
| [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 799,592 | 799,593 | u353919145 | cpp |
p02993 | #include <bits/stdc++.h>
using namespace std;
///////////////////////////////////////////
const long long int INF = 1LL << 60;
const long long int Mod = 1000000007;
const long long int sMod = 998244353;
using ll = long long int;
using ci = const int;
using vi = vector<int>;
using Vi = vector<long long int>;
using P = pair<int, int>;
using PLL = pair<ll, ll>;
using matrix = vector<vector<ll>>;
#define pb(x) push_back(x)
#define mp(x, y) make_pair(x, y)
#define fi first
#define se second
#define all(x) (x).begin(), (x).end()
#define rp(i, N) for (ll i = 0; i < (ll)N; i++)
#define repi(i, a, b) for (ll i = ll(a); i < ll(b); ++i)
template <class T> bool chmax(T &former, const T &b) {
if (former < b) {
former = b;
return true;
}
return false;
}
template <class T> bool chmin(T &former, const T &b) {
if (b < former) {
former = b;
return true;
}
return false;
}
template <class T> T sqar(T x) { return x * x; } // sqrt(x)は平方根;
#define Sort(v) \
std::sort(v.begin(), v.end(), \
std::greater<decltype(v[0])>()) //降順でVをソート
#define p_queue(v) priority_queue<v, vector<v>, greater<v>>
template <class T> inline void princ(T x) { cout << x << " "; };
template <class T> inline void print(T x) { cout << x << "\n"; };
template <class T> inline void Yes(T condition) {
if (condition)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
template <class T> inline void YES(T condition) {
if (condition)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
///////////////////////////////////////////////////////////////////////////////////
void solve() {
string s;
cin >> s;
if (s[0] == s[1] || s[1] == s[2] || s[2] || s[3])
print("Bad");
else
print("Good");
return;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
std::cout << std::fixed << std::setprecision(30);
solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
///////////////////////////////////////////
const long long int INF = 1LL << 60;
const long long int Mod = 1000000007;
const long long int sMod = 998244353;
using ll = long long int;
using ci = const int;
using vi = vector<int>;
using Vi = vector<long long int>;
using P = pair<int, int>;
using PLL = pair<ll, ll>;
using matrix = vector<vector<ll>>;
#define pb(x) push_back(x)
#define mp(x, y) make_pair(x, y)
#define fi first
#define se second
#define all(x) (x).begin(), (x).end()
#define rp(i, N) for (ll i = 0; i < (ll)N; i++)
#define repi(i, a, b) for (ll i = ll(a); i < ll(b); ++i)
template <class T> bool chmax(T &former, const T &b) {
if (former < b) {
former = b;
return true;
}
return false;
}
template <class T> bool chmin(T &former, const T &b) {
if (b < former) {
former = b;
return true;
}
return false;
}
template <class T> T sqar(T x) { return x * x; } // sqrt(x)は平方根;
#define Sort(v) \
std::sort(v.begin(), v.end(), \
std::greater<decltype(v[0])>()) //降順でVをソート
#define p_queue(v) priority_queue<v, vector<v>, greater<v>>
template <class T> inline void princ(T x) { cout << x << " "; };
template <class T> inline void print(T x) { cout << x << "\n"; };
template <class T> inline void Yes(T condition) {
if (condition)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
template <class T> inline void YES(T condition) {
if (condition)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
///////////////////////////////////////////////////////////////////////////////////
void solve() {
string s;
cin >> s;
if (s[0] == s[1] || s[1] == s[2] || s[2] == s[3])
print("Bad");
else
print("Good");
return;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
std::cout << std::fixed << std::setprecision(30);
solve();
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 799,599 | 799,600 | u377907412 | cpp |
p02993 | #include <stdio.h>
#include <string.h>
int main() {
char s[5];
int i, k;
scanf("%s", s);
k = 1;
// k=strlen(s);
for (i = 0; i < 4; i++) {
if (s[i + 1] == s[i]) {
k++;
}
}
if (k >= 2) {
printf("bad");
} else {
printf("good");
}
return 0;
} | #include <stdio.h>
#include <string.h>
int main() {
char s[5];
int i, k;
scanf("%s", s);
// gets(s);
k = 1;
// k=strlen(s);
for (i = 0; i < 4; i++) {
if (s[i + 1] == s[i]) {
k++;
}
}
if (k >= 2) {
printf("Bad");
} else {
printf("Good");
}
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"call.arguments.change",
"io.output.change"
] | 799,601 | 799,602 | u089230684 | cpp |
p02993 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
vector<ll> vec(4);
for (ll i = 0; i < 4; i++) {
cin >> vec.at(i);
}
for (ll i = 0; i < 3; i++) {
if (vec.at(i) == vec.at(i + 1)) {
cout << "Bad" << endl;
return 0;
}
}
cout << "Good" << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
vector<char> vec(4);
for (ll i = 0; i < 4; i++) {
cin >> vec.at(i);
}
for (ll i = 0; i < 3; i++) {
if (vec.at(i) == vec.at(i + 1)) {
cout << "Bad" << endl;
return 0;
}
}
cout << "Good" << endl;
return 0;
}
| [] | 799,610 | 799,611 | u883297128 | cpp |
p02993 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
using ll = long long;
int main() {
string S;
cin >> S;
if (S[0] == S[1] || S[1] == S[2] || S[2] == S[3])
cout << "Bad" << endl;
else
cout << "Yes" << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
using ll = long long;
int main() {
string S;
cin >> S;
if (S[0] == S[1] || S[1] == S[2] || S[2] == S[3])
cout << "Bad" << endl;
else
cout << "Good" << endl;
return 0;
} | [
"literal.string.change",
"io.output.change"
] | 799,616 | 799,617 | u629603666 | cpp |
p02993 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define rep1(i, n) for (ll i = 1; i < n; i++)
using P = pair<ll, ll>;
int main() {
string s;
cin >> s;
rep(i, s.size() - 1) {
if (s[i] == s[i + 1])
cout << "Bad" << endl;
return 0;
}
cout << "Good" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define rep1(i, n) for (ll i = 1; i < n; i++)
using P = pair<ll, ll>;
int main() {
string s;
cin >> s;
rep(i, s.size() - 1) {
if (s[i] == s[i + 1]) {
cout << "Bad" << endl;
return 0;
}
}
cout << "Good" << endl;
return 0;
} | [] | 799,624 | 799,625 | u395125142 | cpp |
p02993 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <string>
using namespace std;
int main() {
string s;
cin >> s;
bool isgood = true;
if (s[0] == s[1]) {
isgood = false;
}
if (s[1] == s[2]) {
isgood = false;
}
if (s[2] == s[3]) {
isgood = false;
}
if (isgood) {
cout << "good";
} else {
cout << "bad";
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <math.h>
#include <string>
using namespace std;
int main() {
string s;
cin >> s;
bool isgood = true;
if (s[0] == s[1]) {
isgood = false;
}
if (s[1] == s[2]) {
isgood = false;
}
if (s[2] == s[3]) {
isgood = false;
}
if (isgood) {
cout << "Good";
} else {
cout << "Bad";
}
return 0;
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 799,626 | 799,627 | u662332836 | cpp |
p02993 | #include <algorithm>
#include <bits/stdc++.h>
#include <ctype.h>
#include <iostream>
#include <string.h>
#include <string>
using namespace std;
int main() {
string s;
cin >> s;
if (s[0] == s[1])
cout << "Bad" << endl;
else if (s[1] == s[2])
cout << "Bad" << endl;
else if (s[2] == s[3])
cout << "Bad" << endl;
else
cout << "Yes" << endl;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <ctype.h>
#include <iostream>
#include <string.h>
#include <string>
using namespace std;
int main() {
string s;
cin >> s;
if (s[0] == s[1])
cout << "Bad" << endl;
else if (s[1] == s[2])
cout << "Bad" << endl;
else if (s[2] == s[3])
cout << "Bad" << endl;
else
cout << "Good" << endl;
} | [
"literal.string.change",
"io.output.change"
] | 799,628 | 799,629 | u337018543 | cpp |
p02993 | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (s[0] == s[1] || s[1] == s[2] || s[2] == s[3])
cout << "bad" << endl;
else
cout << "good" << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (s[0] == s[1] || s[1] == s[2] || s[2] == s[3])
cout << "Bad" << endl;
else
cout << "Good" << endl;
}
| [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 799,636 | 799,637 | u596234104 | cpp |
p02993 | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
bool a = true;
for (int i = 0; i < 3; i++) {
if (s.at(i) == s.at(i + 1)) {
a = false;
break;
}
}
if (a) {
cout << "Good" << endl;
} else {
cout << "Bad" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
bool a = true;
for (int i = 0; i < 3; i++) {
if (s.at(i) == s.at(i + 1)) {
a = false;
break;
}
}
if (a) {
cout << "Good" << endl;
} else {
cout << "Bad" << endl;
}
}
| [] | 799,657 | 799,658 | u758405447 | cpp |
p02993 | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (s.at(0) == s.at(1) || s.at(1) == s.at(2) || s.at(2) == s.at(3)) {
cout << "Bad" << endl;
} else {
cout << "Yes" << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (s.at(0) == s.at(1) || s.at(1) == s.at(2) || s.at(2) == s.at(3)) {
cout << "Bad" << endl;
} else {
cout << "Good" << endl;
}
}
| [
"literal.string.change",
"io.output.change"
] | 799,667 | 799,668 | u856957535 | cpp |
p02993 | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (s.at(0) == s.at(1) || s.at(1) == s.at(2) || s.at(2) == s.at(3)) {
cout << "Good" << endl;
} else {
cout << "Bad" << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (s.at(0) == s.at(1) || s.at(1) == s.at(2) || s.at(2) == s.at(3)) {
cout << "Bad" << endl;
} else {
cout << "Good" << endl;
}
}
| [
"literal.string.change",
"io.output.change"
] | 799,669 | 799,668 | u856957535 | cpp |
p02993 | #include <bits/stdc++.h>
using namespace std;
int main() {
string n;
cin >> n;
bool isgood = true;
if (n[0] == n[1])
isgood = false;
if (n[1] == n[2])
isgood = false;
if (n[2] == n[3])
isgood = false;
if (isgood) {
cout << "good" << endl;
} else {
cout << "bad" << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string n;
cin >> n;
bool isgood = true;
if (n[0] == n[1])
isgood = false;
if (n[1] == n[2])
isgood = false;
if (n[2] == n[3])
isgood = false;
if (isgood) {
cout << "Good" << endl;
} else {
cout << "Bad" << endl;
}
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 799,673 | 799,674 | u321280590 | cpp |
p02993 | #include <bits/stdc++.h>
using namespace std;
int main() {
string n;
cin >> n;
bool isgood = true;
if (n[0] == n[1])
isgood = false;
if (n[1] == n[2])
isgood = false;
if (n[2] == n[3])
isgood = false;
if (isgood) {
cout << "good" << endl;
} else {
cout << "bad" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string n;
cin >> n;
bool isgood = true;
if (n[0] == n[1])
isgood = false;
if (n[1] == n[2])
isgood = false;
if (n[2] == n[3])
isgood = false;
if (isgood) {
cout << "Good" << endl;
} else {
cout << "Bad" << endl;
}
} | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 799,675 | 799,674 | u321280590 | cpp |
p02993 | #include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
bool can = true;
for (int i = 0; i < 2; i++) {
char X = S.at(i);
char Y = S.at(i + 1);
if (X == Y) {
can = false;
break;
}
}
if (can)
cout << "Good" << endl;
else
cout << "Bad" << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
bool can = true;
for (int i = 0; i < 3; i++) {
char X = S.at(i);
char Y = S.at(i + 1);
if (X == Y) {
can = false;
break;
}
}
if (can)
cout << "Good" << endl;
else
cout << "Bad" << endl;
}
| [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 799,696 | 799,697 | u430394202 | cpp |
p02993 | #include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
bool can = true;
for (int i = 0; i < 2; i++) {
char X = S.at(i);
char Y = S.at(i + 1);
if (X != Y) {
can = false;
break;
}
}
if (can)
cout << "Good" << endl;
else
cout << "Bad" << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
bool can = true;
for (int i = 0; i < 3; i++) {
char X = S.at(i);
char Y = S.at(i + 1);
if (X == Y) {
can = false;
break;
}
}
if (can)
cout << "Good" << endl;
else
cout << "Bad" << endl;
}
| [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 799,698 | 799,697 | u430394202 | cpp |
p02993 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define pi 3.141592653589793238
#define fast \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define MOD 1000000007
void solve() {
string s;
cin >> s;
if (s[0] == s[1] || s[1] == s[2] || s[2] == s[4])
cout << "Bad";
else
cout << "Good";
return;
}
int main() {
fast;
ll q;
q = 1;
// cin>>q;
while (q--)
solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define pi 3.141592653589793238
#define fast \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define MOD 1000000007
void solve() {
string s;
cin >> s;
if (s[0] == s[1] || s[1] == s[2] || s[2] == s[3])
cout << "Bad";
else
cout << "Good";
return;
}
int main() {
fast;
ll q;
q = 1;
// cin>>q;
while (q--)
solve();
return 0;
} | [
"literal.number.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 799,715 | 799,716 | u972911059 | cpp |
p02993 | #include <iostream>
#include <string>
using namespace std;
int main() {
string s;
cin >> s;
if (s[0] == s[1] || s[2] == s[3] || s[1] == s[2]) {
cout << "Bat" << endl;
} else
cout << "Good" << endl;
return 0;
} | #include <iostream>
#include <string>
using namespace std;
int main() {
string s;
cin >> s;
if (s[0] == s[1] || s[2] == s[3] || s[1] == s[2])
cout << "Bad" << endl;
else
cout << "Good" << endl;
return 0;
} | [
"literal.string.change",
"io.output.change"
] | 799,719 | 799,720 | u497715246 | cpp |
p02993 | #include <iostream>
#include <string>
using namespace std;
int main() {
string s;
cin >> s;
if (s[0] == s[1] || s[2] == s[3] || s[1] == s[2]) {
cout << "Bat" << endl;
} else
cout << "Good" << endl;
} | #include <iostream>
#include <string>
using namespace std;
int main() {
string s;
cin >> s;
if (s[0] == s[1] || s[2] == s[3] || s[1] == s[2])
cout << "Bad" << endl;
else
cout << "Good" << endl;
return 0;
} | [
"literal.string.change",
"io.output.change",
"control_flow.return.add",
"control_flow.return.0.add"
] | 799,721 | 799,720 | u497715246 | cpp |
p02993 | #include <iostream>
#include <map>
#define REPD(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) REPD(i, 0, n)
using namespace std;
#define fin(ans) cout << (ans) << '\n'
int main() {
string S;
cin >> S;
bool flag = true;
REP(i, S.length() - 1) {
if (S[i] == S[i + 1]) {
bool flag = false;
break;
}
}
if (flag)
fin("Bad");
else
fin("Good");
return 0;
} | #include <iostream>
#include <map>
#define REPD(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) REPD(i, 0, n)
using namespace std;
#define fin(ans) cout << (ans) << '\n'
int main() {
string S;
cin >> S;
bool flag = true;
REP(i, S.length() - 1) {
if (S[i] == S[i + 1]) {
flag = false;
break;
}
}
if (flag)
fin("Good");
else
fin("Bad");
return 0;
} | [
"literal.string.change",
"call.arguments.change"
] | 799,722 | 799,723 | u568426505 | cpp |
p02993 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <utility>
#include <vector>
const double PI = acos(-1);
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
const int mod = 1000000007;
// map<string>a
class mint {
long long x;
public:
mint(long long x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint &a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint &a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint &a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint &a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint &a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint &a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint &a) { return (*this) *= a.inv(); }
mint operator/(const mint &a) const {
mint res(*this);
return res /= a;
}
friend ostream &operator<<(ostream &os, const mint &m) {
os << m.x;
return os;
}
};
int ctoi(char c) {
if (c >= '0' && c <= '9') {
return c - '0';
}
return 0;
}
//組み合わせ
void recursive_comb(vector<int> indexes, int s, int rest,
std::function<void(vector<int>)> f) {
if (rest == 0) {
f(indexes);
} else {
if (s < 0)
return;
recursive_comb(indexes, s - 1, rest, f);
indexes[rest - 1] = s;
recursive_comb(indexes, s - 1, rest - 1, f);
}
}
// nCkの組み合わせに対して処理を実行する
void foreach_comb(int n, int k, std::function<void(vector<int>)> f) {
vector<int> indexes(k);
recursive_comb(indexes, n - 1, k, f);
}
ll gcd(ll a, ll b) {
if (a % b == 0) {
return b;
} else {
return gcd(b, a % b);
}
}
ll lcm(ll a, ll b) { return a * b / gcd(a, b); };
// fixed << setprecision(2)
int main() {
string s;
rep(i, 3) {
if (s[i] == s[i + 1]) {
cout << "Bad";
return 0;
}
}
cout << "Good";
}
| #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <utility>
#include <vector>
const double PI = acos(-1);
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
const int mod = 1000000007;
// map<string>a
class mint {
long long x;
public:
mint(long long x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint &a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint &a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint &a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint &a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint &a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint &a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint &a) { return (*this) *= a.inv(); }
mint operator/(const mint &a) const {
mint res(*this);
return res /= a;
}
friend ostream &operator<<(ostream &os, const mint &m) {
os << m.x;
return os;
}
};
int ctoi(char c) {
if (c >= '0' && c <= '9') {
return c - '0';
}
return 0;
}
//組み合わせ
void recursive_comb(vector<int> indexes, int s, int rest,
std::function<void(vector<int>)> f) {
if (rest == 0) {
f(indexes);
} else {
if (s < 0)
return;
recursive_comb(indexes, s - 1, rest, f);
indexes[rest - 1] = s;
recursive_comb(indexes, s - 1, rest - 1, f);
}
}
// nCkの組み合わせに対して処理を実行する
void foreach_comb(int n, int k, std::function<void(vector<int>)> f) {
vector<int> indexes(k);
recursive_comb(indexes, n - 1, k, f);
}
ll gcd(ll a, ll b) {
if (a % b == 0) {
return b;
} else {
return gcd(b, a % b);
}
}
ll lcm(ll a, ll b) { return a * b / gcd(a, b); };
// fixed << setprecision(2)
int main() {
string s;
cin >> s;
rep(i, 3) {
if (s[i] == s[i + 1]) {
cout << "Bad";
return 0;
}
}
cout << "Good";
}
| [] | 799,726 | 799,727 | u272628953 | cpp |
p02993 | #include <iostream>
using namespace std;
int main() {
char S[4];
int i, a = 0;
cin >> S;
for (i = 0; i < 3; i++) {
if (S[i] == S[i + 1])
a = 1;
break;
}
if (a == 1)
cout << "Bad" << endl;
else
cout << "Good" << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
char S[4];
int i, a = 0;
cin >> S;
for (i = 0; i < 3; i++) {
if (S[i] == S[i + 1]) {
a = 1;
break;
}
}
if (a == 1)
cout << "Bad" << endl;
else
cout << "Good" << endl;
return 0;
}
| [] | 799,728 | 799,729 | u018679195 | cpp |
p02993 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
// ===============================================================
using namespace std;
using ll = long long;
using vl = vector<long long>;
using vll = vector<vector<long long>>;
using vs = vector<string>;
using vc = vector<char>;
using vcc = vector<vector<char>>;
using vm = vector<short>;
using vmm = vector<vector<short>>;
using pii = pair<int, int>;
using psi = pair<string, int>;
using ld = long double;
using ull = unsigned long long;
// ===============================================================
ll gcd(ll a, ll b) //最大公約数
{
if (a % b == 0) {
return (b);
} else {
return (gcd(b, a % b));
}
}
ll lcm(ll a, ll b) //最小公倍数
{
return a * b / gcd(a, b);
}
ll box(double a) // doubleの切り捨て
{
ll b = a;
return b;
}
ll fff(double a) // doubleの四捨五入
{
ll b = a + 0.5;
return b;
}
ll sum(ll n) { //整数sまでの合計
if (n == 0) {
return 0;
}
int s = sum(n - 1);
return s + n;
}
bool prime(ll num) //素数判定、primeならtrue,違うならfalse
{
if (num < 2)
return false;
else if (num == 2)
return true;
else if (num % 2 == 0)
return false;
double sqrtNum = sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2) {
if (num % i == 0) {
return false;
}
}
// 素数である
return true;
}
// ===============================================================
int main() {
string a;
if (a[0] == a[1] || a[1] == a[2] || a[2] == a[3]) {
cout << "Bad" << endl;
} else
cout << "Good" << endl;
} | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
// ===============================================================
using namespace std;
using ll = long long;
using vl = vector<long long>;
using vll = vector<vector<long long>>;
using vs = vector<string>;
using vc = vector<char>;
using vcc = vector<vector<char>>;
using vm = vector<short>;
using vmm = vector<vector<short>>;
using pii = pair<int, int>;
using psi = pair<string, int>;
using ld = long double;
using ull = unsigned long long;
// ===============================================================
ll gcd(ll a, ll b) //最大公約数
{
if (a % b == 0) {
return (b);
} else {
return (gcd(b, a % b));
}
}
ll lcm(ll a, ll b) //最小公倍数
{
return a * b / gcd(a, b);
}
ll box(double a) // doubleの切り捨て
{
ll b = a;
return b;
}
ll fff(double a) // doubleの四捨五入
{
ll b = a + 0.5;
return b;
}
ll sum(ll n) { //整数sまでの合計
if (n == 0) {
return 0;
}
int s = sum(n - 1);
return s + n;
}
bool prime(ll num) //素数判定、primeならtrue,違うならfalse
{
if (num < 2)
return false;
else if (num == 2)
return true;
else if (num % 2 == 0)
return false;
double sqrtNum = sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2) {
if (num % i == 0) {
return false;
}
}
// 素数である
return true;
}
// ===============================================================
int main() {
string a;
cin >> a;
if (a[0] == a[1] || a[1] == a[2] || a[2] == a[3]) {
cout << "Bad" << endl;
} else
cout << "Good" << endl;
} | [] | 799,735 | 799,736 | u926006934 | cpp |
p02993 | // Made by Luis Miguel Baez
// es.luismiguelbaez@gmail.com
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define precise(n, k) fixed << setprecision(k) << n
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define uint unsigned int
#define ll long long
#define ull unsigned long long
#define ld long double
#define pii pair<int, int>
#define piii pair<int, pair<int, int>>
#define pll pair<ll, ll>
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define debug(...) "[" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
string to_string(string s) { return '"' + s + '"'; }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename T> string to_string(A v) {
bool first = true;
string res = "{";
for (const T &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string((T)x);
}
res += "}";
return res;
}
// add templates here
template <class T> void println(const vector<T> &data) {
cout << to_string<vector<T>, T>(data) << endl;
}
template <class T> void println(const T &data) {
cout << to_string((T)data) << endl;
}
const int MOD = int(1e9 + 7);
const int oo = int(1e9 + 20);
const ll lloo = (ll)(1e18 + 10);
int toInt(char num) { return num - '0'; }
void solve() {
string n;
cin >> n;
for (int i = 1; i < n.size(); ++i) {
if (abs(toInt(n[i]) - toInt(n[i - 1])) <= 1) {
cout << "Bad" << endl;
return;
}
}
cout << "Good" << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
} | // Made by Luis Miguel Baez
// es.luismiguelbaez@gmail.com
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define precise(n, k) fixed << setprecision(k) << n
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define uint unsigned int
#define ll long long
#define ull unsigned long long
#define ld long double
#define pii pair<int, int>
#define piii pair<int, pair<int, int>>
#define pll pair<ll, ll>
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define debug(...) "[" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
string to_string(string s) { return '"' + s + '"'; }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename T> string to_string(A v) {
bool first = true;
string res = "{";
for (const T &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string((T)x);
}
res += "}";
return res;
}
// add templates here
template <class T> void println(const vector<T> &data) {
cout << to_string<vector<T>, T>(data) << endl;
}
template <class T> void println(const T &data) {
cout << to_string((T)data) << endl;
}
const int MOD = int(1e9 + 7);
const int oo = int(1e9 + 20);
const ll lloo = (ll)(1e18 + 10);
int toInt(char num) { return num - '0'; }
void solve() {
string n;
cin >> n;
for (int i = 1; i < n.size(); ++i) {
if (abs(toInt(n[i]) - toInt(n[i - 1])) == 0) {
cout << "Bad" << endl;
return;
}
}
cout << "Good" << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
} | [
"control_flow.loop.for.condition.change"
] | 799,745 | 799,746 | u192061265 | cpp |
p02993 | #include <iostream>
using namespace std;
int main() {
string s;
cin >> s;
if (s[0] == s[1] || s[1] == s[2] || s[2] == s[3])
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
string s;
cin >> s;
if (s[0] == s[1] || s[1] == s[2] || s[2] == s[3])
cout << "Bad" << endl;
else
cout << "Good" << endl;
return 0;
} | [
"literal.string.change",
"io.output.change"
] | 799,753 | 799,754 | u553321223 | cpp |
p02993 | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
int main() {
string s;
cin >> s;
int g = s.length();
for (int i = 0; i < g; i++) {
if (s[i] == s[i + 1]) {
cout << "Yes";
return 0;
}
}
cout << "No";
return 0;
} | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
int main() {
string s;
cin >> s;
int g = s.length();
for (int i = 0; i < g; i++) {
if (s[i] == s[i + 1]) {
cout << "Bad";
return 0;
}
}
cout << "Good";
return 0;
} | [
"literal.string.change",
"io.output.change"
] | 799,881 | 799,882 | u311099484 | cpp |
p02993 | #include <bits/stdc++.h>
using namespace std;
int main() {
string S;
for (int i = 1; i < 4; i++) {
if (S[i] == S[i - 1]) {
cout << "Bad" << endl;
return 0;
}
}
cout << "Good" << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
for (int i = 1; i < 4; i++) {
if (S[i] == S[i - 1]) {
cout << "Bad" << endl;
return 0;
}
}
cout << "Good" << endl;
}
| [] | 799,883 | 799,884 | u060116081 | cpp |
p02993 | #include <iostream>
#include <string>
int main() {
std::string S;
std::cin >> S;
bool flag = 0;
for (size_t i = 0; i < S.size() - 1; i++) {
if (S[i] == S[i + 1]) {
flag = 1;
break;
} else {
continue;
}
}
if (flag) {
std::cout << "BAD";
} else {
std::cout << "GOOD";
}
return 0;
}
| #include <iostream>
#include <string>
int main() {
std::string S;
std::cin >> S;
bool flag = 0;
for (size_t i = 0; i < S.size() - 1; i++) {
if (S[i] == S[i + 1]) {
flag = 1;
break;
} else {
continue;
}
}
if (flag) {
std::cout << "Bad";
} else {
std::cout << "Good";
}
return 0;
}
| [
"literal.string.change",
"literal.string.case.change",
"expression.operation.binary.change"
] | 799,885 | 799,886 | u080498875 | cpp |
p02993 | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (s[0] == s[1] || s[1] == s[2] || s[2] == s[3])
cout << "Bad" << endl;
else
cout << "Yes" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (s[0] == s[1] || s[1] == s[2] || s[2] == s[3])
cout << "Bad" << endl;
else
cout << "Good" << endl;
return 0;
} | [
"literal.string.change",
"io.output.change"
] | 799,917 | 799,918 | u836743234 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.