problem_id stringlengths 6 6 | language stringclasses 2 values | original_status stringclasses 3 values | original_src stringlengths 19 243k | changed_src stringlengths 19 243k | change stringclasses 3 values | i1 int64 0 8.44k | i2 int64 0 8.44k | j1 int64 0 8.44k | j2 int64 0 8.44k | error stringclasses 270 values | stderr stringlengths 0 226k |
|---|---|---|---|---|---|---|---|---|---|---|---|
p02990 | C++ | Runtime Error | /*||>>>> Praveen Ojha <<<<>>>> 30 June 2019 <<<<>>>> 01:09:32 <<<<||*/
// #pragma GCC optimize("Ofast") //(Very Fast but Inaccurate)
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
// //(Small operations in many loops) #pragma GCC optimize("unroll-loops")
// #pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define F first
#define S second
#define mod 1000000007
#define inf (int)1e18 + 5
#define sz(x) (int)x.size()
#define PI 3.141592653589793238510
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define __ \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define vi vector<int>
#define vpii vector<pair<int, int>>
#define vvi vector<vector<int>>
#define PRINT_TIME \
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s." << endl;
#define sim template <class c
#define ris return *this
#define dor > debug &operator<<
#define eni(x) \
sim > typename enable_if<sizeof dud<c>(0) x 1, debug &>::type operator<<( \
c i) {
sim > struct rge {
c b, e;
};
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c *x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i;
ris;
} eni(==) ris << range(begin(i), end(i));
}
sim, class b dor(pair<b, c> d) {
ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
*this << "[";
for (auto it = d.b; it != d.e; ++it)
*this << ", " + 2 * (it == d.b) << *it;
ris << "]";
}
#else
sim dor(const c &) { ris; }
#endif
}
;
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
typedef long double ld;
typedef pair<int, int> pii;
// Read Problems Carefully & Check for corner cases N=0,1 ?
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
const int N = 2200;
int fact[N];
inline int powermod(int a, int n) {
int result = 1;
a = a % mod;
while (n > 0) {
if (n & 1)
result = (a * result) % mod;
a = (a * a) % mod;
n /= 2;
}
return result;
}
inline int modInv(int x) { return powermod(x, mod - 2); }
inline int ncr(int n, int r) {
int cur = fact[n];
cur = (cur * modInv(fact[n - r])) % mod;
cur = (cur * modInv(fact[r])) % mod;
return cur;
}
int32_t main() {
__ int n, k;
cin >> n >> k;
int red = n - k;
fact[0] = 1;
for (int i = 1; i < N; i++) {
fact[i] = (i * fact[i - 1]) % mod;
}
for (int i = 1; i <= k; i++) {
cout << ncr(red + 1, i) * ncr(k - 1, i - 1) % mod << "\n";
}
return 0;
} | /*||>>>> Praveen Ojha <<<<>>>> 30 June 2019 <<<<>>>> 01:09:32 <<<<||*/
// #pragma GCC optimize("Ofast") //(Very Fast but Inaccurate)
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
// //(Small operations in many loops) #pragma GCC optimize("unroll-loops")
// #pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define F first
#define S second
#define mod 1000000007
#define inf (int)1e18 + 5
#define sz(x) (int)x.size()
#define PI 3.141592653589793238510
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define __ \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define vi vector<int>
#define vpii vector<pair<int, int>>
#define vvi vector<vector<int>>
#define PRINT_TIME \
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s." << endl;
#define sim template <class c
#define ris return *this
#define dor > debug &operator<<
#define eni(x) \
sim > typename enable_if<sizeof dud<c>(0) x 1, debug &>::type operator<<( \
c i) {
sim > struct rge {
c b, e;
};
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c *x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i;
ris;
} eni(==) ris << range(begin(i), end(i));
}
sim, class b dor(pair<b, c> d) {
ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
*this << "[";
for (auto it = d.b; it != d.e; ++it)
*this << ", " + 2 * (it == d.b) << *it;
ris << "]";
}
#else
sim dor(const c &) { ris; }
#endif
}
;
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
typedef long double ld;
typedef pair<int, int> pii;
// Read Problems Carefully & Check for corner cases N=0,1 ?
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
const int N = 2200;
int fact[N];
inline int powermod(int a, int n) {
int result = 1;
a = a % mod;
while (n > 0) {
if (n & 1)
result = (a * result) % mod;
a = (a * a) % mod;
n /= 2;
}
return result;
}
inline int modInv(int x) { return powermod(x, mod - 2); }
inline int ncr(int n, int r) {
if (n < r)
return 0;
int cur = fact[n];
cur = (cur * modInv(fact[n - r])) % mod;
cur = (cur * modInv(fact[r])) % mod;
return cur;
}
int32_t main() {
__ int n, k;
cin >> n >> k;
int red = n - k;
fact[0] = 1;
for (int i = 1; i < N; i++) {
fact[i] = (i * fact[i - 1]) % mod;
}
for (int i = 1; i <= k; i++) {
cout << ncr(red + 1, i) * ncr(k - 1, i - 1) % mod << "\n";
}
return 0;
} | insert | 80 | 80 | 80 | 82 | 0 | |
p02990 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
const int MOD = 1e+9 + 7;
int main() {
int N, K;
cin >> N >> K;
// C[i][j]: iをj個に分割する仕方(分割数)
vector<vector<long long>> C(N, vector<long long>(N));
for (int i = 0; i < N; ++i) {
C[i][0] = C[i][i] = 1;
for (int j = 1; j < i; ++j) {
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % MOD;
}
}
for (int i = 1; i <= K; ++i) {
cout << (C[N - K + 1][i] * C[K - 1][i - 1]) % MOD << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
const int MOD = 1e+9 + 7;
int main() {
int N, K;
cin >> N >> K;
// C[i][j]: iをj個に分割する仕方(分割数)
vector<vector<long long>> C(N + 1, vector<long long>(N + 1));
for (int i = 0; i <= N; ++i) {
C[i][0] = C[i][i] = 1;
for (int j = 1; j < i; ++j) {
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % MOD;
}
}
for (int i = 1; i <= K; ++i) {
cout << (C[N - K + 1][i] * C[K - 1][i - 1]) % MOD << endl;
}
return 0;
} | replace | 12 | 14 | 12 | 14 | 0 | |
p02990 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
long N = 2000, K = 2000;
long DP_SIZE_N = N + 1;
long DP_SIZE_K = K + 1;
// 全体計算
// nCk
vector<vector<long>> DP;
void init() {
DP.resize(DP_SIZE_N);
for (int i = 0; i < DP_SIZE_N; ++i) {
DP[i].resize(DP_SIZE_K);
}
}
void calc_Combination() {
DP[0][0] = 1;
for (int i = 1; i <= N; ++i) {
DP[i][0] = 1;
for (int j = 1; j <= min(long(i), K); ++j) {
DP[i][j] = (DP[i - 1][j - 1] + DP[i - 1][j]) % MOD;
}
for (int j = min(long(i), K) + 1; j <= K; ++j) {
DP[i][j] = 0;
}
}
}
int main() {
cin >> N >> K;
DP_SIZE_N = N + 1;
DP_SIZE_K = K + 1;
init();
calc_Combination();
// cout<<DP[N][K]<<endl;
for (int i = 1; i <= K; ++i) {
long ans_l = DP[N - K - 1][i - 1 + 1 - 1];
long ans_r = DP[N - K - 1][i - 1 + 1 - 1];
long ans_lr = DP[N - K - 1][i - 1 + 2 - 1];
long ans;
if (i == 1) {
ans = 0;
} else {
ans = DP[N - K - 1][i - 1 + 0 - 1];
}
long ans_sum = (ans_l + ans_r + ans_lr + ans) % MOD;
// cout<<ans_l<<" "<<ans_r<<" "<<ans_lr<<" "<<ans<<endl;
// cout<<DP[K-1][i-1]<<endl;
cout << (DP[K - 1][i - 1] * ans_sum) % MOD << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
long N = 2000, K = 2000;
long DP_SIZE_N = N + 1;
long DP_SIZE_K = K + 1;
// 全体計算
// nCk
vector<vector<long>> DP;
void init() {
DP.resize(DP_SIZE_N);
for (int i = 0; i < DP_SIZE_N; ++i) {
DP[i].resize(DP_SIZE_K);
}
}
void calc_Combination() {
DP[0][0] = 1;
for (int i = 1; i <= N; ++i) {
DP[i][0] = 1;
for (int j = 1; j <= min(long(i), K); ++j) {
DP[i][j] = (DP[i - 1][j - 1] + DP[i - 1][j]) % MOD;
}
for (int j = min(long(i), K) + 1; j <= K; ++j) {
DP[i][j] = 0;
}
}
}
int main() {
cin >> N >> K;
DP_SIZE_N = N + 1;
DP_SIZE_K = K + 1;
init();
calc_Combination();
// cout<<DP[N][K]<<endl;
if (N == K) {
cout << 1 << endl;
for (int i = 2; i <= K; ++i) {
cout << 0 << endl;
}
return 0;
}
for (int i = 1; i <= K; ++i) {
long ans_l = DP[N - K - 1][i - 1 + 1 - 1];
long ans_r = DP[N - K - 1][i - 1 + 1 - 1];
long ans_lr = DP[N - K - 1][i - 1 + 2 - 1];
long ans;
if (i == 1) {
ans = 0;
} else {
ans = DP[N - K - 1][i - 1 + 0 - 1];
}
long ans_sum = (ans_l + ans_r + ans_lr + ans) % MOD;
// cout<<ans_l<<" "<<ans_r<<" "<<ans_lr<<" "<<ans<<endl;
// cout<<DP[K-1][i-1]<<endl;
cout << (DP[K - 1][i - 1] * ans_sum) % MOD << endl;
}
return 0;
}
| insert | 42 | 42 | 42 | 50 | 0 | |
p02990 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <iostream>
#define ll long long
using namespace std;
ll mod = 1e9 + 7, ans, c[2002][2002];
int n, k;
void pre() {
c[0][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= i; j++) {
if (i == j || j == 0)
c[i][j] = 1;
else
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
}
}
int main() {
scanf("%d%d", &n, &k);
pre();
for (int i = 1; i <= k; i++) {
ans = (c[n - k - 1][i - 2] + (2 * c[n - k - 1][i - 1]) % mod +
c[n - k - 1][i]) %
mod;
ans = (c[k - 1][i - 1] * ans) % mod;
printf("%lld\n", ans);
}
return 0;
} | #include <algorithm>
#include <cstdio>
#include <iostream>
#define ll long long
using namespace std;
ll mod = 1e9 + 7, ans, c[2002][2002];
int n, k;
void pre() {
c[0][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= i; j++) {
if (i == j || j == 0)
c[i][j] = 1;
else
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
}
}
int main() {
scanf("%d%d", &n, &k);
pre();
for (int i = 1; i <= k; i++) { // c[n-k-1][i-2]+(2*c[n-k-1][i-1])%mod+
ans = (c[n - k + 1][i] * c[k - 1][i - 1]) % mod;
printf("%lld\n", ans);
}
return 0;
} | replace | 20 | 25 | 20 | 22 | 0 | |
p02990 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace ::std;
#define all(x) (x).begin(), (x).end()
#define sz(x) (int)(x).size()
typedef long long ll;
typedef array<int, 3> tri;
typedef array<int, 2> duo;
typedef long double ld;
template <class T> istream &operator>>(istream &I, vector<T> &v) {
for (T &e : v)
I >> e;
return I;
}
template <class T> ostream &operator<<(ostream &O, const vector<T> &v) {
for (const T &e : v)
O << e << ' ';
return O;
}
const int MOD = 1E9 + 7, N = 2001;
ll fact[N];
ll exp(int a, int n) {
if (n == 0)
return 1;
ll b = exp(a, n / 2);
(b *= b) %= MOD;
if (n & 1)
(b *= a) %= MOD;
return b;
}
ll C(int n, int k) {
return fact[n] * exp(fact[k], MOD - 2) % MOD * exp(fact[n - k], MOD - 2) %
MOD;
}
void _main() {
fact[0] = 1;
int blue, n;
cin >> n >> blue;
int red = n - blue;
for (int i = 1; i <= n; i++)
fact[i] = fact[i - 1] * i % MOD;
for (int i = 1; i <= blue; i++) {
cout << C(red + 1, i) * C(blue - 1, i - 1) % MOD << '\n';
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
// freopen("input.txt", "r", stdin);
int _t = 1;
// cin >> _t;
while (_t--)
_main();
return 0;
}
| #include <bits/stdc++.h>
using namespace ::std;
#define all(x) (x).begin(), (x).end()
#define sz(x) (int)(x).size()
typedef long long ll;
typedef array<int, 3> tri;
typedef array<int, 2> duo;
typedef long double ld;
template <class T> istream &operator>>(istream &I, vector<T> &v) {
for (T &e : v)
I >> e;
return I;
}
template <class T> ostream &operator<<(ostream &O, const vector<T> &v) {
for (const T &e : v)
O << e << ' ';
return O;
}
const int MOD = 1E9 + 7, N = 2001;
ll fact[N];
ll exp(int a, int n) {
if (n == 0)
return 1;
ll b = exp(a, n / 2);
(b *= b) %= MOD;
if (n & 1)
(b *= a) %= MOD;
return b;
}
ll C(int n, int k) {
if (k > n)
return 0;
return fact[n] * exp(fact[k], MOD - 2) % MOD * exp(fact[n - k], MOD - 2) %
MOD;
}
void _main() {
fact[0] = 1;
int blue, n;
cin >> n >> blue;
int red = n - blue;
for (int i = 1; i <= n; i++)
fact[i] = fact[i - 1] * i % MOD;
for (int i = 1; i <= blue; i++) {
cout << C(red + 1, i) * C(blue - 1, i - 1) % MOD << '\n';
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
// freopen("input.txt", "r", stdin);
int _t = 1;
// cin >> _t;
while (_t--)
_main();
return 0;
}
| insert | 35 | 35 | 35 | 37 | 0 | |
p02990 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
static const uint64_t MOD = 1000000007LL;
// uint64_t dp[100005][13];
/* nCk == (n-1)C(k-1) + (n-1)Ck*/
// long mem[4000][4000];
// long combi(int n, int k)
// {
// if (mem[n][k])
// return mem[n][k];
// long ret = 0;
// if ((k == 0) || (n <= k)) {
// ret = 1;
// } else {
// ret = (combi(n - 1, k - 1) + combi(n - 1, k)) % MOD;
// }
//
// mem[n][k] = ret;
// return ret;
// }
int dp[2001][2001];
long combi(int n, int r) {
if (n == r)
return dp[n][r] = 1;
if (r == 0)
return dp[n][r] = 1;
if (r == 1)
return dp[n][r] = n;
if (dp[n][r])
return dp[n][r];
dp[n][r] = (combi(n - 1, r) % MOD + combi(n - 1, r - 1) % MOD) % MOD;
return dp[n][r];
}
int main() {
int n, k; /* k: Bule */
cin >> n >> k;
for (int i = 1; i <= k; i++) {
long cnt = ((long)combi(k - 1, i - 1) * combi(n - k + 1, i)) % MOD;
cout << cnt << endl;
}
} | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
static const uint64_t MOD = 1000000007LL;
// uint64_t dp[100005][13];
/* nCk == (n-1)C(k-1) + (n-1)Ck*/
// long mem[4000][4000];
// long combi(int n, int k)
// {
// if (mem[n][k])
// return mem[n][k];
// long ret = 0;
// if ((k == 0) || (n <= k)) {
// ret = 1;
// } else {
// ret = (combi(n - 1, k - 1) + combi(n - 1, k)) % MOD;
// }
//
// mem[n][k] = ret;
// return ret;
// }
int dp[2001][2001];
long combi(int n, int r) {
if (n == r)
return dp[n][r] = 1;
if (r == 0)
return dp[n][r] = 1;
if (r == 1)
return dp[n][r] = n;
if (dp[n][r])
return dp[n][r];
dp[n][r] = (combi(n - 1, r) % MOD + combi(n - 1, r - 1) % MOD) % MOD;
return dp[n][r];
}
int main() {
int n, k; /* k: Bule */
cin >> n >> k;
for (int i = 1; i <= k; i++) {
if (i > (n - k + 1)) {
puts("0");
} else {
long cnt = ((long)combi(k - 1, i - 1) * combi(n - k + 1, i)) % MOD;
cout << cnt << endl;
}
}
} | replace | 46 | 48 | 46 | 52 | 0 | |
p02990 | C++ | Runtime Error | // include
//------------------------------------------
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#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 <utility>
#include <vector>
using namespace std;
// conversion
//------------------------------------------
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();
}
// math
//-------------------------------------------
template <class T> inline T sqr(T x) { return x * x; }
// typedef
//------------------------------------------
typedef long long ll;
typedef long long LL;
typedef vector<long long> VLL;
typedef vector<long long> vll;
typedef pair<long long, long long> pll;
typedef pair<long long, long long> PLL;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define VECMAX(x) *max_element(ALL(x))
#define VECMIN(x) *min_element(ALL(x))
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define MULTIPLE(i, n, k) for (int i = (k); i < (n); i += k + 1) // 倍数ループ
// constant
//------------------------------------------
const double EPS = 1e-10;
const double PI = acos(-1.0);
// clear memory
#define CLR(a) memset((a), 0, sizeof(a))
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
#define SIZEOF(x) sizeof(x) / sizeof(x[0])
const long long INF = 100000000000000;
const long long NINF = -100000000000000;
//----------------search for specific figure--------------------
//--------------------------------------------------------------
// firstが最大値（最小値） , second が index
pair<LL, LL> maxP(vll a, ll size) {
pair<ll, ll> p;
vll::iterator iter = max_element(a.begin(), a.end());
p.first = *iter;
p.second = distance(a.begin(), iter);
return p;
}
pair<LL, LL> minP(vll a, ll size) {
pair<ll, ll> p;
vll::iterator iter = min_element(a.begin(), a.end());
p.first = *iter;
p.second = distance(a.begin(), iter);
return p;
}
ll sumL(vll a, ll size) {
ll sum = 0;
REP(i, size) { sum += a[i]; }
return sum;
}
// aのなかにtがいくつあるか
ll counT(VLL a, ll t) {
sort(a.begin(), a.end());
return upper_bound(a.begin(), a.end(), t) -
lower_bound(a.begin(), a.end(), t);
}
#define COUNT(a, b) counT((a), (b))
#define MAX(x) maxP(x, x.size())
#define MIN(x) minP(x, x.size())
#define SUM(x) sumL(x, x.size())
//-------------------DIVIDE----------------------
// DIV[i][j] は i の j分割数 j == 0 && i != 0 なら 0
// 並び順を区別しない
ll DIV[1000 + 1][1000 + 1];
void divide(ll n, ll m) {
DIV[0][0] = 1;
FOR(i, 1, n + 1) { DIV[i][0] = 0; }
REP(i, n + 1) { DIV[i][1] = 1; }
FOR(i, 1, m + 1) {
FOR(t, 0, n + 1) {
if (DIV[t][i] > 0)
continue;
if (t >= i) {
DIV[t][i] = DIV[t - i][i] + DIV[t][i - 1];
} else {
DIV[t][i] = DIV[t][i - 1];
}
}
}
}
#define DIVIDE(a, b) (DIV[a][b] - DIV[a][(b)-1])
//-------要素を見つける-----------
ll search(vll &a, ll n) { // a内のnのindexを返す
std::vector<ll>::iterator iter = std::find(a.begin(), a.end(), n);
size_t index = distance(a.begin(), iter);
return index;
}
//------------素数判定-----------------
//------------素数判定-----------------
vector<bool> IS_PRIME_CONTAINER(1000005, true);
// メモリを圧迫する可能性あり
void IsPrime_Contain(ll num) {
IS_PRIME_CONTAINER[0] = false;
IS_PRIME_CONTAINER[1] = false;
FOR(i, 2, sqrt(num) + 1) {
if (IS_PRIME_CONTAINER[i]) {
FOR(j, 2, num / i + 1) {
if (j * i <= num) {
IS_PRIME_CONTAINER[i * j] = false;
}
}
}
}
}
inline bool IsPrime(ll num) { return IS_PRIME_CONTAINER[num]; }
//---------ベルマンフォード----------
struct E {
ll from, to, cost;
};
ll DIST[100005];
// start と 辺の数 m 辺の情報 x を入力
void shortest(LL s, vector<E> &x, ll m) {
REP(i, 100000) { DIST[i] = INF; }
DIST[s] = 0;
while (1) {
bool t = false;
REP(i, m) {
E h = x[i];
if (DIST[h.from] != INF && DIST[h.to] > DIST[h.from] + h.cost) {
DIST[h.to] = DIST[h.from] + h.cost;
t = true;
}
}
if (!t) {
break;
}
}
}
//----UnionFind-----
class UnionFind {
public:
vll par;
vll rank; // rankが高いほど上の親である
UnionFind(LL N) : par(N), rank(N) {
REP(i, N) par[i] = i;
REP(i, N) rank[i] = 0;
}
~UnionFind() {}
LL root(LL x) {
if (par[x] == x)
return x;
else {
par[x] = root(par[x]);
return par[x];
}
}
void unite(LL x, LL y) {
LL rx = root(x);
LL ry = root(y);
if (rx == ry)
return;
if (rank[rx] < rank[ry]) {
par[rx] = ry; // rankの高い方を親にする
} else {
par[ry] = rx;
if (rank[rx] == rank[ry]) {
// rankがどちらも同じ時、どちらか好きな方を親にしてそのrankを1上げる
rank[rx]++;
}
}
}
bool same(LL x, LL y) {
LL rx = root(x);
LL ry = root(y);
return rx == ry;
}
};
//--------BFS---------
class BFS_shortestDistance {
public:
BFS_shortestDistance(vector<vector<char>> p_, ll h_, ll w_) {
p = p_;
h = h_;
w = w_;
initial_number = h * w * 2;
REP(i, h) {
vector<LL> k(w);
REP(t, w) k[t] = initial_number;
field.push_back(k);
}
}
vector<vector<char>> p;
ll h;
ll w;
ll initial_number; // 初期化用数値
vector<vector<LL>> field; // この変数に書き込む
pair<LL, LL> plus(pair<LL, LL> &a, pair<LL, LL> &b) {
pair<LL, LL> p;
p.first = a.first + b.first;
p.second = a.second + b.second;
return p;
}
bool equal(pair<LL, LL> &a, pair<LL, LL> &b) {
return (a.first == b.first && a.second == b.second);
}
bool is_in_field(int h, int w, const pair<LL, LL> &point) {
const int c = point.second;
const int r = point.first;
return (0 <= c && c < w) && (0 <= r && r < h);
}
// fieldの中身を初期化
// 最短距離がh*w*2になることはないのでこれで初期化する
void init() {
REP(i, field.size()) {
REP(t, field[i].size()) { field[i][t] = initial_number; }
}
}
// sy , sx はスタート位置の 『INDEX』!!
// syが縦 sx が横
void shortest(ll sy, ll sx) {
// 初期化
init();
pair<LL, LL> c[4];
c[0].first = 0;
c[0].second = 1;
c[1].first = 0;
c[1].second = -1;
c[2].first = 1;
c[2].second = 0;
c[3].first = -1;
c[3].second = 0;
queue<pair<LL, LL>> Q;
pair<LL, LL> s;
s.first = sy;
s.second = sx;
field[sy][sx] = 0; // スタート位置のみ0で初期化
Q.push(s);
while (Q.empty() == false) {
pair<LL, LL> now = Q.front();
Q.pop();
for (int u = 0; u < 4; u++) {
pair<LL, LL> x = c[u];
pair<LL, LL> next = plus(now, x);
if (is_in_field(h, w, next)) {
if (p[next.first][next.second] == '.') {
// まだ到達してない ＝＝ field の値が initial_number
if (field[next.first][next.second] == initial_number) {
field[next.first][next.second] = field[now.first][now.second] + 1;
Q.push(next);
} else {
// すでに到達済みである＝＝これ以前にQueueから出てきたpairがすでに
// 到達している＝＝すでにfieldの値が最小値であることは明らか;
}
}
}
}
}
}
};
//-----------DP---------------//
// b < a => true , a = b;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
// b > a => true , a = b;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
//-----------MODつきCombination------------//
const int MAX = 1000007;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
//-----------MAIN------------//
ll P(ll n, ll k) {
ll j = 1;
REP(i, k) { j *= n - i; }
return j;
}
ll C(ll n, ll k) {
ll j = 1;
j *= P(n, k);
j /= P(k, k);
return j;
}
int main() {
LL n, k;
cin >> n >> k;
COMinit();
// cout << P(2,2) << " " << C(1 , 1);
ll ans = 1;
REP(i, k) {
ll in = i + 1;
ans *= COM(k - 1, in - 1) * C(n - k + 1, in);
// debug(COM(n-k+1,in))
// debug(P(k-1,in-1))
ans %= MOD;
cout << ans << endl;
ans = 1;
}
return 0;
}
| // include
//------------------------------------------
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#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 <utility>
#include <vector>
using namespace std;
// conversion
//------------------------------------------
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();
}
// math
//-------------------------------------------
template <class T> inline T sqr(T x) { return x * x; }
// typedef
//------------------------------------------
typedef long long ll;
typedef long long LL;
typedef vector<long long> VLL;
typedef vector<long long> vll;
typedef pair<long long, long long> pll;
typedef pair<long long, long long> PLL;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define VECMAX(x) *max_element(ALL(x))
#define VECMIN(x) *min_element(ALL(x))
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define MULTIPLE(i, n, k) for (int i = (k); i < (n); i += k + 1) // 倍数ループ
// constant
//------------------------------------------
const double EPS = 1e-10;
const double PI = acos(-1.0);
// clear memory
#define CLR(a) memset((a), 0, sizeof(a))
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
#define SIZEOF(x) sizeof(x) / sizeof(x[0])
const long long INF = 100000000000000;
const long long NINF = -100000000000000;
//----------------search for specific figure--------------------
//--------------------------------------------------------------
// firstが最大値（最小値） , second が index
pair<LL, LL> maxP(vll a, ll size) {
pair<ll, ll> p;
vll::iterator iter = max_element(a.begin(), a.end());
p.first = *iter;
p.second = distance(a.begin(), iter);
return p;
}
pair<LL, LL> minP(vll a, ll size) {
pair<ll, ll> p;
vll::iterator iter = min_element(a.begin(), a.end());
p.first = *iter;
p.second = distance(a.begin(), iter);
return p;
}
ll sumL(vll a, ll size) {
ll sum = 0;
REP(i, size) { sum += a[i]; }
return sum;
}
// aのなかにtがいくつあるか
ll counT(VLL a, ll t) {
sort(a.begin(), a.end());
return upper_bound(a.begin(), a.end(), t) -
lower_bound(a.begin(), a.end(), t);
}
#define COUNT(a, b) counT((a), (b))
#define MAX(x) maxP(x, x.size())
#define MIN(x) minP(x, x.size())
#define SUM(x) sumL(x, x.size())
//-------------------DIVIDE----------------------
// DIV[i][j] は i の j分割数 j == 0 && i != 0 なら 0
// 並び順を区別しない
ll DIV[1000 + 1][1000 + 1];
void divide(ll n, ll m) {
DIV[0][0] = 1;
FOR(i, 1, n + 1) { DIV[i][0] = 0; }
REP(i, n + 1) { DIV[i][1] = 1; }
FOR(i, 1, m + 1) {
FOR(t, 0, n + 1) {
if (DIV[t][i] > 0)
continue;
if (t >= i) {
DIV[t][i] = DIV[t - i][i] + DIV[t][i - 1];
} else {
DIV[t][i] = DIV[t][i - 1];
}
}
}
}
#define DIVIDE(a, b) (DIV[a][b] - DIV[a][(b)-1])
//-------要素を見つける-----------
ll search(vll &a, ll n) { // a内のnのindexを返す
std::vector<ll>::iterator iter = std::find(a.begin(), a.end(), n);
size_t index = distance(a.begin(), iter);
return index;
}
//------------素数判定-----------------
//------------素数判定-----------------
vector<bool> IS_PRIME_CONTAINER(1000005, true);
// メモリを圧迫する可能性あり
void IsPrime_Contain(ll num) {
IS_PRIME_CONTAINER[0] = false;
IS_PRIME_CONTAINER[1] = false;
FOR(i, 2, sqrt(num) + 1) {
if (IS_PRIME_CONTAINER[i]) {
FOR(j, 2, num / i + 1) {
if (j * i <= num) {
IS_PRIME_CONTAINER[i * j] = false;
}
}
}
}
}
inline bool IsPrime(ll num) { return IS_PRIME_CONTAINER[num]; }
//---------ベルマンフォード----------
struct E {
ll from, to, cost;
};
ll DIST[100005];
// start と 辺の数 m 辺の情報 x を入力
void shortest(LL s, vector<E> &x, ll m) {
REP(i, 100000) { DIST[i] = INF; }
DIST[s] = 0;
while (1) {
bool t = false;
REP(i, m) {
E h = x[i];
if (DIST[h.from] != INF && DIST[h.to] > DIST[h.from] + h.cost) {
DIST[h.to] = DIST[h.from] + h.cost;
t = true;
}
}
if (!t) {
break;
}
}
}
//----UnionFind-----
class UnionFind {
public:
vll par;
vll rank; // rankが高いほど上の親である
UnionFind(LL N) : par(N), rank(N) {
REP(i, N) par[i] = i;
REP(i, N) rank[i] = 0;
}
~UnionFind() {}
LL root(LL x) {
if (par[x] == x)
return x;
else {
par[x] = root(par[x]);
return par[x];
}
}
void unite(LL x, LL y) {
LL rx = root(x);
LL ry = root(y);
if (rx == ry)
return;
if (rank[rx] < rank[ry]) {
par[rx] = ry; // rankの高い方を親にする
} else {
par[ry] = rx;
if (rank[rx] == rank[ry]) {
// rankがどちらも同じ時、どちらか好きな方を親にしてそのrankを1上げる
rank[rx]++;
}
}
}
bool same(LL x, LL y) {
LL rx = root(x);
LL ry = root(y);
return rx == ry;
}
};
//--------BFS---------
class BFS_shortestDistance {
public:
BFS_shortestDistance(vector<vector<char>> p_, ll h_, ll w_) {
p = p_;
h = h_;
w = w_;
initial_number = h * w * 2;
REP(i, h) {
vector<LL> k(w);
REP(t, w) k[t] = initial_number;
field.push_back(k);
}
}
vector<vector<char>> p;
ll h;
ll w;
ll initial_number; // 初期化用数値
vector<vector<LL>> field; // この変数に書き込む
pair<LL, LL> plus(pair<LL, LL> &a, pair<LL, LL> &b) {
pair<LL, LL> p;
p.first = a.first + b.first;
p.second = a.second + b.second;
return p;
}
bool equal(pair<LL, LL> &a, pair<LL, LL> &b) {
return (a.first == b.first && a.second == b.second);
}
bool is_in_field(int h, int w, const pair<LL, LL> &point) {
const int c = point.second;
const int r = point.first;
return (0 <= c && c < w) && (0 <= r && r < h);
}
// fieldの中身を初期化
// 最短距離がh*w*2になることはないのでこれで初期化する
void init() {
REP(i, field.size()) {
REP(t, field[i].size()) { field[i][t] = initial_number; }
}
}
// sy , sx はスタート位置の 『INDEX』!!
// syが縦 sx が横
void shortest(ll sy, ll sx) {
// 初期化
init();
pair<LL, LL> c[4];
c[0].first = 0;
c[0].second = 1;
c[1].first = 0;
c[1].second = -1;
c[2].first = 1;
c[2].second = 0;
c[3].first = -1;
c[3].second = 0;
queue<pair<LL, LL>> Q;
pair<LL, LL> s;
s.first = sy;
s.second = sx;
field[sy][sx] = 0; // スタート位置のみ0で初期化
Q.push(s);
while (Q.empty() == false) {
pair<LL, LL> now = Q.front();
Q.pop();
for (int u = 0; u < 4; u++) {
pair<LL, LL> x = c[u];
pair<LL, LL> next = plus(now, x);
if (is_in_field(h, w, next)) {
if (p[next.first][next.second] == '.') {
// まだ到達してない ＝＝ field の値が initial_number
if (field[next.first][next.second] == initial_number) {
field[next.first][next.second] = field[now.first][now.second] + 1;
Q.push(next);
} else {
// すでに到達済みである＝＝これ以前にQueueから出てきたpairがすでに
// 到達している＝＝すでにfieldの値が最小値であることは明らか;
}
}
}
}
}
}
};
//-----------DP---------------//
// b < a => true , a = b;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
// b > a => true , a = b;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
//-----------MODつきCombination------------//
const int MAX = 1000007;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
//-----------MAIN------------//
ll P(ll n, ll k) {
ll j = 1;
REP(i, k) { j *= n - i; }
return j;
}
ll C(ll n, ll k) {
ll j = 1;
j *= P(n, k);
j /= P(k, k);
return j;
}
int main() {
LL n, k;
cin >> n >> k;
COMinit();
// cout << P(2,2) << " " << C(1 , 1);
ll ans = 1;
REP(i, k) {
ll in = i + 1;
ans *= COM(k - 1, in - 1) * COM(n - k + 1, in);
// debug(COM(n-k+1,in))
// debug(P(k-1,in-1))
ans %= MOD;
cout << ans << endl;
ans = 1;
}
return 0;
}
| replace | 402 | 403 | 402 | 403 | 0 | |
p02990 | C++ | Runtime Error | #define _CRT_SECURE_NO_WARNINGS
#include "bits/stdc++.h"
#if defined(_MSC_VER) || defined(ONLINE_JUDGE)
#define getchar_unlocked _getchar_nolock
#define putchar_unlocked _putchar_nolock
#endif
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define mp make_pair
#define pb push_back
#define dump(x) cerr << #x << " = " << (x) << endl;
using LL = long long;
using VS = vector<string>;
using VD = vector<double>;
using VI = vector<int>;
using VL = vector<LL>;
using VVI = vector<VI>;
using VVL = vector<VL>;
using PII = pair<int, int>;
using PLL = pair<LL, LL>;
const int inf = (int)1e9;
const double pi = acos(-1.0);
const LL MOD = 1000000007;
const string Snum = "0123456789";
const int dx[] = {-1, 0, 1, 0, -1, -1, 1, 1},
dy[] = {0, 1, 0, -1, -1, 1, -1, 1};
template <class T> void Sort(T &a) { sort(a.begin(), a.end()); }
template <class T> void ReSort(T &a) { sort(a.rbegin(), a.rend()); }
template <class T> void Reverse(T &a) { reverse(a.begin(), a.end()); }
template <class T> void Unique(T &a) {
a.erase(unique(a.begin(), a.end()), a.end());
}
template <class T> auto Max(const T &a) {
return *max_element(a.begin(), a.end());
}
template <class T> auto Min(const T &a) {
return *min_element(a.begin(), a.end());
}
template <class T, class U> int Count(const T &a, U c) {
return count(a.begin(), a.end(), c);
}
template <class T, class U> U Sum(const T &a, U init = 0) {
return accumulate(a.begin(), a.end(), init);
}
template <class T, class U> int Lower(const T &a, U s) {
return lower_bound(a.begin(), a.end(), s) - a.begin();
}
template <class T, class U> int Upper(const T &a, U s) {
return upper_bound(a.begin(), a.end(), s) - a.begin();
}
template <class T> T Age(T a, T b) { return (a + b - 1) / b; }
template <class T> T Gcd(T n, T m) { return m == 0 ? n : Gcd(m, n % m); }
template <class T> T Lcm(T n, T m) { return n / Gcd(n, m) * m; }
/* INPUT */
template <class T> T InputF() { return 0; }
template <> char InputF() {
char ret = '\0', c = getchar_unlocked();
while (c != '\0' && c != '\n' && c != '\t' && c != ' ') {
ret = c;
c = getchar_unlocked();
}
return ret;
}
template <> string InputF() {
string ret;
char c = getchar_unlocked();
while (c != '\0' && c != '\n' && c != '\t' && c != ' ') {
ret.push_back(c);
c = getchar_unlocked();
}
return ret;
}
template <> int InputF() {
int ret = 0;
bool neg = false;
char c = getchar_unlocked();
if (c == '-') {
neg = true;
c = getchar_unlocked();
}
while ('0' <= c && c <= '9') {
ret = ret * 10 + (c - '0');
c = getchar_unlocked();
}
return neg ? -ret : ret;
}
template <> LL InputF() {
LL ret = 0;
bool neg = false;
char c = getchar_unlocked();
if (c == '-') {
neg = true;
c = getchar_unlocked();
}
while ('0' <= c && c <= '9') {
ret = ret * 10LL + (LL(c) - LL('0'));
c = getchar_unlocked();
}
return neg ? -ret : ret;
}
template <> double InputF() {
double ret = 0, dp = 1;
bool neg = false, adp = false;
char c = getchar_unlocked();
if (c == '-') {
neg = true;
c = getchar_unlocked();
}
while (('0' <= c && c <= '9') || c == '.') {
if (c == '.') {
adp = true;
} else if (adp) {
dp *= 0.1;
ret += (c - '0') * dp;
} else {
ret = ret * 10.0 + (c - '0');
}
c = getchar_unlocked();
}
return neg ? -ret : ret;
}
template <class T> T StoT(string s) { return s; }
template <> char StoT(string s) { return s.front(); }
template <> string StoT(string s) { return s; }
template <> int StoT(string s) { return stoi(s); }
template <> LL StoT(string s) { return stoll(s); }
template <> double StoT(string s) { return stod(s); }
string GetLine() {
string ret;
char c = getchar_unlocked();
while (c != '\0' && c != '\n') {
ret.push_back(c);
c = getchar_unlocked();
}
return ret;
}
VS InputB;
template <class T> struct InputC {
operator T() { return InputF<T>(); }
vector<T> operator[](int h) {
vector<T> ret(h);
rep(i, h) ret[i] = InputF<T>();
return ret;
}
vector<vector<T>> operator[](PII p) {
int h, w;
tie(h, w) = p;
vector<vector<T>> ret(h, vector<T>(w));
rep(i, h) rep(j, w) ret[i][j] = InputF<T>();
return ret;
}
T at(int n) {
while (sz(InputB) <= n)
InputB.pb(InputF<string>());
return StoT<T>(InputB[n]);
}
vector<T> at(int n, int h) {
vector<T> ret(h);
rep(i, h) ret[i] = at(i + n);
return ret;
}
vector<vector<T>> at(int n, int h, int w) {
vector<vector<T>> ret(h, vector<T>(w));
rep(i, h) rep(j, w) ret[i][j] = at(n + i * w + j);
return ret;
}
};
InputC<char> inc;
InputC<string> ins;
InputC<int> ini;
InputC<LL> inl;
InputC<double> ind;
/* OUTPUT */
class ostreamfbuff : public std::basic_streambuf<char, std::char_traits<char>> {
protected:
int overflow(int nCh = EOF) {
putchar_unlocked(nCh);
return 0;
}
};
class ostreamf : public std::basic_iostream<char, std::char_traits<char>> {
public:
ostreamf(void)
: std::basic_iostream<char, std::char_traits<char>>(new ostreamfbuff()) {}
};
ostreamf coutf;
ostream &operator<<(ostream &ostr, InputC<string> i) {
ostr << string(i);
return ostr;
}
struct BoolStr {
string t, f;
BoolStr(string tr, string fa) : t(tr), f(fa) {}
} yes("yes", "no"), Yes("Yes", "No"), YES("YES", "NO"), Yay("Yay!", ":(");
struct Divizer {
string s;
Divizer(string s_) : s(s_) {}
} spc(" "), nosp(""), comma(","), lin("\n");
struct Output {
bool flag = false;
BoolStr bs;
Divizer di;
Output(bool f, BoolStr b, Divizer d) : flag(f), bs(b), di(d) {}
template <class T> void print(T o) { coutf << o; }
void print(double o) { printf("%.20f", o); }
void print(bool o) { coutf << (o ? bs.t : bs.f); }
template <class T, class U> void print(const pair<T, U> &o) {
print(o.first);
coutf << di.s;
print(o.second);
}
template <class T> void print(const vector<T> &o) {
for (int i = 0; i < (int)o.size(); ++i) {
if (i != 0)
coutf << di.s;
print(o[i]);
}
}
template <class T, class U> void print(const map<T, U> &o) {
coutf << "Map";
for (auto a : o) {
coutf << " {";
print(a);
coutf << "},";
}
coutf << "\n";
}
template <class T> void print(const set<T> &o) {
coutf << "Set {";
for (auto a : o) {
print(a);
coutf << ",";
}
coutf << "}\n";
}
template <class T> Output operator,(T o) {
if (flag)
coutf << di.s;
print(o);
Output t(true, bs, di);
return t;
}
Output operator,(Output o) {
coutf << '\n';
return o;
}
Output operator,(BoolStr b) {
Output t(flag, b, di);
return t;
}
Output operator,(Divizer d) {
Output t(flag, bs, d);
return t;
}
} out(false, Yes, spc);
/* ANSWER */
struct Answer {
int mini = INT_MAX, maxi = INT_MIN, sumi = 0;
LL minl = LLONG_MAX, maxl = LLONG_MIN, suml = 0;
double mind = DBL_MAX, maxd = DBL_MIN, sumd = 0;
int cnt = 0;
void operator=(int n) {
mini = min(mini, n);
maxi = max(maxi, n);
sumi += n;
cnt++;
}
void operator=(LL n) {
minl = min(minl, n);
maxl = max(maxl, n);
suml += n;
cnt++;
}
void operator=(double n) {
mind = min(mind, n);
maxd = max(maxd, n);
sumd += n;
cnt++;
}
} ans;
void comb(VVL &v) {
for (int i = 0; i < sz(v); i++) {
v[i][0] = 1;
v[i][i] = 1;
}
FOR(k, 1, sz(v))
FOR(j, 1, k) v[k][j] = (v[k - 1][j - 1] % MOD + v[k - 1][j] % MOD) % MOD;
}
int main() {
LL n = inl, k = inl;
VVL c(n, VL(n));
comb(c);
rep(i, k) { out, c[k - 1][i] * c[n - k + 1][i + 1] % MOD, out; }
} | #define _CRT_SECURE_NO_WARNINGS
#include "bits/stdc++.h"
#if defined(_MSC_VER) || defined(ONLINE_JUDGE)
#define getchar_unlocked _getchar_nolock
#define putchar_unlocked _putchar_nolock
#endif
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define mp make_pair
#define pb push_back
#define dump(x) cerr << #x << " = " << (x) << endl;
using LL = long long;
using VS = vector<string>;
using VD = vector<double>;
using VI = vector<int>;
using VL = vector<LL>;
using VVI = vector<VI>;
using VVL = vector<VL>;
using PII = pair<int, int>;
using PLL = pair<LL, LL>;
const int inf = (int)1e9;
const double pi = acos(-1.0);
const LL MOD = 1000000007;
const string Snum = "0123456789";
const int dx[] = {-1, 0, 1, 0, -1, -1, 1, 1},
dy[] = {0, 1, 0, -1, -1, 1, -1, 1};
template <class T> void Sort(T &a) { sort(a.begin(), a.end()); }
template <class T> void ReSort(T &a) { sort(a.rbegin(), a.rend()); }
template <class T> void Reverse(T &a) { reverse(a.begin(), a.end()); }
template <class T> void Unique(T &a) {
a.erase(unique(a.begin(), a.end()), a.end());
}
template <class T> auto Max(const T &a) {
return *max_element(a.begin(), a.end());
}
template <class T> auto Min(const T &a) {
return *min_element(a.begin(), a.end());
}
template <class T, class U> int Count(const T &a, U c) {
return count(a.begin(), a.end(), c);
}
template <class T, class U> U Sum(const T &a, U init = 0) {
return accumulate(a.begin(), a.end(), init);
}
template <class T, class U> int Lower(const T &a, U s) {
return lower_bound(a.begin(), a.end(), s) - a.begin();
}
template <class T, class U> int Upper(const T &a, U s) {
return upper_bound(a.begin(), a.end(), s) - a.begin();
}
template <class T> T Age(T a, T b) { return (a + b - 1) / b; }
template <class T> T Gcd(T n, T m) { return m == 0 ? n : Gcd(m, n % m); }
template <class T> T Lcm(T n, T m) { return n / Gcd(n, m) * m; }
/* INPUT */
template <class T> T InputF() { return 0; }
template <> char InputF() {
char ret = '\0', c = getchar_unlocked();
while (c != '\0' && c != '\n' && c != '\t' && c != ' ') {
ret = c;
c = getchar_unlocked();
}
return ret;
}
template <> string InputF() {
string ret;
char c = getchar_unlocked();
while (c != '\0' && c != '\n' && c != '\t' && c != ' ') {
ret.push_back(c);
c = getchar_unlocked();
}
return ret;
}
template <> int InputF() {
int ret = 0;
bool neg = false;
char c = getchar_unlocked();
if (c == '-') {
neg = true;
c = getchar_unlocked();
}
while ('0' <= c && c <= '9') {
ret = ret * 10 + (c - '0');
c = getchar_unlocked();
}
return neg ? -ret : ret;
}
template <> LL InputF() {
LL ret = 0;
bool neg = false;
char c = getchar_unlocked();
if (c == '-') {
neg = true;
c = getchar_unlocked();
}
while ('0' <= c && c <= '9') {
ret = ret * 10LL + (LL(c) - LL('0'));
c = getchar_unlocked();
}
return neg ? -ret : ret;
}
template <> double InputF() {
double ret = 0, dp = 1;
bool neg = false, adp = false;
char c = getchar_unlocked();
if (c == '-') {
neg = true;
c = getchar_unlocked();
}
while (('0' <= c && c <= '9') || c == '.') {
if (c == '.') {
adp = true;
} else if (adp) {
dp *= 0.1;
ret += (c - '0') * dp;
} else {
ret = ret * 10.0 + (c - '0');
}
c = getchar_unlocked();
}
return neg ? -ret : ret;
}
template <class T> T StoT(string s) { return s; }
template <> char StoT(string s) { return s.front(); }
template <> string StoT(string s) { return s; }
template <> int StoT(string s) { return stoi(s); }
template <> LL StoT(string s) { return stoll(s); }
template <> double StoT(string s) { return stod(s); }
string GetLine() {
string ret;
char c = getchar_unlocked();
while (c != '\0' && c != '\n') {
ret.push_back(c);
c = getchar_unlocked();
}
return ret;
}
VS InputB;
template <class T> struct InputC {
operator T() { return InputF<T>(); }
vector<T> operator[](int h) {
vector<T> ret(h);
rep(i, h) ret[i] = InputF<T>();
return ret;
}
vector<vector<T>> operator[](PII p) {
int h, w;
tie(h, w) = p;
vector<vector<T>> ret(h, vector<T>(w));
rep(i, h) rep(j, w) ret[i][j] = InputF<T>();
return ret;
}
T at(int n) {
while (sz(InputB) <= n)
InputB.pb(InputF<string>());
return StoT<T>(InputB[n]);
}
vector<T> at(int n, int h) {
vector<T> ret(h);
rep(i, h) ret[i] = at(i + n);
return ret;
}
vector<vector<T>> at(int n, int h, int w) {
vector<vector<T>> ret(h, vector<T>(w));
rep(i, h) rep(j, w) ret[i][j] = at(n + i * w + j);
return ret;
}
};
InputC<char> inc;
InputC<string> ins;
InputC<int> ini;
InputC<LL> inl;
InputC<double> ind;
/* OUTPUT */
class ostreamfbuff : public std::basic_streambuf<char, std::char_traits<char>> {
protected:
int overflow(int nCh = EOF) {
putchar_unlocked(nCh);
return 0;
}
};
class ostreamf : public std::basic_iostream<char, std::char_traits<char>> {
public:
ostreamf(void)
: std::basic_iostream<char, std::char_traits<char>>(new ostreamfbuff()) {}
};
ostreamf coutf;
ostream &operator<<(ostream &ostr, InputC<string> i) {
ostr << string(i);
return ostr;
}
struct BoolStr {
string t, f;
BoolStr(string tr, string fa) : t(tr), f(fa) {}
} yes("yes", "no"), Yes("Yes", "No"), YES("YES", "NO"), Yay("Yay!", ":(");
struct Divizer {
string s;
Divizer(string s_) : s(s_) {}
} spc(" "), nosp(""), comma(","), lin("\n");
struct Output {
bool flag = false;
BoolStr bs;
Divizer di;
Output(bool f, BoolStr b, Divizer d) : flag(f), bs(b), di(d) {}
template <class T> void print(T o) { coutf << o; }
void print(double o) { printf("%.20f", o); }
void print(bool o) { coutf << (o ? bs.t : bs.f); }
template <class T, class U> void print(const pair<T, U> &o) {
print(o.first);
coutf << di.s;
print(o.second);
}
template <class T> void print(const vector<T> &o) {
for (int i = 0; i < (int)o.size(); ++i) {
if (i != 0)
coutf << di.s;
print(o[i]);
}
}
template <class T, class U> void print(const map<T, U> &o) {
coutf << "Map";
for (auto a : o) {
coutf << " {";
print(a);
coutf << "},";
}
coutf << "\n";
}
template <class T> void print(const set<T> &o) {
coutf << "Set {";
for (auto a : o) {
print(a);
coutf << ",";
}
coutf << "}\n";
}
template <class T> Output operator,(T o) {
if (flag)
coutf << di.s;
print(o);
Output t(true, bs, di);
return t;
}
Output operator,(Output o) {
coutf << '\n';
return o;
}
Output operator,(BoolStr b) {
Output t(flag, b, di);
return t;
}
Output operator,(Divizer d) {
Output t(flag, bs, d);
return t;
}
} out(false, Yes, spc);
/* ANSWER */
struct Answer {
int mini = INT_MAX, maxi = INT_MIN, sumi = 0;
LL minl = LLONG_MAX, maxl = LLONG_MIN, suml = 0;
double mind = DBL_MAX, maxd = DBL_MIN, sumd = 0;
int cnt = 0;
void operator=(int n) {
mini = min(mini, n);
maxi = max(maxi, n);
sumi += n;
cnt++;
}
void operator=(LL n) {
minl = min(minl, n);
maxl = max(maxl, n);
suml += n;
cnt++;
}
void operator=(double n) {
mind = min(mind, n);
maxd = max(maxd, n);
sumd += n;
cnt++;
}
} ans;
void comb(VVL &v) {
for (int i = 0; i < sz(v); i++) {
v[i][0] = 1;
v[i][i] = 1;
}
FOR(k, 1, sz(v))
FOR(j, 1, k) v[k][j] = (v[k - 1][j - 1] % MOD + v[k - 1][j] % MOD) % MOD;
}
int main() {
LL n = inl, k = inl;
VVL c(n + 5, VL(n + 5));
comb(c);
rep(i, k) { out, c[k - 1][i] * c[n - k + 1][i + 1] % MOD, out; }
} | replace | 302 | 303 | 302 | 303 | 0 | |
p02990 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
// const int mod = 998244353;
const int mod = 1000000007;
struct mint {
ll x; // typedef long long ll;
mint(ll 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 { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= 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 { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
mint fact(int n) {
if (n == 0)
return 1;
mint ans = n;
ans *= fact(n - 1);
return ans;
}
mint combi(int n, int k) { return fact(n) / (fact(k) * fact(n - k)); }
int main(void) {
int n, k;
cin >> n >> k;
for (int i = 1; i <= k; i++) {
mint ans = combi(n - k + 1, i);
ans *= combi(k - 1, i - 1);
cout << ans << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
// const int mod = 998244353;
const int mod = 1000000007;
struct mint {
ll x; // typedef long long ll;
mint(ll 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 { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= 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 { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
mint fact(int n) {
if (n == 0)
return 1;
mint ans = n;
ans *= fact(n - 1);
return ans;
}
mint combi(int n, int k) {
if (n < k)
return 0;
return fact(n) / (fact(k) * fact(n - k));
}
int main(void) {
int n, k;
cin >> n >> k;
for (int i = 1; i <= k; i++) {
mint ans = combi(n - k + 1, i);
ans *= combi(k - 1, i - 1);
cout << ans << endl;
}
} | replace | 54 | 55 | 54 | 59 | 0 | |
p02990 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using ll = long long;
const ll MOD = 1000000007;
#define rep(i, n) for (ll i = 0; i < (n); i++)
using namespace std;
int get_gcd(int a, int b) {
while (1) {
if (a < b)
swap(a, b);
if (b == 0)
return a;
a %= b;
}
}
int get_lcm(int a, int b) { return a * b / get_gcd(a, b); }
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
// 組み合わせnCrをMODで割った時の余り
ll c[2001][2001];
int main() {
ll n, k;
cin >> n >> k;
// 組み合わせnCr (0<=n<=2000, 0<=r<=n)を動的計画法で計算する
// まずc[i][i] = 1, c[i][0] = 1とする。
// 次にc[i][j]について、c[i][j] = c[i-1][j] + c[i-1][j-1]を用いて算出する。
for (int i = 0; i <= 2000; n++) {
c[i][i] = 1;
c[i][0] = 1;
}
for (int i = 2; i <= 2000; i++) {
for (int j = 1; j < i; j++) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % MOD;
}
}
// 各i (1<=i<=k)について、解はc[k-1][i-1]*c[n-k+1][i]
for (int i = 1; i <= k; i++) {
cout << (c[k - 1][i - 1] * c[n - k + 1][i]) % MOD << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using ll = long long;
const ll MOD = 1000000007;
#define rep(i, n) for (ll i = 0; i < (n); i++)
using namespace std;
int get_gcd(int a, int b) {
while (1) {
if (a < b)
swap(a, b);
if (b == 0)
return a;
a %= b;
}
}
int get_lcm(int a, int b) { return a * b / get_gcd(a, b); }
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
// 組み合わせnCrをMODで割った時の余り
ll c[2001][2001];
int main() {
ll n, k;
cin >> n >> k;
// 組み合わせnCr (0<=n<=2000, 0<=r<=n)を動的計画法で計算する
// まずc[i][i] = 1, c[i][0] = 1とする。
// 次にc[i][j]について、c[i][j] = c[i-1][j] + c[i-1][j-1]を用いて算出する。
for (int i = 0; i <= 2000; i++) {
c[i][i] = 1;
c[i][0] = 1;
}
for (int i = 2; i <= 2000; i++) {
for (int j = 1; j < i; j++) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % MOD;
}
}
// 各i (1<=i<=k)について、解はc[k-1][i-1]*c[n-k+1][i]
for (int i = 1; i <= k; i++) {
cout << (c[k - 1][i - 1] * c[n - k + 1][i]) % MOD << endl;
}
return 0;
}
| replace | 28 | 29 | 28 | 29 | TLE | |
p02990 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
// 定数
const long long MOD1 = 1000000007;
const long long MOD2 = 998244353;
const long long INF = 1152921504606846976;
const long double PI = 3.1415926535897932;
// 型名省略
#define ll long long
#define ull unsigned long long
#define ld long double
#define pll pair<long long, long long>
#define vl vector<long long>
#define vvl vector<vector<long long>>
#define vc vector<char>
#define vvc vector<vector<char>>
#define vb vector<bool>
#define vvb vector<vector<bool>>
#define mp make_pair
#define mt make_tuple
#define eb emplace_back
#define umap unordered_map
#define uset unordered_set
#define Lqueue priority_queue<long long>
#define Squeue priority_queue<long long, vector<long long>, greater<long long>>
#define Fi first
#define Se second
// マクロ
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rbf(a, x) for (auto &a : x)
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
#define rep2(i, s, n) for (long long i = (s); i < (long long)(n); i++)
#define Maxe(x) *max_element((x).begin(), (x).end())
#define Mine(x) *min_element((x).begin(), (x).end())
#define Size(x) ((long long)(x).size())
// 最大公約数
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
// 最小公倍数
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
// 累乗
template <typename Num> constexpr Num mypow(Num a, ll b) {
if (b == 0)
return 1;
if (a == 0)
return 0;
Num x = 1;
while (b > 0) {
if (b & 1)
x *= a;
a *= a;
b >>= 1;
}
return x;
}
// chmin,chmax
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// MODint
template <int MOD> struct Fp {
long long val;
constexpr Fp(long long v = 0) noexcept : val(v % MOD) {
if (val < 0)
val += MOD;
}
constexpr int getmod() { return MOD; }
constexpr Fp operator-() const noexcept { return val ? MOD - val : 0; }
constexpr Fp operator+(const Fp &r) const noexcept { return Fp(*this) += r; }
constexpr Fp operator-(const Fp &r) const noexcept { return Fp(*this) -= r; }
constexpr Fp operator*(const Fp &r) const noexcept { return Fp(*this) *= r; }
constexpr Fp operator/(const Fp &r) const noexcept { return Fp(*this) /= r; }
constexpr Fp &operator+=(const Fp &r) noexcept {
val += r.val;
if (val >= MOD)
val -= MOD;
return *this;
}
constexpr Fp &operator-=(const Fp &r) noexcept {
val -= r.val;
if (val < 0)
val += MOD;
return *this;
}
constexpr Fp &operator*=(const Fp &r) noexcept {
val = val * r.val % MOD;
return *this;
}
constexpr Fp &operator/=(const Fp &r) noexcept {
long long a = r.val, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
val = val * u % MOD;
if (val < 0)
val += MOD;
return *this;
}
constexpr bool operator==(const Fp &r) const noexcept {
return this->val == r.val;
}
constexpr bool operator!=(const Fp &r) const noexcept {
return this->val != r.val;
}
friend constexpr ostream &operator<<(ostream &os, const Fp<MOD> &x) noexcept {
return os << x.val;
}
friend constexpr istream &operator>>(istream &is, Fp<MOD> &x) {
long long t;
is >> t;
x = t;
return (is);
}
friend constexpr Fp<MOD> modpow(const Fp<MOD> &a, long long n) noexcept {
if (n == 0)
return 1;
auto t = modpow(a, n / 2);
t = t * t;
if (n & 1)
t = t * a;
return t;
}
};
using mint = Fp<MOD1>;
template <class T> struct Comb {
vector<T> fact_, fact_inv_, inv_;
Comb() {}
Comb(int SIZE) : fact_(SIZE, 1), fact_inv_(SIZE, 1), inv_(SIZE, 1) {
init(SIZE);
}
void init(int SIZE) {
fact_.assign(SIZE, 1), fact_inv_.assign(SIZE, 1), inv_.assign(SIZE, 1);
int MOD = fact_[0].getmod();
for (int i = 2; i < SIZE; i++) {
fact_[i] = fact_[i - 1] * i;
inv_[i] = -inv_[MOD % i] * (MOD / i);
fact_inv_[i] = fact_inv_[i - 1] * inv_[i];
}
}
T nCk(int n, int k) {
assert(!(n < k));
assert(!(n < 0 || k < 0));
return fact_[n] * fact_inv_[k] * fact_inv_[n - k];
}
T nHk(int n, int k) {
assert(!(n < 0 || k < 0));
return nCk(n + k - 1, k);
}
T fact(int n) {
assert(!(n < 0));
return fact_[n];
}
T fact_inv(int n) {
assert(!(n < 0));
return fact_inv_[n];
}
T inv(int n) {
assert(!(n < 0));
return inv_[n];
}
};
// start
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
Comb<mint> C(100000);
ll n, k;
cin >> n >> k;
rep2(i, 1, k + 1) {
mint res = 1;
res *= C.nCk(n - k + 1, i);
res *= C.nCk(k - 1, i - 1);
cout << res << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
// 定数
const long long MOD1 = 1000000007;
const long long MOD2 = 998244353;
const long long INF = 1152921504606846976;
const long double PI = 3.1415926535897932;
// 型名省略
#define ll long long
#define ull unsigned long long
#define ld long double
#define pll pair<long long, long long>
#define vl vector<long long>
#define vvl vector<vector<long long>>
#define vc vector<char>
#define vvc vector<vector<char>>
#define vb vector<bool>
#define vvb vector<vector<bool>>
#define mp make_pair
#define mt make_tuple
#define eb emplace_back
#define umap unordered_map
#define uset unordered_set
#define Lqueue priority_queue<long long>
#define Squeue priority_queue<long long, vector<long long>, greater<long long>>
#define Fi first
#define Se second
// マクロ
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rbf(a, x) for (auto &a : x)
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
#define rep2(i, s, n) for (long long i = (s); i < (long long)(n); i++)
#define Maxe(x) *max_element((x).begin(), (x).end())
#define Mine(x) *min_element((x).begin(), (x).end())
#define Size(x) ((long long)(x).size())
// 最大公約数
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
// 最小公倍数
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
// 累乗
template <typename Num> constexpr Num mypow(Num a, ll b) {
if (b == 0)
return 1;
if (a == 0)
return 0;
Num x = 1;
while (b > 0) {
if (b & 1)
x *= a;
a *= a;
b >>= 1;
}
return x;
}
// chmin,chmax
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// MODint
template <int MOD> struct Fp {
long long val;
constexpr Fp(long long v = 0) noexcept : val(v % MOD) {
if (val < 0)
val += MOD;
}
constexpr int getmod() { return MOD; }
constexpr Fp operator-() const noexcept { return val ? MOD - val : 0; }
constexpr Fp operator+(const Fp &r) const noexcept { return Fp(*this) += r; }
constexpr Fp operator-(const Fp &r) const noexcept { return Fp(*this) -= r; }
constexpr Fp operator*(const Fp &r) const noexcept { return Fp(*this) *= r; }
constexpr Fp operator/(const Fp &r) const noexcept { return Fp(*this) /= r; }
constexpr Fp &operator+=(const Fp &r) noexcept {
val += r.val;
if (val >= MOD)
val -= MOD;
return *this;
}
constexpr Fp &operator-=(const Fp &r) noexcept {
val -= r.val;
if (val < 0)
val += MOD;
return *this;
}
constexpr Fp &operator*=(const Fp &r) noexcept {
val = val * r.val % MOD;
return *this;
}
constexpr Fp &operator/=(const Fp &r) noexcept {
long long a = r.val, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
val = val * u % MOD;
if (val < 0)
val += MOD;
return *this;
}
constexpr bool operator==(const Fp &r) const noexcept {
return this->val == r.val;
}
constexpr bool operator!=(const Fp &r) const noexcept {
return this->val != r.val;
}
friend constexpr ostream &operator<<(ostream &os, const Fp<MOD> &x) noexcept {
return os << x.val;
}
friend constexpr istream &operator>>(istream &is, Fp<MOD> &x) {
long long t;
is >> t;
x = t;
return (is);
}
friend constexpr Fp<MOD> modpow(const Fp<MOD> &a, long long n) noexcept {
if (n == 0)
return 1;
auto t = modpow(a, n / 2);
t = t * t;
if (n & 1)
t = t * a;
return t;
}
};
using mint = Fp<MOD1>;
template <class T> struct Comb {
vector<T> fact_, fact_inv_, inv_;
Comb() {}
Comb(int SIZE) : fact_(SIZE, 1), fact_inv_(SIZE, 1), inv_(SIZE, 1) {
init(SIZE);
}
void init(int SIZE) {
fact_.assign(SIZE, 1), fact_inv_.assign(SIZE, 1), inv_.assign(SIZE, 1);
int MOD = fact_[0].getmod();
for (int i = 2; i < SIZE; i++) {
fact_[i] = fact_[i - 1] * i;
inv_[i] = -inv_[MOD % i] * (MOD / i);
fact_inv_[i] = fact_inv_[i - 1] * inv_[i];
}
}
T nCk(int n, int k) {
assert(!(n < k));
assert(!(n < 0 || k < 0));
return fact_[n] * fact_inv_[k] * fact_inv_[n - k];
}
T nHk(int n, int k) {
assert(!(n < 0 || k < 0));
return nCk(n + k - 1, k);
}
T fact(int n) {
assert(!(n < 0));
return fact_[n];
}
T fact_inv(int n) {
assert(!(n < 0));
return fact_inv_[n];
}
T inv(int n) {
assert(!(n < 0));
return inv_[n];
}
};
// start
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
Comb<mint> C(100000);
ll n, k;
cin >> n >> k;
rep2(i, 1, k + 1) {
mint res = 1;
if (n - k + 1 < i || k < i) {
cout << 0 << endl;
continue;
}
res *= C.nCk(n - k + 1, i);
res *= C.nCk(k - 1, i - 1);
cout << res << endl;
}
} | insert | 197 | 197 | 197 | 201 | 0 | |
p02990 | C++ | Runtime Error | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(x) (x).begin(), (x).end()
using namespace std;
template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }
using ll = long long;
using ld = long double;
const int INF = 1e9;
const ld eps = 1e-9, pi = acos(-1.0);
const int mod = 1e9 + 7;
struct Mod {
int n;
Mod() : n(0) { ; }
Mod(int m) : n(m) {
if (n >= mod)
n %= mod;
else if (n < 0)
n = (n % mod + mod) % mod;
}
operator int() { return n; }
};
Mod operator+=(Mod &a, Mod b) {
a.n += b.n;
if (a.n >= mod)
a.n -= mod;
return a;
}
Mod operator-=(Mod &a, Mod b) {
a.n -= b.n;
if (a.n < 0)
a.n += mod;
return a;
}
Mod operator*=(Mod &a, Mod b) {
a.n = ((long long)a.n * b.n) % mod;
return a;
}
Mod operator+(Mod a, Mod b) { return a += b; }
Mod operator-(Mod a, Mod b) { return a -= b; }
Mod operator*(Mod a, Mod b) { return a *= b; }
Mod operator^(Mod a, int n) {
if (n == 0)
return Mod(1);
Mod res = (a * a) ^ (n / 2);
if (n % 2)
res = res * a;
return res;
}
ll inv(ll a, ll p) { return (a == 1 ? 1 : (1 - p * inv(p % a, a)) / a + p); }
Mod operator/(Mod a, Mod b) { return a * Mod(inv(b.n, mod)); }
Mod fact[200005], factinv[200005];
void init() {
fact[0] = Mod(1);
factinv[0] = Mod(1);
REP(i, 200004) {
fact[i + 1] = fact[i] * Mod(i + 1);
factinv[i + 1] = factinv[i] / Mod(i + 1);
}
}
Mod comb(int a, int b) { return fact[a] * factinv[b] * factinv[a - b]; }
int main() {
int n, k;
cin >> n >> k;
init();
for (int i = 1; i < k + 1; i++) {
cout << int(fact[k - 1] * factinv[i - 1] * factinv[k - i] *
comb(n - k + 1, i))
<< endl;
}
} | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(x) (x).begin(), (x).end()
using namespace std;
template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }
using ll = long long;
using ld = long double;
const int INF = 1e9;
const ld eps = 1e-9, pi = acos(-1.0);
const int mod = 1e9 + 7;
struct Mod {
int n;
Mod() : n(0) { ; }
Mod(int m) : n(m) {
if (n >= mod)
n %= mod;
else if (n < 0)
n = (n % mod + mod) % mod;
}
operator int() { return n; }
};
Mod operator+=(Mod &a, Mod b) {
a.n += b.n;
if (a.n >= mod)
a.n -= mod;
return a;
}
Mod operator-=(Mod &a, Mod b) {
a.n -= b.n;
if (a.n < 0)
a.n += mod;
return a;
}
Mod operator*=(Mod &a, Mod b) {
a.n = ((long long)a.n * b.n) % mod;
return a;
}
Mod operator+(Mod a, Mod b) { return a += b; }
Mod operator-(Mod a, Mod b) { return a -= b; }
Mod operator*(Mod a, Mod b) { return a *= b; }
Mod operator^(Mod a, int n) {
if (n == 0)
return Mod(1);
Mod res = (a * a) ^ (n / 2);
if (n % 2)
res = res * a;
return res;
}
ll inv(ll a, ll p) { return (a == 1 ? 1 : (1 - p * inv(p % a, a)) / a + p); }
Mod operator/(Mod a, Mod b) { return a * Mod(inv(b.n, mod)); }
Mod fact[200005], factinv[200005];
void init() {
fact[0] = Mod(1);
factinv[0] = Mod(1);
REP(i, 200004) {
fact[i + 1] = fact[i] * Mod(i + 1);
factinv[i + 1] = factinv[i] / Mod(i + 1);
}
}
Mod comb(int a, int b) { return fact[a] * factinv[b] * factinv[a - b]; }
int main() {
int n, k;
cin >> n >> k;
init();
for (int i = 1; i < k + 1; i++) {
if (n - k + 1 < i) {
cout << 0 << endl;
continue;
}
cout << int(comb(k - 1, i - 1) * comb(n - k + 1, i)) % mod << endl;
}
} | replace | 76 | 79 | 76 | 81 | 0 | |
p02990 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define M 2005
#define mod 1000000007
long long n, k, C[M][M];
int main() {
cin >> n >> k;
int m = n - k;
for (int i = 1; i < M; i++) {
C[i][i] = C[i][0] = 1;
for (int j = 1; j < i; j++)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
}
printf("%lld\n", (C[m - 1][1] + 2 * C[m - 1][0]) % mod * C[k - 1][0] % mod);
for (int i = 2; i <= k; i++)
printf("%lld\n", (C[m - 1][i] + 2 * C[m - 1][i - 1] + C[m - 1][i - 2]) %
mod * C[k - 1][i - 1] % mod);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define M 2005
#define mod 1000000007
long long n, k, C[M][M];
int main() {
cin >> n >> k;
int m = n - k;
if (m == 0) {
for (int i = 1; i <= k; i++)
if (i == 1)
puts("1");
else
puts("0");
return 0;
}
for (int i = 1; i < M; i++) {
C[i][i] = C[i][0] = 1;
for (int j = 1; j < i; j++)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
}
printf("%lld\n", (C[m - 1][1] + 2 * C[m - 1][0]) % mod * C[k - 1][0] % mod);
for (int i = 2; i <= k; i++)
printf("%lld\n", (C[m - 1][i] + 2 * C[m - 1][i - 1] + C[m - 1][i - 2]) %
mod * C[k - 1][i - 1] % mod);
return 0;
} | insert | 8 | 8 | 8 | 16 | 0 | |
p02990 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <string>
#include <vector>
#define MOD 1000000007LL
#define ALL(v) v.begin(), v.end()
#define rep(i, n) for (ll i = 0; i < (n); i++)
using namespace std;
typedef long long int ll;
typedef vector<ll> llvec;
typedef vector<double> dvec;
typedef pair<int, int> P;
typedef priority_queue<ll, vector<ll>, greater<ll>> gpq_int; // sho-jun
typedef priority_queue<ll, vector<ll>, less<ll>> lpq_int; // ko-jun
ll mod(ll a, ll mod) {
ll res = a % mod;
if (res < 0)
res = res + mod;
return res;
}
ll modpow(ll a, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
ll modinv(ll a, ll mod) { return modpow(a, mod - 2, mod); }
bool is_prime(ll n) {
ll i = 2;
if (n == 1)
return false;
if (n == 2)
return true;
bool res = true;
while (i * i < n) {
if (n % i == 0) {
res = false;
}
i = i + 1;
}
// if(i==1)res = false;
if (n % i == 0)
res = false;
return res;
}
void fact(ll a, ll fact[]) {
ll i = 2;
ll original = a;
fact[1] = 1;
rep(i, 1000000 - 1) {
int ii = i + 2;
while (a % ii == 0) {
fact[ii] += 1;
a = a / ii;
}
}
if (a > 1) {
fact[0] = a;
}
return;
}
ll N, K;
ll frac[10010];
ll fracinv[10010];
ll comb(ll n, ll k) {
ll tmp = 1;
tmp = mod(tmp * frac[n], MOD);
tmp = mod(tmp * fracinv[k], MOD);
tmp = mod(tmp * fracinv[n - k], MOD);
return tmp;
}
int main() {
cin >> N >> K;
frac[0] = 1;
fracinv[0] = 1;
rep(i, 10000) {
frac[i + 1] = mod(frac[i] * (i + 1), MOD);
fracinv[i + 1] = modinv(frac[i + 1], MOD);
}
for (ll i = 1; i <= K; i++) {
ll tmp = comb(N - K + 1, i);
ll tmp2 = comb(K - 1, i - 1);
cout << mod(tmp * tmp2, MOD) << endl;
}
}
| #include <algorithm>
#include <iostream>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <string>
#include <vector>
#define MOD 1000000007LL
#define ALL(v) v.begin(), v.end()
#define rep(i, n) for (ll i = 0; i < (n); i++)
using namespace std;
typedef long long int ll;
typedef vector<ll> llvec;
typedef vector<double> dvec;
typedef pair<int, int> P;
typedef priority_queue<ll, vector<ll>, greater<ll>> gpq_int; // sho-jun
typedef priority_queue<ll, vector<ll>, less<ll>> lpq_int; // ko-jun
ll mod(ll a, ll mod) {
ll res = a % mod;
if (res < 0)
res = res + mod;
return res;
}
ll modpow(ll a, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
ll modinv(ll a, ll mod) { return modpow(a, mod - 2, mod); }
bool is_prime(ll n) {
ll i = 2;
if (n == 1)
return false;
if (n == 2)
return true;
bool res = true;
while (i * i < n) {
if (n % i == 0) {
res = false;
}
i = i + 1;
}
// if(i==1)res = false;
if (n % i == 0)
res = false;
return res;
}
void fact(ll a, ll fact[]) {
ll i = 2;
ll original = a;
fact[1] = 1;
rep(i, 1000000 - 1) {
int ii = i + 2;
while (a % ii == 0) {
fact[ii] += 1;
a = a / ii;
}
}
if (a > 1) {
fact[0] = a;
}
return;
}
ll N, K;
ll frac[10010];
ll fracinv[10010];
ll comb(ll n, ll k) {
ll tmp = 1;
tmp = mod(tmp * frac[n], MOD);
tmp = mod(tmp * fracinv[k], MOD);
tmp = mod(tmp * fracinv[n - k], MOD);
return tmp;
}
int main() {
cin >> N >> K;
frac[0] = 1;
fracinv[0] = 1;
rep(i, 10000) {
frac[i + 1] = mod(frac[i] * (i + 1), MOD);
fracinv[i + 1] = modinv(frac[i + 1], MOD);
}
for (ll i = 1; i <= K; i++) {
if (N - K + 1 < i) {
cout << 0 << endl;
} else {
ll tmp = comb(N - K + 1, i);
ll tmp2 = comb(K - 1, i - 1);
cout << mod(tmp * tmp2, MOD) << endl;
}
}
}
| replace | 100 | 103 | 100 | 107 | 0 | |
p02990 | C++ | Runtime Error | #include <bits/stdc++.h>
#define ll long long
using namespace std;
const ll N = 2005, mod = 1000000007;
ll pr[N], pi[N];
ll power(ll x, ll y) {
ll re = 1;
while (y > 0) {
if (y % 2)
re = re * x % mod;
y = y / 2;
x = x * x % mod;
}
return re;
}
ll ncr(ll n, ll r) { return ((pr[n] * pi[r]) % mod) * pi[n - r] % mod; }
int main() {
ll n, k;
cin >> n >> k;
pr[0] = 1;
pi[0] = 1;
for (ll i = 1; i < N; i++) {
pr[i] = i * pr[i - 1] % mod;
pi[i] = power(pr[i], mod - 2);
}
// for(ll i=1;i<=n;i++)cout<<pr[i]<<" ";cout<<endl;
// for(ll i=1;i<=n;i++)cout<<pi[i]<<" ";cout<<endl;
for (ll i = 1; i <= k; i++) {
ll ans = ncr(n - k + 1, i) * ncr(k - 1, i - 1) % mod;
cout << ans << endl;
}
} | #include <bits/stdc++.h>
#define ll long long
using namespace std;
const ll N = 2005, mod = 1000000007;
ll pr[N], pi[N];
ll power(ll x, ll y) {
ll re = 1;
while (y > 0) {
if (y % 2)
re = re * x % mod;
y = y / 2;
x = x * x % mod;
}
return re;
}
ll ncr(ll n, ll r) { return ((pr[n] * pi[r]) % mod) * pi[n - r] % mod; }
int main() {
ll n, k;
cin >> n >> k;
pr[0] = 1;
pi[0] = 1;
for (ll i = 1; i < N; i++) {
pr[i] = i * pr[i - 1] % mod;
pi[i] = power(pr[i], mod - 2);
}
// for(ll i=1;i<=n;i++)cout<<pr[i]<<" ";cout<<endl;
// for(ll i=1;i<=n;i++)cout<<pi[i]<<" ";cout<<endl;
for (ll i = 1; i <= k; i++) {
ll ans = 0;
if (n - k + 1 >= i)
ans = ncr(n - k + 1, i) * ncr(k - 1, i - 1) % mod;
cout << ans << endl;
}
} | replace | 28 | 29 | 28 | 31 | 0 | |
p02990 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1000000007LL;
const int SZ = 2005;
ll combi[SZ][SZ];
ll dp(int a, int b) {
if (a == b)
return 1LL;
if (b == 0)
return 1LL;
if (combi[a][b] != 0LL)
return combi[a][b];
return combi[a][b] = (dp(a - 1, b - 1) + dp(a - 1, b)) % MOD;
}
int main(void) {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
printf("%lld\n", dp(m - 1, i - 1) * dp(n - m + 1, i) % MOD);
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1000000007LL;
const int SZ = 2005;
ll combi[SZ][SZ];
ll dp(int a, int b) {
if (a < b)
return 0LL;
if (a == b)
return 1LL;
if (b == 0)
return 1LL;
if (combi[a][b] != 0LL)
return combi[a][b];
return combi[a][b] = (dp(a - 1, b - 1) + dp(a - 1, b)) % MOD;
}
int main(void) {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
printf("%lld\n", dp(m - 1, i - 1) * dp(n - m + 1, i) % MOD);
}
return 0;
} | insert | 7 | 7 | 7 | 9 | 0 | |
p02990 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll mod = 1e9 + 7;
const ll nmax = 2005;
ll facts[nmax];
void calc_fact() {
facts[0] = 1;
for (ll i = 1; i < nmax; i++) {
facts[i] = facts[i - 1] * i % mod;
}
}
ll powmod(ll a, ll b) {
ll ans = 1;
while (b) {
if (b % 2) {
ans *= a;
ans %= mod;
}
a *= a;
a %= mod;
b /= 2;
}
return ans;
}
ll comb(ll a, ll b) {
return facts[a] * powmod(facts[b], mod - 2) % mod *
powmod(facts[a - b], mod - 2) % mod;
}
int main() {
ll n, k;
cin >> n >> k;
calc_fact();
for (ll i = 1; i <= k; i++) {
cout << comb(n - k + 1, i) * comb(k - 1, i - 1) % mod << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll mod = 1e9 + 7;
const ll nmax = 2005;
ll facts[nmax];
void calc_fact() {
facts[0] = 1;
for (ll i = 1; i < nmax; i++) {
facts[i] = facts[i - 1] * i % mod;
}
}
ll powmod(ll a, ll b) {
ll ans = 1;
while (b) {
if (b % 2) {
ans *= a;
ans %= mod;
}
a *= a;
a %= mod;
b /= 2;
}
return ans;
}
ll comb(ll a, ll b) {
return facts[a] * powmod(facts[b], mod - 2) % mod *
powmod(facts[a - b], mod - 2) % mod;
}
int main() {
ll n, k;
cin >> n >> k;
calc_fact();
for (ll i = 1; i <= k; i++) {
if (n - k + 1 >= i) {
cout << comb(n - k + 1, i) * comb(k - 1, i - 1) % mod << endl;
} else {
cout << 0 << endl;
}
}
return 0;
}
| replace | 41 | 42 | 41 | 46 | 0 | |
p02990 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < int(n); ++i)
#define all(a) (a).begin(), (a).end()
typedef long long ll;
#define rep1(i, n) for (int i = 1; i <= int(n); ++i)
class modint {
public:
using ll = long long;
ll num;
static const ll MOD = 1e9 + 7;
static vector<modint> factorial;
modint() : num(0){};
modint(ll n_) : num((n_ + MOD) % MOD) {}
modint(const modint &r) : num(r.num) {}
operator ll() const { return (num + MOD) % MOD; }
friend istream &operator>>(istream &is, modint &r) {
ll num_;
is >> num_;
r = num_;
return is;
}
modint operator+(const modint &r) const { return modint(num + r.num); }
modint operator-(const modint &r) const { return modint(num - r.num); }
modint operator*(const modint &r) const { return modint(num * r.num); }
template <typename T> modint operator^(const T &r) const {
if (r == 0)
return 1;
return (((*this) * (*this)) ^ (r / 2)) * modint(r & 1 ? num : 1);
}
modint operator/(const modint &r) const { return num * (r ^ (MOD - 2)); }
modint operator+=(const modint &r) { return *this = *this + r; }
modint operator-=(const modint &r) { return *this = *this - r; }
modint operator*=(const modint &r) { return *this = *this * r; }
modint operator/=(const modint &r) { return *this = *this / r; }
template <typename T> modint operator^=(const T &r) {
return *this = *this ^ r;
}
static modint pow(const modint x, ll r) { return x ^ r; }
static modint fact(int n) {
if ((int)factorial.size() <= n)
factorial.resize(n + 1);
if (factorial[n])
return factorial[n];
if (n == 0)
return 1;
return factorial[n] = modint(n) * fact(n - 1);
}
static modint C(ll n, ll r) {
return n >= r ? fact(n) / (fact(n - r) * fact(r)) : modint(0);
}
};
vector<modint> modint::factorial;
#define fact(n) modint::fact(n)
#define C(n, r) modint::C(n, r)
#define H(a, b) C(a + b, a)
int main(void) {
ll n, k;
cin >> n >> k;
rep1(i, k) {
cout << modint::C(k - 1, i - 1) * modint::H((n - k) - (i - 1), i) << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < int(n); ++i)
#define all(a) (a).begin(), (a).end()
typedef long long ll;
#define rep1(i, n) for (int i = 1; i <= int(n); ++i)
class modint {
public:
using ll = long long;
ll num;
static const ll MOD = 1e9 + 7;
static vector<modint> factorial;
modint() : num(0){};
modint(ll n_) : num((n_ + MOD) % MOD) {}
modint(const modint &r) : num(r.num) {}
operator ll() const { return (num + MOD) % MOD; }
friend istream &operator>>(istream &is, modint &r) {
ll num_;
is >> num_;
r = num_;
return is;
}
modint operator+(const modint &r) const { return modint(num + r.num); }
modint operator-(const modint &r) const { return modint(num - r.num); }
modint operator*(const modint &r) const { return modint(num * r.num); }
template <typename T> modint operator^(const T &r) const {
if (r == 0)
return 1;
return (((*this) * (*this)) ^ (r / 2)) * modint(r & 1 ? num : 1);
}
modint operator/(const modint &r) const { return num * (r ^ (MOD - 2)); }
modint operator+=(const modint &r) { return *this = *this + r; }
modint operator-=(const modint &r) { return *this = *this - r; }
modint operator*=(const modint &r) { return *this = *this * r; }
modint operator/=(const modint &r) { return *this = *this / r; }
template <typename T> modint operator^=(const T &r) {
return *this = *this ^ r;
}
static modint pow(const modint x, ll r) { return x ^ r; }
static modint fact(int n) {
if ((int)factorial.size() <= n)
factorial.resize(n + 1);
if (factorial[n])
return factorial[n];
if (n == 0)
return 1;
return factorial[n] = modint(n) * fact(n - 1);
}
static modint C(ll n, ll r) {
return n >= r ? fact(n) / (fact(n - r) * fact(r)) : modint(0);
}
};
vector<modint> modint::factorial;
#define fact(n) modint::fact(n)
#define C(n, r) modint::C(n, r)
#define H(a, b) C(a + b, a)
int main(void) {
ll n, k;
cin >> n >> k;
rep1(i, k) {
if ((n - k) - (i - 1) < 0) {
cout << 0 << endl;
} else {
cout << modint::C(k - 1, i - 1) * modint::H((n - k) - (i - 1), i) << endl;
}
}
return 0;
}
| replace | 69 | 70 | 69 | 74 | 0 | |
p02990 | C++ | Runtime Error | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define dump(x) cout << x << endl
typedef int64_t Int;
using namespace std;
using Graph = vector<vector<Int>>;
const double pi = M_PI;
const Int MOD = 1000000007;
Int modpow(Int a, Int n, Int mod) {
Int ret = 1;
while (n > 0) {
if (n & 1) {
ret = ret * a % mod;
}
a = a * a % mod;
n >>= 1;
}
return ret;
}
vector<Int> factorials(0), invs(0);
bool is_ncr_table = false;
void calc_ncr_table(Int n, Int mod) {
is_ncr_table = true;
// 1! ~ n! の計算
Int f = 1;
factorials.push_back(f);
for (Int i = 1; i < n + 1; i++) {
f *= i;
f %= mod;
factorials.push_back(f);
}
// n!^-1 の計算
Int inv = modpow(factorials[n], mod - 2, mod);
// (n-1)!^-1 ~ 1!^-1 の計算
invs.assign(n, 1);
invs[n] = inv;
for (Int i = n; i >= 1; i--) {
inv *= i;
inv %= mod;
invs[i - 1] = inv;
}
}
Int factorial(Int n, Int mod = 1) {
Int ret = 1;
if (mod == 1) {
for (Int i = 1; i < n + 1; i++) {
ret *= i;
}
return ret;
} else {
for (Int i = 1; i < n + 1; i++) {
ret *= i;
ret %= mod;
}
return ret;
}
}
Int ncr(Int n, Int r, Int mod, bool use_table = false) {
if (n < r) {
return (Int)0;
} else {
if (use_table) {
// modが素数の場合のみ
if (!is_ncr_table) {
calc_ncr_table(n, mod);
}
return (factorials[n] * invs[r] % mod) * invs[n - r] % mod;
} else {
Int x = 1;
for (Int i = n - r + 1; i < n + 1; i++) {
x *= i;
x %= mod;
}
return x * modpow(factorial(r, mod), mod - 2, mod) % mod;
}
}
}
int main() {
Int n, k;
cin >> n >> k;
calc_ncr_table(n, MOD);
vector<Int> rr(k);
for (Int i = 0; i <= k - 1; i++) {
rr[i] = ncr(k - 1, i, MOD, true) % MOD;
}
for (Int i = 1; i <= k; i++) {
Int ans = 0;
Int nn = n - k + 1;
ans += ncr(nn, i, MOD, true);
ans *= rr[i - 1] % MOD;
ans %= MOD;
cout << ans << endl;
}
return 0;
} | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define dump(x) cout << x << endl
typedef int64_t Int;
using namespace std;
using Graph = vector<vector<Int>>;
const double pi = M_PI;
const Int MOD = 1000000007;
Int modpow(Int a, Int n, Int mod) {
Int ret = 1;
while (n > 0) {
if (n & 1) {
ret = ret * a % mod;
}
a = a * a % mod;
n >>= 1;
}
return ret;
}
vector<Int> factorials(0), invs(0);
bool is_ncr_table = false;
void calc_ncr_table(Int n, Int mod) {
is_ncr_table = true;
// 1! ~ n! の計算
Int f = 1;
factorials.push_back(f);
for (Int i = 1; i < n + 1; i++) {
f *= i;
f %= mod;
factorials.push_back(f);
}
// n!^-1 の計算
Int inv = modpow(factorials[n], mod - 2, mod);
// (n-1)!^-1 ~ 1!^-1 の計算
invs.assign(n, 1);
invs[n] = inv;
for (Int i = n; i >= 1; i--) {
inv *= i;
inv %= mod;
invs[i - 1] = inv;
}
}
Int factorial(Int n, Int mod = 1) {
Int ret = 1;
if (mod == 1) {
for (Int i = 1; i < n + 1; i++) {
ret *= i;
}
return ret;
} else {
for (Int i = 1; i < n + 1; i++) {
ret *= i;
ret %= mod;
}
return ret;
}
}
Int ncr(Int n, Int r, Int mod, bool use_table = false) {
if (n < r) {
return (Int)0;
} else {
if (use_table) {
// modが素数の場合のみ
if (!is_ncr_table) {
calc_ncr_table(n, mod);
}
return (factorials[n] * invs[r] % mod) * invs[n - r] % mod;
} else {
Int x = 1;
for (Int i = n - r + 1; i < n + 1; i++) {
x *= i;
x %= mod;
}
return x * modpow(factorial(r, mod), mod - 2, mod) % mod;
}
}
}
int main() {
Int n, k;
cin >> n >> k;
calc_ncr_table(2010, MOD);
vector<Int> rr(k);
for (Int i = 0; i <= k - 1; i++) {
rr[i] = ncr(k - 1, i, MOD, true) % MOD;
}
for (Int i = 1; i <= k; i++) {
Int ans = 0;
Int nn = n - k + 1;
ans += ncr(nn, i, MOD, true);
ans *= rr[i - 1] % MOD;
ans %= MOD;
cout << ans << endl;
}
return 0;
} | replace | 92 | 93 | 92 | 93 | -6 | munmap_chunk(): invalid pointer
|
p02990 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define forn(i, n) for (ll i = 0; i < (n); i++)
#define fori(i, b, e) for (ll i = (b); i < (e); i++)
#define forr(i, b, e) for (ll i = (b); i >= (e); i--)
#define allele(v) v.begin(), v.end()
#define fi first
#define se second
#define Mat vector<vector<ll>>
#define Arr vector<ll>
#define Matd vector<vector<ld>>
#define Arrd vector<ld>
class Combination {
public:
vector<ll> fact;
vector<ll> inv;
ll mod;
ll mod_inv(ll x) {
ll n = mod - 2LL;
ll res = 1LL;
while (n > 0) {
if (n & 1)
res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
ll nCr(ll n, ll r) {
if (r > n)
return 0;
return ((fact[n] * inv[r] % mod) * inv[n - r]) % mod;
}
ll nPr(ll n, ll r) {
if (r > n)
return 0;
return (fact[n] * inv[n - r]) % mod;
}
Combination(ll n, ll _mod) {
mod = _mod;
fact.resize(n + 1);
fact[0] = 1;
forn(i, n) { fact[i + 1] = (fact[i] * (i + 1LL)) % mod; }
inv.resize(n + 1);
forn(i, n + 1) { inv[i] = mod_inv(fact[i]); }
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
const ll mod = 1e9 + 7;
const ll N = 505;
Combination comb(N, mod);
ll b, r;
cin >> r >> b;
r = r - b;
Mat M(N + 1, Arr(N + 1));
forn(i, N) M[i][0] = 1;
forn(j, N) M[0][j] = 0;
fori(i, 1, N) fori(j, 1, N) M[i][j] = (M[i - 1][j] + M[i][j - 1]) % mod;
fori(i, 1, b + 1) {
cout << ((comb.nCr(r + 1, i) * M[i][b - i]) % mod) << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define forn(i, n) for (ll i = 0; i < (n); i++)
#define fori(i, b, e) for (ll i = (b); i < (e); i++)
#define forr(i, b, e) for (ll i = (b); i >= (e); i--)
#define allele(v) v.begin(), v.end()
#define fi first
#define se second
#define Mat vector<vector<ll>>
#define Arr vector<ll>
#define Matd vector<vector<ld>>
#define Arrd vector<ld>
class Combination {
public:
vector<ll> fact;
vector<ll> inv;
ll mod;
ll mod_inv(ll x) {
ll n = mod - 2LL;
ll res = 1LL;
while (n > 0) {
if (n & 1)
res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
ll nCr(ll n, ll r) {
if (r > n)
return 0;
return ((fact[n] * inv[r] % mod) * inv[n - r]) % mod;
}
ll nPr(ll n, ll r) {
if (r > n)
return 0;
return (fact[n] * inv[n - r]) % mod;
}
Combination(ll n, ll _mod) {
mod = _mod;
fact.resize(n + 1);
fact[0] = 1;
forn(i, n) { fact[i + 1] = (fact[i] * (i + 1LL)) % mod; }
inv.resize(n + 1);
forn(i, n + 1) { inv[i] = mod_inv(fact[i]); }
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
const ll mod = 1e9 + 7;
const ll N = 2005;
Combination comb(N, mod);
ll b, r;
cin >> r >> b;
r = r - b;
Mat M(N + 1, Arr(N + 1));
forn(i, N) M[i][0] = 1;
forn(j, N) M[0][j] = 0;
fori(i, 1, N) fori(j, 1, N) M[i][j] = (M[i - 1][j] + M[i][j - 1]) % mod;
fori(i, 1, b + 1) {
cout << ((comb.nCr(r + 1, i) * M[i][b - i]) % mod) << endl;
}
return 0;
} | replace | 55 | 56 | 55 | 56 | 0 | |
p02990 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define SPEED \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
#define read() freopen("in.txt", "r", stdin)
#define write() freopen("out.txt", "w", stdout)
#define sf(n) scanf("%d", &n)
#define sfd(n) scanf("%lf", &n)
#define sl(x) scanf("%I64d", &x)
#define sfl(n) scanf("%lld", &n)
#define sfc(n) scanf(" %c", &n)
#define sful(n) scanf("%llu", &n)
#define ull unsigned long long int
#define endll printf("\n")
#define pf printf
#define pi acos(-1.0)
#define eps 1e-10
#define mem(a, b) memset(a, b, sizeof(a))
#define pb push_back
#define xx first
#define yy second
#define pii pair<int, int>
#define pll pair<ll, ll>
#define MP make_pair
#define ll long long
#define uniq(a) a.erase(unique(a.begin(), a.end()), a.end())
bool Check(unsigned int N, int pos) { return (bool)(N & (1LL << pos)); }
ll Set(unsigned int N, int pos) { return N = N | (1LL << pos); }
#define cnd tree[idx]
#define lnd tree[idx << 1]
#define rnd tree[(idx << 1) + 1]
#define lndp (idx << 1), (b), ((b + e) >> 1)
#define rndp ((idx << 1) + 1), (((b + e) >> 1) + 1), (e)
#define inf 1999999999
#define MX 100005
#define mod 1000000007
#define mod1 1000000009
#define var int ii, i, j, k, z = 0, c = 0, t, x, y, l, r, mid
int dx[8] = {0, 0, 1, -1, -1, 1, 1, -1}; // 8 direction
int dy[8] = {1, -1, 0, 0, 1, -1, 1, -1};
bool chk(int x, int pos) { return (bool)(x & (1 << pos)); }
int Set(int x, int pos) { return x = x | (1 << pos); }
int clr(int x, int pos) { return x = x & ~(1 << pos); }
ll int n, m, a[5000];
ll bigmod(ll x, ll y) {
if (y == 0)
return 1;
ll n = bigmod(x, y >> 1);
n = (n * n) % mod;
if (y & 1)
n = (n * x) % mod;
return n;
}
ll ncr(ll n, ll r) {
ll x = (a[r] * a[n - r]) % mod;
x = bigmod(x, mod - 2);
x *= a[n];
x %= mod;
return x;
}
int main() {
ll var;
a[0] = 1;
for (i = 1; i <= 5000; i++) {
a[i] = a[i - 1] * i;
a[i] %= mod;
}
sfl(n);
sfl(k);
m = n - k;
for (i = 1; i <= k; i++) {
z = ncr(k - 1, i - 1) * ncr(m + 1, i);
z %= mod;
cout << z << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
#define SPEED \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
#define read() freopen("in.txt", "r", stdin)
#define write() freopen("out.txt", "w", stdout)
#define sf(n) scanf("%d", &n)
#define sfd(n) scanf("%lf", &n)
#define sl(x) scanf("%I64d", &x)
#define sfl(n) scanf("%lld", &n)
#define sfc(n) scanf(" %c", &n)
#define sful(n) scanf("%llu", &n)
#define ull unsigned long long int
#define endll printf("\n")
#define pf printf
#define pi acos(-1.0)
#define eps 1e-10
#define mem(a, b) memset(a, b, sizeof(a))
#define pb push_back
#define xx first
#define yy second
#define pii pair<int, int>
#define pll pair<ll, ll>
#define MP make_pair
#define ll long long
#define uniq(a) a.erase(unique(a.begin(), a.end()), a.end())
bool Check(unsigned int N, int pos) { return (bool)(N & (1LL << pos)); }
ll Set(unsigned int N, int pos) { return N = N | (1LL << pos); }
#define cnd tree[idx]
#define lnd tree[idx << 1]
#define rnd tree[(idx << 1) + 1]
#define lndp (idx << 1), (b), ((b + e) >> 1)
#define rndp ((idx << 1) + 1), (((b + e) >> 1) + 1), (e)
#define inf 1999999999
#define MX 100005
#define mod 1000000007
#define mod1 1000000009
#define var int ii, i, j, k, z = 0, c = 0, t, x, y, l, r, mid
int dx[8] = {0, 0, 1, -1, -1, 1, 1, -1}; // 8 direction
int dy[8] = {1, -1, 0, 0, 1, -1, 1, -1};
bool chk(int x, int pos) { return (bool)(x & (1 << pos)); }
int Set(int x, int pos) { return x = x | (1 << pos); }
int clr(int x, int pos) { return x = x & ~(1 << pos); }
ll int n, m, a[5000];
ll bigmod(ll x, ll y) {
if (y == 0)
return 1;
ll n = bigmod(x, y >> 1);
n = (n * n) % mod;
if (y & 1)
n = (n * x) % mod;
return n;
}
ll ncr(ll n, ll r) {
if (n < r)
return 0;
ll x = (a[r] * a[n - r]) % mod;
x = bigmod(x, mod - 2);
x *= a[n];
x %= mod;
return x;
}
int main() {
ll var;
a[0] = 1;
for (i = 1; i <= 5000; i++) {
a[i] = a[i - 1] * i;
a[i] %= mod;
}
sfl(n);
sfl(k);
m = n - k;
for (i = 1; i <= k; i++) {
z = ncr(k - 1, i - 1) * ncr(m + 1, i);
z %= mod;
cout << z << endl;
}
}
| insert | 62 | 62 | 62 | 64 | 0 | |
p02990 | C++ | Runtime Error | #include <bits/stdc++.h>
#define mod 1000000007
#define mod998 998244353
#define sp ' '
#define intmax 2147483647
#define llmax 9223372036854775807
#define mkp make_pair
typedef long long ll;
using namespace std;
int N, K;
ll f[2001];
ll pw(ll x, int y) {
ll a = 1;
while (y) {
if (y & 1) {
a = a * x % mod;
}
x = x * x % mod;
y /= 2;
}
return a;
}
ll modinv(ll x) { return pw(x, mod - 2); }
ll comb(int n, int r) {
return f[n] * modinv(f[r]) % mod * modinv(f[n - r]) % mod;
}
int main() {
f[0] = 1;
for (int i = 1; i <= 2000; ++i) {
f[i] = f[i - 1] * i % mod;
}
cin >> N >> K;
for (int i = 1; i <= K; ++i) {
cout << comb(N - K + 1, i) * comb(K - 1, i - 1) % mod << endl;
}
} | #include <bits/stdc++.h>
#define mod 1000000007
#define mod998 998244353
#define sp ' '
#define intmax 2147483647
#define llmax 9223372036854775807
#define mkp make_pair
typedef long long ll;
using namespace std;
int N, K;
ll f[2001];
ll pw(ll x, int y) {
ll a = 1;
while (y) {
if (y & 1) {
a = a * x % mod;
}
x = x * x % mod;
y /= 2;
}
return a;
}
ll modinv(ll x) { return pw(x, mod - 2); }
ll comb(int n, int r) {
if (n < r)
return 0;
return f[n] * modinv(f[r]) % mod * modinv(f[n - r]) % mod;
}
int main() {
f[0] = 1;
for (int i = 1; i <= 2000; ++i) {
f[i] = f[i - 1] * i % mod;
}
cin >> N >> K;
for (int i = 1; i <= K; ++i) {
cout << comb(N - K + 1, i) * comb(K - 1, i - 1) % mod << endl;
}
} | insert | 28 | 28 | 28 | 30 | 0 | |
p02990 | C++ | Runtime Error | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
long long factorial(long long i) { // 階乗
if (i > 0)
return i * factorial(i - 1);
else
return 1;
}
//// a^n mod
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
//// a^(-1) mod
long long modinv(long long a, long long mod) { return modpow(a, mod - 2, mod); }
int main() {
const ll mod = 1000000000 + 7;
ll N, K;
cin >> N >> K;
vector<ll> fact(max(K + 2, N - K) + 3);
fact[0] = 1;
rep(i, max(K + 2, N - K) + 3) { fact[i + 1] = fact[i] * (i + 1) % mod; }
vector<ll> cnt(K);
ll tmp = 0;
for (int i = 1; i <= K; i++) {
// r の位置 * rの個数
tmp = fact[K - 1] * modinv(fact[i - 1], mod) % mod *
modinv(fact[K - i], mod) % mod;
// cout << "1:" << tmp << endl;
if (N - K - i + 1 < 0) {
tmp = 0;
} else
tmp *= fact[N - K + 1] * modinv(fact[i], mod) % mod *
modinv(fact[N - K - i + 1], mod) % mod;
// cout << "2:" << fact[N-K+1] << ' ' << modinv(fact[i],mod) << ' ' <<
// modinv(fact[N-K-i+1],mod) << endl;
tmp = tmp % mod;
cnt[i - 1] = tmp;
}
rep(i, K) { cout << cnt[i] << endl; }
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
long long factorial(long long i) { // 階乗
if (i > 0)
return i * factorial(i - 1);
else
return 1;
}
//// a^n mod
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
//// a^(-1) mod
long long modinv(long long a, long long mod) { return modpow(a, mod - 2, mod); }
int main() {
const ll mod = 1000000000 + 7;
ll N, K;
cin >> N >> K;
vector<ll> fact(max(K + 2, N - K) + 4);
fact[0] = 1;
rep(i, max(K + 2, N - K) + 3) { fact[i + 1] = fact[i] * (i + 1) % mod; }
vector<ll> cnt(K);
ll tmp = 0;
for (int i = 1; i <= K; i++) {
// r の位置 * rの個数
tmp = fact[K - 1] * modinv(fact[i - 1], mod) % mod *
modinv(fact[K - i], mod) % mod;
// cout << "1:" << tmp << endl;
if (N - K - i + 1 < 0) {
tmp = 0;
} else
tmp *= fact[N - K + 1] * modinv(fact[i], mod) % mod *
modinv(fact[N - K - i + 1], mod) % mod;
// cout << "2:" << fact[N-K+1] << ' ' << modinv(fact[i],mod) << ' ' <<
// modinv(fact[N-K-i+1],mod) << endl;
tmp = tmp % mod;
cnt[i - 1] = tmp;
}
rep(i, K) { cout << cnt[i] << endl; }
return 0;
} | replace | 40 | 41 | 40 | 41 | 0 | |
p02990 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const int N = 2002, mod = 1e9 + 7;
int fact[N * 2];
int fastpower(int b, int p) {
int res = 1;
int v = b;
while (p) {
if (p & 1)
res = (1ll * res * v) % mod;
p >>= 1;
v = (1ll * v * v) % mod;
}
return res;
}
void pre() {
fact[0] = fact[1] = 1;
for (int i = 2; i < N * 2; ++i) {
fact[i] = (1ll * i * fact[i - 1]) % mod;
}
}
int ncr(int n, int r) {
if (n == r || r == 0)
return 1;
int res = fact[n];
res = (1ll * res * fastpower(fact[r], mod - 2)) % mod;
res = (1ll * res * fastpower(fact[n - r], mod - 2)) % mod;
return res;
}
int main() {
// freopen("in.txt", "rt", stdin);
pre();
int n, k;
scanf("%d %d", &n, &k);
long long v;
for (int i = 1; i <= k; ++i) {
int l = k - i;
v = ncr(l + i - 1, i - 1);
v = (1ll * v * ncr(n - k + i - (i - 1), i)) % mod;
printf("%lld\n", v);
}
} | #include <bits/stdc++.h>
using namespace std;
const int N = 2002, mod = 1e9 + 7;
int fact[N * 2];
int fastpower(int b, int p) {
int res = 1;
int v = b;
while (p) {
if (p & 1)
res = (1ll * res * v) % mod;
p >>= 1;
v = (1ll * v * v) % mod;
}
return res;
}
void pre() {
fact[0] = fact[1] = 1;
for (int i = 2; i < N * 2; ++i) {
fact[i] = (1ll * i * fact[i - 1]) % mod;
}
}
int ncr(int n, int r) {
if (r > n || n < 0 || r < 0)
return 0;
if (n == r || r == 0)
return 1;
int res = fact[n];
res = (1ll * res * fastpower(fact[r], mod - 2)) % mod;
res = (1ll * res * fastpower(fact[n - r], mod - 2)) % mod;
return res;
}
int main() {
// freopen("in.txt", "rt", stdin);
pre();
int n, k;
scanf("%d %d", &n, &k);
long long v;
for (int i = 1; i <= k; ++i) {
int l = k - i;
v = ncr(l + i - 1, i - 1);
v = (1ll * v * ncr(n - k + i - (i - 1), i)) % mod;
printf("%lld\n", v);
}
} | insert | 26 | 26 | 26 | 28 | 0 | |
p02990 | C++ | Runtime Error | #include <iostream>
const int mod = 1000000007;
long long power(long long b, int p) {
long long ans = 1;
while (p) {
if (p % 2)
ans = (ans * b) % mod;
b = (b * b) % mod;
p /= 2;
}
return ans;
}
const int size = 20005;
int fact[size]{1, 1};
int df[size]{1, 1};
void Compute() {
for (int i = 2; i < size; ++i) {
fact[i] = (fact[i - 1] * static_cast<long long>(i)) % mod;
df[i] = power(fact[i], mod - 2);
}
}
long long ncr(int n, int r) {
return (((static_cast<long long>(fact[n]) * df[n - r]) % mod) * df[r]) % mod;
}
int main() {
Compute();
int n, k;
std::cin >> n >> k;
for (int i = 1; i <= k; ++i)
std::cout << (ncr(k - 1, i - 1) * ncr(n - k + 1, i)) % mod << '\n';
return 0;
} | #include <iostream>
const int mod = 1000000007;
long long power(long long b, int p) {
long long ans = 1;
while (p) {
if (p % 2)
ans = (ans * b) % mod;
b = (b * b) % mod;
p /= 2;
}
return ans;
}
const int size = 20005;
int fact[size]{1, 1};
int df[size]{1, 1};
void Compute() {
for (int i = 2; i < size; ++i) {
fact[i] = (fact[i - 1] * static_cast<long long>(i)) % mod;
df[i] = power(fact[i], mod - 2);
}
}
long long ncr(int n, int r) {
if (r > n)
return 0;
return (((static_cast<long long>(fact[n]) * df[n - r]) % mod) * df[r]) % mod;
}
int main() {
Compute();
int n, k;
std::cin >> n >> k;
for (int i = 1; i <= k; ++i)
std::cout << (ncr(k - 1, i - 1) * ncr(n - k + 1, i)) % mod << '\n';
return 0;
} | insert | 29 | 29 | 29 | 31 | 0 | |
p02990 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int mod = 1e9 + 7;
void comb(vector<vector<long long>> &v) {
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]) % mod;
}
}
}
// int main(){
// int N,K;
// cin >> N >>K;
// vector<vector<long long int> > v(N+1,vector<long long int>(N+1,0));
// comb(v);
// cout << v[N][K];
// return 0;
// }
int main() {
int N, K;
cin >> N >> K;
vector<vector<long long>> v(2000, vector<long long>(2000, 0));
vector<int> ans(K);
int left = N - K + 1, right;
comb(v);
for (int i = 1; i < K + 1; i++) {
ans[i] = (v[left][i] * v[K - 1][i - 1]) % mod;
}
for (int i = 1; i < K + 1; i++) {
cout << ans[i] << endl;
}
// cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int mod = 1e9 + 7;
void comb(vector<vector<long long>> &v) {
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]) % mod;
}
}
}
// int main(){
// int N,K;
// cin >> N >>K;
// vector<vector<long long int> > v(N+1,vector<long long int>(N+1,0));
// comb(v);
// cout << v[N][K];
// return 0;
// }
int main() {
int N, K;
cin >> N >> K;
vector<vector<long long>> v(2000, vector<long long>(2000, 0));
vector<int> ans(4000);
int left = N - K + 1, right;
comb(v);
for (int i = 1; i < K + 1; i++) {
ans[i] = (v[left][i] * v[K - 1][i - 1]) % mod;
}
for (int i = 1; i < K + 1; i++) {
cout << ans[i] << endl;
}
// cout << ans << endl;
}
| replace | 28 | 29 | 28 | 29 | 0 | |
p02990 | C++ | Runtime Error | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
const int MOD = 1e9 + 7;
typedef long long ll;
using namespace std;
ll modfact[2001];
ll modpow(ll a, ll n) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return res;
}
ll modinv(ll n) { return modpow(modfact[n], MOD - 2); }
ll nCr(ll n, ll r) {
return (modfact[n] * modinv(n - r) % MOD) * modinv(r) % MOD;
}
int main() {
int n, k;
cin >> n >> k;
modfact[0] = 1;
for (int i = 1; i <= 2000; i++) {
modfact[i] = modfact[i - 1] * i % MOD;
}
for (int i = 1; i <= k; i++) {
// if (n-k < i-1) cout << 0 << endl;
cout << nCr(n - k + 1, i) * nCr(k - 1, i - 1) % MOD << endl;
}
return 0;
}
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
const int MOD = 1e9 + 7;
typedef long long ll;
using namespace std;
ll modfact[2001];
ll modpow(ll a, ll n) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return res;
}
ll modinv(ll n) { return modpow(modfact[n], MOD - 2); }
ll nCr(ll n, ll r) {
return (modfact[n] * modinv(n - r) % MOD) * modinv(r) % MOD;
}
int main() {
int n, k;
cin >> n >> k;
modfact[0] = 1;
for (int i = 1; i <= 2000; i++) {
modfact[i] = modfact[i - 1] * i % MOD;
}
for (int i = 1; i <= k; i++) {
if (n - k < i - 1)
cout << 0 << endl;
else
cout << nCr(n - k + 1, i) * nCr(k - 1, i - 1) % MOD << endl;
}
return 0;
}
| replace | 39 | 41 | 39 | 43 | 0 | |
p02990 | C++ | Runtime Error | #include <bits/stdc++.h>
#define F first
#define S second
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
const int N = 5005, M = 1e9 + 7;
ll fact[N];
ll mul(ll a, ll b) {
a %= M;
b %= M;
return (a * b) % M;
}
void pre() {
fact[0] = 1;
for (int i = 1; i < N; ++i)
fact[i] = mul(fact[i - 1], i);
}
ll fp(ll b, ll p) {
if (!p)
return 1;
ll res = fp(b, p >> 1);
res = mul(res, res);
if (p & 1)
res = mul(res, b);
return res;
}
ll inv(ll n) { return fp(n, M - 2); }
ll ncr(ll n, ll r) { return mul(fact[n], mul(inv(fact[r]), inv(fact[n - r]))); }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
pre();
ll n, k;
cin >> n >> k;
for (int i = 1; i <= n - k + 1; ++i)
cout << mul(fp(i, k - i), ncr(n - k + 1, i)) << '\n';
for (int i = n - k + 2; i <= k; ++i)
cout << "0\n";
return 0;
}
| #include <bits/stdc++.h>
#define F first
#define S second
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
const int N = 5005, M = 1e9 + 7;
ll fact[N];
ll mul(ll a, ll b) {
a %= M;
b %= M;
return (a * b) % M;
}
void pre() {
fact[0] = 1;
for (int i = 1; i < N; ++i)
fact[i] = mul(fact[i - 1], i);
}
ll fp(ll b, ll p) {
if (!p)
return 1;
ll res = fp(b, p >> 1);
res = mul(res, res);
if (p & 1)
res = mul(res, b);
return res;
}
ll inv(ll n) { return fp(n, M - 2); }
ll ncr(ll n, ll r) { return mul(fact[n], mul(inv(fact[r]), inv(fact[n - r]))); }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
pre();
ll n, k;
cin >> n >> k;
for (int i = 1; i <= k; ++i) {
if (i <= n - k + 1)
cout << mul(ncr(k - 1, i - 1), ncr(n - k + 1, i));
else
cout << 0;
cout << '\n';
}
return 0;
}
| replace | 36 | 40 | 36 | 43 | 0 | |
p02990 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define INF_LL (int64)1e18
#define INF (int32)1e9
#define REP(i, n) for (int64 i = 0; i < (n); i++)
#define FOR(i, a, b) for (int64 i = (a); i < (b); i++)
#define all(x) x.begin(), x.end()
#define fs first
#define sc second
using int32 = int_fast32_t;
using uint32 = uint_fast32_t;
using int64 = int_fast64_t;
using uint64 = uint_fast64_t;
using PII = pair<int32, int32>;
using PLL = pair<int64, int64>;
const double eps = 1e-10;
template <typename A, typename B> inline void chmin(A &a, B b) {
if (a > b)
a = b;
}
template <typename A, typename B> inline void chmax(A &a, B b) {
if (a < b)
a = b;
}
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename U, typename... V>
typename enable_if<is_same<T, U>::value != 0>::type fill_v(U &u, const V... v) {
u = U(v...);
}
template <typename T, typename U, typename... V>
typename enable_if<is_same<T, U>::value == 0>::type fill_v(U &u, const V... v) {
for (auto &e : u)
fill_v<T>(e, v...);
}
template <typename Data, typename T> struct ReRooting {
struct Node {
int to, rev;
Data data;
};
using F1 = function<T(T, T)>;
using F2 = function<T(T, Data)>;
vector<vector<Node>> g;
vector<vector<T>> ldp, rdp;
vector<int> lptr, rptr;
const F1 f1;
const F2 f2;
const T ident;
ReRooting(int n, const F1 &f1, const F2 &f2, const T &ident)
: g(n), ldp(n), rdp(n), lptr(n), rptr(n), f1(f1), f2(f2), ident(ident) {}
void add_edge(int u, int v, const Data &d) {
g[u].emplace_back((Node){v, (int)g[v].size(), d});
g[v].emplace_back((Node){u, (int)g[u].size() - 1, d});
}
void add_edge_bi(int u, int v, const Data &d, const Data &e) {
g[u].emplace_back((Node){v, (int)g[v].size(), d});
g[v].emplace_back((Node){u, (int)g[u].size() - 1, e});
}
T dfs(int idx, int par) {
while (lptr[idx] != par && lptr[idx] < g[idx].size()) {
auto &e = g[idx][lptr[idx]];
ldp[idx][lptr[idx] + 1] =
f1(ldp[idx][lptr[idx]], f2(dfs(e.to, e.rev), e.data));
++lptr[idx];
}
while (rptr[idx] != par && rptr[idx] >= 0) {
auto &e = g[idx][rptr[idx]];
rdp[idx][rptr[idx]] =
f1(rdp[idx][rptr[idx] + 1], f2(dfs(e.to, e.rev), e.data));
--rptr[idx];
}
if (par < 0)
return rdp[idx][0];
return f1(ldp[idx][par], rdp[idx][par + 1]);
}
vector<T> solve() {
for (int i = 0; i < g.size(); i++) {
ldp[i].assign(g[i].size() + 1, ident);
rdp[i].assign(g[i].size() + 1, ident);
lptr[i] = 0;
rptr[i] = (int)g[i].size() - 1;
}
vector<T> ret;
for (int i = 0; i < g.size(); i++) {
ret.push_back(dfs(i, -1));
}
return ret;
}
};
template <::std::uint_fast64_t mod> class ModInt {
private:
using value_type = ::std::uint_fast64_t;
value_type n;
public:
ModInt() : n(0) {}
ModInt(value_type n_) : n(n_ % mod) {}
ModInt(const ModInt &m) : n(m.n) {}
template <typename T> explicit operator T() const {
return static_cast<T>(n);
}
value_type get() const { return n; }
friend ::std::ostream &operator<<(::std::ostream &os, const ModInt<mod> &a) {
return os << a.n;
}
friend ::std::istream &operator>>(::std::istream &is, ModInt<mod> &a) {
value_type x;
is >> x;
a = ModInt<mod>(x);
return is;
}
bool operator==(const ModInt &m) const { return n == m.n; }
bool operator!=(const ModInt &m) const { return n != m.n; }
ModInt &operator*=(const ModInt &m) {
n = n * m.n % mod;
return *this;
}
ModInt pow(value_type b) const {
ModInt ans = 1, m = ModInt(*this);
while (b) {
if (b & 1)
ans *= m;
m *= m;
b >>= 1;
}
return ans;
}
ModInt inv() const { return (*this).pow(mod - 2); }
ModInt &operator+=(const ModInt &m) {
n += m.n;
n = (n < mod ? n : n - mod);
return *this;
}
ModInt &operator-=(const ModInt &m) {
n += mod - m.n;
n = (n < mod ? n : n - mod);
return *this;
}
ModInt &operator/=(const ModInt &m) {
*this *= m.inv();
return *this;
}
ModInt operator+(const ModInt &m) const { return ModInt(*this) += m; }
ModInt operator-(const ModInt &m) const { return ModInt(*this) -= m; }
ModInt operator*(const ModInt &m) const { return ModInt(*this) *= m; }
ModInt operator/(const ModInt &m) const { return ModInt(*this) /= m; }
ModInt &operator++() {
n += 1;
return *this;
}
ModInt &operator--() {
n -= 1;
return *this;
}
ModInt operator++(int) {
ModInt old(n);
n += 1;
return old;
}
ModInt operator--(int) {
ModInt old(n);
n -= 1;
return old;
}
ModInt operator-() const { return ModInt(mod - n); }
};
template <::std::size_t size, ::std::uint_fast64_t mod = 1000000007>
class Factorial {
private:
using value_type = ModInt<mod>;
::std::vector<value_type> fact, inv;
public:
Factorial() : fact(size + 1, 1), inv(size + 1, 1) {
for (::std::size_t i = 1; i <= size; ++i) {
fact[i] = fact[i - 1] * value_type(i);
inv[i] = fact[i].inv();
}
}
value_type comb(::std::int64_t a, ::std::int64_t b) {
assert(a >= b);
assert(b >= 0);
return fact[a] * inv[b] * inv[a - b];
}
value_type &operator[](::std::size_t k) { return fact[k]; }
};
const int64 mod = 1e9 + 7;
using Mint = ModInt<mod>;
Factorial<10000> f;
int main(void) {
int64 N, K;
cin >> N >> K;
int64 R = N - K;
REP(i, K) {
Mint res = 0;
// if (R-1 >= 0 && i-1 >= 0)
// res += f.comb(K-1, i) * f.comb(R-1, i-1);
// cout << res << " ";
// if (R >= i+1)
// res += f.comb(K-1, i) * f.comb(R, i+1);
// cout << res << " ";
// if (R >= i+2)
// res += f.comb(K-1, i) * f.comb(R, i+2);
res += f.comb(K - 1, i) * f.comb(R + 1, i + 1);
cout << res << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#define INF_LL (int64)1e18
#define INF (int32)1e9
#define REP(i, n) for (int64 i = 0; i < (n); i++)
#define FOR(i, a, b) for (int64 i = (a); i < (b); i++)
#define all(x) x.begin(), x.end()
#define fs first
#define sc second
using int32 = int_fast32_t;
using uint32 = uint_fast32_t;
using int64 = int_fast64_t;
using uint64 = uint_fast64_t;
using PII = pair<int32, int32>;
using PLL = pair<int64, int64>;
const double eps = 1e-10;
template <typename A, typename B> inline void chmin(A &a, B b) {
if (a > b)
a = b;
}
template <typename A, typename B> inline void chmax(A &a, B b) {
if (a < b)
a = b;
}
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename U, typename... V>
typename enable_if<is_same<T, U>::value != 0>::type fill_v(U &u, const V... v) {
u = U(v...);
}
template <typename T, typename U, typename... V>
typename enable_if<is_same<T, U>::value == 0>::type fill_v(U &u, const V... v) {
for (auto &e : u)
fill_v<T>(e, v...);
}
template <typename Data, typename T> struct ReRooting {
struct Node {
int to, rev;
Data data;
};
using F1 = function<T(T, T)>;
using F2 = function<T(T, Data)>;
vector<vector<Node>> g;
vector<vector<T>> ldp, rdp;
vector<int> lptr, rptr;
const F1 f1;
const F2 f2;
const T ident;
ReRooting(int n, const F1 &f1, const F2 &f2, const T &ident)
: g(n), ldp(n), rdp(n), lptr(n), rptr(n), f1(f1), f2(f2), ident(ident) {}
void add_edge(int u, int v, const Data &d) {
g[u].emplace_back((Node){v, (int)g[v].size(), d});
g[v].emplace_back((Node){u, (int)g[u].size() - 1, d});
}
void add_edge_bi(int u, int v, const Data &d, const Data &e) {
g[u].emplace_back((Node){v, (int)g[v].size(), d});
g[v].emplace_back((Node){u, (int)g[u].size() - 1, e});
}
T dfs(int idx, int par) {
while (lptr[idx] != par && lptr[idx] < g[idx].size()) {
auto &e = g[idx][lptr[idx]];
ldp[idx][lptr[idx] + 1] =
f1(ldp[idx][lptr[idx]], f2(dfs(e.to, e.rev), e.data));
++lptr[idx];
}
while (rptr[idx] != par && rptr[idx] >= 0) {
auto &e = g[idx][rptr[idx]];
rdp[idx][rptr[idx]] =
f1(rdp[idx][rptr[idx] + 1], f2(dfs(e.to, e.rev), e.data));
--rptr[idx];
}
if (par < 0)
return rdp[idx][0];
return f1(ldp[idx][par], rdp[idx][par + 1]);
}
vector<T> solve() {
for (int i = 0; i < g.size(); i++) {
ldp[i].assign(g[i].size() + 1, ident);
rdp[i].assign(g[i].size() + 1, ident);
lptr[i] = 0;
rptr[i] = (int)g[i].size() - 1;
}
vector<T> ret;
for (int i = 0; i < g.size(); i++) {
ret.push_back(dfs(i, -1));
}
return ret;
}
};
template <::std::uint_fast64_t mod> class ModInt {
private:
using value_type = ::std::uint_fast64_t;
value_type n;
public:
ModInt() : n(0) {}
ModInt(value_type n_) : n(n_ % mod) {}
ModInt(const ModInt &m) : n(m.n) {}
template <typename T> explicit operator T() const {
return static_cast<T>(n);
}
value_type get() const { return n; }
friend ::std::ostream &operator<<(::std::ostream &os, const ModInt<mod> &a) {
return os << a.n;
}
friend ::std::istream &operator>>(::std::istream &is, ModInt<mod> &a) {
value_type x;
is >> x;
a = ModInt<mod>(x);
return is;
}
bool operator==(const ModInt &m) const { return n == m.n; }
bool operator!=(const ModInt &m) const { return n != m.n; }
ModInt &operator*=(const ModInt &m) {
n = n * m.n % mod;
return *this;
}
ModInt pow(value_type b) const {
ModInt ans = 1, m = ModInt(*this);
while (b) {
if (b & 1)
ans *= m;
m *= m;
b >>= 1;
}
return ans;
}
ModInt inv() const { return (*this).pow(mod - 2); }
ModInt &operator+=(const ModInt &m) {
n += m.n;
n = (n < mod ? n : n - mod);
return *this;
}
ModInt &operator-=(const ModInt &m) {
n += mod - m.n;
n = (n < mod ? n : n - mod);
return *this;
}
ModInt &operator/=(const ModInt &m) {
*this *= m.inv();
return *this;
}
ModInt operator+(const ModInt &m) const { return ModInt(*this) += m; }
ModInt operator-(const ModInt &m) const { return ModInt(*this) -= m; }
ModInt operator*(const ModInt &m) const { return ModInt(*this) *= m; }
ModInt operator/(const ModInt &m) const { return ModInt(*this) /= m; }
ModInt &operator++() {
n += 1;
return *this;
}
ModInt &operator--() {
n -= 1;
return *this;
}
ModInt operator++(int) {
ModInt old(n);
n += 1;
return old;
}
ModInt operator--(int) {
ModInt old(n);
n -= 1;
return old;
}
ModInt operator-() const { return ModInt(mod - n); }
};
template <::std::size_t size, ::std::uint_fast64_t mod = 1000000007>
class Factorial {
private:
using value_type = ModInt<mod>;
::std::vector<value_type> fact, inv;
public:
Factorial() : fact(size + 1, 1), inv(size + 1, 1) {
for (::std::size_t i = 1; i <= size; ++i) {
fact[i] = fact[i - 1] * value_type(i);
inv[i] = fact[i].inv();
}
}
value_type comb(::std::int64_t a, ::std::int64_t b) {
assert(a >= b);
assert(b >= 0);
return fact[a] * inv[b] * inv[a - b];
}
value_type &operator[](::std::size_t k) { return fact[k]; }
};
const int64 mod = 1e9 + 7;
using Mint = ModInt<mod>;
Factorial<10000> f;
int main(void) {
int64 N, K;
cin >> N >> K;
int64 R = N - K;
REP(i, K) {
Mint res = 0;
// if (R-1 >= 0 && i-1 >= 0)
// res += f.comb(K-1, i) * f.comb(R-1, i-1);
// cout << res << " ";
// if (R >= i+1)
// res += f.comb(K-1, i) * f.comb(R, i+1);
// cout << res << " ";
// if (R >= i+2)
// res += f.comb(K-1, i) * f.comb(R, i+2);
if (K - 1 >= i && R + 1 >= i + 1)
res += f.comb(K - 1, i) * f.comb(R + 1, i + 1);
cout << res << endl;
}
} | replace | 235 | 236 | 235 | 237 | 0 | |
p02990 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define reg register
#define debug(x) cerr << #x << " = " << x << endl;
#define rep(a, b, c) for (reg int a = (b), a##_end_ = (c); a <= a##_end_; ++a)
#define ret(a, b, c) for (reg int a = (b), a##_end_ = (c); a < a##_end_; ++a)
#define drep(a, b, c) for (reg int a = (b), a##_end_ = (c); a >= a##_end_; --a)
inline int Read() {
int res = 0, f = 1;
char c;
while (c = getchar(), c < 48 || c > 57)
if (c == '-')
f = 0;
do
res = (res << 3) + (res << 1) + (c ^ 48);
while (c = getchar(), c >= 48 && c <= 57);
return f ? res : -res;
}
template <class T> inline bool Min(T &a, T const &b) {
return a > b ? a = b, 1 : 0;
}
template <class T> inline bool Max(T &a, T const &b) {
return a < b ? a = b, 1 : 0;
}
const int N = 2e3 + 5, mod = 1e9 + 7ll;
int n, k, m, C[N][N];
signed main() {
n = Read(), k = Read(), m = n - k;
C[0][0] = 1ll;
rep(i, 1, n) {
C[i][0] = 1ll;
rep(j, 1, i) C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod;
} // debug(C[7][7]);
printf("%lld\n", (C[m - 1][1] + 2ll) * 1 % mod);
rep(i, 2, k) {
int N1 = C[m - 1][i], N2 = (2 * C[m - 1][i - 1]) % mod,
N3 = C[m - 1][i - 2], K1 = C[k - 1][i - 1];
int Ans = ((N1 + N2 + N3) % mod * K1) % mod;
Ans = (Ans + mod) % mod;
printf("%lld\n", Ans);
}
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define reg register
#define debug(x) cerr << #x << " = " << x << endl;
#define rep(a, b, c) for (reg int a = (b), a##_end_ = (c); a <= a##_end_; ++a)
#define ret(a, b, c) for (reg int a = (b), a##_end_ = (c); a < a##_end_; ++a)
#define drep(a, b, c) for (reg int a = (b), a##_end_ = (c); a >= a##_end_; --a)
inline int Read() {
int res = 0, f = 1;
char c;
while (c = getchar(), c < 48 || c > 57)
if (c == '-')
f = 0;
do
res = (res << 3) + (res << 1) + (c ^ 48);
while (c = getchar(), c >= 48 && c <= 57);
return f ? res : -res;
}
template <class T> inline bool Min(T &a, T const &b) {
return a > b ? a = b, 1 : 0;
}
template <class T> inline bool Max(T &a, T const &b) {
return a < b ? a = b, 1 : 0;
}
const int N = 2e3 + 5, mod = 1e9 + 7ll;
int n, k, m, C[N][N];
signed main() {
n = Read(), k = Read(), m = n - k;
C[0][0] = 1ll;
rep(i, 1, n) {
C[i][0] = 1ll;
rep(j, 1, i) C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod;
} // debug(C[7][7]);
if (n == k) {
puts("1");
rep(i, 2, n) printf("%d\n", 0);
return 0;
}
printf("%lld\n", (C[m - 1][1] + 2ll) * 1 % mod);
rep(i, 2, k) {
int N1 = C[m - 1][i], N2 = (2 * C[m - 1][i - 1]) % mod,
N3 = C[m - 1][i - 2], K1 = C[k - 1][i - 1];
int Ans = ((N1 + N2 + N3) % mod * K1) % mod;
Ans = (Ans + mod) % mod;
printf("%lld\n", Ans);
}
} | insert | 41 | 41 | 41 | 46 | 0 | |
p02990 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const int N = 100 * 1000 + 17;
const int MOD = 1000 * 1000 * 1000 + 7;
int n, k;
long long F[N];
bool read() {
if (!(cin >> n >> k))
return false;
return true;
}
long long binpow(long long a, int n) {
auto res = 1ll;
for (; n > 0; n /= 2, a = a * a % MOD)
if (n & 1)
res = res * a % MOD;
return res;
}
long long rev(long long x) { return binpow(x, MOD - 2); }
long long binomial(int n, int k) { return F[n] * rev(F[k] * F[n - k]) % MOD; }
void solve() {
F[0] = 1;
for (int i = 1; i <= n; ++i)
F[i] = i * F[i - 1] % MOD;
for (int i = 1; i <= k; ++i)
cout << binomial(k - 1, i - 1) * binomial(n - k + 1, i) % MOD << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
while (read())
solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int N = 100 * 1000 + 17;
const int MOD = 1000 * 1000 * 1000 + 7;
int n, k;
long long F[N];
bool read() {
if (!(cin >> n >> k))
return false;
return true;
}
long long binpow(long long a, int n) {
auto res = 1ll;
for (; n > 0; n /= 2, a = a * a % MOD)
if (n & 1)
res = res * a % MOD;
return res;
}
long long rev(long long x) { return binpow(x, MOD - 2); }
long long binomial(int n, int k) {
return n < k ? 0ll : F[n] * rev(F[k] * F[n - k] % MOD) % MOD;
}
void solve() {
F[0] = 1;
for (int i = 1; i <= n; ++i)
F[i] = i * F[i - 1] % MOD;
for (int i = 1; i <= k; ++i)
cout << binomial(k - 1, i - 1) * binomial(n - k + 1, i) % MOD << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
while (read())
solve();
return 0;
}
| replace | 29 | 30 | 29 | 32 | 0 | |
p02990 | C++ | Runtime Error | #include <algorithm>
#include <bits/stdc++.h>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <sstream> // for string streams
#include <stack>
#include <string> // for string
#include <utility>
#include <vector>
#pragma comment(linker, "/STACK:2000000")
#pragma comment(linker, "/HEAP:2000000")
#define ll long long
#define ld long double
#define ull unsigned long long
#define pb push_back
#define f(n) for (ll i = 0; i < n; i++)
#define fn(a, n) for (ll a = 0; a < n; a++)
#define flr(a, l, r) for (ll a = l; a <= r; a++)
#define mp make_pair
#define sorta(a) sort(a.begin(), a.end());
#define sortd(a) sort(a.begin(), a.end(), greater<ll>());
#define sortdp(a) sort(a.begin(), a.end(), greater<pair<ll, ll>>());
#define vec std::vector<ll>
#define vp std::vector<pair<ll, ll>>
#define all(a) a.begin(), a.end()
#define inf (long long)1e18
#define infi (int)1e9
#define endl '\n'
#define ff(a, b) \
for (ll i = 0; i < a; i++) \
for (ll j = 0; j < b; j++)
#define pp1(a) cout << a << endl;
#define pp2(a, b) cout << a << " " << b << endl;
#define pp3(a, b, c) cout << a << " " << b << " " << c << endl;
#define pp4(a, b, c, d) cout << a << " " << b << " " << c << " " << d << endl;
#define vvl vector<vector<ll>>
#define vvc std::vector<std::vector<char>>
#define vvi std::vector<std::vector<int>>
#define blb(a, b) lower_bound(all(a), b) - a.begin();
#define bub(a, b) upper_bound(all(a), b) - a.begin();
#define graph(n) vvl g(n + 1, vector<ll>(0));
#define in(a, n) \
vec a(n); \
f(n) cin >> a[i];
// #define p(n) cout<<n<<"\n";
#define MOD 1000000007
using namespace std;
void print_width(ll x) {
std::cout << std::fixed;
std::cout << std::setprecision(x);
}
ll power(ll x, ll y, ll p = MOD) {
ll res = 1; // Initialize result
x = x % p; // Update x if it is more than or
// equal to p
while (y > 0) {
// If y is odd, multiply x with result
if (y & 1)
res = (res * x) % p;
// y must be even now
y = y >> 1; // y = y/2
x = (x * x) % p;
}
return res;
}
void printArr(ll a[], ll n) {
f(n) cout << a[i] << " ";
cout << endl;
}
void printVector(std::vector<ll> v) {
f(v.size()) cout << v[i] << " ";
cout << endl;
}
void printVectorPair(std::vector<pair<ll, ll>> v) {
f(v.size()) pp2(v[i].first, v[i].second);
cout << endl;
}
ll Min(ll a, ll b, ll c) {
if (a < b and a < c)
return a;
if (b < c)
return b;
return c;
}
void initialize(ll arr[], ll n) {
for (ll i = 0; i <= n; i++)
arr[i] = i;
}
ll root(ll arr[], ll i) {
while (arr[i] != i) {
arr[i] = arr[arr[i]];
i = arr[i];
}
return i;
}
void Union(ll arr[], ll a, ll b) {
ll root_a = root(arr, a);
ll root_b = root(arr, b);
arr[root_a] = root_b;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
ll power_wm(ll x, ll y) {
ll res = 1; // Initialize result
while (y > 0) {
// If y is odd, multiply x with result
if (y & 1)
res = (res * x);
// y must be even now
y = y >> 1; // y = y/2
x = (x * x);
}
return res;
}
long double dpower(long double x, ll y) {
long double res = 1; // Initialize result
while (y > 0) {
// If y is odd, multiply x with result
if (y & 1)
res = (res * x);
// y must be even now
y = y >> 1; // y = y/2
x = (x * x);
}
return res;
}
std::vector<ll> vsum(std::vector<ll> a) {
std::vector<ll> s(a.size());
s[0] = a[0];
flr(i, 1, a.size() - 1) { s[i] = s[i - 1] + a[i]; }
return s;
}
bool comp(pair<ll, ll> a, pair<ll, ll> b) {
ll x = a.second * b.first;
ll y = a.first * b.second;
if (x <= y)
return false;
else
return true;
}
bool is_cap(char a) {
if (a <= 'Z' and a >= 'A')
return true;
else
return false;
}
bool is_small(char a) {
if (a <= 'z' and a >= 'a')
return true;
else
return false;
}
string findSum(string str1, string str2) {
string str = "";
if (str1.size() > str2.size()) {
swap(str1, str2);
}
int n1 = str1.size(), n2 = str2.size();
reverse(all(str1));
reverse(all(str2));
int carry;
carry = 0;
for (int i = 0; i < n1; i++) {
int sum;
sum = ((str1[i] - '0') + (str2[i] - '0') + carry);
str.pb(sum % 10 + '0');
carry = sum / 10;
}
for (int i = n1; i < n2; i++) {
int sum;
sum = ((str2[i] - '0') + carry);
str.pb(sum % 10 + '0');
carry = sum / 10;
}
if (carry)
str.pb(carry + '0');
reverse(all(str));
return str;
}
bool mcomp(ll a, ll b, ll c, ll d) {
if (a == b and b == c and c == d)
return true;
else
return false;
}
// vector<vector<pair<ll, ll>>> adj;
// void dijikstra(int s, vector<ll> & d, vector<ll> & p) {
// ll n = adj.size();
// d.assign(n, inf);
// p.assign(n, -1);
// d[s] = 0;
// set<pair<ll, ll>> q;
// q.insert({0, s});
// while (!q.empty()) {
// ll v = q.begin() -> second;
// q.erase(q.begin());
// for (auto edge: adj[v]) {
// ll to = edge.first;
// ll len = edge.second;
// if (d[v] + len < d[to]) {
// q.erase({d[to], to});
// d[to] = d[v] + len;
// p[to] = v;
// q.insert({d[to], to});
// }
// }
// }
// }
vvl g(200001, vector<ll>(0));
ll dfs(ll x, vec &vis, vec &dfs_seq, vec &children) {
dfs_seq.pb(x);
for (ll i = 0; i < g[x].size(); i++) {
ll y = g[x][i];
if (vis[y] == 0) {
vis[y] = 1;
dfs(y, vis, dfs_seq, children);
children[x] += 1 + children[y];
}
}
return 0;
}
ll c2(ll n) { return (n * (n - 1)) / 2; }
ll modInverse(ll n, ll p) { return power(n, p - 2, p); }
// Returns nCr % p using Fermat's little
// theorem.
ll ncr(ll n, ll r, ll p = MOD) {
// Base case
if (r == 0)
return 1;
// Fill factorial array so that we
// can find all factorial of r, n
// and n-r
ll fac[n + 1];
fac[0] = 1;
for (ll i = 1; i <= n; i++)
fac[i] = fac[i - 1] * i % p;
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
p;
}
void time() {
#ifndef ONLINE_JUDGE
cout << "\nTime: " << 1.0 * clock() / CLOCKS_PER_SEC << "s\n";
#endif
}
int main() {
// FastIO
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
// start your code here
// print_width(15);
ll n, k;
cin >> n >> k;
flr(x, 1, k) {
ll ans = ncr(k - 1, x - 1) * ncr(n - k + 1, x);
pp1(ans);
}
// time();
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <sstream> // for string streams
#include <stack>
#include <string> // for string
#include <utility>
#include <vector>
#pragma comment(linker, "/STACK:2000000")
#pragma comment(linker, "/HEAP:2000000")
#define ll long long
#define ld long double
#define ull unsigned long long
#define pb push_back
#define f(n) for (ll i = 0; i < n; i++)
#define fn(a, n) for (ll a = 0; a < n; a++)
#define flr(a, l, r) for (ll a = l; a <= r; a++)
#define mp make_pair
#define sorta(a) sort(a.begin(), a.end());
#define sortd(a) sort(a.begin(), a.end(), greater<ll>());
#define sortdp(a) sort(a.begin(), a.end(), greater<pair<ll, ll>>());
#define vec std::vector<ll>
#define vp std::vector<pair<ll, ll>>
#define all(a) a.begin(), a.end()
#define inf (long long)1e18
#define infi (int)1e9
#define endl '\n'
#define ff(a, b) \
for (ll i = 0; i < a; i++) \
for (ll j = 0; j < b; j++)
#define pp1(a) cout << a << endl;
#define pp2(a, b) cout << a << " " << b << endl;
#define pp3(a, b, c) cout << a << " " << b << " " << c << endl;
#define pp4(a, b, c, d) cout << a << " " << b << " " << c << " " << d << endl;
#define vvl vector<vector<ll>>
#define vvc std::vector<std::vector<char>>
#define vvi std::vector<std::vector<int>>
#define blb(a, b) lower_bound(all(a), b) - a.begin();
#define bub(a, b) upper_bound(all(a), b) - a.begin();
#define graph(n) vvl g(n + 1, vector<ll>(0));
#define in(a, n) \
vec a(n); \
f(n) cin >> a[i];
// #define p(n) cout<<n<<"\n";
#define MOD 1000000007
using namespace std;
void print_width(ll x) {
std::cout << std::fixed;
std::cout << std::setprecision(x);
}
ll power(ll x, ll y, ll p = MOD) {
ll res = 1; // Initialize result
x = x % p; // Update x if it is more than or
// equal to p
while (y > 0) {
// If y is odd, multiply x with result
if (y & 1)
res = (res * x) % p;
// y must be even now
y = y >> 1; // y = y/2
x = (x * x) % p;
}
return res;
}
void printArr(ll a[], ll n) {
f(n) cout << a[i] << " ";
cout << endl;
}
void printVector(std::vector<ll> v) {
f(v.size()) cout << v[i] << " ";
cout << endl;
}
void printVectorPair(std::vector<pair<ll, ll>> v) {
f(v.size()) pp2(v[i].first, v[i].second);
cout << endl;
}
ll Min(ll a, ll b, ll c) {
if (a < b and a < c)
return a;
if (b < c)
return b;
return c;
}
void initialize(ll arr[], ll n) {
for (ll i = 0; i <= n; i++)
arr[i] = i;
}
ll root(ll arr[], ll i) {
while (arr[i] != i) {
arr[i] = arr[arr[i]];
i = arr[i];
}
return i;
}
void Union(ll arr[], ll a, ll b) {
ll root_a = root(arr, a);
ll root_b = root(arr, b);
arr[root_a] = root_b;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
ll power_wm(ll x, ll y) {
ll res = 1; // Initialize result
while (y > 0) {
// If y is odd, multiply x with result
if (y & 1)
res = (res * x);
// y must be even now
y = y >> 1; // y = y/2
x = (x * x);
}
return res;
}
long double dpower(long double x, ll y) {
long double res = 1; // Initialize result
while (y > 0) {
// If y is odd, multiply x with result
if (y & 1)
res = (res * x);
// y must be even now
y = y >> 1; // y = y/2
x = (x * x);
}
return res;
}
std::vector<ll> vsum(std::vector<ll> a) {
std::vector<ll> s(a.size());
s[0] = a[0];
flr(i, 1, a.size() - 1) { s[i] = s[i - 1] + a[i]; }
return s;
}
bool comp(pair<ll, ll> a, pair<ll, ll> b) {
ll x = a.second * b.first;
ll y = a.first * b.second;
if (x <= y)
return false;
else
return true;
}
bool is_cap(char a) {
if (a <= 'Z' and a >= 'A')
return true;
else
return false;
}
bool is_small(char a) {
if (a <= 'z' and a >= 'a')
return true;
else
return false;
}
string findSum(string str1, string str2) {
string str = "";
if (str1.size() > str2.size()) {
swap(str1, str2);
}
int n1 = str1.size(), n2 = str2.size();
reverse(all(str1));
reverse(all(str2));
int carry;
carry = 0;
for (int i = 0; i < n1; i++) {
int sum;
sum = ((str1[i] - '0') + (str2[i] - '0') + carry);
str.pb(sum % 10 + '0');
carry = sum / 10;
}
for (int i = n1; i < n2; i++) {
int sum;
sum = ((str2[i] - '0') + carry);
str.pb(sum % 10 + '0');
carry = sum / 10;
}
if (carry)
str.pb(carry + '0');
reverse(all(str));
return str;
}
bool mcomp(ll a, ll b, ll c, ll d) {
if (a == b and b == c and c == d)
return true;
else
return false;
}
// vector<vector<pair<ll, ll>>> adj;
// void dijikstra(int s, vector<ll> & d, vector<ll> & p) {
// ll n = adj.size();
// d.assign(n, inf);
// p.assign(n, -1);
// d[s] = 0;
// set<pair<ll, ll>> q;
// q.insert({0, s});
// while (!q.empty()) {
// ll v = q.begin() -> second;
// q.erase(q.begin());
// for (auto edge: adj[v]) {
// ll to = edge.first;
// ll len = edge.second;
// if (d[v] + len < d[to]) {
// q.erase({d[to], to});
// d[to] = d[v] + len;
// p[to] = v;
// q.insert({d[to], to});
// }
// }
// }
// }
vvl g(200001, vector<ll>(0));
ll dfs(ll x, vec &vis, vec &dfs_seq, vec &children) {
dfs_seq.pb(x);
for (ll i = 0; i < g[x].size(); i++) {
ll y = g[x][i];
if (vis[y] == 0) {
vis[y] = 1;
dfs(y, vis, dfs_seq, children);
children[x] += 1 + children[y];
}
}
return 0;
}
ll c2(ll n) { return (n * (n - 1)) / 2; }
ll modInverse(ll n, ll p) { return power(n, p - 2, p); }
// Returns nCr % p using Fermat's little
// theorem.
ll ncr(ll n, ll r, ll p = MOD) {
// Base case
if (r == 0)
return 1;
// Fill factorial array so that we
// can find all factorial of r, n
// and n-r
ll fac[n + 1];
fac[0] = 1;
for (ll i = 1; i <= n; i++)
fac[i] = fac[i - 1] * i % p;
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
p;
}
void time() {
#ifndef ONLINE_JUDGE
cout << "\nTime: " << 1.0 * clock() / CLOCKS_PER_SEC << "s\n";
#endif
}
int main() {
// FastIO
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
// start your code here
// print_width(15);
ll n, k;
cin >> n >> k;
flr(x, 1, k) {
if ((n - k + 1) < x) {
pp1(0);
continue;
}
ll ans = (ncr(k - 1, x - 1) * ncr(n - k + 1, x)) % MOD;
pp1(ans);
}
// time();
return 0;
} | replace | 333 | 334 | 333 | 339 | 0 | |
p02990 | C++ | Memory Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define rep(i, b) FOR(i, 0, b)
#define INF mugen
#define dump(x) cerr << #x << "=" << x << endl
#define ALL(a) (a).begin(), (a).end()
#define EACH(e, v) for (auto &e : v)
#define SORT(v) sort(ALL(v))
#define PERM(v) \
SORT(v); \
for (bool c##p = 1; c##p; c##p = next_permutation(ALL(v)))
typedef vector<int> vi;
typedef vector<vi> vii;
typedef vector<vii> viii;
typedef pair<int, int> P;
template <class T> void chmin(T &a, T const &b) {
if (b < a)
a = b;
}
template <class T> void chmax(T &a, T const &b) {
if (b > a)
a = b;
}
template <typename T> string to_string(const T &n) {
ostringstream stm;
stm << n;
return stm.str();
}
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
using ll = long long;
const ll mod = 1000'000'007;
#define int long long
ll mod_pow(ll a, ll b, ll r) {
return b <= 0 ? 1 : (b % 2 ? a : 1) * mod_pow(a * a % r, b / 2, r) % r;
}
vector<ll> fac(112345678); // n!(mod M)
vector<ll> ifac(112345678); // k!^{M-2} (mod M)
ll comb(ll a, ll b, ll M) { // aCbをmod計算
if (a == 0 && b == 0)
return 1;
if (a < b || a < 0)
return 0;
ll tmp = ifac[a - b] * ifac[b] % M;
return tmp * fac[a] % M;
}
ll dupc(ll a, ll b, ll M) {
if (a == 0 && b == 0)
return 1;
if (a < 0 || b == 0)
return 0;
ll tmp = ifac[a - 1] * ifac[b] % M;
return tmp * fac[a + b - 1] % M;
}
vector<vector<ll>> cmemo;
ll combbi(int n, int k, int MOD) {
if (k == 0 || n == k)
return cmemo[n][k] = 1;
if (cmemo[n][k])
return cmemo[n][k];
if (n < k)
return 0;
return cmemo[n][k] =
((combbi(n - 1, k - 1, MOD) + combbi(n - 1, k, MOD)) % MOD);
}
signed main() {
ll n, k, ans = 0LL;
cin >> n >> k;
fac[0] = 1;
ifac[0] = 1;
for (ll i = 0; i < 112345; i++) {
fac[i + 1] = fac[i] * (i + 1) % mod; // n!(mod M)
ifac[i + 1] = ifac[i] * mod_pow(i + 1, mod - 2, mod); // k!^{M-2} (mod M)
}
cmemo.assign(n + 1, vector<ll>(n + 1, 0));
// dump(comb(4,2,mod));
for (int i = 1; i <= k; i++) {
ans = 0LL;
{
int bres = k - i;
int rres = n - k - (i - 1);
ans += combbi(rres + i, i, mod) % mod;
ans *= combbi(bres + i - 1, i - 1, mod);
}
cout << ans % mod << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define rep(i, b) FOR(i, 0, b)
#define INF mugen
#define dump(x) cerr << #x << "=" << x << endl
#define ALL(a) (a).begin(), (a).end()
#define EACH(e, v) for (auto &e : v)
#define SORT(v) sort(ALL(v))
#define PERM(v) \
SORT(v); \
for (bool c##p = 1; c##p; c##p = next_permutation(ALL(v)))
typedef vector<int> vi;
typedef vector<vi> vii;
typedef vector<vii> viii;
typedef pair<int, int> P;
template <class T> void chmin(T &a, T const &b) {
if (b < a)
a = b;
}
template <class T> void chmax(T &a, T const &b) {
if (b > a)
a = b;
}
template <typename T> string to_string(const T &n) {
ostringstream stm;
stm << n;
return stm.str();
}
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
using ll = long long;
const ll mod = 1000'000'007;
#define int long long
ll mod_pow(ll a, ll b, ll r) {
return b <= 0 ? 1 : (b % 2 ? a : 1) * mod_pow(a * a % r, b / 2, r) % r;
}
vector<ll> fac(1123456); // n!(mod M)
vector<ll> ifac(1123456); // k!^{M-2} (mod M)
ll comb(ll a, ll b, ll M) { // aCbをmod計算
if (a == 0 && b == 0)
return 1;
if (a < b || a < 0)
return 0;
ll tmp = ifac[a - b] * ifac[b] % M;
return tmp * fac[a] % M;
}
ll dupc(ll a, ll b, ll M) {
if (a == 0 && b == 0)
return 1;
if (a < 0 || b == 0)
return 0;
ll tmp = ifac[a - 1] * ifac[b] % M;
return tmp * fac[a + b - 1] % M;
}
vector<vector<ll>> cmemo;
ll combbi(int n, int k, int MOD) {
if (k == 0 || n == k)
return cmemo[n][k] = 1;
if (cmemo[n][k])
return cmemo[n][k];
if (n < k)
return 0;
return cmemo[n][k] =
((combbi(n - 1, k - 1, MOD) + combbi(n - 1, k, MOD)) % MOD);
}
signed main() {
ll n, k, ans = 0LL;
cin >> n >> k;
fac[0] = 1;
ifac[0] = 1;
for (ll i = 0; i < 112345; i++) {
fac[i + 1] = fac[i] * (i + 1) % mod; // n!(mod M)
ifac[i + 1] = ifac[i] * mod_pow(i + 1, mod - 2, mod); // k!^{M-2} (mod M)
}
cmemo.assign(n + 1, vector<ll>(n + 1, 0));
// dump(comb(4,2,mod));
for (int i = 1; i <= k; i++) {
ans = 0LL;
{
int bres = k - i;
int rres = n - k - (i - 1);
ans += combbi(rres + i, i, mod) % mod;
ans *= combbi(bres + i - 1, i - 1, mod);
}
cout << ans % mod << endl;
}
} | replace | 42 | 44 | 42 | 44 | MLE | |
p02990 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
const int mod = 1e9 + 7;
ll N, K;
struct mint {
ll x; // typedef long long ll;
mint(ll 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;
}
};
mint c[4005][4005];
void init() {
c[0][0] = 1;
for (int i = 0; i <= 4000; i++) {
for (int j = 0; j <= i; j++) {
c[i + 1][j] += c[i][j];
c[i + 1][j + 1] += c[i][j];
}
}
}
mint comb(int x, int y) { return c[x][y]; }
mint f2(int x, int y) { return comb(x + y - 1, y - 1); }
mint f(int x, int y) { return f2(x - y, y); }
int main() {
init();
cin >> N >> K;
for (int i = 1; i <= K; i++) {
mint blue = f(K, i);
mint red = 0;
{
red += f(N - K, i - 1);
red += f(N - K, i);
red += f(N - K, i);
red += f(N - K, i + 1);
}
mint ans = blue * red;
printf("%lld\n", ans.x);
}
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
const int mod = 1e9 + 7;
ll N, K;
struct mint {
ll x; // typedef long long ll;
mint(ll 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;
}
};
mint c[4005][4005];
void init() {
c[0][0] = 1;
for (int i = 0; i <= 4000; i++) {
for (int j = 0; j <= i; j++) {
c[i + 1][j] += c[i][j];
c[i + 1][j + 1] += c[i][j];
}
}
}
mint comb(int x, int y) { return c[x][y]; }
mint f2(int x, int y) { return comb(x + y - 1, y - 1); }
mint f(int x, int y) {
if (x < y)
return 0;
if (x == 0 && y == 0)
return 1;
return f2(x - y, y);
}
int main() {
init();
cin >> N >> K;
for (int i = 1; i <= K; i++) {
mint blue = f(K, i);
mint red = 0;
{
red += f(N - K, i - 1);
red += f(N - K, i);
red += f(N - K, i);
red += f(N - K, i + 1);
}
mint ans = blue * red;
printf("%lld\n", ans.x);
}
} | replace | 73 | 74 | 73 | 80 | -11 | |
p02990 | C++ | Runtime Error | #include <algorithm>
#include <chrono>
#include <cmath>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
const int MAX = 2001; // change here as problems
const int MOD = 1000000007;
int64_t fac[MAX], inv[MAX], finv[MAX]; // arrays for factorial, inverse (mod p),
// and inverse of factorial, respectively
void table() {
fac[0] = fac[1] = 1;
inv[1] = 1;
finv[0] = finv[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;
}
}
int64_t comb(int n, int k) {
return fac[n] * finv[k] % MOD * finv[n - k] % MOD;
}
int main(int argc, const char *argv[]) {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
table();
for (int i = 1; i <= k; i++) {
cout << comb(n - k + 1, i) * comb(k - 1, k - i) % MOD << endl;
}
return 0;
}
| #include <algorithm>
#include <chrono>
#include <cmath>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
const int MAX = 2001; // change here as problems
const int MOD = 1000000007;
int64_t fac[MAX], inv[MAX], finv[MAX]; // arrays for factorial, inverse (mod p),
// and inverse of factorial, respectively
void table() {
fac[0] = fac[1] = 1;
inv[1] = 1;
finv[0] = finv[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;
}
}
int64_t comb(int n, int k) {
return fac[n] * finv[k] % MOD * finv[n - k] % MOD;
}
int main(int argc, const char *argv[]) {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
table();
for (int i = 1; i <= k; i++) {
if (k - i >= 0 && n - k + 1 >= i)
cout << comb(n - k + 1, i) * comb(k - 1, k - i) % MOD << endl;
else
cout << 0 << endl;
}
return 0;
}
| replace | 44 | 45 | 44 | 48 | 0 | |
p02990 | C++ | Runtime Error | // Charan Sriramula
#include <bits/stdc++.h>
using namespace std;
typedef long double ld;
typedef long long int ll;
const ll lg = 22;
const ll N = 2e5 + 5;
const ll M = 5e8;
const ll INF = 1e18;
const ll mod = 1e9 + 7;
const double PI = 3.14159265358979323846;
#define is(n) scanf("%d", &n)
#define io(n) printf("%d\n", n)
#define ls(n) scanf("%lld", &n)
#define lo(n) printf("%lld\n", n)
#define f first
#define s second
#define pb(x) push_back(x)
#define pf(x) push_front(x)
#define mp(x, y) make_pair(x, y)
#define GCD(a, b) __gcd((a), (b))
#define all(v) v.begin(), v.end()
#define bits(x) __builtin_popcount(x)
#define LCM(a, b) ((a) * (b)) / GCD((a), (b))
#define fast \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
template <typename T> T power(T x, T y, ll m) {
T ans = 1;
while (y > 0) {
if (y & 1LL)
ans = (ans * x) % m;
y >>= 1LL;
x = (x * x) % m;
}
return ans % m;
}
inline ll mul(ll a, ll b, ll p) { return (a * 1ll * b) % p; }
inline ll sub(ll a, ll b, ll p) {
ll c = a - b;
if (c < 0)
c += p;
return c;
}
inline ll add(ll a, ll b, ll p) {
ll c = a + b;
if (c > p)
c -= p;
return c;
}
#define trace1(x) cerr << #x << ": " << x << endl
#define trace2(x, y) cerr << #x << ": " << x << " | " << #y << ": " << y << endl
#define trace3(x, y, z) \
cerr << #x << ":" << x << " | " << #y << ": " << y << " | " << #z << ": " \
<< z << endl
#define trace4(a, b, c, d) \
cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << endl
#define trace5(a, b, c, d, e) \
cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << " | " << #e << ": " << e << endl
#define trace6(a, b, c, d, e, f) \
cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << " | " << #e << ": " << e << " | " \
<< #f << ": " << f << endl
ll n, k, fac[N];
ll nCr(ll m, ll r) {
ll num = fac[m] % mod;
ll den = ((fac[m - r] % mod) * (fac[r] % mod)) % mod;
ll minv = power(den, mod - 2, mod);
ll fin = ((num % mod) * (minv % mod)) % mod;
return fin;
}
int main() {
cin >> n >> k;
fac[0] = 1;
for (ll i = 1; i <= 4005; i++) {
fac[i] = ((fac[i - 1] % mod) * (i % mod)) % mod;
}
for (ll i = 1; i <= k; i++) {
ll x = nCr(n - k + 1, i);
ll y = nCr(k - 1, i - 1);
x = mul(x, y, mod);
cout << x << endl;
}
} | // Charan Sriramula
#include <bits/stdc++.h>
using namespace std;
typedef long double ld;
typedef long long int ll;
const ll lg = 22;
const ll N = 2e5 + 5;
const ll M = 5e8;
const ll INF = 1e18;
const ll mod = 1e9 + 7;
const double PI = 3.14159265358979323846;
#define is(n) scanf("%d", &n)
#define io(n) printf("%d\n", n)
#define ls(n) scanf("%lld", &n)
#define lo(n) printf("%lld\n", n)
#define f first
#define s second
#define pb(x) push_back(x)
#define pf(x) push_front(x)
#define mp(x, y) make_pair(x, y)
#define GCD(a, b) __gcd((a), (b))
#define all(v) v.begin(), v.end()
#define bits(x) __builtin_popcount(x)
#define LCM(a, b) ((a) * (b)) / GCD((a), (b))
#define fast \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
template <typename T> T power(T x, T y, ll m) {
T ans = 1;
while (y > 0) {
if (y & 1LL)
ans = (ans * x) % m;
y >>= 1LL;
x = (x * x) % m;
}
return ans % m;
}
inline ll mul(ll a, ll b, ll p) { return (a * 1ll * b) % p; }
inline ll sub(ll a, ll b, ll p) {
ll c = a - b;
if (c < 0)
c += p;
return c;
}
inline ll add(ll a, ll b, ll p) {
ll c = a + b;
if (c > p)
c -= p;
return c;
}
#define trace1(x) cerr << #x << ": " << x << endl
#define trace2(x, y) cerr << #x << ": " << x << " | " << #y << ": " << y << endl
#define trace3(x, y, z) \
cerr << #x << ":" << x << " | " << #y << ": " << y << " | " << #z << ": " \
<< z << endl
#define trace4(a, b, c, d) \
cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << endl
#define trace5(a, b, c, d, e) \
cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << " | " << #e << ": " << e << endl
#define trace6(a, b, c, d, e, f) \
cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " \
<< c << " | " << #d << ": " << d << " | " << #e << ": " << e << " | " \
<< #f << ": " << f << endl
ll n, k, fac[N];
ll nCr(ll m, ll r) {
if (m < r) {
return 0;
}
ll num = fac[m] % mod;
ll den = ((fac[m - r] % mod) * (fac[r] % mod)) % mod;
ll minv = power(den, mod - 2, mod);
ll fin = ((num % mod) * (minv % mod)) % mod;
return fin;
}
int main() {
cin >> n >> k;
fac[0] = 1;
for (ll i = 1; i <= 4005; i++) {
fac[i] = ((fac[i - 1] % mod) * (i % mod)) % mod;
}
for (ll i = 1; i <= k; i++) {
ll x = nCr(n - k + 1, i);
ll y = nCr(k - 1, i - 1);
x = mul(x, y, mod);
cout << x << endl;
}
} | insert | 76 | 76 | 76 | 79 | 0 | |
p02990 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define int long long
const int mod = 1e9 + 7;
vector<vector<int>> dp(2009, vector<int>(2009, -1));
int comb(int k, int n) {
if (k > n)
return 0;
if (k == 0 || (n == k))
return 1;
if (dp[k][n] != -1)
return dp[k][n];
return dp[k][n] = (comb(k - 1, n - 1) + comb(k, n - 1)) % mod;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
for (int i = 1; i <= k; i++) {
cout << comb(i - 1, k - 1) * comb(n - k - i + 1, n - k + 1) % mod << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
const int mod = 1e9 + 7;
vector<vector<int>> dp(2009, vector<int>(2009, -1));
int comb(int k, int n) {
if (k < 0 || n < 0 || k > n)
return 0;
if (k == 0 || (n == k))
return 1;
if (dp[k][n] != -1)
return dp[k][n];
return dp[k][n] = (comb(k - 1, n - 1) + comb(k, n - 1)) % mod;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
for (int i = 1; i <= k; i++) {
cout << comb(i - 1, k - 1) * comb(n - k - i + 1, n - k + 1) % mod << endl;
}
}
| replace | 10 | 11 | 10 | 11 | 0 | |
p02990 | C++ | Runtime Error | #include <limits.h>
#include <math.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int acs(const void *a, const void *b) {
return *(int *)a - *(int *)b;
} /* 1,2,3,4.. */
int des(const void *a, const void *b) {
return *(int *)b - *(int *)a;
} /* 8,7,6,5.. */
int cmp_char(const void *a, const void *b) {
return *(char *)a - *(char *)b;
} /* a,b,c,d.. */
int cmp_str(const void *a, const void *b) {
return strcmp(*(const char **)a, *(const char **)b);
} /* aaa,aab.. */
#define min(a, b) (a < b ? a : b)
#define max(a, b) (a > b ? a : b)
#define rep(i, n) for (int i = 0; i < n; i++)
#define mod 1000000007
int main(void) {
int n, k;
scanf("%d %d", &n, &k);
long long int ans;
int i, j;
long long int combi[2001][2001];
for (i = 0; i <= 2001; i++) {
combi[i][0] = 1;
for (j = 1; j < i; j++) {
combi[i][j] = (combi[i - 1][j - 1] + combi[i - 1][j]) % mod;
}
combi[i][i] = 1;
}
for (i = 1; i <= k; i++) {
if (n - k + 1 < i)
ans = 0;
else
ans = (combi[k - 1][i - 1] * combi[n - k + 1][i]) % mod;
printf("%lld\n", ans);
}
return 0;
}
| #include <limits.h>
#include <math.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int acs(const void *a, const void *b) {
return *(int *)a - *(int *)b;
} /* 1,2,3,4.. */
int des(const void *a, const void *b) {
return *(int *)b - *(int *)a;
} /* 8,7,6,5.. */
int cmp_char(const void *a, const void *b) {
return *(char *)a - *(char *)b;
} /* a,b,c,d.. */
int cmp_str(const void *a, const void *b) {
return strcmp(*(const char **)a, *(const char **)b);
} /* aaa,aab.. */
#define min(a, b) (a < b ? a : b)
#define max(a, b) (a > b ? a : b)
#define rep(i, n) for (int i = 0; i < n; i++)
#define mod 1000000007
int main(void) {
int n, k;
scanf("%d %d", &n, &k);
long long int ans;
int i, j;
long long int combi[2001][2001];
for (i = 0; i <= n; i++) {
combi[i][0] = 1;
for (j = 1; j < i; j++) {
combi[i][j] = (combi[i - 1][j - 1] + combi[i - 1][j]) % mod;
}
combi[i][i] = 1;
}
for (i = 1; i <= k; i++) {
if (n - k + 1 < i)
ans = 0;
else
ans = (combi[k - 1][i - 1] * combi[n - k + 1][i]) % mod;
printf("%lld\n", ans);
}
return 0;
}
| replace | 31 | 32 | 31 | 32 | -11 | |
p02990 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mod 1000000007
ll com[2005][2005];
void solve(ll n, ll k) {
ll i, j;
for (i = 0; i <= n; i++) {
for (j = 0; j <= min(i, k); j++) {
if (j == 0 || j == i)
com[i][j] = 1;
else
com[i][j] = (com[i - 1][j - 1] + com[i - 1][j]) % mod;
}
}
}
// D
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll n;
cin >> n;
ll k, i;
cin >> k;
solve(n, k);
for (i = 1; i <= k; i++) {
cout << (com[k - 1][i - 1] * com[n - k + 1][i]) % mod << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mod 1000000007
ll com[2005][2005];
void solve(ll n, ll k) {
ll i, j;
for (i = 0; i <= n; i++) {
for (j = 0; j <= min(i, k); j++) {
if (j == 0 || j == i)
com[i][j] = 1;
else
com[i][j] = (com[i - 1][j - 1] + com[i - 1][j]) % mod;
}
}
}
// D
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll n;
cin >> n;
ll k, i;
cin >> k;
solve(n, k);
for (i = 1; i <= k; i++) {
cout << (com[k - 1][i - 1] * com[n - k + 1][i]) % mod << endl;
}
} | delete | 21 | 24 | 21 | 21 | -11 | |
p02990 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define endl '\n'
#define eb emplace_back
#define fst first
#define scd second
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
constexpr int MOD = 1000000007;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vector<int>> vii;
typedef vector<ll> vl;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
// value
ll N, K;
ll fact[2010], fact_inv[2010];
// 逆元を求める
long long mod_inv(long long value) {
long long b = MOD, u = 1, v = 0;
while (b) {
long long t = value / b;
value -= t * b;
swap(value, b);
u -= t * v;
swap(u, v);
}
u %= MOD;
if (u < 0)
u += MOD;
return u;
}
void calc_fact() {
fact[0] = 1;
fact_inv[0] = 1;
for (int i = 1; i < 2010; i++) {
fact[i] = i * fact[i - 1];
fact[i] %= MOD;
fact_inv[i] = mod_inv(fact[i]);
}
}
ll comb(ll n, ll r) {
if (r == 0)
return 1;
return fact[n] * fact_inv[r] % MOD * fact_inv[n - r] % MOD;
}
void solve() {
cin >> N >> K;
calc_fact();
for (int i = 1; i <= K; i++) {
ll tmp = comb(2, 1) * comb(1998, 2);
ll ans = comb(K - 1, i - 1) * comb(N - K + 1, i) % MOD;
cout << ans << endl;
}
return;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
} | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define endl '\n'
#define eb emplace_back
#define fst first
#define scd second
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
constexpr int MOD = 1000000007;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vector<int>> vii;
typedef vector<ll> vl;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
// value
ll N, K;
ll fact[2010], fact_inv[2010];
// 逆元を求める
long long mod_inv(long long value) {
long long b = MOD, u = 1, v = 0;
while (b) {
long long t = value / b;
value -= t * b;
swap(value, b);
u -= t * v;
swap(u, v);
}
u %= MOD;
if (u < 0)
u += MOD;
return u;
}
void calc_fact() {
fact[0] = 1;
fact_inv[0] = 1;
for (int i = 1; i < 2010; i++) {
fact[i] = i * fact[i - 1];
fact[i] %= MOD;
fact_inv[i] = mod_inv(fact[i]);
}
}
ll comb(ll n, ll r) {
if (r == 0)
return 1;
return fact[n] * fact_inv[r] % MOD * fact_inv[n - r] % MOD;
}
void solve() {
cin >> N >> K;
calc_fact();
for (int i = 1; i <= K; i++) {
if (N - K + 1 < i) {
cout << 0 << endl;
continue;
}
ll ans = comb(K - 1, i - 1) * comb(N - K + 1, i) % MOD;
cout << ans << endl;
}
return;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
} | replace | 85 | 88 | 85 | 89 | 0 | |
p02990 | C++ | Runtime Error | #include <iostream>
#include <stdio.h>
using namespace std;
#define REP(a, i, n) for (int i = a; i < n; ++i)
const int limitation = 2005;
long C[limitation][limitation]; // C[n][k] = n! / (k! * (n - k)!)
long calc(int i, int j) {
if (C[i][j] != 0)
return C[i][j];
if (i == j) {
C[i][j] = 1;
return 1;
} else if (j == 0) {
C[i][j] = 1;
return 1;
} else {
C[i][j] = (calc(i - 1, j - 1) + calc(i - 1, j)) % 1000000007;
return C[i][j];
}
}
int main() {
// 1 <= K <= N <= 2000
int N; // ボール数
int K; // 青いボール数
cin >> N >> K;
REP(0, i, limitation) REP(0, j, limitation) C[i][j] = 0;
REP(1, i, K + 1) {
cout << (calc(N - K + 1, i) * calc(K - 1, i - 1)) % 1000000007 << endl;
}
return 0;
}
| #include <iostream>
#include <stdio.h>
using namespace std;
#define REP(a, i, n) for (int i = a; i < n; ++i)
const int limitation = 2005;
long C[limitation][limitation]; // C[n][k] = n! / (k! * (n - k)!)
long calc(int i, int j) {
if (C[i][j] != 0)
return C[i][j];
if (i < j) {
return 0;
} else if (i == j) {
C[i][j] = 1;
return 1;
} else if (j == 0) {
C[i][j] = 1;
return 1;
} else {
C[i][j] = (calc(i - 1, j - 1) + calc(i - 1, j)) % 1000000007;
return C[i][j];
}
}
int main() {
// 1 <= K <= N <= 2000
int N; // ボール数
int K; // 青いボール数
cin >> N >> K;
REP(0, i, limitation) REP(0, j, limitation) C[i][j] = 0;
REP(1, i, K + 1) {
cout << (calc(N - K + 1, i) * calc(K - 1, i - 1)) % 1000000007 << endl;
}
return 0;
}
| replace | 14 | 15 | 14 | 17 | 0 | |
p02991 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define modulo 100000
#define mod(mod_x) ((((long long)mod_x) + modulo) % modulo)
#define Inf 1000000000
int dijkstra(vector<vector<pair<int, int>>> &E, int start, int goal) {
priority_queue<pair<int, pair<int, int>>, vector<pair<int, pair<int, int>>>,
greater<pair<int, pair<int, int>>>>
P;
vector<int> dis(100, Inf);
dis[start] = 0;
for (int i = 0; i < E[start].size(); i++) {
P.push(make_pair(E[start][i].first, make_pair(start, E[start][i].second)));
}
while (P.size() != 0) {
pair<int, pair<int, int>> X;
X = P.top();
P.pop();
int cost = X.first;
int from = X.second.first;
int to = X.second.second;
if (dis[to] == Inf) {
dis[to] = cost;
for (int i = 0; i < E[to].size(); i++) {
P.push(make_pair(E[to][i].first + dis[to],
make_pair(to, E[to][i].second)));
}
}
}
return dis[goal];
}
int main() {
int N, M;
cin >> N >> M;
vector<vector<pair<int, int>>> E(3 * N, vector<pair<int, int>>(0));
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
E[a].push_back(make_pair(1, b + N));
E[a + N].push_back(make_pair(1, b + 2 * N));
E[a + 2 * N].push_back(make_pair(1, b));
}
int S, T;
cin >> S >> T;
S--;
T--;
int a = dijkstra(E, S, T);
if (a == Inf) {
cout << -1 << endl;
} else {
cout << a / 3 << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define modulo 100000
#define mod(mod_x) ((((long long)mod_x) + modulo) % modulo)
#define Inf 1000000000
int dijkstra(vector<vector<pair<int, int>>> &E, int start, int goal) {
priority_queue<pair<int, pair<int, int>>, vector<pair<int, pair<int, int>>>,
greater<pair<int, pair<int, int>>>>
P;
vector<int> dis(E.size(), Inf);
dis[start] = 0;
for (int i = 0; i < E[start].size(); i++) {
P.push(make_pair(E[start][i].first, make_pair(start, E[start][i].second)));
}
while (P.size() != 0) {
pair<int, pair<int, int>> X;
X = P.top();
P.pop();
int cost = X.first;
int from = X.second.first;
int to = X.second.second;
if (dis[to] == Inf) {
dis[to] = cost;
for (int i = 0; i < E[to].size(); i++) {
P.push(make_pair(E[to][i].first + dis[to],
make_pair(to, E[to][i].second)));
}
}
}
return dis[goal];
}
int main() {
int N, M;
cin >> N >> M;
vector<vector<pair<int, int>>> E(3 * N, vector<pair<int, int>>(0));
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
E[a].push_back(make_pair(1, b + N));
E[a + N].push_back(make_pair(1, b + 2 * N));
E[a + 2 * N].push_back(make_pair(1, b));
}
int S, T;
cin >> S >> T;
S--;
T--;
int a = dijkstra(E, S, T);
if (a == Inf) {
cout << -1 << endl;
} else {
cout << a / 3 << endl;
}
return 0;
}
| replace | 10 | 11 | 10 | 11 | 0 | |
p02991 | C++ | Runtime Error | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using std::cerr;
using std::cin;
using std::cout;
using std::endl;
struct Path {
int node, times;
Path(int n, int t) {
node = n;
times = t;
}
};
struct State {
int node, times, depth;
State(int n, int t, int d) {
node = n;
times = t;
depth = d;
}
};
int main(void) {
cout << std::fixed << std::setprecision(10);
cin.tie(0);
std::ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
std::vector<Path> node[100001][3];
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
node[u][0].push_back(Path(v, 1));
node[u][1].push_back(Path(v, 2));
node[u][2].push_back(Path(v, 0));
}
int s, t;
cin >> s >> t;
bool visited[100001][3] = {};
visited[s][0] = true;
std::queue<State> bfs;
bfs.push(State(s, 0, 0));
while (!bfs.empty()) {
State curr = bfs.front();
bfs.pop();
if (visited[t][0]) {
assert(curr.depth % 3 == 0);
cout << curr.depth / 3 << endl;
return 0;
}
for (auto x : node[curr.node][curr.times]) {
if (!visited[x.node][x.times]) {
visited[x.node][x.times] = true;
bfs.push(State(x.node, x.times, curr.depth + 1));
}
}
}
cout << -1 << endl;
return 0;
}
| #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using std::cerr;
using std::cin;
using std::cout;
using std::endl;
struct Path {
int node, times;
Path(int n, int t) {
node = n;
times = t;
}
};
struct State {
int node, times, depth;
State(int n, int t, int d) {
node = n;
times = t;
depth = d;
}
};
int main(void) {
cout << std::fixed << std::setprecision(10);
cin.tie(0);
std::ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
std::vector<Path> node[100001][3];
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
node[u][0].push_back(Path(v, 1));
node[u][1].push_back(Path(v, 2));
node[u][2].push_back(Path(v, 0));
}
int s, t;
cin >> s >> t;
bool visited[100001][3] = {};
visited[s][0] = true;
std::queue<State> bfs;
bfs.push(State(s, 0, 0));
while (!bfs.empty()) {
State curr = bfs.front();
bfs.pop();
if (curr.node == t && curr.times == 0) {
assert(curr.depth % 3 == 0);
cout << curr.depth / 3 << endl;
return 0;
}
for (auto x : node[curr.node][curr.times]) {
if (!visited[x.node][x.times]) {
visited[x.node][x.times] = true;
bfs.push(State(x.node, x.times, curr.depth + 1));
}
}
}
cout << -1 << endl;
return 0;
}
| replace | 64 | 65 | 64 | 65 | 0 | |
p02991 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define all(x) (x).begin(), (x).end()
const int INF = 1001001001;
int N, M, S, T;
int dist[10005][3];
signed main() {
cin >> N >> M;
vector<vector<int>> edge(N);
rep(i, M) {
int x, y;
cin >> x >> y;
--x;
--y;
edge[x].push_back(y);
}
cin >> S >> T;
--S;
--T;
rep(i, N) rep(j, 3) 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 len = Q.front().second;
Q.pop();
int nlen = (len + 1) % 3;
for (int u : edge[v]) {
if (dist[u][nlen] != INF)
continue;
dist[u][nlen] = dist[v][len] + 1;
Q.push(make_pair(u, nlen));
}
}
int ans = dist[T][0];
if (ans == INF)
ans = -3;
cout << ans / 3 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define all(x) (x).begin(), (x).end()
const int INF = 1001001001;
int N, M, S, T;
int dist[100005][3];
signed main() {
cin >> N >> M;
vector<vector<int>> edge(N);
rep(i, M) {
int x, y;
cin >> x >> y;
--x;
--y;
edge[x].push_back(y);
}
cin >> S >> T;
--S;
--T;
rep(i, N) rep(j, 3) 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 len = Q.front().second;
Q.pop();
int nlen = (len + 1) % 3;
for (int u : edge[v]) {
if (dist[u][nlen] != INF)
continue;
dist[u][nlen] = dist[v][len] + 1;
Q.push(make_pair(u, nlen));
}
}
int ans = dist[T][0];
if (ans == INF)
ans = -3;
cout << ans / 3 << endl;
}
| replace | 7 | 8 | 7 | 8 | 0 | |
p02991 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
// long long
using ll = long long;
// pair<int, int>
using PII = pair<int, int>;
// 最大値、mod
const int MOD = 1000000007;
const int mod = 1000000007;
const int INF = 1000000000;
const long long LINF = 1e18;
const int MAX = 510000;
// 出力系
#define print(x) cout << x << endl
#define prints(x) cout << fixed << setprecision(20) << x << endl
#define printc(x) cout << setw(2) << setfill('0') << x << endl;
#define yes cout << "Yes" << endl
#define YES cout << "YES" << endl
#define no cout << "No" << endl
#define NO cout << "NO" << endl
// 配列入力
vector<long long> vecin(ll n) {
vector<long long> res(n);
for (int i = 0; i < n; i++)
cin >> res[i];
return res;
}
// begin() end()
#define all(x) (x).begin(), (x).end()
// for
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define rrep(i, a, b) for (int i = (a); i > (b); i--)
#define rep(i, a, b) for (int i = (a); i < (b); i++)
// 最大公約数
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
// 最小公倍数
unsigned lcm(unsigned a, unsigned b) { return a / gcd(a, b) * b; }
// a = max(a, b), a = min(a, b)
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
// 階乗(MODをとる)
ll pow_mod(ll num, ll pow, ll mod) {
ll prod = 1;
num %= mod;
while (pow > 0) {
if (pow & 1)
prod = prod * num % mod;
num = num * num % mod;
pow >>= 1;
}
return prod;
}
// 二項係数(MODとる、1 ≦ k ≦ n ≦ 10^7 程度)
// COMinit()
// COM(x, y)
// とコンビで使う
// テーブルを作る前処理
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
// UnionFind
struct UnionFind {
vector<int> par;
vector<int> rank;
vector<ll> Size;
UnionFind(int n = 1) { init(n); }
void init(int n = 1) {
par.resize(n + 1);
rank.resize(n + 1);
Size.resize(n + 1);
for (int i = 0; i <= n; ++i)
par[i] = i, rank[i] = 0, Size[i] = 1;
}
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;
Size[x] += Size[y];
return true;
}
ll size(int x) { return Size[root(x)]; }
};
// modint構造体
struct Mint {
int val;
Mint inv() const {
int tmp, a = val, b = mod, x = 1, y = 0;
while (b)
tmp = a / b, a -= tmp * b, swap(a, b), x -= tmp * y, swap(x, y);
return Mint(x);
}
public:
Mint() : val(0) {}
Mint(ll x) {
if ((val = x % mod) < 0)
val += mod;
}
Mint pow(ll t) {
Mint res = 1, b = *this;
while (t) {
if (t & 1)
res *= b;
b *= b;
t >>= 1;
}
return res;
}
Mint &operator+=(const Mint &x) {
if ((val += x.val) >= mod)
val -= mod;
return *this;
}
Mint &operator-=(const Mint &x) {
if ((val += mod - x.val) >= mod)
val -= mod;
return *this;
}
Mint &operator*=(const Mint &x) {
val = (ll)val * x.val % mod;
return *this;
}
Mint &operator/=(const Mint &x) { return *this *= x.inv(); }
bool operator==(const Mint &x) const { return val == x.val; }
bool operator!=(const Mint &x) const { return val != x.val; }
bool operator<(const Mint &x) const { return val < x.val; }
bool operator<=(const Mint &x) const { return val <= x.val; }
bool operator>(const Mint &x) const { return val > x.val; }
bool operator>=(const Mint &x) const { return val >= x.val; }
Mint operator+(const Mint &x) const { return Mint(*this) += x; }
Mint operator-(const Mint &x) const { return Mint(*this) -= x; }
Mint operator*(const Mint &x) const { return Mint(*this) *= x; }
Mint operator/(const Mint &x) const { return Mint(*this) /= x; }
};
struct factorial {
vector<Mint> Fact, Finv;
public:
// factorial fact(10000010);
// fact.nCr(a, b)
// 「fact」の部分は自由に名前変更可能
factorial(int maxx) {
Fact.resize(maxx + 1), Finv.resize(maxx + 1);
Fact[0] = Mint(1);
rep(i, 0, maxx) Fact[i + 1] = Fact[i] * (i + 1);
Finv[maxx] = Mint(1) / Fact[maxx];
rrep(i, maxx, 0) Finv[i - 1] = Finv[i] * i;
}
Mint fact(int n, bool inv = 0) {
if (inv)
return Finv[n];
else
return Fact[n];
}
Mint nPr(int n, int r) {
if (n < 0 || n < r || r < 0)
return Mint(0);
else
return Fact[n] * Finv[n - r];
}
Mint nCr(int n, int r) {
if (n < 0 || n < r || r < 0)
return Mint(0);
else
return Fact[n] * Finv[r] * Finv[n - r];
}
};
// 1 * 2 * 3 .... * n (mod)
ll modfact(ll n) {
if (n <= 1)
return 1;
return (n * modfact(n - 1)) % MOD;
}
// kが角度だった場合:cos(k * (PI / 180));
const double PI = acos(-1);
// 多次元 vector 生成 例: auto dp = make_vec<long long>(N+1, 5, 5, 5);
template <class T> vector<T> make_vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
// 素因数分解
vector<pair<long long, int>> factorize(long long n) {
vector<pair<long long, int>> res;
for (long long i = 2; i * i <= n; ++i) {
if (n % i)
continue;
res.emplace_back(i, 0);
while (n % i == 0) {
n /= i;
res.back().second++;
}
}
if (n != 1)
res.emplace_back(n, 1);
return res;
}
// 素数判定
bool primejudge(long long a) {
if (a <= 1)
return false;
for (long long i = 2; i * i <= a; i++) {
if (a % i == 0)
return false;
}
return true;
}
// 累積和
vector<long long> sums(vector<int> n) {
vector<long long> res(n.size() + 1, 0);
for (int i = 0; i < n.size(); i++)
res[i + 1] = n[i] + res[i];
return res;
}
// int dx[4] = {0, 0, 1, -1}, dy[4] = {1, -1, 0, 0};
vector<vector<int>> g;
int s, t;
int n, m;
ll solve() {
vector<vector<ll>> dist(n, vector<ll>(3, -1));
dist[s][0] = 0;
queue<PII> que;
que.push({s, 0});
while (!que.empty()) {
PII p = que.front();
que.pop();
int v = p.first;
int d = p.second;
for (auto nv : g[v]) {
int np = (d + 1) % 3;
if (dist[nv][np] == -1) {
dist[nv][np] = dist[v][d] + 1;
que.push({nv, np});
}
}
}
if (dist[t][0] == -1)
return -1;
else
return dist[t][0] / 3;
}
int main() {
cin >> n;
cin >> m;
// g.assign(n, vector<int>());
g.resize(n);
REP(i, m) {
int x, y;
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
}
cin >> s >> t;
cout << solve() << endl;
}
| #include <bits/stdc++.h>
using namespace std;
// long long
using ll = long long;
// pair<int, int>
using PII = pair<int, int>;
// 最大値、mod
const int MOD = 1000000007;
const int mod = 1000000007;
const int INF = 1000000000;
const long long LINF = 1e18;
const int MAX = 510000;
// 出力系
#define print(x) cout << x << endl
#define prints(x) cout << fixed << setprecision(20) << x << endl
#define printc(x) cout << setw(2) << setfill('0') << x << endl;
#define yes cout << "Yes" << endl
#define YES cout << "YES" << endl
#define no cout << "No" << endl
#define NO cout << "NO" << endl
// 配列入力
vector<long long> vecin(ll n) {
vector<long long> res(n);
for (int i = 0; i < n; i++)
cin >> res[i];
return res;
}
// begin() end()
#define all(x) (x).begin(), (x).end()
// for
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define rrep(i, a, b) for (int i = (a); i > (b); i--)
#define rep(i, a, b) for (int i = (a); i < (b); i++)
// 最大公約数
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
// 最小公倍数
unsigned lcm(unsigned a, unsigned b) { return a / gcd(a, b) * b; }
// a = max(a, b), a = min(a, b)
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
// 階乗(MODをとる)
ll pow_mod(ll num, ll pow, ll mod) {
ll prod = 1;
num %= mod;
while (pow > 0) {
if (pow & 1)
prod = prod * num % mod;
num = num * num % mod;
pow >>= 1;
}
return prod;
}
// 二項係数(MODとる、1 ≦ k ≦ n ≦ 10^7 程度)
// COMinit()
// COM(x, y)
// とコンビで使う
// テーブルを作る前処理
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
// UnionFind
struct UnionFind {
vector<int> par;
vector<int> rank;
vector<ll> Size;
UnionFind(int n = 1) { init(n); }
void init(int n = 1) {
par.resize(n + 1);
rank.resize(n + 1);
Size.resize(n + 1);
for (int i = 0; i <= n; ++i)
par[i] = i, rank[i] = 0, Size[i] = 1;
}
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;
Size[x] += Size[y];
return true;
}
ll size(int x) { return Size[root(x)]; }
};
// modint構造体
struct Mint {
int val;
Mint inv() const {
int tmp, a = val, b = mod, x = 1, y = 0;
while (b)
tmp = a / b, a -= tmp * b, swap(a, b), x -= tmp * y, swap(x, y);
return Mint(x);
}
public:
Mint() : val(0) {}
Mint(ll x) {
if ((val = x % mod) < 0)
val += mod;
}
Mint pow(ll t) {
Mint res = 1, b = *this;
while (t) {
if (t & 1)
res *= b;
b *= b;
t >>= 1;
}
return res;
}
Mint &operator+=(const Mint &x) {
if ((val += x.val) >= mod)
val -= mod;
return *this;
}
Mint &operator-=(const Mint &x) {
if ((val += mod - x.val) >= mod)
val -= mod;
return *this;
}
Mint &operator*=(const Mint &x) {
val = (ll)val * x.val % mod;
return *this;
}
Mint &operator/=(const Mint &x) { return *this *= x.inv(); }
bool operator==(const Mint &x) const { return val == x.val; }
bool operator!=(const Mint &x) const { return val != x.val; }
bool operator<(const Mint &x) const { return val < x.val; }
bool operator<=(const Mint &x) const { return val <= x.val; }
bool operator>(const Mint &x) const { return val > x.val; }
bool operator>=(const Mint &x) const { return val >= x.val; }
Mint operator+(const Mint &x) const { return Mint(*this) += x; }
Mint operator-(const Mint &x) const { return Mint(*this) -= x; }
Mint operator*(const Mint &x) const { return Mint(*this) *= x; }
Mint operator/(const Mint &x) const { return Mint(*this) /= x; }
};
struct factorial {
vector<Mint> Fact, Finv;
public:
// factorial fact(10000010);
// fact.nCr(a, b)
// 「fact」の部分は自由に名前変更可能
factorial(int maxx) {
Fact.resize(maxx + 1), Finv.resize(maxx + 1);
Fact[0] = Mint(1);
rep(i, 0, maxx) Fact[i + 1] = Fact[i] * (i + 1);
Finv[maxx] = Mint(1) / Fact[maxx];
rrep(i, maxx, 0) Finv[i - 1] = Finv[i] * i;
}
Mint fact(int n, bool inv = 0) {
if (inv)
return Finv[n];
else
return Fact[n];
}
Mint nPr(int n, int r) {
if (n < 0 || n < r || r < 0)
return Mint(0);
else
return Fact[n] * Finv[n - r];
}
Mint nCr(int n, int r) {
if (n < 0 || n < r || r < 0)
return Mint(0);
else
return Fact[n] * Finv[r] * Finv[n - r];
}
};
// 1 * 2 * 3 .... * n (mod)
ll modfact(ll n) {
if (n <= 1)
return 1;
return (n * modfact(n - 1)) % MOD;
}
// kが角度だった場合:cos(k * (PI / 180));
const double PI = acos(-1);
// 多次元 vector 生成 例: auto dp = make_vec<long long>(N+1, 5, 5, 5);
template <class T> vector<T> make_vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
// 素因数分解
vector<pair<long long, int>> factorize(long long n) {
vector<pair<long long, int>> res;
for (long long i = 2; i * i <= n; ++i) {
if (n % i)
continue;
res.emplace_back(i, 0);
while (n % i == 0) {
n /= i;
res.back().second++;
}
}
if (n != 1)
res.emplace_back(n, 1);
return res;
}
// 素数判定
bool primejudge(long long a) {
if (a <= 1)
return false;
for (long long i = 2; i * i <= a; i++) {
if (a % i == 0)
return false;
}
return true;
}
// 累積和
vector<long long> sums(vector<int> n) {
vector<long long> res(n.size() + 1, 0);
for (int i = 0; i < n.size(); i++)
res[i + 1] = n[i] + res[i];
return res;
}
// int dx[4] = {0, 0, 1, -1}, dy[4] = {1, -1, 0, 0};
vector<vector<int>> g;
int s, t;
int n, m;
ll solve() {
vector<vector<ll>> dist(n, vector<ll>(3, -1));
dist[s][0] = 0;
queue<PII> que;
que.push({s, 0});
while (!que.empty()) {
PII p = que.front();
que.pop();
int v = p.first;
int d = p.second;
for (auto nv : g[v]) {
int np = (d + 1) % 3;
if (dist[nv][np] == -1) {
dist[nv][np] = dist[v][d] + 1;
que.push({nv, np});
}
}
}
if (dist[t][0] == -1)
return -1;
else
return dist[t][0] / 3;
}
int main() {
cin >> n;
cin >> m;
// g.assign(n, vector<int>());
g.resize(n);
REP(i, m) {
int x, y;
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
}
cin >> s >> t;
s--;
t--;
cout << solve() << endl;
}
| insert | 326 | 326 | 326 | 328 | 0 | |
p02991 | C++ | Runtime Error | /*
* atcoder/abc132/e.cpp
*/
// C++ 14
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstring> // memset
#include <iostream>
#include <vector>
using namespace std;
#define ll long long
#define loop(__x, __start, __end) for (int __x = __start; __x < __end; __x++)
template <class T> ostream &operator<<(ostream &out, vector<T> const &v) {
for (auto &&a : v)
out << a << " ";
out << endl;
return out;
}
template <class T> void dump(T &a) { cout << a << endl; }
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
#include <queue>
const int MAX = 100000;
const int INF = 10000000;
int N, M, S, T;
vector<int> G[MAX];
int dist[MAX][3];
int bfs() {
queue<pair<int, int>> Q;
Q.push({S, 0});
dist[S][0] = 0;
while (Q.size()) {
auto p = Q.front();
Q.pop();
int u = p.first;
int d = p.second;
d++;
for (auto &&v : G[u]) {
if (dist[v][d % 3] < INF)
continue;
dist[v][d % 3] = d;
Q.push({v, d});
if (v == T and d % 3 == 0) {
return d / 3;
}
}
}
return -1;
}
void solve() {
cin >> N >> M;
int a, b;
loop(m, 0, M) {
cin >> a >> b;
a--;
b--;
G[a].push_back(b);
}
cin >> S >> T;
S--;
T--;
loop(i, 0, N + 1) {
loop(j, 0, 3) { dist[i][j] = INF; }
}
cout << bfs() << endl;
}
int main() {
// cout.precision(15); cout << fixed;
solve();
return 0;
}
| /*
* atcoder/abc132/e.cpp
*/
// C++ 14
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstring> // memset
#include <iostream>
#include <vector>
using namespace std;
#define ll long long
#define loop(__x, __start, __end) for (int __x = __start; __x < __end; __x++)
template <class T> ostream &operator<<(ostream &out, vector<T> const &v) {
for (auto &&a : v)
out << a << " ";
out << endl;
return out;
}
template <class T> void dump(T &a) { cout << a << endl; }
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
#include <queue>
const int MAX = 100001;
const int INF = 10000000;
int N, M, S, T;
vector<int> G[MAX];
int dist[MAX][3];
int bfs() {
queue<pair<int, int>> Q;
Q.push({S, 0});
dist[S][0] = 0;
while (Q.size()) {
auto p = Q.front();
Q.pop();
int u = p.first;
int d = p.second;
d++;
for (auto &&v : G[u]) {
if (dist[v][d % 3] < INF)
continue;
dist[v][d % 3] = d;
Q.push({v, d});
if (v == T and d % 3 == 0) {
return d / 3;
}
}
}
return -1;
}
void solve() {
cin >> N >> M;
int a, b;
loop(m, 0, M) {
cin >> a >> b;
a--;
b--;
G[a].push_back(b);
}
cin >> S >> T;
S--;
T--;
loop(i, 0, N + 1) {
loop(j, 0, 3) { dist[i][j] = INF; }
}
cout << bfs() << endl;
}
int main() {
// cout.precision(15); cout << fixed;
solve();
return 0;
}
| replace | 37 | 38 | 37 | 38 | 0 | |
p02991 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define loop(i, n) for (int i = 0; i < int(n); i++)
#define rloop(i, n) for (int i = int(n); i >= 0; i--)
#define range(i, a, b) for (int i = int(a); i <= int(b); i++)
#define SZ(c) int(c.size())
#define ALL(c) c.begin(), c.end()
#define RALL(c) c.rbegin(), c.rend()
#define PI acos(-1)
#define pb push_back
#define mp make_pair
#define fr first
#define sc second
#define sfi1(v) scanf("%d", &v)
#define sfi2(v1, v2) scanf("%d %d", &v1, &v2)
#define sfi3(v1, v2, v3) scanf("%d %d %d", &v1, &v2, &v3)
#define sfll1(v) scanf("%I64d", &v);
#define sfll2(v1, v2) scanf("%I64d %I64d", &v1, &v2)
#define sfll3(v1, v2, v3) scanf("%I64d %I64d %I64d", &v1, &v2, &v3)
#define endl '\n'
typedef vector<int> vi;
typedef vector<pair<int, int>> vii;
typedef long long ll;
typedef pair<int, int> pii;
const int N = 1e5 + 5;
int dis[N];
set<int> adj[3][N];
vi radj[3][N];
int n, m;
void Remove(int u, int i) {
for (auto nxt : radj[i][u]) {
adj[i][nxt].erase(u);
}
}
int main() {
#ifndef ONLINE_JUDGE
freopen("in.in", "r", stdin);
// freopen("out.in", "w", stdout);
#endif
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int a, b, s, t;
cin >> n >> m;
loop(i, m) {
cin >> a >> b;
loop(j, 3) {
adj[j][a].insert(b);
radj[j][b].pb(a);
}
}
cin >> s >> t;
memset(dis, -1, sizeof dis);
dis[s] = 0;
queue<int> q;
q.push(s);
Remove(s, 2);
int tmp;
while (!q.empty()) {
int u = q.front();
q.pop();
for (auto it0 = adj[0][u].begin(); it0 != adj[0][u].end();) {
for (auto it1 = adj[1][*it0].begin(); it1 != adj[1][*it0].end();) {
for (auto it2 = adj[2][*it1].begin(); it2 != adj[2][*it1].end();) {
dis[*it2] = dis[u] + 1;
q.push(*it2);
tmp = *it2;
it2++;
Remove(tmp, 2);
}
tmp = *it1;
it1++;
Remove(tmp, 1);
}
tmp = *it0;
it0++;
Remove(tmp, 0);
}
}
cout << dis[t] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define loop(i, n) for (int i = 0; i < int(n); i++)
#define rloop(i, n) for (int i = int(n); i >= 0; i--)
#define range(i, a, b) for (int i = int(a); i <= int(b); i++)
#define SZ(c) int(c.size())
#define ALL(c) c.begin(), c.end()
#define RALL(c) c.rbegin(), c.rend()
#define PI acos(-1)
#define pb push_back
#define mp make_pair
#define fr first
#define sc second
#define sfi1(v) scanf("%d", &v)
#define sfi2(v1, v2) scanf("%d %d", &v1, &v2)
#define sfi3(v1, v2, v3) scanf("%d %d %d", &v1, &v2, &v3)
#define sfll1(v) scanf("%I64d", &v);
#define sfll2(v1, v2) scanf("%I64d %I64d", &v1, &v2)
#define sfll3(v1, v2, v3) scanf("%I64d %I64d %I64d", &v1, &v2, &v3)
#define endl '\n'
typedef vector<int> vi;
typedef vector<pair<int, int>> vii;
typedef long long ll;
typedef pair<int, int> pii;
const int N = 1e5 + 5;
int dis[N];
set<int> adj[3][N];
vi radj[3][N];
int n, m;
void Remove(int u, int i) {
for (auto nxt : radj[i][u]) {
adj[i][nxt].erase(u);
}
}
int main() {
#ifndef ONLINE_JUDGE
// freopen("in.in", "r", stdin);
// freopen("out.in", "w", stdout);
#endif
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int a, b, s, t;
cin >> n >> m;
loop(i, m) {
cin >> a >> b;
loop(j, 3) {
adj[j][a].insert(b);
radj[j][b].pb(a);
}
}
cin >> s >> t;
memset(dis, -1, sizeof dis);
dis[s] = 0;
queue<int> q;
q.push(s);
Remove(s, 2);
int tmp;
while (!q.empty()) {
int u = q.front();
q.pop();
for (auto it0 = adj[0][u].begin(); it0 != adj[0][u].end();) {
for (auto it1 = adj[1][*it0].begin(); it1 != adj[1][*it0].end();) {
for (auto it2 = adj[2][*it1].begin(); it2 != adj[2][*it1].end();) {
dis[*it2] = dis[u] + 1;
q.push(*it2);
tmp = *it2;
it2++;
Remove(tmp, 2);
}
tmp = *it1;
it1++;
Remove(tmp, 1);
}
tmp = *it0;
it0++;
Remove(tmp, 0);
}
}
cout << dis[t] << endl;
return 0;
}
| replace | 43 | 45 | 43 | 45 | -11 | |
p02991 | C++ | Time Limit Exceeded | #include <iostream>
#include <queue>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
constexpr int INF = 1e9;
int main() {
int N, M;
cin >> N >> M;
vector<vector<int>> G(N);
for (int i = 0; i < M; ++i) {
int u, v;
cin >> u >> v;
--u, --v;
G[u].push_back(v);
}
int s, t;
cin >> s >> t;
--s, --t;
vector<vector<int>> D(N, vector<int>(3, INF));
D[s][0] = 0;
queue<pair<int, int>> Q;
Q.emplace(s, 0);
while (Q.size()) {
int v, d;
tie(v, d) = Q.front();
Q.pop();
int c = D[v][d] + (d == 0);
int d_ = (d + 1) % 3;
for (auto v_ : G[v]) {
if (D[v_][d_] < c)
continue;
D[v_][d_] = c;
Q.emplace(v_, d_);
}
}
if (D[t][0] >= INF) {
cout << -1 << endl;
return 0;
}
cout << D[t][0] << endl;
}
| #include <iostream>
#include <queue>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
constexpr int INF = 1e9;
int main() {
int N, M;
cin >> N >> M;
vector<vector<int>> G(N);
for (int i = 0; i < M; ++i) {
int u, v;
cin >> u >> v;
--u, --v;
G[u].push_back(v);
}
int s, t;
cin >> s >> t;
--s, --t;
vector<vector<int>> D(N, vector<int>(3, INF));
D[s][0] = 0;
queue<pair<int, int>> Q;
Q.emplace(s, 0);
while (Q.size()) {
int v, d;
tie(v, d) = Q.front();
Q.pop();
int c = D[v][d] + (d == 0);
int d_ = (d + 1) % 3;
for (auto v_ : G[v]) {
if (D[v_][d_] <= c)
continue;
D[v_][d_] = c;
Q.emplace(v_, d_);
}
}
if (D[t][0] >= INF) {
cout << -1 << endl;
return 0;
}
cout << D[t][0] << endl;
}
| replace | 32 | 33 | 32 | 33 | TLE | |
p02991 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int(i) = 0; (i) < (N); (i)++)
#define all(V) V.begin(), V.end()
using i64 = int_fast64_t;
using P = pair<int, int>;
void dfs(vector<vector<int>> &G, vector<vector<int>> &visited, int v,
int dist) {
if (visited[v][dist % 3] <= dist)
return;
visited[v][dist % 3] = dist;
for (auto nxt : G[v])
dfs(G, visited, nxt, dist + 1);
}
int main() {
int N, M;
cin >> N >> M;
vector<vector<int>> G(N);
vector<vector<int>> visited(N, vector<int>(3, 1e9));
int u, v;
rep(i, M) {
cin >> u >> v;
u--, v--;
G[u].emplace_back(v);
}
int S, T;
cin >> S >> T;
S--, T--;
bool bfs = true;
chrono::steady_clock::time_point start = chrono::steady_clock::now();
const chrono::milliseconds limit = 500ms;
struct info {
int now, dist;
};
queue<info> que;
que.push({S, 0});
visited[S][0] = 0;
while (!que.empty() && visited[T][0] == 1e9) {
info foo = que.front();
que.pop();
visited[foo.now][foo.dist % 3] = foo.dist;
for (int nxt : G[foo.now]) {
chrono::steady_clock::time_point now = chrono::steady_clock::now();
chrono::milliseconds t =
chrono::duration_cast<chrono::milliseconds>(start - now);
if (t > limit) {
bfs = false;
visited[T][0]--;
break;
}
if (visited[nxt][(foo.dist + 1) % 3] != 1e9)
continue;
que.push({nxt, foo.dist + 1});
}
}
if (!bfs) {
visited = vector<vector<int>>(N, vector<int>(3, 1e9));
dfs(G, visited, S, 0);
}
int ans = visited[T][0];
if (ans != 1e9)
ans /= 3;
else
ans = -1;
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int(i) = 0; (i) < (N); (i)++)
#define all(V) V.begin(), V.end()
using i64 = int_fast64_t;
using P = pair<int, int>;
void dfs(vector<vector<int>> &G, vector<vector<int>> &visited, int v,
int dist) {
if (visited[v][dist % 3] <= dist)
return;
visited[v][dist % 3] = dist;
for (auto nxt : G[v])
dfs(G, visited, nxt, dist + 1);
}
int main() {
int N, M;
cin >> N >> M;
vector<vector<int>> G(N);
vector<vector<int>> visited(N, vector<int>(3, 1e9));
int u, v;
rep(i, M) {
cin >> u >> v;
u--, v--;
G[u].emplace_back(v);
}
int S, T;
cin >> S >> T;
S--, T--;
bool bfs = true;
chrono::steady_clock::time_point start = chrono::steady_clock::now();
const chrono::milliseconds limit = 500ms;
struct info {
int now, dist;
};
queue<info> que;
que.push({S, 0});
visited[S][0] = 0;
while (!que.empty() && visited[T][0] == 1e9) {
info foo = que.front();
que.pop();
visited[foo.now][foo.dist % 3] = foo.dist;
for (int nxt : G[foo.now]) {
chrono::steady_clock::time_point now = chrono::steady_clock::now();
chrono::milliseconds t =
chrono::duration_cast<chrono::milliseconds>(now - start);
if (t > limit) {
bfs = false;
visited[T][0]--;
break;
}
if (visited[nxt][(foo.dist + 1) % 3] != 1e9)
continue;
que.push({nxt, foo.dist + 1});
}
}
if (!bfs) {
visited = vector<vector<int>>(N, vector<int>(3, 1e9));
dfs(G, visited, S, 0);
}
int ans = visited[T][0];
if (ans != 1e9)
ans /= 3;
else
ans = -1;
cout << ans << endl;
}
| replace | 50 | 51 | 50 | 51 | TLE | |
p02991 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
// const bool debug=true;
const bool debug = false;
#define DEBUG if (debug == true)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const ll MOD = 1000000007;
int main(void) {
int n, m;
cin >> n >> m;
int ne = 3 * n;
vector<int> edges[ne + 1];
int s, t;
rep(i, m) {
int u, v;
cin >> u >> v;
rep(i, 3) { edges[u + i * n].push_back(v + ((i + 1) % 3) * n); }
}
cin >> s >> t;
int d[ne + 1];
rep(i, ne + 1) {
if (i == s)
d[i] = 0;
else
d[i] = 1LL << 30;
}
int value = s;
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
que;
do {
if (!que.empty())
que.pop();
DEBUG { cout << "value " << value << endl; }
for (auto x : edges[value]) {
if (d[value] + 1 <= d[x]) {
d[x] = d[value] + 1;
que.push(make_pair(d[value] + 1, x));
}
}
if (!que.empty()) {
DEBUG { cout << "top " << que.top().second << endl; }
value = que.top().second;
}
} while (!que.empty());
cout << ((d[t] == 1LL << 30) ? -1 : d[t] / 3) << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
// const bool debug=true;
const bool debug = false;
#define DEBUG if (debug == true)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const ll MOD = 1000000007;
int main(void) {
int n, m;
cin >> n >> m;
int ne = 3 * n;
vector<int> edges[ne + 1];
int s, t;
rep(i, m) {
int u, v;
cin >> u >> v;
rep(i, 3) { edges[u + i * n].push_back(v + ((i + 1) % 3) * n); }
}
cin >> s >> t;
int d[ne + 1];
rep(i, ne + 1) {
if (i == s)
d[i] = 0;
else
d[i] = 1LL << 30;
}
int value = s;
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
que;
do {
if (!que.empty())
que.pop();
DEBUG { cout << "value " << value << endl; }
for (auto x : edges[value]) {
if (d[value] + 1 < d[x]) {
d[x] = d[value] + 1;
que.push(make_pair(d[value] + 1, x));
}
}
if (!que.empty()) {
DEBUG { cout << "top " << que.top().second << endl; }
value = que.top().second;
}
} while (!que.empty());
cout << ((d[t] == 1LL << 30) ? -1 : d[t] / 3) << endl;
return 0;
}
| replace | 38 | 39 | 38 | 39 | TLE | |
p02991 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, l, r) for (int i = (int)(l); i < (int)(r); i++)
#define all(x) (x).begin(), (x).end()
#define pb push_back
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
const int inf = 1LL << 60;
const int mod = 1e9 + 7;
const double eps = 1e-9;
/*{
}*/
int n, m;
int s, t;
vi g[100000];
signed main() {
cin >> n >> m;
rep(i, 0, m) {
int u, v;
cin >> u >> v;
u--;
v--;
g[u].pb(v);
}
cin >> s >> t;
s--;
t--;
priority_queue<pair<int, pii>> que;
vvi d(3, vi(n, inf));
d[0][s] = 0;
que.push(pair<int, pii>(0, pii(0, s)));
while (!que.empty()) {
auto p = que.top();
que.pop();
int u = p.second.first;
int v = p.second.second;
if (p.first > d[u][v])
continue;
// cout << u << ", " << v << endl;
for (auto to : g[v]) {
if (d[(u + 1) % 3][to] > d[u][v] + 1) {
d[(u + 1) % 3][to] = d[u][v] + 1;
que.push(pair<int, pii>(d[(u + 1) % 3][to], pii((u + 1) % 3, to)));
}
}
}
if (d[0][t] == inf)
cout << -1 << endl;
else
cout << d[0][t] / 3 << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, l, r) for (int i = (int)(l); i < (int)(r); i++)
#define all(x) (x).begin(), (x).end()
#define pb push_back
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
const int inf = 1LL << 60;
const int mod = 1e9 + 7;
const double eps = 1e-9;
/*{
}*/
int n, m;
int s, t;
vi g[100000];
signed main() {
cin >> n >> m;
rep(i, 0, m) {
int u, v;
cin >> u >> v;
u--;
v--;
g[u].pb(v);
}
cin >> s >> t;
s--;
t--;
priority_queue<pair<int, pii>, vector<pair<int, pii>>,
greater<pair<int, pii>>>
que;
vvi d(3, vi(n, inf));
d[0][s] = 0;
que.push(pair<int, pii>(0, pii(0, s)));
while (!que.empty()) {
auto p = que.top();
que.pop();
int u = p.second.first;
int v = p.second.second;
if (p.first > d[u][v])
continue;
// cout << u << ", " << v << endl;
for (auto to : g[v]) {
if (d[(u + 1) % 3][to] > d[u][v] + 1) {
d[(u + 1) % 3][to] = d[u][v] + 1;
que.push(pair<int, pii>(d[(u + 1) % 3][to], pii((u + 1) % 3, to)));
}
}
}
if (d[0][t] == inf)
cout << -1 << endl;
else
cout << d[0][t] / 3 << endl;
return 0;
}
| replace | 50 | 51 | 50 | 53 | TLE | |
p02991 | C++ | Time Limit Exceeded | #define _USE_MATH_DEFINES
#include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define MOD 1000000007
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define FOR(i, c) \
for (decltype((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ll long long
#define ull unsigned long long
#define all(hoge) (hoge).begin(), (hoge).end()
typedef pair<ll, ll> P;
const long long INF = 1LL << 60;
typedef vector<ll> Array;
typedef vector<Array> Matrix;
// priority_queue<ll> max;//大きい順
// priority_queue<ll, Array, greater<ll>> min;//小さい順
/*firstについては昇順 secondについては降順
sort(all(wh), [&](P x, P y) {
if (x.first == y.first)return x.second > y.second;
return x.first < y.first;
});
*/
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// substr 文字列取り出し
// upper_bound
// ある値より大きい一番左のイテレータを返す、lowerは以上(setに対して使うとO(N)なので、setのメンバ関数を使う
// stoi
struct Edge { // グラフ
ll to, cap, rev;
Edge(ll _to, ll _cap, ll _rev) {
to = _to;
cap = _cap;
rev = _rev;
}
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
void add_edge(Graph &G, ll from, ll to, ll cap, bool revFlag,
ll revCap) { // 最大フロー求める Ford-fulkerson
G[from].push_back(Edge(to, cap, (ll)G[to].size()));
if (revFlag)
G[to].push_back(Edge(
from, revCap, (ll)G[from].size() - 1)); // 最小カットの場合逆辺は0にする
}
void erase_edge(Graph &G, ll from, ll num) { // 使っちゃいけないタイミングあり
swap(G[from][num], G[from][G[from].size() - 1]);
G[from].pop_back();
}
ll max_flow_dfs(Graph &G, ll v, ll t, ll f, vector<bool> &used) {
if (v == t)
return f;
used[v] = true;
for (int i = 0; i < G[v].size(); ++i) {
Edge &e = G[v][i];
if (!used[e.to] && e.cap > 0) {
ll d = max_flow_dfs(G, e.to, t, min(f, e.cap), used);
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
// 二分グラフの最大マッチングを求めたりも出来る また二部グラフの最大独立集合は頂点数-最大マッチングのサイズ
ll max_flow(Graph &G, ll s, ll t) // O(V(V+E))
{
ll flow = 0;
for (;;) {
vector<bool> used(G.size());
REP(i, used.size()) used[i] = false;
ll f = max_flow_dfs(G, s, t, INF, used);
if (f == 0) {
return flow;
}
flow += f;
}
}
void BellmanFord(Graph &G, ll s, Array &d, Array &negative) { // O(|E||V|)
d.resize(G.size());
negative.resize(G.size());
REP(i, d.size()) d[i] = INF;
REP(i, d.size()) negative[i] = false;
d[s] = 0;
REP(k, G.size() - 2) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
}
}
}
}
REP(k, G.size() - 2) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
negative[G[i][j].to] = true;
}
if (negative[i] == true)
negative[G[i][j].to] = true;
}
}
}
}
void Dijkstra(Graph &G, ll s, Array &d) { // O(|E|log|V|)
d.resize(G.size());
REP(i, d.size()) d[i] = INF;
d[s] = 0;
priority_queue<P, vector<P>, greater<P>> q;
q.push(make_pair(0, s));
while (!q.empty()) {
P a = q.top();
q.pop();
if (d[a.second] < a.first)
continue;
REP(i, G[a.second].size()) {
Edge e = G[a.second][i];
if (d[e.to] > d[a.second] + e.cap) {
d[e.to] = d[a.second] + e.cap;
q.push(make_pair(d[e.to], e.to));
}
}
}
}
void WarshallFloyd(Graph &G, Matrix &d) { // O(V^3)
d.resize(G.size());
REP(i, d.size()) d[i].resize(G.size());
REP(i, d.size()) {
REP(j, d[i].size()) { d[i][j] = INF; }
}
REP(i, G.size()) {
REP(j, G[i].size()) { d[i][G[i][j].to] = G[i][j].cap; }
}
REP(i, G.size()) {
REP(j, G.size()) {
REP(k, G.size()) { chmin(d[j][k], d[j][i] + d[i][k]); }
}
}
}
class UnionFind {
vector<int> data;
ll num;
public:
UnionFind(int size) : data(size, -1), num(size) {}
bool unionSet(int x, int y) { // xとyの集合を統合する
x = root(x);
y = root(y);
if (x != y) {
if (data[y] < data[x])
swap(x, y);
data[x] += data[y];
data[y] = x;
}
num -= (x != y);
return x != y;
}
bool findSet(int x, int y) { // xとyが同じ集合か返す
return root(x) == root(y);
}
int root(int x) { // xのルートを返す
return data[x] < 0 ? x : data[x] = root(data[x]);
}
int size(int x) { // xの集合のサイズを返す
return -data[root(x)];
}
int numSet() { // 集合の数を返す
return num;
}
};
class SumSegTree {
private:
int _sum(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return 0; // 交差しない
if (a <= l && r <= b)
return dat[k]; // a,l,r,bの順で完全に含まれる
else {
int s1 = _sum(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
int s2 = _sum(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
return s1 + s2;
}
}
public:
int n, height;
vector<int> dat;
// 初期化（_nは最大要素数）
SumSegTree(int _n) {
n = 1;
height = 1;
while (n < _n) {
n *= 2;
height++;
}
dat = vector<int>(2 * n - 1, 0);
}
// 場所i(0-indexed)にxを足す
void add(int i, int x) {
i += n - 1; // i番目の葉ノードへ
dat[i] += x;
while (i > 0) { // 下から上がっていく
i = (i - 1) / 2;
dat[i] += x;
}
}
// 区間[a,b)の総和。ノードk=[l,r)に着目している。
int sum(int a, int b) { return _sum(a, b, 0, 0, n); }
};
class RmqTree {
private:
ll _find(ll a, ll b, ll k, ll l, ll r) {
if (r <= a || b <= l)
return INF; // 交差しない
if (a <= l && r <= b)
return dat[k]; // a,l,r,bの順で完全に含まれる
else {
ll s1 = _find(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
ll s2 = _find(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
return min(s1, s2);
}
}
public:
ll n, height;
vector<ll> dat;
// 初期化（_nは最大要素数）
RmqTree(ll _n) {
n = 1;
height = 1;
while (n < _n) {
n *= 2;
height++;
}
dat = vector<ll>(2 * n - 1, INF);
}
// 場所i(0-indexed)をxにする
void update(ll i, ll x) {
i += n - 1; // i番目の葉ノードへ
dat[i] = x;
while (i > 0) { // 下から上がっていく
i = (i - 1) / 2;
dat[i] = min(dat[i * 2 + 1], dat[i * 2 + 2]);
}
}
// 区間[a,b)の最小値。ノードk=[l,r)に着目している。
ll find(ll a, ll b) { return _find(a, b, 0, 0, n); }
};
// 約数求める //約数
void divisor(ll n, vector<ll> &ret) {
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(ret.begin(), ret.end());
}
vector<ll> lis_fast(const vector<ll> &a) { // 最長部分増加列
const ll n = a.size();
vector<ll> A(n, INT_MAX);
vector<ll> id(n);
for (int i = 0; i < n; ++i) {
id[i] = distance(A.begin(), lower_bound(A.begin(), A.end(), a[i]));
A[id[i]] = a[i];
}
ll m = *max_element(id.begin(), id.end());
vector<ll> b(m + 1);
for (int i = n - 1; i >= 0; --i)
if (id[i] == m)
b[m--] = a[i];
return b;
}
ll ModPow(ll x, ll n) {
ll res = 1LL;
while (n > 0) {
if (n & 1)
res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
// nCrとか
class Combination {
public:
Array fact;
Array inv;
ll mod;
ll mod_inv(ll x) {
ll n = mod - 2LL;
ll res = 1LL;
while (n > 0) {
if (n & 1)
res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
ll nCr(ll n, ll r) { return ((fact[n] * inv[r] % mod) * inv[n - r]) % mod; }
ll nPr(ll n, ll r) { return (fact[n] * inv[n - r]) % mod; }
ll nHr(ll n, ll r) { return nCr(r + n - 1, r); }
Combination(ll n, ll _mod) {
mod = _mod;
fact.resize(n + 1);
fact[0] = 1;
REP(i, n) { fact[i + 1] = (fact[i] * (i + 1LL)) % mod; }
inv.resize(n + 1);
REP(i, n + 1) { inv[i] = mod_inv(fact[i]); }
}
};
ll gcd(ll m, ll n) {
if (n == 0)
return m;
return gcd(n, m % n);
} // gcd
ll lcm(ll m, ll n) { return m / gcd(m, n) * n; }
Matrix mIdentity(ll n) {
Matrix A(n, Array(n));
for (int i = 0; i < n; ++i)
A[i][i] = 1;
return A;
}
Matrix mMul(const Matrix &A, const Matrix &B) {
Matrix C(A.size(), Array(B[0].size()));
for (int i = 0; i < C.size(); ++i)
for (int j = 0; j < C[i].size(); ++j)
for (int k = 0; k < A[i].size(); ++k)
(C[i][j] += (A[i][k] % MOD) * (B[k][j] % MOD)) %= MOD;
return C;
}
// O( n^3 log e )
Matrix mPow(const Matrix &A, ll e) {
return e == 0 ? mIdentity(A.size())
: e % 2 == 0 ? mPow(mMul(A, A), e / 2)
: mMul(A, mPow(A, e - 1));
}
Matrix used(100100, Array(3, 0));
ll cost[100100];
void dfs(Graph &graph, ll v, ll num) {
used[v][num % 3] = num;
if (num % 3 == 0)
chmin(cost[v], num);
REP(i, graph[v].size()) {
if (used[graph[v][i].to][(num + 1) % 3] > num + 1) {
dfs(graph, graph[v][i].to, num + 1);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n, m;
cin >> n >> m;
Graph graph(n);
REP(i, m) {
ll u, v;
cin >> u >> v;
u--;
v--;
add_edge(graph, u, v, 1, false, 0);
}
ll s, t;
cin >> s >> t;
s--;
t--;
REP(i, n) cost[i] = INF;
REP(i, n) {
REP(j, 3) { used[i][j] = INF; }
}
dfs(graph, s, 0);
if (cost[t] == INF) {
cout << -1;
} else {
cout << cost[t] / 3;
}
return 0;
} | #define _USE_MATH_DEFINES
#include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define MOD 1000000007
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define FOR(i, c) \
for (decltype((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ll long long
#define ull unsigned long long
#define all(hoge) (hoge).begin(), (hoge).end()
typedef pair<ll, ll> P;
const long long INF = 1LL << 60;
typedef vector<ll> Array;
typedef vector<Array> Matrix;
// priority_queue<ll> max;//大きい順
// priority_queue<ll, Array, greater<ll>> min;//小さい順
/*firstについては昇順 secondについては降順
sort(all(wh), [&](P x, P y) {
if (x.first == y.first)return x.second > y.second;
return x.first < y.first;
});
*/
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// substr 文字列取り出し
// upper_bound
// ある値より大きい一番左のイテレータを返す、lowerは以上(setに対して使うとO(N)なので、setのメンバ関数を使う
// stoi
struct Edge { // グラフ
ll to, cap, rev;
Edge(ll _to, ll _cap, ll _rev) {
to = _to;
cap = _cap;
rev = _rev;
}
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
void add_edge(Graph &G, ll from, ll to, ll cap, bool revFlag,
ll revCap) { // 最大フロー求める Ford-fulkerson
G[from].push_back(Edge(to, cap, (ll)G[to].size()));
if (revFlag)
G[to].push_back(Edge(
from, revCap, (ll)G[from].size() - 1)); // 最小カットの場合逆辺は0にする
}
void erase_edge(Graph &G, ll from, ll num) { // 使っちゃいけないタイミングあり
swap(G[from][num], G[from][G[from].size() - 1]);
G[from].pop_back();
}
ll max_flow_dfs(Graph &G, ll v, ll t, ll f, vector<bool> &used) {
if (v == t)
return f;
used[v] = true;
for (int i = 0; i < G[v].size(); ++i) {
Edge &e = G[v][i];
if (!used[e.to] && e.cap > 0) {
ll d = max_flow_dfs(G, e.to, t, min(f, e.cap), used);
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
// 二分グラフの最大マッチングを求めたりも出来る また二部グラフの最大独立集合は頂点数-最大マッチングのサイズ
ll max_flow(Graph &G, ll s, ll t) // O(V(V+E))
{
ll flow = 0;
for (;;) {
vector<bool> used(G.size());
REP(i, used.size()) used[i] = false;
ll f = max_flow_dfs(G, s, t, INF, used);
if (f == 0) {
return flow;
}
flow += f;
}
}
void BellmanFord(Graph &G, ll s, Array &d, Array &negative) { // O(|E||V|)
d.resize(G.size());
negative.resize(G.size());
REP(i, d.size()) d[i] = INF;
REP(i, d.size()) negative[i] = false;
d[s] = 0;
REP(k, G.size() - 2) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
}
}
}
}
REP(k, G.size() - 2) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
negative[G[i][j].to] = true;
}
if (negative[i] == true)
negative[G[i][j].to] = true;
}
}
}
}
void Dijkstra(Graph &G, ll s, Array &d) { // O(|E|log|V|)
d.resize(G.size());
REP(i, d.size()) d[i] = INF;
d[s] = 0;
priority_queue<P, vector<P>, greater<P>> q;
q.push(make_pair(0, s));
while (!q.empty()) {
P a = q.top();
q.pop();
if (d[a.second] < a.first)
continue;
REP(i, G[a.second].size()) {
Edge e = G[a.second][i];
if (d[e.to] > d[a.second] + e.cap) {
d[e.to] = d[a.second] + e.cap;
q.push(make_pair(d[e.to], e.to));
}
}
}
}
void WarshallFloyd(Graph &G, Matrix &d) { // O(V^3)
d.resize(G.size());
REP(i, d.size()) d[i].resize(G.size());
REP(i, d.size()) {
REP(j, d[i].size()) { d[i][j] = INF; }
}
REP(i, G.size()) {
REP(j, G[i].size()) { d[i][G[i][j].to] = G[i][j].cap; }
}
REP(i, G.size()) {
REP(j, G.size()) {
REP(k, G.size()) { chmin(d[j][k], d[j][i] + d[i][k]); }
}
}
}
class UnionFind {
vector<int> data;
ll num;
public:
UnionFind(int size) : data(size, -1), num(size) {}
bool unionSet(int x, int y) { // xとyの集合を統合する
x = root(x);
y = root(y);
if (x != y) {
if (data[y] < data[x])
swap(x, y);
data[x] += data[y];
data[y] = x;
}
num -= (x != y);
return x != y;
}
bool findSet(int x, int y) { // xとyが同じ集合か返す
return root(x) == root(y);
}
int root(int x) { // xのルートを返す
return data[x] < 0 ? x : data[x] = root(data[x]);
}
int size(int x) { // xの集合のサイズを返す
return -data[root(x)];
}
int numSet() { // 集合の数を返す
return num;
}
};
class SumSegTree {
private:
int _sum(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return 0; // 交差しない
if (a <= l && r <= b)
return dat[k]; // a,l,r,bの順で完全に含まれる
else {
int s1 = _sum(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
int s2 = _sum(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
return s1 + s2;
}
}
public:
int n, height;
vector<int> dat;
// 初期化（_nは最大要素数）
SumSegTree(int _n) {
n = 1;
height = 1;
while (n < _n) {
n *= 2;
height++;
}
dat = vector<int>(2 * n - 1, 0);
}
// 場所i(0-indexed)にxを足す
void add(int i, int x) {
i += n - 1; // i番目の葉ノードへ
dat[i] += x;
while (i > 0) { // 下から上がっていく
i = (i - 1) / 2;
dat[i] += x;
}
}
// 区間[a,b)の総和。ノードk=[l,r)に着目している。
int sum(int a, int b) { return _sum(a, b, 0, 0, n); }
};
class RmqTree {
private:
ll _find(ll a, ll b, ll k, ll l, ll r) {
if (r <= a || b <= l)
return INF; // 交差しない
if (a <= l && r <= b)
return dat[k]; // a,l,r,bの順で完全に含まれる
else {
ll s1 = _find(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
ll s2 = _find(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
return min(s1, s2);
}
}
public:
ll n, height;
vector<ll> dat;
// 初期化（_nは最大要素数）
RmqTree(ll _n) {
n = 1;
height = 1;
while (n < _n) {
n *= 2;
height++;
}
dat = vector<ll>(2 * n - 1, INF);
}
// 場所i(0-indexed)をxにする
void update(ll i, ll x) {
i += n - 1; // i番目の葉ノードへ
dat[i] = x;
while (i > 0) { // 下から上がっていく
i = (i - 1) / 2;
dat[i] = min(dat[i * 2 + 1], dat[i * 2 + 2]);
}
}
// 区間[a,b)の最小値。ノードk=[l,r)に着目している。
ll find(ll a, ll b) { return _find(a, b, 0, 0, n); }
};
// 約数求める //約数
void divisor(ll n, vector<ll> &ret) {
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
sort(ret.begin(), ret.end());
}
vector<ll> lis_fast(const vector<ll> &a) { // 最長部分増加列
const ll n = a.size();
vector<ll> A(n, INT_MAX);
vector<ll> id(n);
for (int i = 0; i < n; ++i) {
id[i] = distance(A.begin(), lower_bound(A.begin(), A.end(), a[i]));
A[id[i]] = a[i];
}
ll m = *max_element(id.begin(), id.end());
vector<ll> b(m + 1);
for (int i = n - 1; i >= 0; --i)
if (id[i] == m)
b[m--] = a[i];
return b;
}
ll ModPow(ll x, ll n) {
ll res = 1LL;
while (n > 0) {
if (n & 1)
res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
// nCrとか
class Combination {
public:
Array fact;
Array inv;
ll mod;
ll mod_inv(ll x) {
ll n = mod - 2LL;
ll res = 1LL;
while (n > 0) {
if (n & 1)
res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
ll nCr(ll n, ll r) { return ((fact[n] * inv[r] % mod) * inv[n - r]) % mod; }
ll nPr(ll n, ll r) { return (fact[n] * inv[n - r]) % mod; }
ll nHr(ll n, ll r) { return nCr(r + n - 1, r); }
Combination(ll n, ll _mod) {
mod = _mod;
fact.resize(n + 1);
fact[0] = 1;
REP(i, n) { fact[i + 1] = (fact[i] * (i + 1LL)) % mod; }
inv.resize(n + 1);
REP(i, n + 1) { inv[i] = mod_inv(fact[i]); }
}
};
ll gcd(ll m, ll n) {
if (n == 0)
return m;
return gcd(n, m % n);
} // gcd
ll lcm(ll m, ll n) { return m / gcd(m, n) * n; }
Matrix mIdentity(ll n) {
Matrix A(n, Array(n));
for (int i = 0; i < n; ++i)
A[i][i] = 1;
return A;
}
Matrix mMul(const Matrix &A, const Matrix &B) {
Matrix C(A.size(), Array(B[0].size()));
for (int i = 0; i < C.size(); ++i)
for (int j = 0; j < C[i].size(); ++j)
for (int k = 0; k < A[i].size(); ++k)
(C[i][j] += (A[i][k] % MOD) * (B[k][j] % MOD)) %= MOD;
return C;
}
// O( n^3 log e )
Matrix mPow(const Matrix &A, ll e) {
return e == 0 ? mIdentity(A.size())
: e % 2 == 0 ? mPow(mMul(A, A), e / 2)
: mMul(A, mPow(A, e - 1));
}
Matrix used(100100, Array(3, 0));
ll cost[100100];
void dfs(Graph &graph, ll v, ll num) {
used[v][num % 3] = num;
if (num % 3 == 0)
chmin(cost[v], num);
REP(i, graph[v].size()) {
if (used[graph[v][i].to][(num + 1) % 3] > num + 1) {
dfs(graph, graph[v][i].to, num + 1);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n, m;
cin >> n >> m;
Graph graph(n);
REP(i, m) {
ll u, v;
cin >> u >> v;
u--;
v--;
add_edge(graph, u, v, 1, false, 0);
}
ll s, t;
cin >> s >> t;
s--;
t--;
REP(i, n) cost[i] = INF;
REP(i, n) {
REP(j, 3) { used[i][j] = INF; }
}
queue<P> que;
que.push(make_pair(s, 0));
used[s][0] = 0;
ll i = 0;
while (que.size()) {
ll v = que.front().first;
ll num = que.front().second;
REP(i, graph[v].size()) {
if (used[graph[v][i].to][(num + 1) % 3] > num + 1) {
if (graph[v][i].to == t && (num + 1) % 3 == 0) {
cout << (num + 1) / 3;
return 0;
}
que.push(make_pair(graph[v][i].to, num + 1));
used[graph[v][i].to][(num + 1) % 3] = num + 1;
}
}
que.pop();
i++;
if (i >= 90000000) {
cout << -1;
return 0;
}
}
cout << -1;
return 0;
} | replace | 424 | 430 | 424 | 450 | TLE | |
p02991 | C++ | Runtime Error | #include <bits/stdc++.h>
#define F first
#define S second
#define PB push_back
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
typedef priority_queue<int> HEAP;
typedef priority_queue<int, vector<int>, greater<int>> RHEAP;
const int N = 100010, M = 3 * N;
int n, m;
int h[N], e[M], ne[M], idx;
int dist[N], q[M];
void add(int a, int b) { e[idx] = b, ne[idx] = h[a], h[a] = idx++; }
int bfs(int st, int ed) {
memset(dist, -1, sizeof dist);
int hh = 0, tt = -1;
dist[st * 3] = 0;
q[++tt] = st * 3;
while (hh <= tt) {
int t = q[hh++];
for (int i = h[t]; ~i; i = ne[i]) {
int j = e[i];
if (dist[j] != -1)
continue;
dist[j] = dist[t] + 1;
q[++tt] = j;
}
}
if (dist[ed * 3] == -1)
return -1;
else
return dist[ed * 3] / 3;
}
int main() {
memset(h, -1, sizeof h);
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
add(3 * a, 3 * b + 1);
add(3 * a + 1, 3 * b + 2);
add(3 * a + 2, 3 * b);
}
int st, ed;
scanf("%d%d", &st, &ed);
printf("%d\n", bfs(st, ed));
return 0;
} | #include <bits/stdc++.h>
#define F first
#define S second
#define PB push_back
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
typedef priority_queue<int> HEAP;
typedef priority_queue<int, vector<int>, greater<int>> RHEAP;
const int N = 300010, M = 3 * N;
int n, m;
int h[N], e[M], ne[M], idx;
int dist[N], q[M];
void add(int a, int b) { e[idx] = b, ne[idx] = h[a], h[a] = idx++; }
int bfs(int st, int ed) {
memset(dist, -1, sizeof dist);
int hh = 0, tt = -1;
dist[st * 3] = 0;
q[++tt] = st * 3;
while (hh <= tt) {
int t = q[hh++];
for (int i = h[t]; ~i; i = ne[i]) {
int j = e[i];
if (dist[j] != -1)
continue;
dist[j] = dist[t] + 1;
q[++tt] = j;
}
}
if (dist[ed * 3] == -1)
return -1;
else
return dist[ed * 3] / 3;
}
int main() {
memset(h, -1, sizeof h);
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
add(3 * a, 3 * b + 1);
add(3 * a + 1, 3 * b + 2);
add(3 * a + 2, 3 * b);
}
int st, ed;
scanf("%d%d", &st, &ed);
printf("%d\n", bfs(st, ed));
return 0;
} | replace | 13 | 14 | 13 | 14 | 0 | |
p02991 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define rep(i, n) for (lli i = 0; i < n; i++)
#define repb(i, n) for (lli i = n - 1; i >= 0; i--)
#define pb push_back
#define mp make_pair
#define bg() begin()
#define en() end()
#define ft first
#define sc second
#define vect_lli_it vector<lli>::iterator
#define set_lli_it set<lli>::iterator
#define inf 1e18
#define all(X) X.begin(), X.end()
#define iterate(X) for (it = X.begin(); it != X.end(); it++)
lli combi(lli n, lli k) {
lli ans = 1;
k = k > n - k ? n - k : k;
lli j = 1;
for (; j <= k; j++, n--) {
if (n % j == 0) {
ans *= n / j;
} else if (ans % j == 0) {
ans = ans / j * n;
} else {
ans = (ans * n) / j;
}
}
return ans;
}
lli gcd(lli a, lli b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
lli findlcm(vector<lli> arr, lli n) {
lli ans = arr[0];
for (lli i = 1; i < n; i++)
ans = (((arr[i] * ans)) / (gcd(arr[i], ans)));
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
lli n, m;
cin >> n >> m;
vector<vector<lli>> vect(n + 1);
lli u, v;
rep(i, m) {
cin >> u >> v;
vect[u].pb(v);
}
lli s, t;
cin >> s >> t;
lli dis[n + 1][3];
for (lli i = 1; i <= n; i++) {
for (lli j = 0; j < 3; j++)
dis[i][j] = inf;
}
dis[s][0] = 0;
priority_queue<pair<lli, lli>> q;
q.push(mp(0, s));
while (!q.empty()) {
pair<lli, lli> p = q.top();
q.pop();
lli t = (p.ft + 1) % 3;
for (lli i = 0; i < vect[p.sc].size(); i++) {
if (dis[vect[p.sc][i]][t] > (p.ft + 1)) {
dis[vect[p.sc][i]][t] = p.ft + 1;
q.push(mp(p.ft + 1, vect[p.sc][i]));
}
}
}
if (dis[t][0] == inf)
cout << "-1\n";
else
cout << dis[t][0] / 3;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define rep(i, n) for (lli i = 0; i < n; i++)
#define repb(i, n) for (lli i = n - 1; i >= 0; i--)
#define pb push_back
#define mp make_pair
#define bg() begin()
#define en() end()
#define ft first
#define sc second
#define vect_lli_it vector<lli>::iterator
#define set_lli_it set<lli>::iterator
#define inf 1e18
#define all(X) X.begin(), X.end()
#define iterate(X) for (it = X.begin(); it != X.end(); it++)
lli combi(lli n, lli k) {
lli ans = 1;
k = k > n - k ? n - k : k;
lli j = 1;
for (; j <= k; j++, n--) {
if (n % j == 0) {
ans *= n / j;
} else if (ans % j == 0) {
ans = ans / j * n;
} else {
ans = (ans * n) / j;
}
}
return ans;
}
lli gcd(lli a, lli b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
lli findlcm(vector<lli> arr, lli n) {
lli ans = arr[0];
for (lli i = 1; i < n; i++)
ans = (((arr[i] * ans)) / (gcd(arr[i], ans)));
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
lli n, m;
cin >> n >> m;
vector<vector<lli>> vect(n + 1);
lli u, v;
rep(i, m) {
cin >> u >> v;
vect[u].pb(v);
}
lli s, t;
cin >> s >> t;
lli dis[n + 1][3];
for (lli i = 1; i <= n; i++) {
for (lli j = 0; j < 3; j++)
dis[i][j] = inf;
}
dis[s][0] = 0;
priority_queue<pair<lli, lli>, vector<pair<lli, lli>>,
greater<pair<lli, lli>>>
q;
q.push(mp(0, s));
while (!q.empty()) {
pair<lli, lli> p = q.top();
q.pop();
lli t = (p.ft + 1) % 3;
for (lli i = 0; i < vect[p.sc].size(); i++) {
if (dis[vect[p.sc][i]][t] > (p.ft + 1)) {
dis[vect[p.sc][i]][t] = p.ft + 1;
q.push(mp(p.ft + 1, vect[p.sc][i]));
}
}
}
if (dis[t][0] == inf)
cout << "-1\n";
else
cout << dis[t][0] / 3;
return 0;
}
| replace | 62 | 63 | 62 | 65 | TLE | |
p02991 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rep1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define irep(i, a, n) for (int i = a; i < (int)(n); ++i)
#define rrep(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define rrep1(i, n) for (int i = (int)(n); i >= 1; --i)
#define allrep(V, v) for (auto &&V : v)
#define all(x) (x).begin(), (x).end()
using lint = long long;
constexpr int INF = 1 << 30;
constexpr lint INFL = 1LL << 62;
constexpr int MOD = 1e9 + 7;
constexpr double EPS = 1e-9;
using namespace std;
using Weight = int;
struct Edge {
int src, dst;
Weight weight;
Edge(void) {}
Edge(int src_val, int dst_val, Weight weight_val)
: src(src_val), dst(dst_val), weight(weight_val) {}
};
using Edges = std::vector<Edge>;
using Graph = std::vector<Edges>;
Graph edges_to_graph(const Edges &edges, const int vertices_num,
const bool directed = true) {
Graph ret(vertices_num);
for (const auto &e : edges) {
ret[e.src].push_back(e);
if (!directed)
ret[e.src].push_back(Edge(e.dst, e.src, e.weight));
}
return ret;
}
void dfs(Graph &g, vector<lint> &check, int v, lint cnt) {
if (check[v] <= cnt)
return;
check[v] = cnt;
for (const auto es : g[v]) {
dfs(g, check, es.dst, cnt + 1);
}
}
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
int n, m;
cin >> n >> m;
Edges edges(3 * m);
rep(i, m) {
int s, d;
cin >> s >> d;
edges[i].src = s;
edges[i].dst = d + n;
edges[i + m].src = s + n;
edges[i + m].dst = d + 2 * n;
edges[i + 2 * m].src = s + 2 * n;
edges[i + 2 * m].dst = d;
}
int s, t;
cin >> s >> t;
Graph graph = edges_to_graph(edges, 3 * n + 1);
vector<lint> check(3 * n + 1, INFL);
dfs(graph, check, s, 0);
cout << (check[t] != INFL ? check[t] / 3 : -1) << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rep1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define irep(i, a, n) for (int i = a; i < (int)(n); ++i)
#define rrep(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define rrep1(i, n) for (int i = (int)(n); i >= 1; --i)
#define allrep(V, v) for (auto &&V : v)
#define all(x) (x).begin(), (x).end()
using lint = long long;
constexpr int INF = 1 << 30;
constexpr lint INFL = 1LL << 62;
constexpr int MOD = 1e9 + 7;
constexpr double EPS = 1e-9;
using namespace std;
using Weight = int;
struct Edge {
int src, dst;
Weight weight;
Edge(void) {}
Edge(int src_val, int dst_val, Weight weight_val)
: src(src_val), dst(dst_val), weight(weight_val) {}
};
using Edges = std::vector<Edge>;
using Graph = std::vector<Edges>;
Graph edges_to_graph(const Edges &edges, const int vertices_num,
const bool directed = true) {
Graph ret(vertices_num);
for (const auto &e : edges) {
ret[e.src].push_back(e);
if (!directed)
ret[e.src].push_back(Edge(e.dst, e.src, e.weight));
}
return ret;
}
void dfs(Graph &g, vector<lint> &check, int v, lint cnt) {
if (check[v] <= cnt)
return;
check[v] = cnt;
for (const auto es : g[v]) {
dfs(g, check, es.dst, cnt + 1);
}
}
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
int n, m;
cin >> n >> m;
Edges edges(3 * m);
rep(i, m) {
int s, d;
cin >> s >> d;
edges[i].src = s;
edges[i].dst = d + n;
edges[i + m].src = s + n;
edges[i + m].dst = d + 2 * n;
edges[i + 2 * m].src = s + 2 * n;
edges[i + 2 * m].dst = d;
}
int s, t;
cin >> s >> t;
Graph graph = edges_to_graph(edges, 3 * n + 1);
vector<lint> check(3 * n + 1, INFL);
queue<pair<int, int>> que;
que.push({s, 0});
while (!que.empty()) {
int v = que.front().first, cnt = que.front().second;
que.pop();
if (check[v] <= cnt)
continue;
check[v] = cnt;
for (const auto es : graph[v]) {
que.push({es.dst, cnt + 1});
}
}
cout << (check[t] != INFL ? check[t] / 3 : -1) << endl;
return 0;
} | replace | 68 | 69 | 68 | 80 | TLE | |
p02991 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int i = 0; i < int(N); ++i)
#define rep1(i, N) for (int i = 1; i < int(N); ++i)
#define all(a) (a).begin(), (a).end() // sort(all(vi S)) sort(all(string S))
#define print(v) \
{ \
cerr << #v << ": [ "; \
for (auto _ : v) \
cerr << _ << ", "; \
cerr << "]" << endl; \
}
#define printpair(v) \
{ \
cerr << #v << ": [ "; \
for (auto _ : v) \
cerr << "{" << _.first << "," << _.second << "}" \
<< ", "; \
cerr << "]" << endl; \
}
using P = pair<int, int>; // P.first, P.second
typedef long long ll;
typedef vector<int> vi;
typedef set<int> seti;
typedef vector<string> vs;
const int MOD = 1e9 + 7;
const int INF = 1e9;
int dist[100005][3];
int main() {
int N, M;
cin >> N >> M;
vector<vector<int>> to(N);
rep(i, N) {
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({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({u, nl});
}
}
int ans = dist[tv][0];
if (ans == INF)
ans = -1;
else
ans /= 3;
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int i = 0; i < int(N); ++i)
#define rep1(i, N) for (int i = 1; i < int(N); ++i)
#define all(a) (a).begin(), (a).end() // sort(all(vi S)) sort(all(string S))
#define print(v) \
{ \
cerr << #v << ": [ "; \
for (auto _ : v) \
cerr << _ << ", "; \
cerr << "]" << endl; \
}
#define printpair(v) \
{ \
cerr << #v << ": [ "; \
for (auto _ : v) \
cerr << "{" << _.first << "," << _.second << "}" \
<< ", "; \
cerr << "]" << endl; \
}
using P = pair<int, int>; // P.first, P.second
typedef long long ll;
typedef vector<int> vi;
typedef set<int> seti;
typedef vector<string> vs;
const int MOD = 1e9 + 7;
const int INF = 1e9;
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({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({u, nl});
}
}
int ans = dist[tv][0];
if (ans == INF)
ans = -1;
else
ans /= 3;
cout << ans << endl;
} | replace | 35 | 36 | 35 | 36 | 0 | |
p02991 | C++ | Runtime Error | // Author : Sarthak Kapoor
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
using namespace __gnu_pbds;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define repa(i, a, n) for (int i = a; i < n; ++i)
#define repr(i, n) for (int i = n - 1; i >= 0; --i)
#define repba(i, b, a) for (int i = b; i >= a; --i)
#define repab(i, a, b) for (int i = a; i < b; ++i)
#define ll long long
#define ull unsigned long long
#define vi vector<int>
#define msi map<string, int>
#define mii map<int, int>
#define viip vector<pair<int, pair<int, int>>>
#define mp make_pair
#define vip vector<pair<int, int>>
#define pb push_back
#define po pop_back
#define fi first
#define sec second
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define s(v) v.size()
ll mod = 1000000007;
mt19937 rng(chrono::steady_clock::now()
.time_since_epoch()
.count()); // use rng()%n for numbers in range [0,n-1]
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
const ll inf = 1e17;
const int maxn = 1e5 + 2;
vi v[maxn];
bool vis[maxn];
ll dp[maxn][3];
void dfs(int u) {
vis[u] = true;
for (auto x : v[u]) {
rep(i, 3) {
if (dp[u][i] != inf) {
// if(dp[x][(i+1)])
dp[x][(i + 1) % 3] = min(dp[u][i] + 1ll, dp[x][(i + 1) % 3]);
}
}
if (!vis[x]) {
dfs(x);
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int n;
cin >> n;
int m;
cin >> m;
rep(i, m) {
int x, y;
cin >> x >> y;
v[x].pb(y);
}
int s, t;
cin >> s >> t;
rep(i, maxn) {
rep(j, 3) { dp[i][j] = inf; }
}
dp[s][0] = 0ll;
rep(j, 20) {
rep(i, maxn) vis[i] = false;
dfs(s);
}
// dfs(s);
// rep(i,maxn)vis[i]=false;
// dfs(s);
// repa(i,1,7){
// rep(j,3){
// cout<<dp[i][j]<<" ";
// }
// cout<<"\n";
// }
if (dp[t][0] != inf) {
cout << dp[t][0] / 3;
} else {
cout << -1;
}
return 0;
} | // Author : Sarthak Kapoor
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
using namespace __gnu_pbds;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define repa(i, a, n) for (int i = a; i < n; ++i)
#define repr(i, n) for (int i = n - 1; i >= 0; --i)
#define repba(i, b, a) for (int i = b; i >= a; --i)
#define repab(i, a, b) for (int i = a; i < b; ++i)
#define ll long long
#define ull unsigned long long
#define vi vector<int>
#define msi map<string, int>
#define mii map<int, int>
#define viip vector<pair<int, pair<int, int>>>
#define mp make_pair
#define vip vector<pair<int, int>>
#define pb push_back
#define po pop_back
#define fi first
#define sec second
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define s(v) v.size()
ll mod = 1000000007;
mt19937 rng(chrono::steady_clock::now()
.time_since_epoch()
.count()); // use rng()%n for numbers in range [0,n-1]
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
const ll inf = 1e17;
const int maxn = 1e5 + 2;
vi v[maxn];
bool vis[maxn];
ll dp[maxn][3];
void dfs(int u) {
vis[u] = true;
for (auto x : v[u]) {
rep(i, 3) {
if (dp[u][i] != inf) {
// if(dp[x][(i+1)])
dp[x][(i + 1) % 3] = min(dp[u][i] + 1ll, dp[x][(i + 1) % 3]);
}
}
if (!vis[x]) {
dfs(x);
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int m;
cin >> m;
rep(i, m) {
int x, y;
cin >> x >> y;
v[x].pb(y);
}
int s, t;
cin >> s >> t;
rep(i, maxn) {
rep(j, 3) { dp[i][j] = inf; }
}
dp[s][0] = 0ll;
rep(j, 20) {
rep(i, maxn) vis[i] = false;
dfs(s);
}
// dfs(s);
// rep(i,maxn)vis[i]=false;
// dfs(s);
// repa(i,1,7){
// rep(j,3){
// cout<<dp[i][j]<<" ";
// }
// cout<<"\n";
// }
if (dp[t][0] != inf) {
cout << dp[t][0] / 3;
} else {
cout << -1;
}
return 0;
} | replace | 57 | 61 | 57 | 58 | -6 | terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
|
p02991 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
int n, m;
int f[3][N];
vector<int> g[N];
int main() {
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
--u, --v;
g[u].push_back(v);
}
int S, F;
cin >> S >> F;
--S, --F;
for (int j = 0; j < 3; ++j)
for (int i = 0; i < n; ++i)
f[j][i] = 1e9;
f[S][0] = 0;
queue<pair<int, int>> q;
q.push(make_pair(S, 0));
while (q.size()) {
int u = q.front().first, o = q.front().second;
q.pop();
for (int v : g[u]) {
if (f[(o + 1) % 3][v] != 1e9)
continue;
f[(o + 1) % 3][v] = f[o][u] + 1;
q.push(make_pair(v, (o + 1) % 3));
}
}
int res = f[0][F];
if (res == 1e9)
res = -1;
else
res /= 3;
cout << res << endl;
}
| #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
int n, m;
int f[3][N];
vector<int> g[N];
int main() {
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
--u, --v;
g[u].push_back(v);
}
int S, F;
cin >> S >> F;
--S, --F;
for (int j = 0; j < 3; ++j)
for (int i = 0; i < n; ++i)
f[j][i] = 1e9;
f[0][S] = 0;
queue<pair<int, int>> q;
q.push(make_pair(S, 0));
while (q.size()) {
int u = q.front().first, o = q.front().second;
q.pop();
for (int v : g[u]) {
if (f[(o + 1) % 3][v] != 1e9)
continue;
f[(o + 1) % 3][v] = f[o][u] + 1;
q.push(make_pair(v, (o + 1) % 3));
}
}
int res = f[0][F];
if (res == 1e9)
res = -1;
else
res /= 3;
cout << res << endl;
}
| replace | 25 | 26 | 25 | 26 | 0 | |
p02991 | C++ | Runtime Error | #include <iostream>
#include <queue>
#include <vector>
#define NMAX 10000
#define MOD 1000000007
#define INF 2000000000
#define MIN(a, b) (a < b ? a : b)
using namespace std;
struct Node {
int node;
int level;
};
int n, m;
int s, t;
vector<int> graph[3 * NMAX];
queue<Node> Q;
bool vis[3 * NMAX];
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
graph[a].push_back(b + n);
graph[a + n].push_back(b + 2 * n);
graph[a + 2 * n].push_back(b);
}
cin >> s >> t;
s--;
t--;
Node start = {s, 0};
Q.push(start);
int minPath = INF;
while (!Q.empty()) {
Node node = Q.front();
if (node.node == t && node.level < minPath && node.level % 3 == 0)
minPath = node.level;
Q.pop();
for (int i = 0; i < graph[node.node].size() && !vis[node.node]; i++) {
Node other = {graph[node.node][i], node.level + 1};
Q.push(other);
}
vis[node.node] = 1;
}
cout << (minPath != INF ? minPath / 3 : -1) << '\n';
return 0;
} | #include <iostream>
#include <queue>
#include <vector>
#define NMAX 100000
#define MOD 1000000007
#define INF 2000000000
#define MIN(a, b) (a < b ? a : b)
using namespace std;
struct Node {
int node;
int level;
};
int n, m;
int s, t;
vector<int> graph[3 * NMAX];
queue<Node> Q;
bool vis[3 * NMAX];
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
graph[a].push_back(b + n);
graph[a + n].push_back(b + 2 * n);
graph[a + 2 * n].push_back(b);
}
cin >> s >> t;
s--;
t--;
Node start = {s, 0};
Q.push(start);
int minPath = INF;
while (!Q.empty()) {
Node node = Q.front();
if (node.node == t && node.level < minPath && node.level % 3 == 0)
minPath = node.level;
Q.pop();
for (int i = 0; i < graph[node.node].size() && !vis[node.node]; i++) {
Node other = {graph[node.node][i], node.level + 1};
Q.push(other);
}
vis[node.node] = 1;
}
cout << (minPath != INF ? minPath / 3 : -1) << '\n';
return 0;
} | replace | 4 | 5 | 4 | 5 | 0 | |
p02991 | C++ | Runtime Error | #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;
} | replace | 60 | 66 | 60 | 68 | -11 | |
p02991 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define M 100001
struct D {
int x, step;
} nxt;
int n, m, st, ed;
vector<int> edge[M];
bool mark[M][3];
int spfa() {
queue<D> Q;
Q.push((D){st, 0});
mark[st][0] = 1;
while (!Q.empty()) {
D now = Q.front();
Q.pop();
for (int i = 0; i < edge[now.x].size(); i++) {
int y = edge[now.x][i];
nxt.x = y, nxt.step = now.step + 1;
if (mark[y][nxt.step % 3])
continue;
if (y == ed && nxt.step % 3 == 0)
return nxt.step / 3;
Q.push(nxt);
}
}
return -1;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, u, v; i <= m; i++) {
scanf("%d%d", &u, &v);
edge[u].push_back(v);
}
scanf("%d%d", &st, &ed);
printf("%d", spfa());
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define M 100001
struct D {
int x, step;
} nxt;
int n, m, st, ed;
vector<int> edge[M];
bool mark[M][3];
int spfa() {
queue<D> Q;
Q.push((D){st, 0});
mark[st][0] = 1;
while (!Q.empty()) {
D now = Q.front();
Q.pop();
for (int i = 0; i < edge[now.x].size(); i++) {
int y = edge[now.x][i];
nxt.x = y, nxt.step = now.step + 1;
if (mark[y][nxt.step % 3])
continue;
mark[y][nxt.step % 3] = 1;
if (y == ed && nxt.step % 3 == 0)
return nxt.step / 3;
Q.push(nxt);
}
}
return -1;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, u, v; i <= m; i++) {
scanf("%d%d", &u, &v);
edge[u].push_back(v);
}
scanf("%d%d", &st, &ed);
printf("%d", spfa());
return 0;
} | insert | 21 | 21 | 21 | 22 | TLE | |
p02991 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); ++i)
#define erep(i, n) for (ll i = 0; i <= (ll)(n); ++i)
#define FOR(i, a, b) for (ll i = (a); i < (ll)(b); ++i)
#define EFOR(i, a, b) for (ll i = (a); i <= (ll)(b); ++i)
void chmax(ll &a, ll b) { a = max(a, b); }
void chmin(ll &a, ll b) { a = min(a, b); }
using P = pair<int, int>;
const int MAX_N = 1e5 + 5;
const int INF = 1001001001;
vector<int> a, ans;
int dp[MAX_N][3];
ll modnum = 1e9 + 7;
using Graph = vector<vector<int>>;
Graph to(MAX_N);
void dfs(int u, int count = 0, int rem = 2) {
if (rem == -1) {
count++;
rem = 2;
}
if (dp[u][2 - rem] <= count) {
return;
} else {
dp[u][2 - rem] = count;
}
for (auto v : to[u]) {
dfs(v, count, rem - 1);
}
}
int main() {
int n, m;
cin >> n >> m;
rep(i, m) {
int u, v;
cin >> u >> v;
u--;
v--;
to[u].push_back(v);
}
int s, t;
cin >> s >> t;
s--;
t--;
rep(i, MAX_N) rep(j, 3) dp[i][j] = INF;
dfs(s);
if (dp[t][0] == INF) {
cout << -1 << endl;
} else {
cout << dp[t][0] << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); ++i)
#define erep(i, n) for (ll i = 0; i <= (ll)(n); ++i)
#define FOR(i, a, b) for (ll i = (a); i < (ll)(b); ++i)
#define EFOR(i, a, b) for (ll i = (a); i <= (ll)(b); ++i)
void chmax(ll &a, ll b) { a = max(a, b); }
void chmin(ll &a, ll b) { a = min(a, b); }
using P = pair<int, int>;
const int MAX_N = 1e5 + 5;
const int INF = 1001001001;
vector<int> a, ans;
int dp[MAX_N][3];
ll modnum = 1e9 + 7;
using Graph = vector<vector<int>>;
Graph to(MAX_N);
void dfs(int u, int count = 0, int rem = 2) {
if (rem == -1) {
count++;
rem = 2;
}
if (dp[u][2 - rem] <= count) {
return;
} else {
dp[u][2 - rem] = count;
}
for (auto v : to[u]) {
dfs(v, count, rem - 1);
}
}
int main() {
int n, m;
cin >> n >> m;
rep(i, m) {
int u, v;
cin >> u >> v;
u--;
v--;
to[u].push_back(v);
}
int s, t;
cin >> s >> t;
s--;
t--;
rep(i, MAX_N) rep(j, 3) dp[i][j] = INF;
queue<P> que;
que.emplace(s, 0);
while (!que.empty()) {
P p = que.front();
que.pop();
if (dp[p.first][p.second % 3] > p.second / 3) {
dp[p.first][p.second % 3] = p.second / 3;
for (auto u : to[p.first]) {
que.emplace(u, p.second + 1);
}
}
}
if (dp[t][0] == INF) {
cout << -1 << endl;
} else {
cout << dp[t][0] << endl;
}
return 0;
}
| replace | 57 | 59 | 57 | 69 | TLE | |
p02991 | C++ | Runtime Error | #include <iostream>
#include <queue>
#include <vector>
using namespace std;
const int MAX = 1000000;
typedef pair<int, int> P;
int main() {
int N, M, S, T, u, v;
vector<int> vec[30000];
int ans[30000];
priority_queue<P, vector<P>, greater<P>> que;
P p;
cin >> N >> M;
for (int i = 0; i < M; i++) {
cin >> u >> v;
u--;
v--;
vec[u].push_back(v + N);
vec[u + N].push_back(v + 2 * N);
vec[u + 2 * N].push_back(v);
}
fill(ans, ans + 3 * N, MAX);
cin >> S >> T;
S--;
T--;
ans[S] = 0;
que.push(P(0, S));
while (!que.empty()) {
p = que.top();
que.pop();
for (int i : vec[p.second]) {
if (ans[i] > ans[p.second] + 1) {
ans[i] = ans[p.second] + 1;
que.push(P(ans[i], i));
}
}
}
if (ans[T] < MAX)
cout << ans[T] / 3;
else
cout << -1;
return 0;
} | #include <iostream>
#include <queue>
#include <vector>
using namespace std;
const int MAX = 1000000;
typedef pair<int, int> P;
int main() {
int N, M, S, T, u, v;
vector<int> vec[300000];
int ans[300000];
priority_queue<P, vector<P>, greater<P>> que;
P p;
cin >> N >> M;
for (int i = 0; i < M; i++) {
cin >> u >> v;
u--;
v--;
vec[u].push_back(v + N);
vec[u + N].push_back(v + 2 * N);
vec[u + 2 * N].push_back(v);
}
fill(ans, ans + 3 * N, MAX);
cin >> S >> T;
S--;
T--;
ans[S] = 0;
que.push(P(0, S));
while (!que.empty()) {
p = que.top();
que.pop();
for (int i : vec[p.second]) {
if (ans[i] > ans[p.second] + 1) {
ans[i] = ans[p.second] + 1;
que.push(P(ans[i], i));
}
}
}
if (ans[T] < MAX)
cout << ans[T] / 3;
else
cout << -1;
return 0;
} | replace | 8 | 10 | 8 | 10 | 0 | |
p02991 | C++ | Time Limit Exceeded | // #include<bits/stdc++.h>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define INF 1000000007
int main() {
long long n, m;
cin >> n >> m;
vector<long long> graph[3 * n + 1];
long long u, v;
for (int i = 0; i < m; i++) {
cin >> u >> v;
graph[u].push_back(v + n);
graph[u + n].push_back(v + 2 * n);
graph[u + 2 * n].push_back(v);
}
long long S, T;
cin >> S >> T;
long long num = 3 * n + 1;
long long dist[num];
for (int i = 0; i < num; i++) {
dist[i] = INF;
}
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
q;
q.push(make_pair(0, S));
while (!q.empty()) {
pair<long long, long long> now = q.top();
q.pop();
if (dist[T] != INF)
continue;
dist[now.second] = now.first;
for (int i = 0; i < graph[now.second].size(); i++) {
if (dist[graph[now.second][i]] == INF) {
q.push(make_pair(dist[now.second] + 1, graph[now.second][i]));
}
}
}
if (dist[T] == INF)
cout << -1 << endl;
else
cout << dist[T] / 3 << endl;
return 0;
}
| // #include<bits/stdc++.h>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define INF 1000000007
int main() {
long long n, m;
cin >> n >> m;
vector<long long> graph[3 * n + 1];
long long u, v;
for (int i = 0; i < m; i++) {
cin >> u >> v;
graph[u].push_back(v + n);
graph[u + n].push_back(v + 2 * n);
graph[u + 2 * n].push_back(v);
}
long long S, T;
cin >> S >> T;
long long num = 3 * n + 1;
long long dist[num];
for (int i = 0; i < num; i++) {
dist[i] = INF;
}
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
q;
q.push(make_pair(0, S));
while (!q.empty()) {
pair<long long, long long> now = q.top();
q.pop();
if (dist[now.second] != INF)
continue;
dist[now.second] = now.first;
for (int i = 0; i < graph[now.second].size(); i++) {
if (dist[graph[now.second][i]] == INF) {
q.push(make_pair(dist[now.second] + 1, graph[now.second][i]));
}
}
}
if (dist[T] == INF)
cout << -1 << endl;
else
cout << dist[T] / 3 << endl;
return 0;
} | replace | 44 | 45 | 44 | 45 | TLE | |
p02991 | C++ | Runtime Error | #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[20005][3];
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> to(n);
rep(i, m) {
int u, v;
cin >> u >> v;
u--;
v--;
to[u].push_back(v);
}
int s, t;
cin >> s >> t;
s--;
t--;
rep(i, n) rep(j, 3) dist[i][j] = INF;
dist[s][0] = 0;
queue<P> q;
q.push(P(s, 0));
while (!q.empty()) {
int a = q.front().first, b = q.front().second;
q.pop();
for (auto c : to[a]) {
int nl = (1 + b) % 3;
if (dist[c][nl] != INF)
continue;
dist[c][nl] = dist[a][b] + 1;
q.push(P(c, nl));
}
}
int ans = dist[t][0];
if (ans == INF) {
puts("-1");
return 0;
}
cout << ans / 3 << endl;
} | #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 u, v;
cin >> u >> v;
u--;
v--;
to[u].push_back(v);
}
int s, t;
cin >> s >> t;
s--;
t--;
rep(i, n) rep(j, 3) dist[i][j] = INF;
dist[s][0] = 0;
queue<P> q;
q.push(P(s, 0));
while (!q.empty()) {
int a = q.front().first, b = q.front().second;
q.pop();
for (auto c : to[a]) {
int nl = (1 + b) % 3;
if (dist[c][nl] != INF)
continue;
dist[c][nl] = dist[a][b] + 1;
q.push(P(c, nl));
}
}
int ans = dist[t][0];
if (ans == INF) {
puts("-1");
return 0;
}
cout << ans / 3 << endl;
} | replace | 6 | 7 | 6 | 7 | 0 | |
p02991 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#include <stdio.h>
using namespace std;
#define inputInt(a) \
int a; \
cin >> a;
#define inputInt2(a, b) \
int a; \
int b; \
cin >> a >> b;
#define inputInt3(a, b, c) \
int a; \
int b; \
int c; \
cin >> a >> b >> c;
#define inputLong(a) \
long a; \
cin >> a;
#define inputIntArray(a, N) \
int a[N]; \
for (int i = 0; i < N; i++) { \
cin >> a[i]; \
}
#define inputLongArray(a, N) \
long a[N]; \
for (int i = 0; i < N; i++) { \
cin >> a[i]; \
}
#define inputIntArray2(a, b, N) \
int a[N]; \
int b[N]; \
for (int i = 0; i < N; i++) { \
cin >> a[i] >> b[i]; \
}
#define output(answer) cout << answer << endl;
#define fN(i, N) for (int i = 0; i < N; i++)
#define fSE(i, s, e) for (int i = s; i <= e; i++)
#define ll long long
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second
#define FOR(i, N) for (int i = 0; i < N; i++)
#define cinv(v, N) \
vector<int> v(N); \
for (int i = 0; i < N; i++) { \
cin >> v[i]; \
}
#define mt make_tuple
#define vll vector<long long int>
#define vvll vector<vector<long long int>>
#define all(v) (v).begin(), (v).end()
#define show(v) \
FOR(i, v.size()) { cout << v[i] << " "; } \
cout << endl;
#define showshow(v) \
FOR(i, v.size()) { \
FOR(j, v[i].size()) { cout << v[i][j] << " "; } \
cout << endl; \
}
const ll MOD = 1e9 + 7;
const ll MOD2 = 998244353;
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;
}
// Combination計算 //ComInitしないと何もできません。
const int LIMIT = 1e6; // 1e6→50ms,1e7→500ms,1e8→5000ms程度。
// const ll MOD = 1e9+7;
vector<ll> FacMod(LIMIT), InvMod(LIMIT), FacInvMod(LIMIT);
const int dpComTableLIMIT = 3e3 + 1;
vector<vector<ll>> Com(dpComTableLIMIT, vector<ll>(dpComTableLIMIT, 0));
const int ComKTableLIMIT = 1e7;
vector<ll> ComK(ComKTableLIMIT);
void DPComInit() {
// Com[0][j]は0で初期化されている。
for (int i = 0; i < dpComTableLIMIT; i++) {
Com[i][0] = 1;
}
for (int i = 1; i < dpComTableLIMIT; i++) {
for (int j = 1; j < dpComTableLIMIT; j++) {
Com[i][j] = (Com[i - 1][j - 1] + Com[i - 1][j]) % MOD;
}
}
}
void ComKInit(ll N) {
for (int i = 0; i <= ComKTableLIMIT; i++) {
if (0 < i && i <= N / 2) {
ComK[i] = (ComK[i - 1] * (N - i + 1) / i) % MOD;
} else if (i == 0) {
ComK[i] = 1;
} else if (N / 2 < i && i <= N) {
ComK[i] = ComK[N - i];
} else { // i>Nの時
ComK[i] = -1;
}
}
}
void ComInit() { // tableを作成
FacMod[0] = FacMod[1] = 1;
InvMod[0] = 0;
InvMod[1] = 1; // InvMod[0]は定義できない
FacInvMod[0] = FacInvMod[1] = 1;
for (int i = 2; i < LIMIT; i++) {
FacMod[i] = FacMod[i - 1] * i % MOD;
InvMod[i] = -InvMod[MOD % i] * (MOD / i) % MOD + MOD;
FacInvMod[i] = FacInvMod[i - 1] * InvMod[i] % MOD;
}
}
ll ComMod(int n, int k) {
if (n >= 0 && k >= 0 && n >= k) {
return FacMod[n] * (FacInvMod[k] * FacInvMod[n - k] % MOD) % MOD;
} else {
return 0; // 戻り値を0にする方が計算結果に影響が少ない。
}
}
// 繰り返し2乗法
ll power(ll x, ll y) { // 繰り返し2乗法
if (y < 0) {
return 0;
} else if (y == 0) {
return 1LL;
} else if (y % 2 == 0) { // 偶数
return power(x, y / 2) * power(x, y / 2);
} else { // 奇数
return power(x, y - 1) * x;
}
}
// 繰り返し2乗法
ll mpower(ll x, ll y, ll m) { // 繰り返し2乗法
if (y < 0) {
return 0;
} else if (y == 0) {
return 1LL;
} else if (y % 2 == 0) { // 偶数
return mpower(x, y / 2, m) * mpower(x, y / 2, m) % m;
} else { // 奇数
return mpower(x, y - 1, m) * x % m;
}
}
// 互除法
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; }
// 素因数分解
pair<map<ll, ll>, bool> PrimeFactorization(ll N) {
pair<map<ll, ll>, bool> ret; //<素因数分解,素数判定>
ret.second = true;
// 素因数分解
if (N != 2) {
while (N % 2 == 0) { // p=2の時。
N /= 2;
ret.first[2]++;
ret.second = false;
}
}
for (ll i = 3; i * i <= N; i += 2) { // p>=3の時。
while (N % i == 0) {
N /= i;
ret.first[i]++;
ret.second = false;
}
}
if (N != 1) { // Nが素数の時
ret.first[N]++;
}
// 返り値
return ret;
}
// pair型のソート
bool compare_by_second(pair<ll, ll> a, pair<ll, ll> b) {
return a.second != b.second ? a.second < b.second : a.first < b.first;
}
class UnionFind {
vector<int> parent;
vector<int> rank;
vector<int> size;
public:
UnionFind(int N);
int root(int x);
void unite(int x, int y);
bool isUnited(int x, int y);
int getRank(int x);
int getSize(int x);
};
UnionFind::UnionFind(int N) : parent(N), rank(N, 1), size(N, 1) {
for (int i = 0; i < N; i++) {
parent[i] = i;
}
}
int UnionFind::root(int x) {
if (parent[x] == x)
return x;
return root(parent[x]);
/*parent[x] = parent[parent[x]];
if(parent[x]!=parent[parent[x]]) rank[x]-=1;*/
}
void UnionFind::unite(int x, int y) { // xとyの木を併合
int rx = root(x); // xの根をrx
int ry = root(y); // yの根をry
// cout << x << " " << y << " " << parent[x] << " " << parent[y] << endl;
if (rx == ry)
return; // xとyの根が同じ(=同じ木にある)時はそのまま
ll xs = size[root(x)];
ll ys = size[root(y)];
size[root(x)] += ys;
size[root(y)] += xs;
// cout << x << " " << y << " " << size[root(x)] << " " << size[root(y)] <<
// endl;
if (rank[x] >= rank[y]) {
parent[ry] = rx;
rank[y] += 1;
} // 大きい木に小さい木が併合される
else {
parent[rx] = ry;
rank[x] += 1;
} // 根に直接辺を張る
}
bool UnionFind::isUnited(
int x, int y) { // 2つのデータx, yが属する木が同じならtrueを返す
int rx = root(x);
int ry = root(y);
parent[x] = rx;
parent[y] = ry;
rank[x] = 2;
rank[y] = 2;
return rx == ry;
}
int UnionFind::getRank(int x) { return rank[x]; }
int UnionFind::getSize(int x) { return size[root(x)]; }
bool isOK(ll condition) {
// return false;
return true;
}
ll binary_search() {
// 最小値を求める時
ll ok = 1e18; // 解が存在する最大値
ll ng = -1; // 解が存在しない最小値
/*
//最大値を求める時
ll ok = -1;//解が存在する最小値
ll ng = 1e18;//解が存在しない最大値
*/
while (abs(ok - ng) > 1) {
ll mid = (ok + ng) / 2;
if (isOK(mid)) {
ok = mid;
} else {
ng = mid;
}
}
return ok;
}
int main() {
// input
cin.tie(0);
ios::sync_with_stdio(false);
ll N, M;
cin >> N >> M;
vector<vector<ll>> graph(3 * N);
vector<ll> u(M), v(M);
FOR(i, M) {
ll from, to;
cin >> from >> to;
from--;
to--;
u[i] = from;
v[i] = to;
graph[3 * from].pb(3 * to + 1);
graph[3 * from + 1].pb(3 * to + 2);
graph[3 * from + 2].pb(3 * to);
}
ll S, T;
cin >> S >> T;
S--;
T--;
// main
// bfs
vector<bool> isSearched(3 * N, false);
vector<ll> dist(3 * N, 1e9);
queue<ll> q;
q.push(3 * S);
dist[3 * S] = 0;
while (!q.empty()) {
ll now = q.front();
q.pop();
// if(isSearched[now])continue;
isSearched[now] = true;
for (auto next : graph[now]) {
if (isSearched[next])
continue;
if (dist[next] > dist[now] + 1)
dist[next] = dist[now] + 1;
q.push(next);
}
}
ll ans = 0;
if (dist[3 * T] == 1e9) {
ans = -1;
} else {
ans = dist[3 * T] / 3;
}
// output
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <stdio.h>
using namespace std;
#define inputInt(a) \
int a; \
cin >> a;
#define inputInt2(a, b) \
int a; \
int b; \
cin >> a >> b;
#define inputInt3(a, b, c) \
int a; \
int b; \
int c; \
cin >> a >> b >> c;
#define inputLong(a) \
long a; \
cin >> a;
#define inputIntArray(a, N) \
int a[N]; \
for (int i = 0; i < N; i++) { \
cin >> a[i]; \
}
#define inputLongArray(a, N) \
long a[N]; \
for (int i = 0; i < N; i++) { \
cin >> a[i]; \
}
#define inputIntArray2(a, b, N) \
int a[N]; \
int b[N]; \
for (int i = 0; i < N; i++) { \
cin >> a[i] >> b[i]; \
}
#define output(answer) cout << answer << endl;
#define fN(i, N) for (int i = 0; i < N; i++)
#define fSE(i, s, e) for (int i = s; i <= e; i++)
#define ll long long
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second
#define FOR(i, N) for (int i = 0; i < N; i++)
#define cinv(v, N) \
vector<int> v(N); \
for (int i = 0; i < N; i++) { \
cin >> v[i]; \
}
#define mt make_tuple
#define vll vector<long long int>
#define vvll vector<vector<long long int>>
#define all(v) (v).begin(), (v).end()
#define show(v) \
FOR(i, v.size()) { cout << v[i] << " "; } \
cout << endl;
#define showshow(v) \
FOR(i, v.size()) { \
FOR(j, v[i].size()) { cout << v[i][j] << " "; } \
cout << endl; \
}
const ll MOD = 1e9 + 7;
const ll MOD2 = 998244353;
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;
}
// Combination計算 //ComInitしないと何もできません。
const int LIMIT = 1e6; // 1e6→50ms,1e7→500ms,1e8→5000ms程度。
// const ll MOD = 1e9+7;
vector<ll> FacMod(LIMIT), InvMod(LIMIT), FacInvMod(LIMIT);
const int dpComTableLIMIT = 3e3 + 1;
vector<vector<ll>> Com(dpComTableLIMIT, vector<ll>(dpComTableLIMIT, 0));
const int ComKTableLIMIT = 1e7;
vector<ll> ComK(ComKTableLIMIT);
void DPComInit() {
// Com[0][j]は0で初期化されている。
for (int i = 0; i < dpComTableLIMIT; i++) {
Com[i][0] = 1;
}
for (int i = 1; i < dpComTableLIMIT; i++) {
for (int j = 1; j < dpComTableLIMIT; j++) {
Com[i][j] = (Com[i - 1][j - 1] + Com[i - 1][j]) % MOD;
}
}
}
void ComKInit(ll N) {
for (int i = 0; i <= ComKTableLIMIT; i++) {
if (0 < i && i <= N / 2) {
ComK[i] = (ComK[i - 1] * (N - i + 1) / i) % MOD;
} else if (i == 0) {
ComK[i] = 1;
} else if (N / 2 < i && i <= N) {
ComK[i] = ComK[N - i];
} else { // i>Nの時
ComK[i] = -1;
}
}
}
void ComInit() { // tableを作成
FacMod[0] = FacMod[1] = 1;
InvMod[0] = 0;
InvMod[1] = 1; // InvMod[0]は定義できない
FacInvMod[0] = FacInvMod[1] = 1;
for (int i = 2; i < LIMIT; i++) {
FacMod[i] = FacMod[i - 1] * i % MOD;
InvMod[i] = -InvMod[MOD % i] * (MOD / i) % MOD + MOD;
FacInvMod[i] = FacInvMod[i - 1] * InvMod[i] % MOD;
}
}
ll ComMod(int n, int k) {
if (n >= 0 && k >= 0 && n >= k) {
return FacMod[n] * (FacInvMod[k] * FacInvMod[n - k] % MOD) % MOD;
} else {
return 0; // 戻り値を0にする方が計算結果に影響が少ない。
}
}
// 繰り返し2乗法
ll power(ll x, ll y) { // 繰り返し2乗法
if (y < 0) {
return 0;
} else if (y == 0) {
return 1LL;
} else if (y % 2 == 0) { // 偶数
return power(x, y / 2) * power(x, y / 2);
} else { // 奇数
return power(x, y - 1) * x;
}
}
// 繰り返し2乗法
ll mpower(ll x, ll y, ll m) { // 繰り返し2乗法
if (y < 0) {
return 0;
} else if (y == 0) {
return 1LL;
} else if (y % 2 == 0) { // 偶数
return mpower(x, y / 2, m) * mpower(x, y / 2, m) % m;
} else { // 奇数
return mpower(x, y - 1, m) * x % m;
}
}
// 互除法
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; }
// 素因数分解
pair<map<ll, ll>, bool> PrimeFactorization(ll N) {
pair<map<ll, ll>, bool> ret; //<素因数分解,素数判定>
ret.second = true;
// 素因数分解
if (N != 2) {
while (N % 2 == 0) { // p=2の時。
N /= 2;
ret.first[2]++;
ret.second = false;
}
}
for (ll i = 3; i * i <= N; i += 2) { // p>=3の時。
while (N % i == 0) {
N /= i;
ret.first[i]++;
ret.second = false;
}
}
if (N != 1) { // Nが素数の時
ret.first[N]++;
}
// 返り値
return ret;
}
// pair型のソート
bool compare_by_second(pair<ll, ll> a, pair<ll, ll> b) {
return a.second != b.second ? a.second < b.second : a.first < b.first;
}
class UnionFind {
vector<int> parent;
vector<int> rank;
vector<int> size;
public:
UnionFind(int N);
int root(int x);
void unite(int x, int y);
bool isUnited(int x, int y);
int getRank(int x);
int getSize(int x);
};
UnionFind::UnionFind(int N) : parent(N), rank(N, 1), size(N, 1) {
for (int i = 0; i < N; i++) {
parent[i] = i;
}
}
int UnionFind::root(int x) {
if (parent[x] == x)
return x;
return root(parent[x]);
/*parent[x] = parent[parent[x]];
if(parent[x]!=parent[parent[x]]) rank[x]-=1;*/
}
void UnionFind::unite(int x, int y) { // xとyの木を併合
int rx = root(x); // xの根をrx
int ry = root(y); // yの根をry
// cout << x << " " << y << " " << parent[x] << " " << parent[y] << endl;
if (rx == ry)
return; // xとyの根が同じ(=同じ木にある)時はそのまま
ll xs = size[root(x)];
ll ys = size[root(y)];
size[root(x)] += ys;
size[root(y)] += xs;
// cout << x << " " << y << " " << size[root(x)] << " " << size[root(y)] <<
// endl;
if (rank[x] >= rank[y]) {
parent[ry] = rx;
rank[y] += 1;
} // 大きい木に小さい木が併合される
else {
parent[rx] = ry;
rank[x] += 1;
} // 根に直接辺を張る
}
bool UnionFind::isUnited(
int x, int y) { // 2つのデータx, yが属する木が同じならtrueを返す
int rx = root(x);
int ry = root(y);
parent[x] = rx;
parent[y] = ry;
rank[x] = 2;
rank[y] = 2;
return rx == ry;
}
int UnionFind::getRank(int x) { return rank[x]; }
int UnionFind::getSize(int x) { return size[root(x)]; }
bool isOK(ll condition) {
// return false;
return true;
}
ll binary_search() {
// 最小値を求める時
ll ok = 1e18; // 解が存在する最大値
ll ng = -1; // 解が存在しない最小値
/*
//最大値を求める時
ll ok = -1;//解が存在する最小値
ll ng = 1e18;//解が存在しない最大値
*/
while (abs(ok - ng) > 1) {
ll mid = (ok + ng) / 2;
if (isOK(mid)) {
ok = mid;
} else {
ng = mid;
}
}
return ok;
}
int main() {
// input
cin.tie(0);
ios::sync_with_stdio(false);
ll N, M;
cin >> N >> M;
vector<vector<ll>> graph(3 * N);
vector<ll> u(M), v(M);
FOR(i, M) {
ll from, to;
cin >> from >> to;
from--;
to--;
u[i] = from;
v[i] = to;
graph[3 * from].pb(3 * to + 1);
graph[3 * from + 1].pb(3 * to + 2);
graph[3 * from + 2].pb(3 * to);
}
ll S, T;
cin >> S >> T;
S--;
T--;
// main
// bfs
vector<bool> isSearched(3 * N, false);
vector<ll> dist(3 * N, 1e9);
queue<ll> q;
q.push(3 * S);
dist[3 * S] = 0;
while (!q.empty()) {
ll now = q.front();
q.pop();
if (isSearched[now])
continue;
isSearched[now] = true;
for (auto next : graph[now]) {
if (isSearched[next])
continue;
if (dist[next] > dist[now] + 1)
dist[next] = dist[now] + 1;
q.push(next);
}
}
ll ans = 0;
if (dist[3 * T] == 1e9) {
ans = -1;
} else {
ans = dist[3 * T] / 3;
}
// output
cout << ans << endl;
return 0;
}
| replace | 329 | 330 | 329 | 331 | TLE | |
p02991 | C++ | Time Limit Exceeded | #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;
}
| replace | 207 | 208 | 207 | 208 | TLE | |
p02991 | C++ | Time Limit Exceeded | // #include <atcoder/all>
#include <bits/stdc++.h>
using namespace std;
// using namespace atcoder;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repr(i, n) for (int i = (n - 1); i >= 0; --i)
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 long long ll;
typedef pair<int, int> P;
const int MAX = 100005;
const ll INF = 1001001001001001001;
const int MOD = 1000000007;
vector<int> G[MAX];
ll dp[MAX][3];
int main() {
int N, M;
cin >> N >> M;
rep(i, M) {
int u, v;
cin >> u >> v;
u--, v--;
G[u].emplace_back(v);
}
int S, T;
cin >> S >> T;
S--, T--;
rep(i, N) rep(j, 3) dp[i][j] = INF;
priority_queue<tuple<ll, int, int>> q;
dp[S][0] = 0;
q.emplace(0, S, 0);
while (q.size()) {
auto [d, n, c] = q.top();
q.pop();
if (dp[n][c] < d)
continue;
for (auto next : G[n]) {
int nc = c + 1;
if (nc < 3) {
if (chmin(dp[next][nc], d)) {
q.emplace(d, next, nc);
}
} else {
if (chmin(dp[next][0], d + 1)) {
q.emplace(d + 1, next, 0);
}
}
}
}
ll ans = dp[T][0];
if (ans == INF)
ans = -1;
cout << ans << endl;
} | // #include <atcoder/all>
#include <bits/stdc++.h>
using namespace std;
// using namespace atcoder;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repr(i, n) for (int i = (n - 1); i >= 0; --i)
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 long long ll;
typedef pair<int, int> P;
const int MAX = 100005;
const ll INF = 1001001001001001001;
const int MOD = 1000000007;
vector<int> G[MAX];
ll dp[MAX][3];
int main() {
int N, M;
cin >> N >> M;
rep(i, M) {
int u, v;
cin >> u >> v;
u--, v--;
G[u].emplace_back(v);
}
int S, T;
cin >> S >> T;
S--, T--;
rep(i, N) rep(j, 3) dp[i][j] = INF;
priority_queue<tuple<ll, int, int>, vector<tuple<ll, int, int>>,
greater<tuple<ll, int, int>>>
q;
dp[S][0] = 0;
q.emplace(0, S, 0);
while (q.size()) {
auto [d, n, c] = q.top();
q.pop();
if (dp[n][c] < d)
continue;
for (auto next : G[n]) {
int nc = c + 1;
if (nc < 3) {
if (chmin(dp[next][nc], d)) {
q.emplace(d, next, nc);
}
} else {
if (chmin(dp[next][0], d + 1)) {
q.emplace(d + 1, next, 0);
}
}
}
}
ll ans = dp[T][0];
if (ans == INF)
ans = -1;
cout << ans << endl;
} | replace | 50 | 51 | 50 | 53 | TLE | |
p02991 | C++ | Runtime Error | /*
* じょえチャンネル
* 高評価・チャンネル登録よろしくおねがいします！
* https://www.youtube.com/channel/UCRXsI3FL_kvaVL9zoolBfbQ
*/
#include <bits/stdc++.h>
#define f(i, n) for (int i = 0; i < (n); i++)
#define inf (int)(3e18)
#define int long long
#define mod (int)(1000000007)
#define intt long long
#define P pair<int, int>
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n) for (int i = 1; i <= n; i++)
using namespace std;
// Library
// モッドパウ
int modpow(int x, int y, int m = mod) {
int res = 1;
while (y) {
if (y % 2) {
res *= x;
res %= m;
}
x = x * x % mod;
y /= 2;
}
return res;
}
int mypow(int x, int y) {
int res = 1;
while (y) {
if (y % 2) {
res *= x;
}
x = x * x;
y /= 2;
}
return res;
}
// is the number (x) a prime number?
bool prime(int x) {
for (int i = 2; i * i <= x; i++) {
if (!(x % i)) {
return false;
}
}
return true;
}
// saidai-kouyakusuu
inline int gcd(int x, int y) {
if (!y) {
return x;
}
return gcd(y, x % y);
}
// number of keta
int keta(int x) {
int ans = 0;
while (x) {
x /= 10;
ans++;
}
return ans;
}
// sum of keta
int ketasum(int x) {
int ans = 0;
while (x) {
ans += x % 10;
x /= 10;
}
return ans;
}
inline int lcm(int x, int y) {
int ans = x / gcd(x, y) * y;
return ans;
}
int twobeki(int x) {
int ans = 0;
while (1) {
if (!(x & 1)) {
ans++;
x /= 2;
} else {
break;
}
}
return ans;
}
template <class T, class U> inline bool chmax(T &lhs, const U &rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U> inline bool chmin(T &lhs, const U &rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
void Yes() { cout << "Yes" << endl; }
void No() { cout << "No" << endl; }
void YES() { cout << "YES" << endl; }
void NO() { cout << "NO" << endl; }
#define fin(i) scanf("%lld", &i)
#define fout(i) printf("%lld", i)
#define fendl printf("\n")
// Library-End
// SegTree
template <class T> class LazySegTree {
int n; // 葉の数
vector<T> data; // データを格納するvector
vector<T> lazy;
T def; // 初期値かつ単位元
function<T(T, T)> operation; // 区間クエリで使う処理
function<T(T, T)> update; // 点更新で使う処理
// 区間[a,b)の総和。ノードk=[l,r)に着目している。
T _query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return def; // 交差しない
if (a <= l && r <= b)
return data[k]; // a,l,r,bの順で完全に含まれる
else {
T c1 = _query(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
T c2 = _query(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
return operation(c1, c2);
}
}
public:
// _n:必要サイズ, _def:初期値かつ単位元, _operation:クエリ関数,
// _update:更新関数
LazySegTree(size_t _n, T _def, function<T(T, T)> _operation,
function<T(T, T)> _update)
: def(_def), operation(_operation), update(_update) {
n = 1;
while (n < _n) {
n *= 2;
}
data = vector<T>(2 * n - 1, def);
}
// 場所i(0-indexed)の値をxで更新
void change(int i, T x) {
i += n - 1;
data[i] = update(data[i], x);
while (i > 0) {
i = (i - 1) / 2;
data[i] = operation(data[i * 2 + 1], data[i * 2 + 2]);
}
}
void change(int i, int j, T x) {
i += n - 1;
data[i] = update(data[i], x);
while (i > 0) {
i = (i - 1) / 2;
data[i] = operation(data[i * 2 + 1], data[i * 2 + 2]);
}
}
// [a, b)の区間クエリを実行
T query(int a, int b) { return _query(a, b, 0, 0, n); }
// 添字でアクセス
T operator[](int i) { return data[i + n - 1]; }
};
#define R_MIN ([](long long a, long long b) { return min(a, b); })
#define R_MAX ([](long long a, long long b) { return max(a, b); })
#define R_SUM ([](long long a, long long b) { return a + b; })
#define NORMAL_UPDATE ([](long long a, long long b) { return b; })
#define ADD_UPDATE ([](long long a, long long b) { return a + b; })
#define MINUS_UPDATE ([](long long a, long long b) { return a - b; }
class Union_Find {
vector<int> par;
vector<int> rankmy;
public:
Union_Find(int size) {
par = vector<int>(size);
rankmy = vector<int>(size);
for (int i = 0; i < size; i++) {
par[i] = i;
}
}
int find(int x) {
if (par[x] == x) {
return x;
}
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) {
return;
}
if (rankmy[x] < rankmy[y]) {
par[x] = y;
} else {
par[y] = x;
if (rankmy[x] == rankmy[y]) {
rankmy[x]++;
}
}
}
bool same(int x, int y) { return find(x) == find(y); }
};
// Union-Find-End
int n, m, u, v, s, t, kyo[100004];
bool went[100004];
vector<int> road[100004];
signed main() {
cin >> n >> m;
rep(i, m) {
fin(u);
fin(v);
road[u * 3].push_back(v * 3 + 1);
road[u * 3 + 1].push_back(v * 3 + 2);
road[u * 3 + 2].push_back(v * 3);
}
cin >> s >> t;
queue<P> q;
q.push({s * 3, 0});
while (!q.empty()) {
P top = q.front();
rep(i, road[top.first].size()) {
if (!went[road[top.first][i]]) {
went[road[top.first][i]] = 1;
kyo[road[top.first][i]] = top.second + 1;
q.push({road[top.first][i], top.second + 1});
}
}
q.pop();
}
if (!kyo[t * 3]) {
cout << -1 << endl;
} else {
cout << kyo[t * 3] / 3 << endl;
}
}
| /*
* じょえチャンネル
* 高評価・チャンネル登録よろしくおねがいします！
* https://www.youtube.com/channel/UCRXsI3FL_kvaVL9zoolBfbQ
*/
#include <bits/stdc++.h>
#define f(i, n) for (int i = 0; i < (n); i++)
#define inf (int)(3e18)
#define int long long
#define mod (int)(1000000007)
#define intt long long
#define P pair<int, int>
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n) for (int i = 1; i <= n; i++)
using namespace std;
// Library
// モッドパウ
int modpow(int x, int y, int m = mod) {
int res = 1;
while (y) {
if (y % 2) {
res *= x;
res %= m;
}
x = x * x % mod;
y /= 2;
}
return res;
}
int mypow(int x, int y) {
int res = 1;
while (y) {
if (y % 2) {
res *= x;
}
x = x * x;
y /= 2;
}
return res;
}
// is the number (x) a prime number?
bool prime(int x) {
for (int i = 2; i * i <= x; i++) {
if (!(x % i)) {
return false;
}
}
return true;
}
// saidai-kouyakusuu
inline int gcd(int x, int y) {
if (!y) {
return x;
}
return gcd(y, x % y);
}
// number of keta
int keta(int x) {
int ans = 0;
while (x) {
x /= 10;
ans++;
}
return ans;
}
// sum of keta
int ketasum(int x) {
int ans = 0;
while (x) {
ans += x % 10;
x /= 10;
}
return ans;
}
inline int lcm(int x, int y) {
int ans = x / gcd(x, y) * y;
return ans;
}
int twobeki(int x) {
int ans = 0;
while (1) {
if (!(x & 1)) {
ans++;
x /= 2;
} else {
break;
}
}
return ans;
}
template <class T, class U> inline bool chmax(T &lhs, const U &rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U> inline bool chmin(T &lhs, const U &rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
void Yes() { cout << "Yes" << endl; }
void No() { cout << "No" << endl; }
void YES() { cout << "YES" << endl; }
void NO() { cout << "NO" << endl; }
#define fin(i) scanf("%lld", &i)
#define fout(i) printf("%lld", i)
#define fendl printf("\n")
// Library-End
// SegTree
template <class T> class LazySegTree {
int n; // 葉の数
vector<T> data; // データを格納するvector
vector<T> lazy;
T def; // 初期値かつ単位元
function<T(T, T)> operation; // 区間クエリで使う処理
function<T(T, T)> update; // 点更新で使う処理
// 区間[a,b)の総和。ノードk=[l,r)に着目している。
T _query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return def; // 交差しない
if (a <= l && r <= b)
return data[k]; // a,l,r,bの順で完全に含まれる
else {
T c1 = _query(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
T c2 = _query(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
return operation(c1, c2);
}
}
public:
// _n:必要サイズ, _def:初期値かつ単位元, _operation:クエリ関数,
// _update:更新関数
LazySegTree(size_t _n, T _def, function<T(T, T)> _operation,
function<T(T, T)> _update)
: def(_def), operation(_operation), update(_update) {
n = 1;
while (n < _n) {
n *= 2;
}
data = vector<T>(2 * n - 1, def);
}
// 場所i(0-indexed)の値をxで更新
void change(int i, T x) {
i += n - 1;
data[i] = update(data[i], x);
while (i > 0) {
i = (i - 1) / 2;
data[i] = operation(data[i * 2 + 1], data[i * 2 + 2]);
}
}
void change(int i, int j, T x) {
i += n - 1;
data[i] = update(data[i], x);
while (i > 0) {
i = (i - 1) / 2;
data[i] = operation(data[i * 2 + 1], data[i * 2 + 2]);
}
}
// [a, b)の区間クエリを実行
T query(int a, int b) { return _query(a, b, 0, 0, n); }
// 添字でアクセス
T operator[](int i) { return data[i + n - 1]; }
};
#define R_MIN ([](long long a, long long b) { return min(a, b); })
#define R_MAX ([](long long a, long long b) { return max(a, b); })
#define R_SUM ([](long long a, long long b) { return a + b; })
#define NORMAL_UPDATE ([](long long a, long long b) { return b; })
#define ADD_UPDATE ([](long long a, long long b) { return a + b; })
#define MINUS_UPDATE ([](long long a, long long b) { return a - b; }
class Union_Find {
vector<int> par;
vector<int> rankmy;
public:
Union_Find(int size) {
par = vector<int>(size);
rankmy = vector<int>(size);
for (int i = 0; i < size; i++) {
par[i] = i;
}
}
int find(int x) {
if (par[x] == x) {
return x;
}
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) {
return;
}
if (rankmy[x] < rankmy[y]) {
par[x] = y;
} else {
par[y] = x;
if (rankmy[x] == rankmy[y]) {
rankmy[x]++;
}
}
}
bool same(int x, int y) { return find(x) == find(y); }
};
// Union-Find-End
int n, m, u, v, s, t, kyo[300004];
bool went[300004];
vector<int> road[300004];
signed main() {
cin >> n >> m;
rep(i, m) {
fin(u);
fin(v);
road[u * 3].push_back(v * 3 + 1);
road[u * 3 + 1].push_back(v * 3 + 2);
road[u * 3 + 2].push_back(v * 3);
}
cin >> s >> t;
queue<P> q;
q.push({s * 3, 0});
while (!q.empty()) {
P top = q.front();
rep(i, road[top.first].size()) {
if (!went[road[top.first][i]]) {
went[road[top.first][i]] = 1;
kyo[road[top.first][i]] = top.second + 1;
q.push({road[top.first][i], top.second + 1});
}
}
q.pop();
}
if (!kyo[t * 3]) {
cout << -1 << endl;
} else {
cout << kyo[t * 3] / 3 << endl;
}
}
| replace | 234 | 237 | 234 | 237 | 0 | |
p02991 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const ll mod = 1e9 + 7;
const ll MAXN = 2e3 + 5;
vector<vector<ll>> adj(MAXN, vector<ll>());
vector<vector<ll>> d(MAXN, vector<ll>(3, LLONG_MAX));
vector<bool> used(MAXN, false);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
ll u, v;
cin >> u >> v;
adj[u].push_back(v);
}
ll st, t;
cin >> st >> t;
d[st][0] = 0;
set<pair<vector<ll>, ll>> s;
s.insert({d[st], st});
while (!s.empty()) {
ll u = s.begin()->second;
s.erase(s.begin());
for (auto to : adj[u]) {
if (d[u][0] != LLONG_MAX && d[to][1] > d[u][0] + 1) {
s.erase({d[to], to});
d[to][1] = d[u][0] + 1;
s.insert({d[to], to});
}
if (d[u][1] != LLONG_MAX && d[to][2] > d[u][1] + 1) {
s.erase({d[to], to});
d[to][2] = d[u][1] + 1;
s.insert({d[to], to});
}
if (d[u][2] != LLONG_MAX && d[to][0] > d[u][2] + 1) {
s.erase({d[to], to});
d[to][0] = d[u][2] + 1;
s.insert({d[to], to});
}
}
}
if (d[t][0] == LLONG_MAX)
cout << -1 << endl;
else
cout << d[t][0] / 3 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const ll mod = 1e9 + 7;
const ll MAXN = 1e5 + 5;
vector<vector<ll>> adj(MAXN, vector<ll>());
vector<vector<ll>> d(MAXN, vector<ll>(3, LLONG_MAX));
vector<bool> used(MAXN, false);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
ll u, v;
cin >> u >> v;
adj[u].push_back(v);
}
ll st, t;
cin >> st >> t;
d[st][0] = 0;
set<pair<vector<ll>, ll>> s;
s.insert({d[st], st});
while (!s.empty()) {
ll u = s.begin()->second;
s.erase(s.begin());
for (auto to : adj[u]) {
if (d[u][0] != LLONG_MAX && d[to][1] > d[u][0] + 1) {
s.erase({d[to], to});
d[to][1] = d[u][0] + 1;
s.insert({d[to], to});
}
if (d[u][1] != LLONG_MAX && d[to][2] > d[u][1] + 1) {
s.erase({d[to], to});
d[to][2] = d[u][1] + 1;
s.insert({d[to], to});
}
if (d[u][2] != LLONG_MAX && d[to][0] > d[u][2] + 1) {
s.erase({d[to], to});
d[to][0] = d[u][2] + 1;
s.insert({d[to], to});
}
}
}
if (d[t][0] == LLONG_MAX)
cout << -1 << endl;
else
cout << d[t][0] / 3 << endl;
}
| replace | 7 | 8 | 7 | 8 | 0 | |
p02991 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cmath>
#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 <utility>
#include <vector>
using namespace std;
#define MAX 100000
#define INF 2140000000
#define MOD 1000000007
int bfs(vector<vector<int>> &adj, int s, int t) {
vector<int> d(adj.size(), MAX);
int flag[MAX] = {0};
queue<int> q;
flag[s] = 1;
d[s] = 0;
q.push(s);
while (!q.empty()) {
int u = q.front();
if (u == t) {
return d[u] / 3;
}
q.pop();
for (int i = 0; i < adj[u].size(); ++i) {
int v = adj[u][i];
if (!flag[v]) {
flag[v] = 1;
d[v] = d[u] + 1;
q.push(v);
}
}
}
return -1;
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> adj(3 * n);
int u, v;
for (int i = 0; i < m; ++i) {
cin >> u >> v;
u--;
v--;
adj[u].push_back(v + n);
adj[u + n].push_back(v + 2 * n);
adj[u + 2 * n].push_back(v);
}
int s, t;
cin >> s >> t;
cout << bfs(adj, s - 1, t - 1) << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#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 <utility>
#include <vector>
using namespace std;
#define MAX 300000
#define INF 2140000000
#define MOD 1000000007
int bfs(vector<vector<int>> &adj, int s, int t) {
vector<int> d(adj.size(), MAX);
int flag[MAX] = {0};
queue<int> q;
flag[s] = 1;
d[s] = 0;
q.push(s);
while (!q.empty()) {
int u = q.front();
if (u == t) {
return d[u] / 3;
}
q.pop();
for (int i = 0; i < adj[u].size(); ++i) {
int v = adj[u][i];
if (!flag[v]) {
flag[v] = 1;
d[v] = d[u] + 1;
q.push(v);
}
}
}
return -1;
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> adj(3 * n);
int u, v;
for (int i = 0; i < m; ++i) {
cin >> u >> v;
u--;
v--;
adj[u].push_back(v + n);
adj[u + n].push_back(v + 2 * n);
adj[u + 2 * n].push_back(v);
}
int s, t;
cin >> s >> t;
cout << bfs(adj, s - 1, t - 1) << endl;
return 0;
} | replace | 23 | 24 | 23 | 24 | 0 | |
p02991 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
struct edge {
int to, cost;
};
typedef pair<int, int> P;
int n;
vector<edge> g[300030];
int d[100010];
int inf = 2000000007;
void dijkstra(int s) {
priority_queue<P, vector<P>, greater<P>> que;
for (int i = 0; i <= 3 * n; i++) {
d[i] = inf;
}
d[s] = 0;
que.push(P(0, s));
while (!que.empty()) {
P p = que.top();
que.pop();
int v = p.second;
if (d[v] < p.first)
continue;
for (int i = 0; i < g[v].size(); i++) {
edge e = g[v][i];
if (d[e.to] > d[v] + e.cost) {
d[e.to] = d[v] + e.cost;
que.push(P(d[e.to], e.to));
// cout << 'v' << v << endl;
}
}
}
}
int main() {
int m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
edge e;
e.to = v + n;
e.cost = 1;
g[u].push_back(e);
e.to = v + 2 * n;
g[u + n].push_back(e);
e.to = v;
g[u + 2 * n].push_back(e);
}
int s, t;
cin >> s >> t;
s--;
t--;
dijkstra(s);
if (d[t] == inf) {
cout << -1 << endl;
} else {
cout << d[t] / 3 << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
struct edge {
int to, cost;
};
typedef pair<int, int> P;
int n;
vector<edge> g[300030];
int d[300030];
int inf = 2000000007;
void dijkstra(int s) {
priority_queue<P, vector<P>, greater<P>> que;
for (int i = 0; i <= 3 * n; i++) {
d[i] = inf;
}
d[s] = 0;
que.push(P(0, s));
while (!que.empty()) {
P p = que.top();
que.pop();
int v = p.second;
if (d[v] < p.first)
continue;
for (int i = 0; i < g[v].size(); i++) {
edge e = g[v][i];
if (d[e.to] > d[v] + e.cost) {
d[e.to] = d[v] + e.cost;
que.push(P(d[e.to], e.to));
// cout << 'v' << v << endl;
}
}
}
}
int main() {
int m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
edge e;
e.to = v + n;
e.cost = 1;
g[u].push_back(e);
e.to = v + 2 * n;
g[u + n].push_back(e);
e.to = v;
g[u + 2 * n].push_back(e);
}
int s, t;
cin >> s >> t;
s--;
t--;
dijkstra(s);
if (d[t] == inf) {
cout << -1 << endl;
} else {
cout << d[t] / 3 << endl;
}
} | replace | 10 | 11 | 10 | 11 | 0 | |
p02991 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rep1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define irep(i, a, n) for (int i = a; i < (int)(n); ++i)
#define rrep(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define rrep1(i, n) for (int i = (int)(n); i >= 1; --i)
#define allrep(V, v) for (auto &&V : v)
#define all(x) (x).begin(), (x).end()
using lint = long long;
constexpr int INF = 1 << 30;
constexpr lint INFL = 1LL << 62;
constexpr int MOD = 1e9 + 7;
constexpr double EPS = 1e-9;
using namespace std;
using Weight = int;
struct Edge {
int src, dst;
Weight weight;
Edge(void) {}
Edge(int src_val, int dst_val, Weight weight_val)
: src(src_val), dst(dst_val), weight(weight_val) {}
};
using Edges = std::vector<Edge>;
using Graph = std::vector<Edges>;
Graph edges_to_graph(const Edges &edges, const int vertices_num,
const bool directed = true) {
Graph ret(vertices_num);
for (const auto &e : edges) {
ret[e.src].push_back(e);
if (!directed)
ret[e.src].push_back(Edge(e.dst, e.src, e.weight));
}
return ret;
}
void dfs(Graph &g, vector<vector<lint>> &check, int v, int cnt) {
int step = cnt % 3;
if (check[v][step] <= cnt)
return;
check[v][step] = cnt;
for (const auto es : g[v]) {
dfs(g, check, es.dst, cnt + 1);
}
}
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
int n, m;
cin >> n >> m;
Edges edges(m);
rep(i, m) cin >> edges[i].src >> edges[i].dst;
int s, t;
cin >> s >> t;
Graph graph = edges_to_graph(edges, n + 1);
vector<vector<lint>> check(n + 1, vector<lint>(3, INFL));
dfs(graph, check, s, 0);
cout << (check[t][0] != INFL ? check[t][0] / 3 : -1) << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rep1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define irep(i, a, n) for (int i = a; i < (int)(n); ++i)
#define rrep(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define rrep1(i, n) for (int i = (int)(n); i >= 1; --i)
#define allrep(V, v) for (auto &&V : v)
#define all(x) (x).begin(), (x).end()
using lint = long long;
constexpr int INF = 1 << 30;
constexpr lint INFL = 1LL << 62;
constexpr int MOD = 1e9 + 7;
constexpr double EPS = 1e-9;
using namespace std;
using Weight = int;
struct Edge {
int src, dst;
Weight weight;
Edge(void) {}
Edge(int src_val, int dst_val, Weight weight_val)
: src(src_val), dst(dst_val), weight(weight_val) {}
};
using Edges = std::vector<Edge>;
using Graph = std::vector<Edges>;
Graph edges_to_graph(const Edges &edges, const int vertices_num,
const bool directed = true) {
Graph ret(vertices_num);
for (const auto &e : edges) {
ret[e.src].push_back(e);
if (!directed)
ret[e.src].push_back(Edge(e.dst, e.src, e.weight));
}
return ret;
}
void dfs(Graph &g, vector<vector<lint>> &check, int v, int cnt) {
int step = cnt % 3;
if (check[v][step] <= cnt)
return;
check[v][step] = cnt;
for (const auto es : g[v]) {
dfs(g, check, es.dst, cnt + 1);
}
}
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
int n, m;
cin >> n >> m;
Edges edges(m);
rep(i, m) cin >> edges[i].src >> edges[i].dst;
int s, t;
cin >> s >> t;
Graph graph = edges_to_graph(edges, n + 1);
vector<vector<lint>> check(n + 1, vector<lint>(3, INFL));
queue<pair<int, int>> que;
que.push({s, 0});
while (!que.empty()) {
int v = que.front().first, cnt = que.front().second, step = cnt % 3;
que.pop();
if (check[v][step] <= cnt)
continue;
check[v][step] = cnt;
for (const auto es : graph[v]) {
que.push({es.dst, cnt + 1});
}
}
cout << (check[t][0] != INFL ? check[t][0] / 3 : -1) << endl;
return 0;
} | replace | 60 | 61 | 60 | 72 | TLE | |
p02991 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
using P = pair<int, int>;
int n, m;
vector<vector<int>> G;
int s, t;
ll dist[10010][3];
ll bfs() {
memset(dist, -1LL, sizeof(dist));
dist[s][0] = 0;
queue<P> stt;
stt.push(P(s, 0));
while (!stt.empty()) {
int v = stt.front().first;
int m = stt.front().second;
stt.pop();
for (auto nv : G[v]) {
if (dist[nv][(m + 1) % 3] != -1) {
continue;
} else {
dist[nv][(m + 1) % 3] = dist[v][m] + 1;
stt.push(P(nv, (m + 1) % 3));
}
}
}
if (dist[t][0] == -1)
return -1;
else
return dist[t][0] / 3;
}
int main(void) {
cin >> n >> m;
G.assign(n, vector<int>());
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
G[u].push_back(v);
// 有向グラフなのでuからvだけ辺を張りましょう。
// G[v].push_back(u);
}
cin >> s >> t;
s--;
t--;
cout << bfs() << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
using P = pair<int, int>;
int n, m;
vector<vector<int>> G;
int s, t;
ll dist[100010][3];
ll bfs() {
memset(dist, -1LL, sizeof(dist));
dist[s][0] = 0;
queue<P> stt;
stt.push(P(s, 0));
while (!stt.empty()) {
int v = stt.front().first;
int m = stt.front().second;
stt.pop();
for (auto nv : G[v]) {
if (dist[nv][(m + 1) % 3] != -1) {
continue;
} else {
dist[nv][(m + 1) % 3] = dist[v][m] + 1;
stt.push(P(nv, (m + 1) % 3));
}
}
}
if (dist[t][0] == -1)
return -1;
else
return dist[t][0] / 3;
}
int main(void) {
cin >> n >> m;
G.assign(n, vector<int>());
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
G[u].push_back(v);
// 有向グラフなのでuからvだけ辺を張りましょう。
// G[v].push_back(u);
}
cin >> s >> t;
s--;
t--;
cout << bfs() << endl;
return 0;
} | replace | 8 | 9 | 8 | 9 | 0 | |
p02991 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define per(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define pb push_back
#define mp make_pair
#define bg begin()
#define en end()
#define all(v) (v).begin(), (v).end()
#define sz(v) (int)(v).size()
using namespace std;
typedef long long ll;
typedef long double ld;
using P = pair<int, int>;
static const long long MOD = 1000000007;
static const long long LINF = (ll)(1e18 + 99);
static const int INF = 1e9 + 99;
int ans, n, m, s, t;
int d[100005];
vector<int> g[100005];
void bfs(int s) {
queue<int> q1, q2, q3;
rep(i, 0, n) d[i] = -1;
q1.push(s);
d[s] = 0;
while (!q1.empty()) {
int u = q1.front();
q1.pop();
for (int v1 : g[u]) {
q2.push(v1);
}
while (!q2.empty()) {
int v1 = q2.front();
q2.pop();
for (int v2 : g[v1]) {
q3.push(v2);
}
}
while (!q3.empty()) {
int v2 = q3.front();
q3.pop();
for (int v3 : g[v2]) {
if (d[v3] == -1) {
d[v3] = d[u] + 1;
q1.push(v3);
}
}
}
}
}
int main(void) {
cin >> n >> m;
rep(i, 0, m) {
int u, v;
cin >> u >> v;
u--;
v--;
g[u].pb(v);
}
cin >> s >> t;
s--;
t--;
bfs(s);
cout << d[t] << "\n";
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define per(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define pb push_back
#define mp make_pair
#define bg begin()
#define en end()
#define all(v) (v).begin(), (v).end()
#define sz(v) (int)(v).size()
using namespace std;
typedef long long ll;
typedef long double ld;
using P = pair<int, int>;
static const long long MOD = 1000000007;
static const long long LINF = (ll)(1e18 + 99);
static const int INF = 1e9 + 99;
int ans, n, m, s, t;
int d[100005];
vector<int> g[100005];
void bfs(int s) {
queue<int> q1, q2, q3;
rep(i, 0, n) d[i] = -1;
q1.push(s);
d[s] = 0;
while (!q1.empty()) {
int u = q1.front();
q1.pop();
for (int v1 : g[u]) {
q2.push(v1);
}
while (!q2.empty()) {
int v1 = q2.front();
q2.pop();
for (int v2 : g[v1]) {
q3.push(v2);
}
}
while (!q3.empty()) {
int v2 = q3.front();
q3.pop();
for (int v3 : g[v2]) {
if (d[v3] == -1) {
d[v3] = d[u] + 1;
if (v3 == t)
return;
q1.push(v3);
}
}
}
}
}
int main(void) {
cin >> n >> m;
rep(i, 0, m) {
int u, v;
cin >> u >> v;
u--;
v--;
g[u].pb(v);
}
cin >> s >> t;
s--;
t--;
bfs(s);
cout << d[t] << "\n";
return 0;
}
| insert | 61 | 61 | 61 | 63 | TLE | |
p02991 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
template <typename T> vector<T> make_vector(size_t sz) { return vector<T>(sz); }
template <typename T, typename... U> auto make_vector(size_t sz, U... tail) {
return vector<decltype(make_vector<T>(tail...))>(sz, make_vector<T>(tail...));
}
template <typename T> void fill_vector(vector<T> &v, T init) {
fill(v.begin(), v.end(), init);
}
template <typename T, typename U> void fill_vector(vector<U> &vec, T init) {
for (auto &v : vec) {
fill_vector<T>(v, init);
}
}
int main() {
int64_t n, m, s, t, inf = (1LL << 60);
cin >> n >> m;
auto ps = make_vector<pair<int64_t, int64_t>>(m);
for (auto &p : ps) {
cin >> p.first >> p.second;
p.first--;
p.second--;
}
cin >> s >> t;
s--;
t--;
auto g = make_vector<pair<int64_t, int64_t>>(3, n, 0);
for (auto &p : ps) {
g[0][p.first].push_back({1, p.second});
g[1][p.first].push_back({2, p.second});
g[2][p.first].push_back({0, p.second});
}
auto dist = make_vector<int64_t>(3, n);
fill_vector<int64_t>(dist, inf);
priority_queue<pair<int64_t, pair<int64_t, int64_t>>,
vector<pair<int64_t, pair<int64_t, int64_t>>>, greater<>>
pq;
dist[0][s] = 0;
pq.push({dist[0][s], {0, s}});
while (!pq.empty()) {
int64_t d = pq.top().first;
int64_t i = pq.top().second.first;
int64_t v = pq.top().second.second;
pq.pop();
if (dist[i][v] < d) {
continue;
}
for (auto &p : g[i][v]) {
int64_t j = p.first;
int64_t u = p.second;
if (dist[j][u] < dist[i][v] + 1) {
continue;
}
dist[j][u] = dist[i][v] + 1;
pq.push({dist[j][u], {j, u}});
}
}
cout << ((dist[0][t] == inf) ? -1 : (dist[0][t] / 3)) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
template <typename T> vector<T> make_vector(size_t sz) { return vector<T>(sz); }
template <typename T, typename... U> auto make_vector(size_t sz, U... tail) {
return vector<decltype(make_vector<T>(tail...))>(sz, make_vector<T>(tail...));
}
template <typename T> void fill_vector(vector<T> &v, T init) {
fill(v.begin(), v.end(), init);
}
template <typename T, typename U> void fill_vector(vector<U> &vec, T init) {
for (auto &v : vec) {
fill_vector<T>(v, init);
}
}
int main() {
int64_t n, m, s, t, inf = (1LL << 60);
cin >> n >> m;
auto ps = make_vector<pair<int64_t, int64_t>>(m);
for (auto &p : ps) {
cin >> p.first >> p.second;
p.first--;
p.second--;
}
cin >> s >> t;
s--;
t--;
auto g = make_vector<pair<int64_t, int64_t>>(3, n, 0);
for (auto &p : ps) {
g[0][p.first].push_back({1, p.second});
g[1][p.first].push_back({2, p.second});
g[2][p.first].push_back({0, p.second});
}
auto dist = make_vector<int64_t>(3, n);
fill_vector<int64_t>(dist, inf);
priority_queue<pair<int64_t, pair<int64_t, int64_t>>,
vector<pair<int64_t, pair<int64_t, int64_t>>>, greater<>>
pq;
dist[0][s] = 0;
pq.push({dist[0][s], {0, s}});
while (!pq.empty()) {
int64_t d = pq.top().first;
int64_t i = pq.top().second.first;
int64_t v = pq.top().second.second;
pq.pop();
if (dist[i][v] < d) {
continue;
}
for (auto &p : g[i][v]) {
int64_t j = p.first;
int64_t u = p.second;
if (dist[j][u] <= dist[i][v] + 1) {
continue;
}
dist[j][u] = dist[i][v] + 1;
pq.push({dist[j][u], {j, u}});
}
}
cout << ((dist[0][t] == inf) ? -1 : (dist[0][t] / 3)) << endl;
return 0;
} | replace | 62 | 63 | 62 | 63 | 0 | |
p02991 | C++ | Time Limit Exceeded | /**
* @brief : c++ code for AtCoder
* @author : rk222
* @created: 2019.06.29 20:58:50
*/
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> P;
typedef pair<int, P> P1;
#define fr first
#define sc second
#define mp make_pair
#define pb push_back
#define rep(i, x) for (int i = 0; i < x; i++)
#define rep1(i, x) for (int i = 1; i <= x; i++)
#define rrep(i, x) for (int i = x - 1; i >= 0; i--)
#define rrep1(i, x) for (int i = x; i > 0; i--)
#define sor(v) sort(v.begin(), v.end())
#define rev(s) reverse(s.begin(), s.end())
#define lb(vec, a) lower_bound(vec.begin(), vec.end(), a)
#define ub(vec, a) upper_bound(vec.begin(), vec.end(), a)
#define uniq(vec) vec.erase(unique(vec.begin(), vec.end()), vec.end())
#define mp1(a, b, c) P1(a, P(b, c))
#define disp(x) cout << #x << ": " << x << endl
#define disp_vec(v) \
cout << #v << ":"; \
rep(i, v.size()) cout << " " << v[i]; \
cout << endl
const int INF = 100000000;
const int M = 100000000;
const int dir_4[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
const int dir_8[8][2] = {{1, 0}, {1, 1}, {0, 1}, {-1, 1},
{-1, 0}, {-1, -1}, {0, -1}, {1, -1}};
/* ------------------------------------- */
vector<int> G[100010];
int ret[100010][3];
void dfs(int u, int step, int time) {
step = (step + 1) % 3;
if (step == 0) {
time++;
}
rep(i, G[u].size()) {
if (ret[G[u][i]][step] > time) {
ret[G[u][i]][step] = time;
dfs(G[u][i], step, time);
}
}
return;
}
int main() {
int n, m, s, t;
scanf("%d%d", &n, &m);
int ut, vt;
rep(i, m) {
scanf("%d%d", &ut, &vt);
G[ut - 1].pb(vt - 1);
}
scanf("%d%d", &s, &t);
s--;
t--;
rep(i, 3) rep(j, 100010) { ret[j][i] = INF; }
ret[s][0] = 0;
dfs(s, 0, 0);
if (ret[t][0] != INF) {
printf("%d\n", ret[t][0]);
} else {
printf("%d\n", -1);
}
/* --------------------------------- */
return 0;
} | /**
* @brief : c++ code for AtCoder
* @author : rk222
* @created: 2019.06.29 20:58:50
*/
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> P;
typedef pair<int, P> P1;
#define fr first
#define sc second
#define mp make_pair
#define pb push_back
#define rep(i, x) for (int i = 0; i < x; i++)
#define rep1(i, x) for (int i = 1; i <= x; i++)
#define rrep(i, x) for (int i = x - 1; i >= 0; i--)
#define rrep1(i, x) for (int i = x; i > 0; i--)
#define sor(v) sort(v.begin(), v.end())
#define rev(s) reverse(s.begin(), s.end())
#define lb(vec, a) lower_bound(vec.begin(), vec.end(), a)
#define ub(vec, a) upper_bound(vec.begin(), vec.end(), a)
#define uniq(vec) vec.erase(unique(vec.begin(), vec.end()), vec.end())
#define mp1(a, b, c) P1(a, P(b, c))
#define disp(x) cout << #x << ": " << x << endl
#define disp_vec(v) \
cout << #v << ":"; \
rep(i, v.size()) cout << " " << v[i]; \
cout << endl
const int INF = 100000000;
const int M = 100000000;
const int dir_4[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
const int dir_8[8][2] = {{1, 0}, {1, 1}, {0, 1}, {-1, 1},
{-1, 0}, {-1, -1}, {0, -1}, {1, -1}};
/* ------------------------------------- */
vector<int> G[100010];
int ret[100010][3];
void dfs(int u, int step, int time) {
step = (step + 1) % 3;
if (step == 0) {
time++;
}
rep(i, G[u].size()) {
if (ret[G[u][i]][step] > time) {
ret[G[u][i]][step] = time;
dfs(G[u][i], step, time);
}
}
return;
}
int main() {
int n, m, s, t;
scanf("%d%d", &n, &m);
int ut, vt;
rep(i, m) {
scanf("%d%d", &ut, &vt);
G[ut - 1].pb(vt - 1);
}
scanf("%d%d", &s, &t);
s--;
t--;
rep(i, 3) rep(j, 100010) { ret[j][i] = INF; }
ret[s][0] = 0;
queue<P1> que;
que.push(P1(s, P(0, 0)));
int u, step, time;
while (que.size()) {
P1 p = que.front();
que.pop();
u = p.fr;
step = p.sc.fr;
time = p.sc.sc;
step = (step + 1) % 3;
if (step == 0) {
time++;
}
rep(i, G[u].size()) {
if (ret[G[u][i]][step] > time) {
ret[G[u][i]][step] = time;
que.push(P1(G[u][i], P(step, time)));
}
}
}
if (ret[t][0] != INF) {
printf("%d\n", ret[t][0]);
} else {
printf("%d\n", -1);
}
/* --------------------------------- */
return 0;
} | replace | 85 | 86 | 85 | 108 | TLE | |
p02991 | C++ | Time Limit Exceeded | #pragma once
#include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
#define _USE_MATH_DEFINES
#include <math.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define bit(x, v) ((ll)x << v)
const ll INF = 1000000007;
const int MAX = 210000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int pr[100010];
void uini(int n) {
for (size_t i = 0; i <= n; i++) {
pr[i] = i;
}
}
int parent(int x) {
if (x == pr[x])
return x;
return pr[x] = parent(pr[x]);
}
bool unit(int x, int y) {
int px = parent(x);
int py = parent(y);
if (px == py)
return false;
if (px < py) {
pr[py] = px;
} else {
pr[px] = py;
}
return true;
}
// res[i][c] := i 文字目以降で最初に文字 c が登場する index (存在しないときは n)
vector<vector<int>> calcNext(const string &S) {
int n = (int)S.size();
vector<vector<int>> res(n + 1, vector<int>(26, n));
for (int i = n - 1; i >= 0; --i) {
for (int j = 0; j < 26; ++j)
res[i][j] = res[i + 1][j];
res[i][S[i] - 'a'] = i;
}
return res;
}
vector<int> es[100010];
void solv() {
int n, m;
cin >> n >> m;
for (size_t i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
es[u].push_back(v);
}
int s, t;
cin >> s >> t;
priority_queue<vector<int>, vector<vector<int>>, greater<vector<int>>> q;
q.push({0, 2, s});
int d[3][100010];
memset(d, -1, sizeof(d));
while (!q.empty()) {
auto v = q.top();
q.pop();
int cnt = v[0];
int step = v[1];
int f = v[2];
if (d[step][f] != -1 && d[step][f] < cnt)
continue;
d[step][f] = cnt;
int nextcnt = step == 2 ? cnt + 1 : cnt;
int nextstep = (step + 1) % 3;
for (auto e : es[f]) {
q.push({nextcnt, nextstep, e, f});
}
}
cout << d[2][t] << endl;
}
int main() {
COMinit();
solv();
return 0;
}
| #pragma once
#include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
#define _USE_MATH_DEFINES
#include <math.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define bit(x, v) ((ll)x << v)
const ll INF = 1000000007;
const int MAX = 210000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int pr[100010];
void uini(int n) {
for (size_t i = 0; i <= n; i++) {
pr[i] = i;
}
}
int parent(int x) {
if (x == pr[x])
return x;
return pr[x] = parent(pr[x]);
}
bool unit(int x, int y) {
int px = parent(x);
int py = parent(y);
if (px == py)
return false;
if (px < py) {
pr[py] = px;
} else {
pr[px] = py;
}
return true;
}
// res[i][c] := i 文字目以降で最初に文字 c が登場する index (存在しないときは n)
vector<vector<int>> calcNext(const string &S) {
int n = (int)S.size();
vector<vector<int>> res(n + 1, vector<int>(26, n));
for (int i = n - 1; i >= 0; --i) {
for (int j = 0; j < 26; ++j)
res[i][j] = res[i + 1][j];
res[i][S[i] - 'a'] = i;
}
return res;
}
vector<int> es[100010];
void solv() {
int n, m;
cin >> n >> m;
for (size_t i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
es[u].push_back(v);
}
int s, t;
cin >> s >> t;
priority_queue<vector<int>, vector<vector<int>>, greater<vector<int>>> q;
q.push({0, 2, s});
int d[3][100010];
memset(d, -1, sizeof(d));
while (!q.empty()) {
auto v = q.top();
q.pop();
int cnt = v[0];
int step = v[1];
int f = v[2];
if (d[step][f] != -1 && d[step][f] <= cnt)
continue;
d[step][f] = cnt;
int nextcnt = step == 2 ? cnt + 1 : cnt;
int nextstep = (step + 1) % 3;
for (auto e : es[f]) {
q.push({nextcnt, nextstep, e, f});
}
}
cout << d[2][t] << endl;
}
int main() {
COMinit();
solv();
return 0;
}
| replace | 121 | 122 | 121 | 122 | TLE | |
p02991 | C++ | Time Limit Exceeded | /*input
*/
#include <bits/stdc++.h>
using namespace std;
#define all(a) a.begin(), a.end()
#define ff first
#define ss second
#define pb push_back
using ll = long long;
using pii = pair<int, int>;
template <typename T> using V = vector<T>;
const int MAX_N = 1e5 + 5;
vector<int> adj[3 * MAX_N];
bool visit[3 * MAX_N];
int dist[3 * MAX_N];
inline void make_edge(int u, int v) { adj[u].pb(v); }
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int N, M;
cin >> N >> M;
for (int i = 0; i < M; ++i) {
int u, v;
cin >> u >> v;
make_edge(3 * u, 3 * v + 1);
make_edge(3 * u + 1, 3 * v + 2);
make_edge(3 * u + 2, 3 * v);
}
int S, T;
cin >> S >> T;
S *= 3;
T *= 3;
queue<int> Q;
dist[S] = 0;
Q.push(S);
while (!Q.empty()) {
int cur = Q.front();
Q.pop();
visit[cur] = true;
for (auto nxt : adj[cur]) {
if (!visit[nxt]) {
Q.push(nxt);
dist[nxt] = dist[cur] + 1;
}
}
}
cout << (visit[T] ? (dist[T] / 3) : -1) << '\n';
return 0;
} | /*input
*/
#include <bits/stdc++.h>
using namespace std;
#define all(a) a.begin(), a.end()
#define ff first
#define ss second
#define pb push_back
using ll = long long;
using pii = pair<int, int>;
template <typename T> using V = vector<T>;
const int MAX_N = 1e5 + 5;
vector<int> adj[3 * MAX_N];
bool visit[3 * MAX_N];
int dist[3 * MAX_N];
inline void make_edge(int u, int v) { adj[u].pb(v); }
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int N, M;
cin >> N >> M;
for (int i = 0; i < M; ++i) {
int u, v;
cin >> u >> v;
make_edge(3 * u, 3 * v + 1);
make_edge(3 * u + 1, 3 * v + 2);
make_edge(3 * u + 2, 3 * v);
}
int S, T;
cin >> S >> T;
S *= 3;
T *= 3;
queue<int> Q;
dist[S] = 0;
Q.push(S);
while (!Q.empty()) {
int cur = Q.front();
Q.pop();
if (visit[cur])
continue;
visit[cur] = true;
for (auto nxt : adj[cur]) {
if (!visit[nxt]) {
Q.push(nxt);
dist[nxt] = dist[cur] + 1;
}
}
}
cout << (visit[T] ? (dist[T] / 3) : -1) << '\n';
return 0;
} | insert | 44 | 44 | 44 | 46 | TLE | |
p02991 | C++ | Time Limit Exceeded | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define FOR(k, m, n) for (ll(k) = (m); (k) < (n); (k)++)
#define REP(i, n) FOR((i), 0, (n))
#define WAITING(str) \
int str; \
std::cin >> str;
#define DEBUGING(str) cout << #str << " " str << endl
constexpr int INF = (1 << 30);
constexpr ll INFL = (1ll << 60);
constexpr ll MOD = 1000000007; // 10^9+7
int main() {
int N, M, S, T;
cin >> N >> M;
vector<vector<int>> edges(N);
vector<vector<int>> dp(N, vector<int>(3, INF));
REP(i, M) {
int u, v;
cin >> u >> v;
u--;
v--;
edges[u].push_back(v);
}
cin >> S >> T;
S--;
T--;
queue<pair<int, int>> q;
q.push({0, S});
dp[S][0] = 0;
while (!q.empty()) {
auto p = q.front();
q.pop();
int dist = p.first;
int pos = p.second;
for (auto next : edges[pos]) {
int ndist = dist + 1;
if (dp[next][ndist % 3] <= dist)
continue;
dp[next][ndist % 3] = ndist;
q.push({ndist, next});
}
}
if (dp[T][0] == INF)
cout << -1 << endl;
else
cout << dp[T][0] / 3 << endl;
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define FOR(k, m, n) for (ll(k) = (m); (k) < (n); (k)++)
#define REP(i, n) FOR((i), 0, (n))
#define WAITING(str) \
int str; \
std::cin >> str;
#define DEBUGING(str) cout << #str << " " str << endl
constexpr int INF = (1 << 30);
constexpr ll INFL = (1ll << 60);
constexpr ll MOD = 1000000007; // 10^9+7
int main() {
int N, M, S, T;
cin >> N >> M;
vector<vector<int>> edges(N);
vector<vector<int>> dp(N, vector<int>(3, INF));
REP(i, M) {
int u, v;
cin >> u >> v;
u--;
v--;
edges[u].push_back(v);
}
cin >> S >> T;
S--;
T--;
queue<pair<int, int>> q;
q.push({0, S});
dp[S][0] = 0;
while (!q.empty()) {
auto p = q.front();
q.pop();
int dist = p.first;
int pos = p.second;
for (auto next : edges[pos]) {
int ndist = dist + 1;
if (dp[next][ndist % 3] <= ndist)
continue;
dp[next][ndist % 3] = ndist;
q.push({ndist, next});
}
}
if (dp[T][0] == INF)
cout << -1 << endl;
else
cout << dp[T][0] / 3 << endl;
return 0;
}
| replace | 46 | 47 | 46 | 47 | TLE | |
p02991 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
// #include <ext/pb_ds/detail/standard_policies.hpp>
using namespace std;
using namespace __gnu_pbds;
// const ll RANDOM =
// chrono::high_resolution_clock::now().time_since_epoch().count();
// gp_hash_table<int, int> table;
#define ll long long int
#define vii vector<ll>
#define pb push_back
#define pii pair<ll, ll>
#define all(x) x.begin(), x.end()
#define S second
#define F first
#define ins insert
#define ld long double
#define lp(l, r) for (i = l; i <= r; ++i)
#define lpj(l, r) for (j = l; j <= r; ++j)
#define lpr(l, r) for (i = r; i >= l; --i)
#define lprj(l, r) for (j = r; j >= l; --j)
#define swap(a, b) \
{ \
auto _t = a; \
a = b, b = _t; \
}
#define flush() cout.flush()
#define popcount __builtin_popcount
// typedef __int128 bign;
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << std::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 trace(...)
#endif
#define MD 1000000007
#define M 3000
#define LN 14
#define fftmod 998244353
#define EPS (double)1e-10
ll md = MD;
ll inf = 1e18;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
inline ll exp(ll a, ll b) {
ll r = 1LL;
while (b > 0) {
if (b & 1) {
r = r * (a % md);
r = (r + md) % md;
}
b /= 2;
a = (a % md) * (a % md);
a = (a + md) % md;
}
return (r + md) % md;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
if (a == 0)
return b;
return gcd(b, a % b);
}
inline ll poww(ll a, ll b) {
ll r = 1LL;
while (b > 0) {
if (b & 1)
r = r * a;
b /= 2;
a = a * a;
}
return (ll)r;
}
using cd = complex<double>;
const double PI = acos(-1);
inline ll rand(ll l, ll r) { return l + rng() % (r - l + 1); }
vii g[M];
ll in[M], out[M];
ll vis[M][3];
ll dp[M][3];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// ifstream fin("input.txt");ofstream fout("outut.txt");
ll t, i, j, m, n, s, z, k, p, T;
string s1, s2;
ll qa;
ll x, y;
cin >> n >> m;
lp(1, m) {
cin >> x >> y;
g[x].pb(y);
}
cin >> x >> y;
memset(dp, -1, sizeof(dp));
dp[x][0] = 0;
queue<pii> q;
q.push({x, 0});
while (!q.empty()) {
pii u = q.front();
q.pop();
vis[u.F][u.S] = 1;
for (auto v : g[u.F]) {
ll nx = u.S + 1;
nx %= 3;
if (!vis[v][nx]) {
vis[v][nx] = 1;
dp[v][nx] = dp[u.F][u.S] + 1;
q.push({v, nx});
}
}
}
if (dp[y][0] == -1)
cout << -1 << "\n";
else
cout << dp[y][0] / 3 << "\n";
return 0;
}
| #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
// #include <ext/pb_ds/detail/standard_policies.hpp>
using namespace std;
using namespace __gnu_pbds;
// const ll RANDOM =
// chrono::high_resolution_clock::now().time_since_epoch().count();
// gp_hash_table<int, int> table;
#define ll long long int
#define vii vector<ll>
#define pb push_back
#define pii pair<ll, ll>
#define all(x) x.begin(), x.end()
#define S second
#define F first
#define ins insert
#define ld long double
#define lp(l, r) for (i = l; i <= r; ++i)
#define lpj(l, r) for (j = l; j <= r; ++j)
#define lpr(l, r) for (i = r; i >= l; --i)
#define lprj(l, r) for (j = r; j >= l; --j)
#define swap(a, b) \
{ \
auto _t = a; \
a = b, b = _t; \
}
#define flush() cout.flush()
#define popcount __builtin_popcount
// typedef __int128 bign;
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << std::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 trace(...)
#endif
#define MD 1000000007
#define M 100011
#define LN 14
#define fftmod 998244353
#define EPS (double)1e-10
ll md = MD;
ll inf = 1e18;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
inline ll exp(ll a, ll b) {
ll r = 1LL;
while (b > 0) {
if (b & 1) {
r = r * (a % md);
r = (r + md) % md;
}
b /= 2;
a = (a % md) * (a % md);
a = (a + md) % md;
}
return (r + md) % md;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
if (a == 0)
return b;
return gcd(b, a % b);
}
inline ll poww(ll a, ll b) {
ll r = 1LL;
while (b > 0) {
if (b & 1)
r = r * a;
b /= 2;
a = a * a;
}
return (ll)r;
}
using cd = complex<double>;
const double PI = acos(-1);
inline ll rand(ll l, ll r) { return l + rng() % (r - l + 1); }
vii g[M];
ll in[M], out[M];
ll vis[M][3];
ll dp[M][3];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// ifstream fin("input.txt");ofstream fout("outut.txt");
ll t, i, j, m, n, s, z, k, p, T;
string s1, s2;
ll qa;
ll x, y;
cin >> n >> m;
lp(1, m) {
cin >> x >> y;
g[x].pb(y);
}
cin >> x >> y;
memset(dp, -1, sizeof(dp));
dp[x][0] = 0;
queue<pii> q;
q.push({x, 0});
while (!q.empty()) {
pii u = q.front();
q.pop();
vis[u.F][u.S] = 1;
for (auto v : g[u.F]) {
ll nx = u.S + 1;
nx %= 3;
if (!vis[v][nx]) {
vis[v][nx] = 1;
dp[v][nx] = dp[u.F][u.S] + 1;
q.push({v, nx});
}
}
}
if (dp[y][0] == -1)
cout << -1 << "\n";
else
cout << dp[y][0] / 3 << "\n";
return 0;
}
| replace | 53 | 54 | 53 | 54 | 0 | |
p02991 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long int64;
#define repeat(i, n) forloop(i, 0, n)
#define forloop(i, a, b) for (int i = (a); i < (b); ++i)
#define debug(x) \
cerr << #x << ": " << x << " " \
<< "(L:" << __LINE__ << ")" << '\n'
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
};
template <class T> inline bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
};
const int MOD = 1e9 + 7;
const int64 INF64 = (1LL << 62) - 1;
const int INF = (1 << 30) - 1;
struct point {
int x;
int y;
};
int main() {
int n, m;
cin >> n >> m;
vector<bool> reached[3];
vector<int> dist[3];
unordered_map<int, set<int>> linked_nodes;
repeat(i, 3) {
reached[i].resize(n, false);
dist[i].resize(n, INF);
}
repeat(i, m) {
int a, b;
cin >> a >> b;
linked_nodes[a - 1].insert(b - 1);
}
int s, t;
cin >> s >> t;
s--;
t--;
dist[0][s] = 0;
queue<pair<int, int>> q;
q.push(make_pair(0, s));
while (not q.empty()) {
int step = q.front().first;
int node = q.front().second;
int next_step = (step + 1) % 3;
q.pop();
for (auto next_node : linked_nodes[node]) {
if (reached[next_step][next_node])
continue;
q.push(make_pair(next_step, next_node));
reached[step][node] = true;
if (step == 2) {
chmin(dist[next_step][next_node], dist[step][node] + 1);
} else {
chmin(dist[next_step][next_node], dist[step][node]);
}
}
}
if (dist[0][t] == INF)
cout << -1 << endl;
else
cout << dist[0][t] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int64;
#define repeat(i, n) forloop(i, 0, n)
#define forloop(i, a, b) for (int i = (a); i < (b); ++i)
#define debug(x) \
cerr << #x << ": " << x << " " \
<< "(L:" << __LINE__ << ")" << '\n'
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
};
template <class T> inline bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
};
const int MOD = 1e9 + 7;
const int64 INF64 = (1LL << 62) - 1;
const int INF = (1 << 30) - 1;
struct point {
int x;
int y;
};
int main() {
int n, m;
cin >> n >> m;
vector<bool> reached[3];
vector<int> dist[3];
unordered_map<int, set<int>> linked_nodes;
repeat(i, 3) {
reached[i].resize(n, false);
dist[i].resize(n, INF);
}
repeat(i, m) {
int a, b;
cin >> a >> b;
linked_nodes[a - 1].insert(b - 1);
}
int s, t;
cin >> s >> t;
s--;
t--;
dist[0][s] = 0;
queue<pair<int, int>> q;
q.push(make_pair(0, s));
while (not q.empty()) {
int step = q.front().first;
int node = q.front().second;
int next_step = (step + 1) % 3;
q.pop();
for (auto next_node : linked_nodes[node]) {
if (reached[next_step][next_node])
continue;
q.push(make_pair(next_step, next_node));
reached[next_step][next_node] = true;
if (step == 2) {
chmin(dist[next_step][next_node], dist[step][node] + 1);
} else {
chmin(dist[next_step][next_node], dist[step][node]);
}
}
}
if (dist[0][t] == INF)
cout << -1 << endl;
else
cout << dist[0][t] << endl;
return 0;
} | replace | 65 | 66 | 65 | 66 | TLE | |
p02991 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
#define show(x) \
{ \
for (auto i : x) { \
cout << i << " "; \
} \
cout << endl; \
}
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = 1e9;
int dist[300005];
int main() {
// bfs、各頂点の状態数３
int N, M;
cin >> N >> M;
vector<int> graph[3 * N]; // 0-indexed
rep(i, M) {
int a, b;
cin >> a >> b;
--a;
--b;
a *= 3;
b *= 3;
rep(j, 3) {
graph[a + j].push_back(b + ((j + 1) % 3));
// graph[b+j].push_back(a+((j+1)%3));
}
}
queue<P> que;
rep(i, 3 * N) dist[i] = INF;
auto push = [&](int x, int d) {
if (dist[x] < d)
return;
dist[x] = d;
for (auto next : graph[x]) {
if (dist[next] == INF)
que.push(P(next, d + 1));
}
};
int S, T;
cin >> S >> T;
--S;
--T;
S *= 3;
T *= 3;
push(S, 0);
while (!que.empty()) {
auto p = que.front();
que.pop();
int x = p.first, d = p.second;
push(x, d);
}
int ans = dist[T];
if (ans == INF)
ans = -1;
else
ans /= 3;
cout << ans << '\n';
return 0;
}
// 40 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
#define show(x) \
{ \
for (auto i : x) { \
cout << i << " "; \
} \
cout << endl; \
}
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = 1e9;
int dist[300005];
int main() {
// bfs、各頂点の状態数３
int N, M;
cin >> N >> M;
vector<int> graph[3 * N]; // 0-indexed
rep(i, M) {
int a, b;
cin >> a >> b;
--a;
--b;
a *= 3;
b *= 3;
rep(j, 3) {
graph[a + j].push_back(b + ((j + 1) % 3));
// graph[b+j].push_back(a+((j+1)%3));
}
}
queue<P> que;
rep(i, 3 * N) dist[i] = INF;
auto push = [&](int x, int d) {
if (dist[x] < d)
return;
dist[x] = d;
for (auto next : graph[x]) {
if (dist[next] == INF)
que.push(P(next, d + 1));
}
};
int S, T;
cin >> S >> T;
--S;
--T;
S *= 3;
T *= 3;
push(S, 0);
while (!que.empty()) {
auto p = que.front();
que.pop();
int x = p.first, d = p.second;
if (dist[x] == INF)
push(x, d);
}
int ans = dist[T];
if (ans == INF)
ans = -1;
else
ans /= 3;
cout << ans << '\n';
return 0;
}
// 40 | replace | 56 | 57 | 56 | 58 | TLE | |
p02991 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<int, int> Pi;
typedef vector<ll> Vec;
typedef vector<int> Vi;
typedef vector<string> Vs;
typedef vector<vector<ll>> VV;
#define REP(i, a, b) for (ll i = (a); i < (b); i++)
#define rep(i, n) REP(i, 0, n)
const int INF = 1e9;
const int MOD = 1000000007;
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl;
#define ALL(v) v.begin(), v.end()
#define dbg(x_) cerr << #x_ << ":" << x_ << endl;
#define pb(x) push_back(x)
#define mp(a, b) make_pair(a, b)
#define Each(a, b) for (auto &a : b)
#define REPM(i, mp) for (auto i = mp.begin(); i != mp.end(); ++i)
#define dbgmap(mp) \
for (auto i = mp.begin(); i != mp.end(); ++i) { \
cout << i->first << ":" << i->second << endl; \
}
#define sum(v) accumulate(ALL(v), 0)
#define fi first
#define se second
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &p) {
return s << "(" << p.first << ", " << p.second << ")";
}
// vector
template <typename T> ostream &operator<<(ostream &s, const vector<T> &v) {
int len = v.size();
for (int i = 0; i < len; ++i) {
s << v[i];
if (i < len - 1)
s << " ";
}
return s;
}
// 2 dimentional vector
template <typename T>
ostream &operator<<(ostream &s, const vector<vector<T>> &vv) {
int len = vv.size();
for (int i = 0; i < len; ++i) {
s << vv[i] << endl;
}
return s;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m, t, s;
cin >> n >> m;
VV graph(m + 1);
rep(i, m) {
ll a, b;
cin >> a >> b;
graph[a].pb(b);
}
cin >> s >> t;
// i頂点に、aけんぱ余りbで到達。
VV d(n + 1, Vec(3, INF));
queue<tuple<ll, ll, ll>> q;
// 地点、けんぱすう、余り
q.push(make_tuple(s, 0, 0));
while (!q.empty()) {
tuple<ll, ll, ll> &tp = q.front();
Vec &g = graph[get<0>(tp)];
Each(child, g) {
if (d[child][(get<2>(tp) + 1) % 3] <= get<1>(tp) + (get<2>(tp) + 1) / 3) {
continue;
}
d[child][(get<2>(tp) + 1) % 3] = get<1>(tp) + (get<2>(tp) + 1) / 3;
// dbg(d);
q.push(make_tuple(child, get<1>(tp) + (get<2>(tp) + 1) / 3,
(get<2>(tp) + 1) % 3));
}
q.pop();
}
ll ans = d[t][0];
if (ans == INF) {
cout << -1 << endl;
} else {
cout << ans << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<int, int> Pi;
typedef vector<ll> Vec;
typedef vector<int> Vi;
typedef vector<string> Vs;
typedef vector<vector<ll>> VV;
#define REP(i, a, b) for (ll i = (a); i < (b); i++)
#define rep(i, n) REP(i, 0, n)
const int INF = 1e9;
const int MOD = 1000000007;
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl;
#define ALL(v) v.begin(), v.end()
#define dbg(x_) cerr << #x_ << ":" << x_ << endl;
#define pb(x) push_back(x)
#define mp(a, b) make_pair(a, b)
#define Each(a, b) for (auto &a : b)
#define REPM(i, mp) for (auto i = mp.begin(); i != mp.end(); ++i)
#define dbgmap(mp) \
for (auto i = mp.begin(); i != mp.end(); ++i) { \
cout << i->first << ":" << i->second << endl; \
}
#define sum(v) accumulate(ALL(v), 0)
#define fi first
#define se second
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &p) {
return s << "(" << p.first << ", " << p.second << ")";
}
// vector
template <typename T> ostream &operator<<(ostream &s, const vector<T> &v) {
int len = v.size();
for (int i = 0; i < len; ++i) {
s << v[i];
if (i < len - 1)
s << " ";
}
return s;
}
// 2 dimentional vector
template <typename T>
ostream &operator<<(ostream &s, const vector<vector<T>> &vv) {
int len = vv.size();
for (int i = 0; i < len; ++i) {
s << vv[i] << endl;
}
return s;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m, t, s;
cin >> n >> m;
VV graph(m + 10);
rep(i, m) {
ll a, b;
cin >> a >> b;
graph[a].pb(b);
}
cin >> s >> t;
// i頂点に、aけんぱ余りbで到達。
VV d(n + 1, Vec(3, INF));
queue<tuple<ll, ll, ll>> q;
// 地点、けんぱすう、余り
q.push(make_tuple(s, 0, 0));
while (!q.empty()) {
tuple<ll, ll, ll> &tp = q.front();
Vec &g = graph[get<0>(tp)];
Each(child, g) {
if (d[child][(get<2>(tp) + 1) % 3] <= get<1>(tp) + (get<2>(tp) + 1) / 3) {
continue;
}
d[child][(get<2>(tp) + 1) % 3] = get<1>(tp) + (get<2>(tp) + 1) / 3;
// dbg(d);
q.push(make_tuple(child, get<1>(tp) + (get<2>(tp) + 1) / 3,
(get<2>(tp) + 1) % 3));
}
q.pop();
}
ll ans = d[t][0];
if (ans == INF) {
cout << -1 << endl;
} else {
cout << ans << endl;
}
return 0;
}
| replace | 62 | 63 | 62 | 63 | 0 | |
p02991 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rp(i, k, n) for (int i = k; i < n; i++)
typedef long long ll;
typedef double ld;
ll mod = 1e9 + 7ll;
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;
}
const ll INF = 1ll << 60;
const int MAX_V = 100009;
typedef pair<int, ll> P;
vector<P> d(MAX_V); // 結果格納 intは親 到達不可能なら-1, inf
vector<vector<P>> graph(MAX_V);
void dijkstra(int s) {
priority_queue<P, vector<P>, greater<P>> que;
for (int i = 0; i < d.size(); ++i) {
d.at(i) = P(-1, INF);
}
que.push(make_pair(s, 0ll));
d.at(s) = P(s, 0);
while (!que.empty()) {
P p = que.top();
que.pop();
int v = p.first;
if (p.second > d.at(v).second)
continue;
for (int i = 0; i < graph.at(v).size(); ++i) {
P edge = graph.at(v).at(i);
if (d.at(edge.first).second > d.at(v).second + edge.second) {
d.at(edge.first).second = d.at(v).second + edge.second;
d.at(edge.first).first = v;
que.push(make_pair(edge.first, d.at(edge.first).second));
}
}
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
rp(i, 0, m) {
int u, v;
scanf("%d%d", &u, &v);
graph.at(u).push_back(P(v + n, 1ll));
graph.at(u + n).push_back(P(v + 2 * n, 1ll));
graph.at(u + 2 * n).push_back(P(v, 1ll));
}
int s, t;
scanf("%d%d", &s, &t);
dijkstra(s);
if (d.at(t).first == -1)
printf("-1\n");
else
printf("%d\n", int(d.at(t).second) / 3);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rp(i, k, n) for (int i = k; i < n; i++)
typedef long long ll;
typedef double ld;
ll mod = 1e9 + 7ll;
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;
}
const ll INF = 1ll << 60;
const int MAX_V = 500009;
typedef pair<int, ll> P;
vector<P> d(MAX_V); // 結果格納 intは親 到達不可能なら-1, inf
vector<vector<P>> graph(MAX_V);
void dijkstra(int s) {
priority_queue<P, vector<P>, greater<P>> que;
for (int i = 0; i < d.size(); ++i) {
d.at(i) = P(-1, INF);
}
que.push(make_pair(s, 0ll));
d.at(s) = P(s, 0);
while (!que.empty()) {
P p = que.top();
que.pop();
int v = p.first;
if (p.second > d.at(v).second)
continue;
for (int i = 0; i < graph.at(v).size(); ++i) {
P edge = graph.at(v).at(i);
if (d.at(edge.first).second > d.at(v).second + edge.second) {
d.at(edge.first).second = d.at(v).second + edge.second;
d.at(edge.first).first = v;
que.push(make_pair(edge.first, d.at(edge.first).second));
}
}
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
rp(i, 0, m) {
int u, v;
scanf("%d%d", &u, &v);
graph.at(u).push_back(P(v + n, 1ll));
graph.at(u + n).push_back(P(v + 2 * n, 1ll));
graph.at(u + 2 * n).push_back(P(v, 1ll));
}
int s, t;
scanf("%d%d", &s, &t);
dijkstra(s);
if (d.at(t).first == -1)
printf("-1\n");
else
printf("%d\n", int(d.at(t).second) / 3);
return 0;
}
| replace | 23 | 24 | 23 | 24 | 0 | |
p02991 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define pb push_back
using ll = long long;
using P = pair<int, int>;
using Graph = vector<vector<int>>;
const int INF = 1001001001;
int dist[100005][3];
int main() {
int n, m;
cin >> n >> m;
cin >> n >> m;
Graph G(n);
rep(i, m) {
int a, b;
cin >> a >> b;
--a, --b;
G[a].pb(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 : G[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;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define pb push_back
using ll = long long;
using P = pair<int, int>;
using Graph = vector<vector<int>>;
const int INF = 1001001001;
int dist[100005][3];
int main() {
int n, m;
cin >> n >> m;
Graph G(n);
rep(i, m) {
int a, b;
cin >> a >> b;
--a, --b;
G[a].pb(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 : G[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;
} | delete | 16 | 17 | 16 | 16 | -6 | terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
|
p02991 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define Int int64_t
#define dump(x) cout << (x) << endl
#define fi first
#define se second
Int mod = 1e9 + 7;
Int INF = 1e18;
double EPS = 0.00000001;
// Int mod = 1e6+3;
Int n, m;
vector<Int> G[300005];
Int s, t;
Int d[300005];
void dfs(Int x) {
for (Int i = 0; i < (Int)G[x].size(); i++) {
Int to = G[x][i];
if (d[x] + 1 < d[to]) {
d[to] = d[x] + 1;
dfs(to);
}
}
}
int main() {
cin >> n >> m;
for (Int i = 0; i < m; i++) {
Int a, b;
cin >> a >> b;
a *= 3;
b *= 3;
G[a].emplace_back(b + 1);
G[a + 1].emplace_back(b + 2);
G[a + 2].emplace_back(b);
}
cin >> s >> t;
for (Int i = 1; i < (n + 1) * 3; i++)
d[i] = INF;
d[3 * s] = 0;
dfs(3 * s);
// for (Int i = 3; i < (n + 1) * 3; i++) cout << d[i] << " ";
// cout << endl;
dump(d[3 * t] == INF ? -1 : d[3 * t] / 3);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define Int int64_t
#define dump(x) cout << (x) << endl
#define fi first
#define se second
Int mod = 1e9 + 7;
Int INF = 1e18;
double EPS = 0.00000001;
// Int mod = 1e6+3;
Int n, m;
vector<Int> G[300005];
Int s, t;
Int d[300005];
void dfs(Int x) {
for (Int i = 0; i < (Int)G[x].size(); i++) {
Int to = G[x][i];
if (d[x] + 1 < d[to]) {
d[to] = d[x] + 1;
dfs(to);
}
}
}
int main() {
cin >> n >> m;
for (Int i = 0; i < m; i++) {
Int a, b;
cin >> a >> b;
a *= 3;
b *= 3;
G[a].emplace_back(b + 1);
G[a + 1].emplace_back(b + 2);
G[a + 2].emplace_back(b);
}
cin >> s >> t;
for (Int i = 1; i < (n + 1) * 3; i++)
d[i] = INF;
d[3 * s] = 0;
queue<Int> q;
q.push(3 * s);
while (!q.empty()) {
Int x = q.front();
q.pop();
for (Int i = 0; i < (Int)G[x].size(); i++) {
Int to = G[x][i];
if (d[x] + 1 < d[to]) {
d[to] = d[x] + 1;
q.push(to);
}
}
}
dump(d[3 * t] == INF ? -1 : d[3 * t] / 3);
return 0;
} | replace | 41 | 44 | 41 | 54 | TLE | |
p02991 | C++ | Time Limit Exceeded | #include "bits/stdc++.h"
using namespace std;
////////////// Prewritten code follows. Look down for solution. ////////////////
#define fs first
#define sc second
#define pb push_back
#define mp(a, b) make_pair(a, b)
#define len(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define fastio \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef long long ll;
typedef pair<ll, ll> pll;
template <typename T> const T INF = (is_same<T, int>::value ? 1e9 : 1e18);
template <typename T> inline T mod(T n, T mod) {
T res = n % mod;
if (res < 0)
res += mod;
return res;
}
/// command for char arrays with spaces -> scanf(" %[^\n]", text);
////////////////////////// Solution starts below. //////////////////////////////
int main() {
fastio;
int n, m;
cin >> n >> m;
vvi adj(n + 1, vi()), vis(n + 1, vi(4, 0));
;
while (m--) {
int a, b;
cin >> a >> b;
adj[a].pb(b);
}
int s, t;
cin >> s >> t;
function<int(int)> bfs = [&](int sc) {
queue<pii> q;
q.push({sc, 0});
while (!q.empty()) {
int v = q.front().fs;
int d = q.front().sc;
q.pop();
if (vis[v][d % 3])
continue;
if (v == t and d % 3 == 0)
return d / 3;
for (int u : adj[v]) {
q.push({u, d + 1});
}
}
return -1;
};
cout << bfs(s) << endl;
return 0;
} | #include "bits/stdc++.h"
using namespace std;
////////////// Prewritten code follows. Look down for solution. ////////////////
#define fs first
#define sc second
#define pb push_back
#define mp(a, b) make_pair(a, b)
#define len(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define fastio \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef long long ll;
typedef pair<ll, ll> pll;
template <typename T> const T INF = (is_same<T, int>::value ? 1e9 : 1e18);
template <typename T> inline T mod(T n, T mod) {
T res = n % mod;
if (res < 0)
res += mod;
return res;
}
/// command for char arrays with spaces -> scanf(" %[^\n]", text);
////////////////////////// Solution starts below. //////////////////////////////
int main() {
fastio;
int n, m;
cin >> n >> m;
vvi adj(n + 1, vi()), vis(n + 1, vi(4, 0));
;
while (m--) {
int a, b;
cin >> a >> b;
adj[a].pb(b);
}
int s, t;
cin >> s >> t;
function<int(int)> bfs = [&](int sc) {
queue<pii> q;
q.push({sc, 0});
while (!q.empty()) {
int v = q.front().fs;
int d = q.front().sc;
q.pop();
if (vis[v][d % 3])
continue;
vis[v][d % 3] = 1;
if (v == t and d % 3 == 0)
return d / 3;
for (int u : adj[v]) {
q.push({u, d + 1});
}
}
return -1;
};
cout << bfs(s) << endl;
return 0;
} | insert | 56 | 56 | 56 | 57 | TLE | |
p02991 | C++ | Runtime Error | #include <bits/stdc++.h>
#define all(x) begin(x), end(x)
#define dbg(x) cerr << #x << " = " << x << endl
#define _ << ' ' <<
using namespace std;
using ll = long long;
using vi = vector<int>;
int n, m, s, t;
vi adj[100001];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
}
cin >> s >> t;
queue<pair<int, int>> q;
q.emplace(s, 0);
vector<vi> d(n + 1, vi(n + 1, -1));
d[s][0] = 0;
while (!q.empty()) {
int x, k;
tie(x, k) = q.front();
q.pop();
for (int y : adj[x]) {
if (d[y][(k + 1) % 3] == -1) {
d[y][(k + 1) % 3] = d[x][k] + 1;
q.emplace(y, (k + 1) % 3);
}
}
}
if (d[t][0] == -1)
cout << -1;
else
cout << d[t][0] / 3;
}
| #include <bits/stdc++.h>
#define all(x) begin(x), end(x)
#define dbg(x) cerr << #x << " = " << x << endl
#define _ << ' ' <<
using namespace std;
using ll = long long;
using vi = vector<int>;
int n, m, s, t;
vi adj[100001];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
}
cin >> s >> t;
queue<pair<int, int>> q;
q.emplace(s, 0);
vector<vi> d(n + 1, vi(3, -1));
d[s][0] = 0;
while (!q.empty()) {
int x, k;
tie(x, k) = q.front();
q.pop();
for (int y : adj[x]) {
if (d[y][(k + 1) % 3] == -1) {
d[y][(k + 1) % 3] = d[x][k] + 1;
q.emplace(y, (k + 1) % 3);
}
}
}
if (d[t][0] == -1)
cout << -1;
else
cout << d[t][0] / 3;
}
| replace | 23 | 24 | 23 | 24 | 0 | |
p02991 | C++ | Runtime Error | #include "bits/stdc++.h"
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
struct edge {
ll to, cost;
};
const int MAX_V = 100000;
const ll INF = 1LL << 60;
int V;
vector<edge> G[MAX_V];
ll d[MAX_V];
void dijkstra(ll s) {
// greater<P>を指定することでfirstが小さい順に取り出せるようにする
priority_queue<P, vector<P>, greater<P>> que;
fill(d, d + V, INF);
d[s] = 0;
que.push(P(0, s));
while (!que.empty()) {
P p = que.top();
que.pop();
int v = p.second;
if (d[v] < p.first)
continue;
rep(i, G[v].size()) {
edge e = G[v][i];
if (d[e.to] > d[v] + e.cost) {
d[e.to] = d[v] + e.cost;
que.push(P(d[e.to], e.to));
}
}
}
}
int main() {
int N, M, S, T;
cin >> N >> M;
V = N * 3;
vector<int> u(M), v(M);
rep(i, M) {
cin >> u[i] >> v[i];
u[i]--;
v[i]--;
G[u[i]].push_back({v[i] + N, 1});
G[u[i] + N].push_back({v[i] + N + N, 1});
G[u[i] + N + N].push_back({v[i], 1});
}
cin >> S >> T;
S--;
T--;
dijkstra(S);
if (d[T] == INF)
cout << "-1\n";
else
cout << d[T] / 3 << endl;
// rep(i, V) cout << i << " " << d[i] << endl;
} | #include "bits/stdc++.h"
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
struct edge {
ll to, cost;
};
const int MAX_V = 300000;
const ll INF = 1LL << 60;
int V;
vector<edge> G[MAX_V];
ll d[MAX_V];
void dijkstra(ll s) {
// greater<P>を指定することでfirstが小さい順に取り出せるようにする
priority_queue<P, vector<P>, greater<P>> que;
fill(d, d + V, INF);
d[s] = 0;
que.push(P(0, s));
while (!que.empty()) {
P p = que.top();
que.pop();
int v = p.second;
if (d[v] < p.first)
continue;
rep(i, G[v].size()) {
edge e = G[v][i];
if (d[e.to] > d[v] + e.cost) {
d[e.to] = d[v] + e.cost;
que.push(P(d[e.to], e.to));
}
}
}
}
int main() {
int N, M, S, T;
cin >> N >> M;
V = N * 3;
vector<int> u(M), v(M);
rep(i, M) {
cin >> u[i] >> v[i];
u[i]--;
v[i]--;
G[u[i]].push_back({v[i] + N, 1});
G[u[i] + N].push_back({v[i] + N + N, 1});
G[u[i] + N + N].push_back({v[i], 1});
}
cin >> S >> T;
S--;
T--;
dijkstra(S);
if (d[T] == INF)
cout << "-1\n";
else
cout << d[T] / 3 << endl;
// rep(i, V) cout << i << " " << d[i] << endl;
} | replace | 10 | 11 | 10 | 11 | 0 | |
p02991 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <queue>
#include <utility>
#include <vector>
using namespace std;
#define ll long long
// <最短距離, 頂点の番号>
typedef pair<ll, ll> P;
const int INF = 1e9;
const int MAX_N = 1000;
struct edge {
int to;
int cost;
};
// ノード数
int V;
// ある頂点から出るエッジを保持
vector<edge> G[MAX_N];
// コストを保持
int d[MAX_N];
void dijkstra(int s) {
// cout << V;
// Pのコスト昇順の優先度付きキュー
priority_queue<P, vector<P>, greater<P>> que;
// INFで初期化
fill(d, d + V + 10, INF);
d[s] = 0;
que.push(P(0, s));
while (!que.empty()) {
P p = que.top();
que.pop();
int v = p.second;
if (d[v] < p.first)
continue;
for (int i = 0; i < G[v].size(); ++i) {
edge e = G[v][i];
if (d[e.to] > d[v] + e.cost) {
d[e.to] = d[v] + e.cost;
que.push(P(d[e.to], e.to));
}
}
}
}
int main() {
int E, S, T, V_r;
cin >> V >> E;
V_r = V;
V = 3 * V;
// cout << V_r << endl;
for (int i = 0; i < E; ++i) {
int a, b;
int c = 1;
cin >> a >> b;
edge e1 = {b + V_r, c};
edge e2 = {b + 2 * V_r, c};
edge e3 = {b, c};
G[a].push_back(e1);
G[a + V_r].push_back(e2);
G[a + 2 * V_r].push_back(e3);
}
cin >> S >> T;
dijkstra(S);
for (int i = 1; i <= V; ++i) {
// cout << "始点：" << i << endl;
// for(int j = 0; j < G[i].size(); j++){
// cout << "行き先：" << G[i][j].to << endl;
// }
// cout << S <<"から" << i << "までのコスト: " << d[i] << endl;
}
if (d[T] != INF)
cout << d[T] / 3 << endl;
else
cout << -1 << endl;
}
| #include <algorithm>
#include <iostream>
#include <queue>
#include <utility>
#include <vector>
using namespace std;
#define ll long long
// <最短距離, 頂点の番号>
typedef pair<ll, ll> P;
const int INF = 1e9;
const int MAX_N = 3 * 1000000;
struct edge {
int to;
int cost;
};
// ノード数
int V;
// ある頂点から出るエッジを保持
vector<edge> G[MAX_N];
// コストを保持
int d[MAX_N];
void dijkstra(int s) {
// cout << V;
// Pのコスト昇順の優先度付きキュー
priority_queue<P, vector<P>, greater<P>> que;
// INFで初期化
fill(d, d + V + 10, INF);
d[s] = 0;
que.push(P(0, s));
while (!que.empty()) {
P p = que.top();
que.pop();
int v = p.second;
if (d[v] < p.first)
continue;
for (int i = 0; i < G[v].size(); ++i) {
edge e = G[v][i];
if (d[e.to] > d[v] + e.cost) {
d[e.to] = d[v] + e.cost;
que.push(P(d[e.to], e.to));
}
}
}
}
int main() {
int E, S, T, V_r;
cin >> V >> E;
V_r = V;
V = 3 * V;
// cout << V_r << endl;
for (int i = 0; i < E; ++i) {
int a, b;
int c = 1;
cin >> a >> b;
edge e1 = {b + V_r, c};
edge e2 = {b + 2 * V_r, c};
edge e3 = {b, c};
G[a].push_back(e1);
G[a + V_r].push_back(e2);
G[a + 2 * V_r].push_back(e3);
}
cin >> S >> T;
dijkstra(S);
for (int i = 1; i <= V; ++i) {
// cout << "始点：" << i << endl;
// for(int j = 0; j < G[i].size(); j++){
// cout << "行き先：" << G[i][j].to << endl;
// }
// cout << S <<"から" << i << "までのコスト: " << d[i] << endl;
}
if (d[T] != INF)
cout << d[T] / 3 << endl;
else
cout << -1 << endl;
}
| replace | 11 | 12 | 11 | 12 | 0 | |
p02991 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update
using namespace std;
using namespace __gnu_pbds;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
int N, M;
vector<int> G[100005];
bool visited[100005][3];
int main() {
ios_base::sync_with_stdio(false);
cin >> N >> M;
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
G[a].push_back(b);
// G[b].push_back(a);
}
int S, T;
cin >> S >> T;
queue<pair<int, int>> q;
q.push({S, 0});
while (!q.empty()) {
int v = q.front().first;
int dis = q.front().second;
q.pop();
// if(visited[v][dis % 3])
// continue;
visited[v][dis % 3] = true;
if (v == T && dis % 3 == 0) {
cout << dis / 3 << endl;
return 0;
}
for (auto u : G[v])
if (!visited[u][(dis + 1) % 3]) {
q.push({u, dis + 1});
}
}
cout << -1;
}
| #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update
using namespace std;
using namespace __gnu_pbds;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
int N, M;
vector<int> G[100005];
bool visited[100005][3];
int main() {
ios_base::sync_with_stdio(false);
cin >> N >> M;
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
G[a].push_back(b);
// G[b].push_back(a);
}
int S, T;
cin >> S >> T;
queue<pair<int, int>> q;
q.push({S, 0});
while (!q.empty()) {
int v = q.front().first;
int dis = q.front().second;
q.pop();
if (visited[v][dis % 3])
continue;
visited[v][dis % 3] = true;
if (v == T && dis % 3 == 0) {
cout << dis / 3 << endl;
return 0;
}
for (auto u : G[v])
if (!visited[u][(dis + 1) % 3]) {
q.push({u, dis + 1});
}
}
cout << -1;
}
| replace | 34 | 36 | 34 | 36 | TLE | |
p02991 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
int main() {
using namespace std;
size_t N, M;
cin >> N >> M;
vector<vector<unsigned long>> edge(3 * N);
for (size_t i = 0, u, v; i < M; ++i) {
cin >> u >> v;
--u;
--v;
edge[u].push_back(v + N);
edge[u + N].push_back(v + 2 * N);
edge[u + 2 * N].push_back(v);
}
deque<bool> visited(3 * N);
queue<pair<size_t, size_t>> q;
size_t S, T;
cin >> S >> T;
--S;
--T;
q.emplace(S, 0);
while (!q.empty()) {
auto t = q.front();
q.pop();
if (t.first == T) {
cout << t.second / 3 << endl;
return 0;
}
visited[t.first] = true;
for (const auto &i : edge[t.first])
if (!visited[i])
q.emplace(i, t.second + 1);
}
puts("-1");
return 0;
} | #include <bits/stdc++.h>
int main() {
using namespace std;
size_t N, M;
cin >> N >> M;
vector<vector<unsigned long>> edge(3 * N);
for (size_t i = 0, u, v; i < M; ++i) {
cin >> u >> v;
--u;
--v;
edge[u].push_back(v + N);
edge[u + N].push_back(v + 2 * N);
edge[u + 2 * N].push_back(v);
}
deque<bool> visited(3 * N);
queue<pair<size_t, size_t>> q;
size_t S, T;
cin >> S >> T;
--S;
--T;
q.emplace(S, 0);
while (!q.empty()) {
auto t = q.front();
q.pop();
if (visited[t.first])
continue;
if (t.first == T) {
cout << t.second / 3 << endl;
return 0;
}
visited[t.first] = true;
for (const auto &i : edge[t.first])
if (!visited[i])
q.emplace(i, t.second + 1);
}
puts("-1");
return 0;
} | insert | 25 | 25 | 25 | 27 | TLE | |
p02991 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <string>
#include <unistd.h>
#include <vector>
#define mod (1e9 + 7)
#define pb push_back
using namespace std;
typedef pair<int, int> pii;
vector<vector<int>> vvi;
int vis[111111][3];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i <= n; i++) {
vvi.pb(vector<int>());
vis[i][0] = mod;
vis[i][1] = mod;
vis[i][2] = mod;
}
int u, v;
for (int i = 0; i < m; i++) {
cin >> u >> v;
vvi[u].pb(v);
}
int s, t;
cin >> s >> t;
priority_queue<pii, vector<pii>, greater<pii>> pq;
pq.push(pii(0, s));
while (!pq.empty()) {
pii cur_q = pq.top();
pq.pop();
int cur_c, cur_v;
cur_c = cur_q.first;
cur_v = cur_q.second;
if (cur_c >= vis[cur_v][cur_c % 3])
vis[-1000][-1000] = 1000;
vis[cur_v][cur_c % 3] = cur_c;
// printf("%d %d\n",cur_c,cur_v);
// sleep(1);
for (int i = 0; i < vvi[cur_v].size(); i++) {
if (vis[vvi[cur_v][i]][(cur_c + 1) % 3] != mod)
continue;
pq.push(pii(cur_c + 1, vvi[cur_v][i]));
}
}
if (vis[t][0] != mod) {
cout << vis[t][0] / 3 << endl;
} else
cout << -1 << endl;
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <string>
#include <unistd.h>
#include <vector>
#define mod (1e9 + 7)
#define pb push_back
using namespace std;
typedef pair<int, int> pii;
vector<vector<int>> vvi;
int vis[111111][3];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i <= n; i++) {
vvi.pb(vector<int>());
vis[i][0] = mod;
vis[i][1] = mod;
vis[i][2] = mod;
}
int u, v;
for (int i = 0; i < m; i++) {
cin >> u >> v;
vvi[u].pb(v);
}
int s, t;
cin >> s >> t;
priority_queue<pii, vector<pii>, greater<pii>> pq;
pq.push(pii(0, s));
while (!pq.empty()) {
pii cur_q = pq.top();
pq.pop();
int cur_c, cur_v;
cur_c = cur_q.first;
cur_v = cur_q.second;
if (cur_c >= vis[cur_v][cur_c % 3])
continue; // vis[-1000][-1000]=1000;
vis[cur_v][cur_c % 3] = cur_c;
// printf("%d %d\n",cur_c,cur_v);
// sleep(1);
for (int i = 0; i < vvi[cur_v].size(); i++) {
if (vis[vvi[cur_v][i]][(cur_c + 1) % 3] != mod)
continue;
pq.push(pii(cur_c + 1, vvi[cur_v][i]));
}
}
if (vis[t][0] != mod) {
cout << vis[t][0] / 3 << endl;
} else
cout << -1 << endl;
return 0;
}
| replace | 47 | 48 | 47 | 48 | 0 | |
p02991 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <queue>
#include <utility>
using namespace std;
#define int long long
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define DEBUG(x) cerr << #x << " = " << x << endl
constexpr int INF = (int)1e9;
int d[10000][3];
signed main() {
int N, M;
cin >> N >> M;
vector<vector<int>> G(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--;
REP(i, N) REP(j, 3) d[i][j] = INF;
queue<pair<int, int>> Q;
Q.emplace(S, 0);
d[S][0] = 0;
while (!Q.empty()) {
pair<int, int> p = Q.front();
Q.pop();
int u = p.first;
int m = p.second;
for (int v : G[u]) {
int m1 = (m + 1) % 3;
if (d[v][m1] > d[u][m] + 1) {
d[v][m1] = d[u][m] + 1;
Q.emplace(v, m1);
}
}
}
if (d[T][0] == INF) {
cout << -1 << endl;
} else {
cout << d[T][0] / 3 << endl;
}
}
| #include <algorithm>
#include <iostream>
#include <queue>
#include <utility>
using namespace std;
#define int long long
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define DEBUG(x) cerr << #x << " = " << x << endl
constexpr int INF = (int)1e9;
int d[100000][3];
signed main() {
int N, M;
cin >> N >> M;
vector<vector<int>> G(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--;
REP(i, N) REP(j, 3) d[i][j] = INF;
queue<pair<int, int>> Q;
Q.emplace(S, 0);
d[S][0] = 0;
while (!Q.empty()) {
pair<int, int> p = Q.front();
Q.pop();
int u = p.first;
int m = p.second;
for (int v : G[u]) {
int m1 = (m + 1) % 3;
if (d[v][m1] > d[u][m] + 1) {
d[v][m1] = d[u][m] + 1;
Q.emplace(v, m1);
}
}
}
if (d[T][0] == INF) {
cout << -1 << endl;
} else {
cout << d[T][0] / 3 << endl;
}
}
| replace | 9 | 10 | 9 | 10 | 0 | |
p02991 | C++ | Runtime Error | #include <bits/stdc++.h>
#define For(a, b, c) for (int a = b; a <= c; ++a)
#define Dor(a, b, c) for (int a = b; a >= c; --a)
using namespace std;
const int N = 100007;
int n, m, s, e, hd[N], nt[N], to[N], Q[N * 3], D[N * 3], F[N * 3], B[N][3];
int main() {
scanf("%d%d", &n, &m);
For(i, 1, m) {
int x, y;
scanf("%d%d", &x, &y);
nt[i] = hd[x], hd[x] = i, to[i] = y;
}
scanf("%d%d", &s, &e);
Q[1] = s, D[1] = 0;
int h = 0, t = 1;
while (h < t) {
int u = Q[++h], d = D[h];
for (int i = hd[u]; i; i = nt[i])
if (!B[to[i]][(d + 1) % 3]) {
Q[++t] = to[i], D[t] = (d + 1) % 3, F[t] = F[h] + 1;
if (Q[t] == e && !D[t]) {
printf("%d\n", F[t] / 3);
return 0;
}
}
}
puts("-1");
return 0;
} | #include <bits/stdc++.h>
#define For(a, b, c) for (int a = b; a <= c; ++a)
#define Dor(a, b, c) for (int a = b; a >= c; --a)
using namespace std;
const int N = 100007;
int n, m, s, e, hd[N], nt[N], to[N], Q[N * 3], D[N * 3], F[N * 3], B[N][3];
int main() {
scanf("%d%d", &n, &m);
For(i, 1, m) {
int x, y;
scanf("%d%d", &x, &y);
nt[i] = hd[x], hd[x] = i, to[i] = y;
}
scanf("%d%d", &s, &e);
Q[1] = s, D[1] = 0;
int h = 0, t = 1;
while (h < t) {
int u = Q[++h], d = D[h];
for (int i = hd[u]; i; i = nt[i])
if (!B[to[i]][(d + 1) % 3]) {
Q[++t] = to[i], D[t] = (d + 1) % 3, F[t] = F[h] + 1,
B[to[i]][(d + 1) % 3] = 1;
if (Q[t] == e && !D[t]) {
printf("%d\n", F[t] / 3);
return 0;
}
}
}
puts("-1");
return 0;
} | replace | 20 | 21 | 20 | 22 | 0 | |
p02991 | C++ | Time Limit Exceeded | #pragma GCC optimize("Ofast")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,popcnt,fma,abm,mmx,avx,tune=native")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp>
#include <functional> // for less
#include <iostream>
using namespace __gnu_pbds;
using namespace std;
#define ll int
typedef tree<pair<ll, ll>, null_type, less<pair<ll, ll>>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
using namespace std;
#define fr(i, a, b) for (int i = (a), _b = (b); i <= _b; i++)
#define frr(i, a, b) for (int i = (a), _b = (b); i >= _b; i--)
#define rep(i, n) for (long long i = 0, _n = (n); i < _n; i++)
#define repr(i, n) for (long long i = (n)-1; i >= 0; i--)
#define foreach(it, ar) \
for (typeof(ar.begin()) it = ar.begin(); it != ar.end(); it++)
#define fill(ar, val) memset(ar, val, sizeof(ar))
#define fill0(ar) fill((ar), 0)
#define fillinf(ar, n) fr(i, 0, (n)) ar[i] = INF
#define debug(x) cout << #x << ": " << x << endl
#define arr1d(a, n) \
cout << #a << " : "; \
fr(_, 1, n) cout << a[_] << ' '; \
cout << endl;
#define arr1d0(a, n) \
cout << #a << " : "; \
rep(_, n) cout << a[_] << ' '; \
cout << endl;
#define arr2d(a, n, m) \
cout << #a << " :" << endl; \
fr(_, 1, n) { \
fr(__, 1, m) cout << a[_][__] << ' '; \
cout << endl; \
}
#define arr2d0(a, n, m) \
cout << #a << " :" << endl; \
rep(_, n) { \
rep(__, m) cout << a[_][__] << ' '; \
cout << endl; \
}
/*Author Ritick Goenka || ritick(codechef) ||ritick(codeforces) */
/*IIT Roorkee = <3 */
#define ull unsigned long long
#define ld long double
#define ui unsigned int
#define all(ar) ar.begin(), ar.end()
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define y0 yyyyyy0
auto clk = clock();
#define y1 yyyyyy1
#define setb __builtin_popcount
#define BIT(n) (1 << (n))
#define SQR(x) ((x) * (x))
#define CUBE(x) ((x) * (x) * (x))
#define LSOne(S) (S) & (-S)
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
typedef pair<int, int> ii;
typedef pair<int, ii> iii;
typedef vector<ii> vii;
typedef vector<int> vi;
typedef vector<string> vs;
template <typename T> inline T gcd(T a, T b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
// template<typename T>inline T lcm(T a, T b){return (a * b) / gcd(a, b);}
template <typename T> string toStr(T x) {
stringstream st;
st << x;
string s;
st >> s;
return s;
}
template <class T> void splitStr(const string &s, vector<T> &out) {
istringstream in(s);
out.clear();
copy(istream_iterator<T>(in), istream_iterator<T>(), back_inserter(out));
}
inline int two(int n) { return 1 << n; }
inline int isOnBit(int n, int b) { return (n >> b) & 1; }
inline void onBit(int &n, int b) { n |= two(b); }
inline void offBit(int &n, int b) { n &= ~two(b); }
inline int lastBit(int n) { return n & (-n); }
inline int cntBit(int n) {
int res = 0;
while (n && ++res)
n -= n & (-n);
return res;
}
const int dx4[] = {-1, 0, 1, 0};
const int dy4[] = {0, 1, 0, -1};
const int dx8[] = {-1, 0, 1, 0, -1, -1, 1, 1};
const int dy8[] = {0, 1, 0, -1, -1, 1, -1, 1};
#define INP "test.inp"
#define OUT "test.out"
#define PI 3.1415926535897932385
#define INF 10000000000000000ll
#define EPS 1e-7
#define MAXN 100000
#define MOD 1000000007
#define dec decr
#define endl '\n'
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
ll gcd(ll a, ll b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
ll modexp(ll x, ll y, ll p) {
ll res = 1;
x = x % p;
while (y > 0) {
if (y % 2 == 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
// ll mark[100005][3];
ll s, t;
ll dp[100005][3];
vector<ll> adj[100005];
void dfs(ll x, ll y) {
ll yy = y + 1;
yy = yy % 3;
for (auto z : adj[x]) {
if (dp[z][yy] == -1) {
dp[z][yy] = dp[x][y] + 1;
dfs(z, yy);
} else if (dp[z][yy] > dp[x][y] + 1) {
dp[z][yy] = dp[x][y] + 1;
dfs(z, yy);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed;
cout << setprecision(9);
#ifdef rg
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ll n, m;
cin >> n >> m;
rep(i, m) {
ll x, y;
cin >> x >> y;
adj[x].pb(y);
}
rep(i, n) { shuffle(all(adj[i + 1]), rng); }
rep(i, 100005) {
rep(j, 3) { dp[i][j] = -1; }
}
cin >> s >> t;
dp[s][0] = 0;
dfs(s, 0);
if (dp[t][0] == -1) {
cout << "-1";
} else {
cout << dp[t][0] / 3;
}
#ifdef rg
cout << endl
<< endl
<< "Time elapsed: " << (double)(clock() - clk) / CLOCKS_PER_SEC << endl;
#endif
return 0;
}
| #pragma GCC optimize("Ofast")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,popcnt,fma,abm,mmx,avx,tune=native")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp>
#include <functional> // for less
#include <iostream>
using namespace __gnu_pbds;
using namespace std;
#define ll int
typedef tree<pair<ll, ll>, null_type, less<pair<ll, ll>>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
using namespace std;
#define fr(i, a, b) for (int i = (a), _b = (b); i <= _b; i++)
#define frr(i, a, b) for (int i = (a), _b = (b); i >= _b; i--)
#define rep(i, n) for (long long i = 0, _n = (n); i < _n; i++)
#define repr(i, n) for (long long i = (n)-1; i >= 0; i--)
#define foreach(it, ar) \
for (typeof(ar.begin()) it = ar.begin(); it != ar.end(); it++)
#define fill(ar, val) memset(ar, val, sizeof(ar))
#define fill0(ar) fill((ar), 0)
#define fillinf(ar, n) fr(i, 0, (n)) ar[i] = INF
#define debug(x) cout << #x << ": " << x << endl
#define arr1d(a, n) \
cout << #a << " : "; \
fr(_, 1, n) cout << a[_] << ' '; \
cout << endl;
#define arr1d0(a, n) \
cout << #a << " : "; \
rep(_, n) cout << a[_] << ' '; \
cout << endl;
#define arr2d(a, n, m) \
cout << #a << " :" << endl; \
fr(_, 1, n) { \
fr(__, 1, m) cout << a[_][__] << ' '; \
cout << endl; \
}
#define arr2d0(a, n, m) \
cout << #a << " :" << endl; \
rep(_, n) { \
rep(__, m) cout << a[_][__] << ' '; \
cout << endl; \
}
/*Author Ritick Goenka || ritick(codechef) ||ritick(codeforces) */
/*IIT Roorkee = <3 */
#define ull unsigned long long
#define ld long double
#define ui unsigned int
#define all(ar) ar.begin(), ar.end()
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define y0 yyyyyy0
auto clk = clock();
#define y1 yyyyyy1
#define setb __builtin_popcount
#define BIT(n) (1 << (n))
#define SQR(x) ((x) * (x))
#define CUBE(x) ((x) * (x) * (x))
#define LSOne(S) (S) & (-S)
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
typedef pair<int, int> ii;
typedef pair<int, ii> iii;
typedef vector<ii> vii;
typedef vector<int> vi;
typedef vector<string> vs;
template <typename T> inline T gcd(T a, T b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
// template<typename T>inline T lcm(T a, T b){return (a * b) / gcd(a, b);}
template <typename T> string toStr(T x) {
stringstream st;
st << x;
string s;
st >> s;
return s;
}
template <class T> void splitStr(const string &s, vector<T> &out) {
istringstream in(s);
out.clear();
copy(istream_iterator<T>(in), istream_iterator<T>(), back_inserter(out));
}
inline int two(int n) { return 1 << n; }
inline int isOnBit(int n, int b) { return (n >> b) & 1; }
inline void onBit(int &n, int b) { n |= two(b); }
inline void offBit(int &n, int b) { n &= ~two(b); }
inline int lastBit(int n) { return n & (-n); }
inline int cntBit(int n) {
int res = 0;
while (n && ++res)
n -= n & (-n);
return res;
}
const int dx4[] = {-1, 0, 1, 0};
const int dy4[] = {0, 1, 0, -1};
const int dx8[] = {-1, 0, 1, 0, -1, -1, 1, 1};
const int dy8[] = {0, 1, 0, -1, -1, 1, -1, 1};
#define INP "test.inp"
#define OUT "test.out"
#define PI 3.1415926535897932385
#define INF 10000000000000000ll
#define EPS 1e-7
#define MAXN 100000
#define MOD 1000000007
#define dec decr
#define endl '\n'
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
ll gcd(ll a, ll b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
ll modexp(ll x, ll y, ll p) {
ll res = 1;
x = x % p;
while (y > 0) {
if (y % 2 == 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
// ll mark[100005][3];
ll s, t;
ll dp[100005][3];
vector<ll> adj[100005];
void dfs(ll x, ll y) {
ll yy = y + 1;
yy = yy % 3;
for (auto z : adj[x]) {
if (dp[z][yy] == -1) {
dp[z][yy] = dp[x][y] + 1;
dfs(z, yy);
} else if (dp[z][yy] > dp[x][y] + 1) {
dp[z][yy] = dp[x][y] + 1;
dfs(z, yy);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed;
cout << setprecision(9);
#ifdef rg
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ll n, m;
cin >> n >> m;
rep(i, m) {
ll x, y;
cin >> x >> y;
adj[x].pb(y);
}
rep(i, n) { shuffle(all(adj[i + 1]), rng); }
rep(i, 100005) {
rep(j, 3) { dp[i][j] = -1; }
}
cin >> s >> t;
dp[s][0] = 0;
// dfs(s,0);
queue<pair<ll, ll>> q;
q.push(mp(s, 0));
while (!q.empty()) {
auto z = q.front();
q.pop();
ll x = z.ff;
ll y = z.ss;
ll yy = (y + 1) % 3;
for (auto z : adj[x]) {
if (dp[z][yy] == -1) {
dp[z][yy] = dp[x][y] + 1;
q.push(mp(z, yy));
} else if (dp[z][yy] > dp[x][y] + 1) {
dp[z][yy] = dp[x][y] + 1;
q.push(mp(z, yy));
}
}
}
if (dp[t][0] == -1) {
cout << "-1";
} else {
cout << dp[t][0] / 3;
}
#ifdef rg
cout << endl
<< endl
<< "Time elapsed: " << (double)(clock() - clk) / CLOCKS_PER_SEC << endl;
#endif
return 0;
}
| replace | 177 | 178 | 177 | 196 | TLE | |
p02991 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define M 1000000007
#define N 1000016
#define ff first.first
#define fs first.second
#define sf second.first
#define ss second.second
#define f first
#define s second
#define inf 9000000000000000000
ll dis[100001], cur;
vector<ll> v[N];
queue<ll> q;
void dfs(ll x, ll power) {
if (power == 0) {
if (dis[x] > cur + 1) {
dis[x] = cur + 1;
q.push(x);
}
return;
}
for (auto node : v[x])
dfs(node, power - 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll n, m, s, t;
cin >> n >> m;
fill(dis, dis + n + 1, inf);
for (ll i = 1; i <= m; i++) {
ll a, b;
cin >> a >> b;
v[b].push_back(a);
}
cin >> s >> t;
q.push(t);
dis[t] = 0;
while (!q.empty()) {
ll x = q.front();
q.pop();
cur = dis[x];
dfs(x, 3);
}
if (dis[s] == inf)
cout << "-1\n";
else
cout << dis[s] << "\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define M 1000000007
#define N 1000016
#define ff first.first
#define fs first.second
#define sf second.first
#define ss second.second
#define f first
#define s second
#define inf 9000000000000000000
ll dis[100001], cur;
vector<ll> v[N];
queue<ll> q;
void dfs(ll x, ll power) {
if (power == 0) {
if (dis[x] > cur + 1) {
dis[x] = cur + 1;
q.push(x);
}
return;
}
for (auto node : v[x])
dfs(node, power - 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll n, m, s, t;
cin >> n >> m;
fill(dis, dis + n + 1, inf);
for (ll i = 1; i <= m; i++) {
ll a, b;
cin >> a >> b;
v[b].push_back(a);
}
cin >> s >> t;
q.push(t);
dis[t] = 0;
while (!q.empty()) {
ll x = q.front();
q.pop();
cur = dis[x];
dfs(x, 3);
if (dis[s] != inf)
break;
}
if (dis[s] == inf)
cout << "-1\n";
else
cout << dis[s] << "\n";
return 0;
}
| insert | 54 | 54 | 54 | 56 | TLE | |
p02991 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPr(i, n) for (int i = (n)-1; i >= 0; --i)
#define FORq(i, m, n) for (int i = (m); i <= (n); ++i)
#define FORqr(i, m, n) for (int i = (n); i >= (m); --i)
#define PB push_back
#define MP make_pair
#define DEBUG printf("%s\n", "debug")
#define fst first
#define snd second
#define SIN(x, S) (S.count(x) != 0)
#define M0(x) memset(x, 0, sizeof(x))
#define FILL(x, y) memset(x, y, sizeof(x))
#define MM(x) memset(x, -1, sizeof(x))
#define ALL(x) (x).begin(), (x).end()
#define SCD(n) scanf("%d", &n)
#define SCD2(m, n) scanf("%d%d", &m, &n)
#define SCD3(m, n, k) scanf("%d%d%d", &m, &n, &k)
#define SCLLD(n) scanf("%lld", &n)
#define SCLLD2(m, n) scanf("%lld%lld", &m, &n)
#define SCLLD3(m, n, k) scanf("%lld%lld%lld", &m, &n, &k)
using namespace std;
typedef pair<int, int> PII;
typedef pair<long long, long long> PLL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<long long> VL;
typedef long long ll;
typedef long long integer;
///////////////////////////////////////////////
const ll MOD = 1e9 + 7;
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
///////////////////////////////////////////////
/*🍈( '-' 🍈*/
int main() {
int N, M;
cin >> N >> M;
static bool visited[300005] = {};
static ll cost[300005] = {};
vector<vector<int>> E(300005);
REP(i, M) {
int u, v;
cin >> u >> v;
u *= 3;
v *= 3;
E[u].PB(v + 1);
E[u + 1].PB(v + 2);
E[u + 2].PB(v);
}
queue<int> Q;
int S, T;
cin >> S >> T;
S *= 3;
T *= 3;
Q.push(S);
visited[S] = true;
while (!Q.empty()) {
int now = Q.front();
visited[now] = true;
Q.pop();
for (int i = 0; i < E[now].size(); ++i) {
int next = E[now][i];
if (visited[next])
continue;
cost[next] = cost[now] + 1;
Q.push(next);
}
}
if (visited[T])
cout << cost[T] / 3 << endl;
else
cout << -1 << endl;
return 0;
}
| #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPr(i, n) for (int i = (n)-1; i >= 0; --i)
#define FORq(i, m, n) for (int i = (m); i <= (n); ++i)
#define FORqr(i, m, n) for (int i = (n); i >= (m); --i)
#define PB push_back
#define MP make_pair
#define DEBUG printf("%s\n", "debug")
#define fst first
#define snd second
#define SIN(x, S) (S.count(x) != 0)
#define M0(x) memset(x, 0, sizeof(x))
#define FILL(x, y) memset(x, y, sizeof(x))
#define MM(x) memset(x, -1, sizeof(x))
#define ALL(x) (x).begin(), (x).end()
#define SCD(n) scanf("%d", &n)
#define SCD2(m, n) scanf("%d%d", &m, &n)
#define SCD3(m, n, k) scanf("%d%d%d", &m, &n, &k)
#define SCLLD(n) scanf("%lld", &n)
#define SCLLD2(m, n) scanf("%lld%lld", &m, &n)
#define SCLLD3(m, n, k) scanf("%lld%lld%lld", &m, &n, &k)
using namespace std;
typedef pair<int, int> PII;
typedef pair<long long, long long> PLL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<long long> VL;
typedef long long ll;
typedef long long integer;
///////////////////////////////////////////////
const ll MOD = 1e9 + 7;
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
///////////////////////////////////////////////
/*🍈( '-' 🍈*/
int main() {
int N, M;
cin >> N >> M;
static bool visited[300005] = {};
static ll cost[300005] = {};
vector<vector<int>> E(300005);
REP(i, M) {
int u, v;
cin >> u >> v;
u *= 3;
v *= 3;
E[u].PB(v + 1);
E[u + 1].PB(v + 2);
E[u + 2].PB(v);
}
queue<int> Q;
int S, T;
cin >> S >> T;
S *= 3;
T *= 3;
Q.push(S);
visited[S] = true;
while (!Q.empty()) {
int now = Q.front();
visited[now] = true;
Q.pop();
for (int i = 0; i < E[now].size(); ++i) {
int next = E[now][i];
if (visited[next])
continue;
visited[next] = true;
cost[next] = cost[now] + 1;
Q.push(next);
}
}
if (visited[T])
cout << cost[T] / 3 << endl;
else
cout << -1 << endl;
return 0;
}
| insert | 87 | 87 | 87 | 88 | TLE | |
p02991 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int n, m, s, t;
vector<int> adjl[100002];
int dist[100002][3];
queue<pair<int, int>> bfs;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
memset(dist, -1, sizeof dist);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adjl[u].push_back(v);
}
cin >> s >> t;
bfs.push({s, 0});
while (!bfs.empty()) {
int now = bfs.front().first;
int distnow = bfs.front().second;
bfs.pop();
if (dist[now][distnow % 3] != -1 && dist[now][distnow % 3] < distnow)
continue;
dist[now][distnow % 3] = distnow;
for (int next : adjl[now])
bfs.push({next, distnow + 1});
}
cout << (dist[t][0] == -1 ? -1 : dist[t][0] / 3) << "\n";
} | #include <bits/stdc++.h>
using namespace std;
int n, m, s, t;
vector<int> adjl[100002];
int dist[100002][3];
queue<pair<int, int>> bfs;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
memset(dist, -1, sizeof dist);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adjl[u].push_back(v);
}
cin >> s >> t;
bfs.push({s, 0});
while (!bfs.empty()) {
int now = bfs.front().first;
int distnow = bfs.front().second;
bfs.pop();
if (dist[now][distnow % 3] != -1)
continue;
dist[now][distnow % 3] = distnow;
for (int next : adjl[now])
bfs.push({next, distnow + 1});
}
cout << (dist[t][0] == -1 ? -1 : dist[t][0] / 3) << "\n";
} | replace | 24 | 25 | 24 | 25 | TLE |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.