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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
p02727 | C++ | Time Limit Exceeded | //
// main.cpp
// ProgrammingContestChallengeBook2
//
// Created by Hisaki Kobayashi on 2020/04/04.
// Copyright © 2020 Hisaki Kobayashi. All rights reserved.
//
#include <bits/stdc++.h>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string>
// #include "mylibrary.hpp"
using namespace std;
int main() {
int X, Y, A, B, C;
cin >> X >> Y >> A >> B >> C;
vector<int> p(A);
for (int i = 0; i < A; i++)
cin >> p[i];
vector<int> q(B);
for (int i = 0; i < B; i++)
cin >> q[i];
vector<int> r(C);
for (int i = 0; i < C; i++)
cin >> r[i];
for (int i = 0; i < A; i++)
sort(p.rbegin(), p.rend());
for (int i = 0; i < B; i++)
sort(q.rbegin(), q.rend());
vector<int> d;
for (int i = 0; i < X; i++)
d.push_back(p[i]);
for (int i = 0; i < Y; i++)
d.push_back(q[i]);
for (int i = 0; i < C; i++)
d.push_back(r[i]);
sort(d.rbegin(), d.rend());
long long sum = 0;
for (int i = 0; i < X + Y; i++) {
sum += d[i];
}
cout << sum << endl;
return 0;
}
| //
// main.cpp
// ProgrammingContestChallengeBook2
//
// Created by Hisaki Kobayashi on 2020/04/04.
// Copyright © 2020 Hisaki Kobayashi. All rights reserved.
//
#include <bits/stdc++.h>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string>
// #include "mylibrary.hpp"
using namespace std;
int main() {
int X, Y, A, B, C;
cin >> X >> Y >> A >> B >> C;
vector<int> p(A);
for (int i = 0; i < A; i++)
cin >> p[i];
vector<int> q(B);
for (int i = 0; i < B; i++)
cin >> q[i];
vector<int> r(C);
for (int i = 0; i < C; i++)
cin >> r[i];
sort(p.rbegin(), p.rend());
sort(q.rbegin(), q.rend());
vector<int> d;
for (int i = 0; i < X; i++)
d.push_back(p[i]);
for (int i = 0; i < Y; i++)
d.push_back(q[i]);
for (int i = 0; i < C; i++)
d.push_back(r[i]);
sort(d.rbegin(), d.rend());
long long sum = 0;
for (int i = 0; i < X + Y; i++) {
sum += d[i];
}
cout << sum << endl;
return 0;
}
| replace | 29 | 33 | 29 | 32 | TLE | |
p02727 | C++ | Runtime Error | #include "bits/stdc++.h"
#define REP(i, n, N) for (ll i = (n); i < (N); i++)
#define RREP(i, n, N) for (ll i = (N - 1); i >= (n); i--)
#define p(s) cout << (s) << endl
#define p2(a, b) cout << (a) << " " << (b) << endl
using namespace std;
typedef long long ll;
ll mod = 1e9 + 7;
ll inf = 1e18;
ll X, Y, A, B, C;
ll p[100010], q[100010], r[100010];
priority_queue<ll> pq;
ll ans;
int main() {
cin >> X >> Y >> A >> B >> C;
REP(i, 0, A) cin >> p[i];
REP(i, 0, B) cin >> q[i];
REP(i, 0, C) cin >> r[i];
sort(p, p + A);
sort(q, q + B);
sort(r, r + C);
REP(i, 0, X) { pq.push(p[A - i - 1]); }
REP(i, 0, Y) { pq.push(q[B - i - 1]); }
REP(i, 0, X + Y) { pq.push(r[C - i - 1]); }
REP(i, 0, X + Y) {
ans += pq.top();
pq.pop();
}
p(ans);
return 0;
}
| #include "bits/stdc++.h"
#define REP(i, n, N) for (ll i = (n); i < (N); i++)
#define RREP(i, n, N) for (ll i = (N - 1); i >= (n); i--)
#define p(s) cout << (s) << endl
#define p2(a, b) cout << (a) << " " << (b) << endl
using namespace std;
typedef long long ll;
ll mod = 1e9 + 7;
ll inf = 1e18;
ll X, Y, A, B, C;
ll p[100010], q[100010], r[100010];
priority_queue<ll> pq;
ll ans;
int main() {
cin >> X >> Y >> A >> B >> C;
REP(i, 0, A) cin >> p[i];
REP(i, 0, B) cin >> q[i];
REP(i, 0, C) cin >> r[i];
sort(p, p + A);
sort(q, q + B);
sort(r, r + C);
REP(i, 0, min(A, X)) { pq.push(p[A - i - 1]); }
REP(i, 0, min(B, Y)) { pq.push(q[B - i - 1]); }
REP(i, 0, min(C, X + Y)) { pq.push(r[C - i - 1]); }
REP(i, 0, X + Y) {
ans += pq.top();
pq.pop();
}
p(ans);
return 0;
}
| replace | 23 | 26 | 23 | 26 | 0 | |
p02727 | C++ | Time Limit Exceeded | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define DB double
#define ST string
#define BS bitset
#define VE vector
#define VL vector<LL>
#define VP vector<pair<LL, LL>>
#define VVL vector<vector<LL>>
#define PQ priority_queue
#define PQS priority_queue<LL, vector<LL>, greater<LL>>
#define PB push_back
#define POB pop_back
#define PF push_front
#define POF pop_front
#define MP make_pair
#define TS to_string
#define TU to_ullong
#define FOR(i, a, n) for (i = a; i < n; i++)
#define rep(i, n) FOR(i, 0, n)
#define ALL(a) a.begin(), a.end()
#define RALL(a) a.rbegin(), a.rend()
#define SORT(a) sort(ALL(a))
#define REV(a) reverse(ALL(a))
#define UB(a, n) *upper_bound(ALL(a), n)
#define LB(a, n) *lower_bound(ALL(a), n)
#define INF 1145141919810364364
#define PI 3.14159265358979
// #define MOD 1000000007
#define MOD 998244353
#define ERR 0.00000000000001
#define NUM 200010
#define FAST \
cin.tie(0); \
ios::sync_with_stdio(false)
void Yn(LL a) {
if (a)
printf("Yes\n");
else
printf("No\n");
}
void YN(LL a) {
if (a)
printf("YES\n");
else
printf("NO\n");
}
LL pwmn(LL a, LL n) {
LL ans = 1;
while (ans < a)
ans *= n;
return ans;
}
LL GCD(LL a, LL b) {
LL c = 1, tmp = max(a, b);
b = min(a, b);
a = tmp;
while (c != 0) {
c = a % b;
a = b;
b = c;
}
return a;
}
LL LCM(LL a, LL b) { return a * b / GCD(a, b); }
LL mod(LL a, LL m) {
if (a < 0)
return a % m + m;
else
return a % m;
}
LL DIV(LL a, LL d) {
LL m = MOD, x = 1, y = 0, k;
while (m) {
k = d / m;
d -= k * m;
swap(m, d);
x -= k * y;
swap(x, y);
}
return mod(a * mod(x, MOD), MOD);
}
LL FAC(LL a) {
LL i, ans = 1;
FOR(i, 1, a + 1) {
ans *= i;
if (MOD > 0 && ans > MOD)
ans %= MOD;
}
return ans;
}
LL POW(LL a, LL n) {
LL ans = 1;
while (n > 0) {
if (n & 1)
ans = ans * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return ans;
}
LL fact[NUM], finv[NUM], inv[NUM];
void comi() {
LL i;
fact[0] = fact[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
FOR(i, 2, NUM) {
fact[i] = fact[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
LL com(LL n, LL k) {
if (n < k || n < 0 || k < 0)
return 0;
return fact[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
bool cmps(pair<LL, LL> a, pair<LL, LL> b) {
if (a.second != b.second)
return a.second < b.second;
return a.first < b.first;
}
int lcmpr(const void *a, const void *b) {
if (*(LL *)a > *(LL *)b)
return -1;
if (*(LL *)a < *(LL *)b)
return 1;
return 0;
}
int main() {
FAST;
LL i, ans = 0, X, Y, A, B, C;
cin >> X >> Y >> A >> B >> C;
LL p[A], q[B], r[C];
PQS a, b;
rep(i, A) cin >> p[i];
rep(i, B) cin >> q[i];
rep(i, C) cin >> r[i];
qsort(p, A, sizeof(LL), lcmpr);
qsort(q, B, sizeof(LL), lcmpr);
qsort(r, C, sizeof(LL), lcmpr);
rep(i, X) {
a.push(p[i]);
ans += p[i];
}
rep(i, Y) {
b.push(q[i]);
ans += q[i];
}
rep(i, C) {
if (a.top() <= b.top() && a.top() <= r[i]) {
ans -= a.top();
a.pop();
ans += r[i];
a.push(r[i]);
} else if (b.top() <= a.top() && b.top() <= r[i]) {
ans -= b.top();
b.pop();
ans += r[i];
b.push(r[i]);
} else
break;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define LL long long
#define DB double
#define ST string
#define BS bitset
#define VE vector
#define VL vector<LL>
#define VP vector<pair<LL, LL>>
#define VVL vector<vector<LL>>
#define PQ priority_queue
#define PQS priority_queue<LL, vector<LL>, greater<LL>>
#define PB push_back
#define POB pop_back
#define PF push_front
#define POF pop_front
#define MP make_pair
#define TS to_string
#define TU to_ullong
#define FOR(i, a, n) for (i = a; i < n; i++)
#define rep(i, n) FOR(i, 0, n)
#define ALL(a) a.begin(), a.end()
#define RALL(a) a.rbegin(), a.rend()
#define SORT(a) sort(ALL(a))
#define REV(a) reverse(ALL(a))
#define UB(a, n) *upper_bound(ALL(a), n)
#define LB(a, n) *lower_bound(ALL(a), n)
#define INF 1145141919810364364
#define PI 3.14159265358979
// #define MOD 1000000007
#define MOD 998244353
#define ERR 0.00000000000001
#define NUM 200010
#define FAST \
cin.tie(0); \
ios::sync_with_stdio(false)
void Yn(LL a) {
if (a)
printf("Yes\n");
else
printf("No\n");
}
void YN(LL a) {
if (a)
printf("YES\n");
else
printf("NO\n");
}
LL pwmn(LL a, LL n) {
LL ans = 1;
while (ans < a)
ans *= n;
return ans;
}
LL GCD(LL a, LL b) {
LL c = 1, tmp = max(a, b);
b = min(a, b);
a = tmp;
while (c != 0) {
c = a % b;
a = b;
b = c;
}
return a;
}
LL LCM(LL a, LL b) { return a * b / GCD(a, b); }
LL mod(LL a, LL m) {
if (a < 0)
return a % m + m;
else
return a % m;
}
LL DIV(LL a, LL d) {
LL m = MOD, x = 1, y = 0, k;
while (m) {
k = d / m;
d -= k * m;
swap(m, d);
x -= k * y;
swap(x, y);
}
return mod(a * mod(x, MOD), MOD);
}
LL FAC(LL a) {
LL i, ans = 1;
FOR(i, 1, a + 1) {
ans *= i;
if (MOD > 0 && ans > MOD)
ans %= MOD;
}
return ans;
}
LL POW(LL a, LL n) {
LL ans = 1;
while (n > 0) {
if (n & 1)
ans = ans * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return ans;
}
LL fact[NUM], finv[NUM], inv[NUM];
void comi() {
LL i;
fact[0] = fact[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
FOR(i, 2, NUM) {
fact[i] = fact[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
LL com(LL n, LL k) {
if (n < k || n < 0 || k < 0)
return 0;
return fact[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
bool cmps(pair<LL, LL> a, pair<LL, LL> b) {
if (a.second != b.second)
return a.second < b.second;
return a.first < b.first;
}
int lcmpr(const void *a, const void *b) {
if (*(LL *)a > *(LL *)b)
return -1;
if (*(LL *)a < *(LL *)b)
return 1;
return 0;
}
int main() {
FAST;
LL i, ans = 0, X, Y, A, B, C;
cin >> X >> Y >> A >> B >> C;
LL p[A], q[B], r[C];
PQS a, b;
rep(i, A) cin >> p[i];
rep(i, B) cin >> q[i];
rep(i, C) cin >> r[i];
qsort(p, A, sizeof(LL), lcmpr);
qsort(q, B, sizeof(LL), lcmpr);
qsort(r, C, sizeof(LL), lcmpr);
rep(i, X) {
a.push(p[i]);
ans += p[i];
}
rep(i, Y) {
b.push(q[i]);
ans += q[i];
}
rep(i, C) {
if (a.top() <= b.top() && a.top() <= r[i]) {
ans -= a.top();
a.pop();
ans += r[i];
a.push(r[i]);
} else if (b.top() <= a.top() && b.top() <= r[i]) {
ans -= b.top();
b.pop();
ans += r[i];
b.push(r[i]);
} else
break;
}
cout << ans << endl;
}
| delete | 0 | 1 | 0 | 0 | TLE | |
p02727 | C++ | Runtime Error | #pragma GCC optimize("O3")
#pragma GCC target("avx")
#pragma GCC optimize("unroll-loops")
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define DB double
#define ST string
#define BS bitset
#define VE vector
#define VL vector<LL>
#define VP vector<pair<LL, LL>>
#define VVL vector<vector<LL>>
// #define PQ priority_queue
#define PQS priority_queue<LL, vector<LL>, greater<LL>>
#define PB push_back
#define POB pop_back
#define PF push_front
#define POF pop_front
#define EB emplace_back
#define MP make_pair
#define TS to_string
#define TU to_ullong
#define FOR(i, a, n) for (i = a; i < n; i++)
#define rep(i, n) FOR(i, 0, n)
#define ALL(a) a.begin(), a.end()
#define RALL(a) a.rbegin(), a.rend()
#define SORT(a) sort(ALL(a))
#define REV(a) reverse(ALL(a))
#define UB(a, n) *upper_bound(ALL(a), n)
#define LB(a, n) *lower_bound(ALL(a), n)
#define INF 1145141919810364364
#define PI 3.14159265358979
#define MOD 1000000007
// #define MOD 998244353
#define ERR 0.00000000000001
#define NUM 2000
#define FAST \
cin.tie(0); \
ios::sync_with_stdio(false)
void Yn(LL a) {
if (a)
printf("Yes\n");
else
printf("No\n");
}
void YN(LL a) {
if (a)
printf("YES\n");
else
printf("NO\n");
}
LL pwmn(LL a, LL n) {
LL ans = 1;
while (ans < a)
ans *= n;
return ans;
}
LL GCD(LL a, LL b) {
LL c = 1, tmp = max(a, b);
b = min(a, b);
a = tmp;
while (c != 0) {
c = a % b;
a = b;
b = c;
}
return a;
}
LL LCM(LL a, LL b) { return a * b / GCD(a, b); }
LL mod(LL a, LL m) {
if (a < 0)
return a % m + m;
else
return a % m;
}
LL DIV(LL a, LL d) {
LL m = MOD, x = 1, y = 0, k;
while (m) {
k = d / m;
d -= k * m;
swap(m, d);
x -= k * y;
swap(x, y);
}
return mod(a * mod(x, MOD), MOD);
}
LL POW(LL a, LL n) {
LL ans = 1;
while (n > 0) {
if (n & 1)
ans = ans * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return ans;
}
LL fact[NUM], finv[NUM], inv[NUM];
void comi() {
LL i;
fact[0] = fact[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
FOR(i, 2, NUM) {
fact[i] = fact[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
LL com(LL n, LL k) {
if (n < k || n < 0 || k < 0)
return 0;
return fact[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
bool cmps(pair<LL, LL> a, pair<LL, LL> b) {
if (a.second != b.second)
return a.second < b.second;
return a.first < b.first;
}
typedef struct {
LL pid, pnum, rpid[NUM], cpid[NUM], que[NUM];
} PQ;
// ポインタ渡し、pid/pnum初期化 忘れずに
LL judge(LL a, LL b, PQ *pq) {
if (pq->pnum < b || b == 1)
return 0;
return pq->cpid[pq->que[a]] > pq->cpid[pq->que[b]] ? 1 : 0;
}
void push(LL a, LL n, PQ *pq) {
LL i = ++pq->pid, j = ++pq->pnum;
pq->rpid[i] = n, pq->cpid[i] = a, pq->que[j] = i;
while (judge(j / 2, j, pq))
pq->que[j] = pq->que[j / 2], pq->que[j /= 2] = i;
}
LL pop(PQ *pq) {
LL ans = pq->rpid[pq->que[1]], i = 1, j;
LL n = pq->que[pq->pnum--];
pq->que[1] = n;
while (judge(i, j = i * 2 + judge(i * 2, i * 2 + 1, pq), pq))
pq->que[i] = pq->que[j], pq->que[i = j] = n;
return ans;
}
int main() {
FAST;
LL i, ans = 0, X, Y, A, B, C, pa, pb;
cin >> X >> Y >> A >> B >> C;
VL p(A), q(B), r(C);
PQ a, b;
a.pid = a.pnum = b.pid = b.pnum = 0;
rep(i, A) cin >> p[i];
rep(i, B) cin >> q[i];
rep(i, C) cin >> r[i];
SORT(p);
SORT(q);
SORT(r);
REV(p);
REV(q);
REV(r);
rep(i, X) {
push(p[i], p[i], &a);
ans += p[i];
}
rep(i, Y) {
push(q[i], q[i], &b);
ans += q[i];
}
rep(i, C) {
pa = pop(&a);
pb = pop(&b);
if (pa <= pb && pa <= r[i]) {
ans -= pa;
ans += r[i];
push(r[i], r[i], &a);
push(pb, pb, &b);
} else if (pb <= pa && pb <= r[i]) {
ans -= pb;
ans += r[i];
push(r[i], r[i], &b);
push(pa, pa, &a);
} else
break;
}
cout << ans << endl;
}
| #pragma GCC optimize("O3")
#pragma GCC target("avx")
#pragma GCC optimize("unroll-loops")
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define DB double
#define ST string
#define BS bitset
#define VE vector
#define VL vector<LL>
#define VP vector<pair<LL, LL>>
#define VVL vector<vector<LL>>
// #define PQ priority_queue
#define PQS priority_queue<LL, vector<LL>, greater<LL>>
#define PB push_back
#define POB pop_back
#define PF push_front
#define POF pop_front
#define EB emplace_back
#define MP make_pair
#define TS to_string
#define TU to_ullong
#define FOR(i, a, n) for (i = a; i < n; i++)
#define rep(i, n) FOR(i, 0, n)
#define ALL(a) a.begin(), a.end()
#define RALL(a) a.rbegin(), a.rend()
#define SORT(a) sort(ALL(a))
#define REV(a) reverse(ALL(a))
#define UB(a, n) *upper_bound(ALL(a), n)
#define LB(a, n) *lower_bound(ALL(a), n)
#define INF 1145141919810364364
#define PI 3.14159265358979
#define MOD 1000000007
// #define MOD 998244353
#define ERR 0.00000000000001
#define NUM 200010
#define FAST \
cin.tie(0); \
ios::sync_with_stdio(false)
void Yn(LL a) {
if (a)
printf("Yes\n");
else
printf("No\n");
}
void YN(LL a) {
if (a)
printf("YES\n");
else
printf("NO\n");
}
LL pwmn(LL a, LL n) {
LL ans = 1;
while (ans < a)
ans *= n;
return ans;
}
LL GCD(LL a, LL b) {
LL c = 1, tmp = max(a, b);
b = min(a, b);
a = tmp;
while (c != 0) {
c = a % b;
a = b;
b = c;
}
return a;
}
LL LCM(LL a, LL b) { return a * b / GCD(a, b); }
LL mod(LL a, LL m) {
if (a < 0)
return a % m + m;
else
return a % m;
}
LL DIV(LL a, LL d) {
LL m = MOD, x = 1, y = 0, k;
while (m) {
k = d / m;
d -= k * m;
swap(m, d);
x -= k * y;
swap(x, y);
}
return mod(a * mod(x, MOD), MOD);
}
LL POW(LL a, LL n) {
LL ans = 1;
while (n > 0) {
if (n & 1)
ans = ans * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return ans;
}
LL fact[NUM], finv[NUM], inv[NUM];
void comi() {
LL i;
fact[0] = fact[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
FOR(i, 2, NUM) {
fact[i] = fact[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
LL com(LL n, LL k) {
if (n < k || n < 0 || k < 0)
return 0;
return fact[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
bool cmps(pair<LL, LL> a, pair<LL, LL> b) {
if (a.second != b.second)
return a.second < b.second;
return a.first < b.first;
}
typedef struct {
LL pid, pnum, rpid[NUM], cpid[NUM], que[NUM];
} PQ;
// ポインタ渡し、pid/pnum初期化 忘れずに
LL judge(LL a, LL b, PQ *pq) {
if (pq->pnum < b || b == 1)
return 0;
return pq->cpid[pq->que[a]] > pq->cpid[pq->que[b]] ? 1 : 0;
}
void push(LL a, LL n, PQ *pq) {
LL i = ++pq->pid, j = ++pq->pnum;
pq->rpid[i] = n, pq->cpid[i] = a, pq->que[j] = i;
while (judge(j / 2, j, pq))
pq->que[j] = pq->que[j / 2], pq->que[j /= 2] = i;
}
LL pop(PQ *pq) {
LL ans = pq->rpid[pq->que[1]], i = 1, j;
LL n = pq->que[pq->pnum--];
pq->que[1] = n;
while (judge(i, j = i * 2 + judge(i * 2, i * 2 + 1, pq), pq))
pq->que[i] = pq->que[j], pq->que[i = j] = n;
return ans;
}
int main() {
FAST;
LL i, ans = 0, X, Y, A, B, C, pa, pb;
cin >> X >> Y >> A >> B >> C;
VL p(A), q(B), r(C);
PQ a, b;
a.pid = a.pnum = b.pid = b.pnum = 0;
rep(i, A) cin >> p[i];
rep(i, B) cin >> q[i];
rep(i, C) cin >> r[i];
SORT(p);
SORT(q);
SORT(r);
REV(p);
REV(q);
REV(r);
rep(i, X) {
push(p[i], p[i], &a);
ans += p[i];
}
rep(i, Y) {
push(q[i], q[i], &b);
ans += q[i];
}
rep(i, C) {
pa = pop(&a);
pb = pop(&b);
if (pa <= pb && pa <= r[i]) {
ans -= pa;
ans += r[i];
push(r[i], r[i], &a);
push(pb, pb, &b);
} else if (pb <= pa && pb <= r[i]) {
ans -= pb;
ans += r[i];
push(r[i], r[i], &b);
push(pa, pa, &a);
} else
break;
}
cout << ans << endl;
}
| replace | 37 | 38 | 37 | 38 | 0 | |
p02727 | C++ | Runtime Error | #pragma region template
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vi;
typedef pair<ll, ll> ii;
#define REP(i, n) for (ll i = 0; i < (n); ++i)
#define REP1(i, n) for (ll i = 1; i <= (n); ++i)
#define OUT(x) cout << (x) << endl;
#define OUTA(a) \
REP(i, (a).size()) { cout << (a[i]) << (i == (a).size() - 1 ? "\n" : " "); }
#define ALL(a) (a).begin(), (a).end()
#define SORT(a) sort(ALL(a))
#define RSORT(a) \
SORT(a); \
reverse(ALL(a))
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
int main() {
ll X, Y, A, B, C;
cin >> X >> Y >> A >> B >> C;
vi p(A), q(B), r(C);
REP(i, A) { cin >> p[i]; }
REP(i, B) { cin >> q[i]; }
REP(i, C) { cin >> r[i]; }
RSORT(p);
RSORT(q);
RSORT(r);
vi d;
ll ans = 0;
REP(i, X) {
d.push_back(p[i]);
ans += p[i];
}
REP(i, Y) {
d.push_back(q[i]);
ans += q[i];
}
SORT(d);
REP(i, C) {
if (d[i] < r[i]) {
ans += r[i] - d[i];
}
}
OUT(ans);
}
#pragma endregion template | #pragma region template
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vi;
typedef pair<ll, ll> ii;
#define REP(i, n) for (ll i = 0; i < (n); ++i)
#define REP1(i, n) for (ll i = 1; i <= (n); ++i)
#define OUT(x) cout << (x) << endl;
#define OUTA(a) \
REP(i, (a).size()) { cout << (a[i]) << (i == (a).size() - 1 ? "\n" : " "); }
#define ALL(a) (a).begin(), (a).end()
#define SORT(a) sort(ALL(a))
#define RSORT(a) \
SORT(a); \
reverse(ALL(a))
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
int main() {
ll X, Y, A, B, C;
cin >> X >> Y >> A >> B >> C;
vi p(A), q(B), r(C);
REP(i, A) { cin >> p[i]; }
REP(i, B) { cin >> q[i]; }
REP(i, C) { cin >> r[i]; }
RSORT(p);
RSORT(q);
RSORT(r);
vi d;
ll ans = 0;
REP(i, X) {
d.push_back(p[i]);
ans += p[i];
}
REP(i, Y) {
d.push_back(q[i]);
ans += q[i];
}
SORT(d);
REP(i, C) {
if (i < d.size() and d[i] < r[i]) {
ans += r[i] - d[i];
}
}
OUT(ans);
}
#pragma endregion template | replace | 44 | 45 | 44 | 45 | 0 | |
p02727 | C++ | Time Limit Exceeded | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.14159265358979323846;
typedef long long ll;
const double EPS = 1e-9;
// #define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep(i, n) for (ll i = 0; i < (n); ++i)
// typedef pair<ll, ll> P;
typedef pair<ll, ll> P;
const ll INF = 10e17;
#define cmin(x, y) x = min(x, y)
#define cmax(x, y) x = max(x, y)
#define ret() return 0;
std::istream &operator>>(std::istream &in, set<int> &o) {
ll a;
in >> a;
o.insert(a);
return in;
}
std::istream &operator>>(std::istream &in, queue<int> &o) {
ll a;
in >> a;
o.push(a);
return in;
}
bool contain(set<int> &s, int a) { return s.find(a) != s.end(); }
// ofstream outfile("log.txt");
// outfile << setw(6) << setfill('0') << prefecture << setw(6) << setfill('0')
// << rank << endl;
// std::cout << std::bitset<8>(9);
// const ll mod = 1e10;
typedef priority_queue<ll, vector<ll>, greater<ll>> PQ_ASK;
int main() {
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<ll> reds(a), blues(b), whites(c);
rep(i, a) cin >> reds[i];
rep(i, b) cin >> blues[i];
rep(i, c) cin >> whites[i];
sort(reds.rbegin(), reds.rend());
sort(blues.rbegin(), blues.rend());
sort(whites.rbegin(), whites.rend());
vector<ll> eats;
rep(i, x) eats.push_back(reds[i]);
rep(i, y) eats.push_back(blues[i]);
for (ll l : whites)
eats.push_back(l);
sort(eats.rbegin(), eats.rend());
ll ans = accumulate(eats.begin(), eats.begin() + x + y, 0ll);
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
const double PI = 3.14159265358979323846;
typedef long long ll;
const double EPS = 1e-9;
// #define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep(i, n) for (ll i = 0; i < (n); ++i)
// typedef pair<ll, ll> P;
typedef pair<ll, ll> P;
const ll INF = 10e17;
#define cmin(x, y) x = min(x, y)
#define cmax(x, y) x = max(x, y)
#define ret() return 0;
std::istream &operator>>(std::istream &in, set<int> &o) {
ll a;
in >> a;
o.insert(a);
return in;
}
std::istream &operator>>(std::istream &in, queue<int> &o) {
ll a;
in >> a;
o.push(a);
return in;
}
bool contain(set<int> &s, int a) { return s.find(a) != s.end(); }
// ofstream outfile("log.txt");
// outfile << setw(6) << setfill('0') << prefecture << setw(6) << setfill('0')
// << rank << endl;
// std::cout << std::bitset<8>(9);
// const ll mod = 1e10;
typedef priority_queue<ll, vector<ll>, greater<ll>> PQ_ASK;
int main() {
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<ll> reds(a), blues(b), whites(c);
rep(i, a) cin >> reds[i];
rep(i, b) cin >> blues[i];
rep(i, c) cin >> whites[i];
sort(reds.rbegin(), reds.rend());
sort(blues.rbegin(), blues.rend());
sort(whites.rbegin(), whites.rend());
vector<ll> eats;
rep(i, x) eats.push_back(reds[i]);
rep(i, y) eats.push_back(blues[i]);
for (ll l : whites)
eats.push_back(l);
sort(eats.rbegin(), eats.rend());
ll ans = accumulate(eats.begin(), eats.begin() + x + y, 0ll);
cout << ans << endl;
}
| delete | 0 | 2 | 0 | 0 | TLE | |
p02727 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define REP(i, d, n) for (int i = (d); i < (n); ++i)
#define all(v) v.begin(), v.end()
using ll = long long;
using P = pair<int, int>;
int main() {
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<ll> p(a);
rep(i, a) { cin >> p[i]; }
sort(all(p));
reverse(all(p));
vector<ll> q(a);
rep(i, b) { cin >> q[i]; }
sort(all(q));
reverse(all(q));
priority_queue<ll> r;
rep(i, c) {
ll d;
cin >> d;
r.push(d);
}
rep(i, x) { r.push(p[i]); }
rep(i, y) { r.push(q[i]); }
ll ans = 0;
rep(i, x + y) {
ll tmp = r.top();
r.pop();
ans += tmp;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define REP(i, d, n) for (int i = (d); i < (n); ++i)
#define all(v) v.begin(), v.end()
using ll = long long;
using P = pair<int, int>;
int main() {
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<ll> p(a);
rep(i, a) { cin >> p[i]; }
sort(all(p));
reverse(all(p));
vector<ll> q(b);
rep(i, b) { cin >> q[i]; }
sort(all(q));
reverse(all(q));
priority_queue<ll> r;
rep(i, c) {
ll d;
cin >> d;
r.push(d);
}
rep(i, x) { r.push(p[i]); }
rep(i, y) { r.push(q[i]); }
ll ans = 0;
rep(i, x + y) {
ll tmp = r.top();
r.pop();
ans += tmp;
}
cout << ans << endl;
return 0;
} | replace | 17 | 18 | 17 | 18 | 0 | |
p02727 | C++ | Runtime Error | #include <bits/stdc++.h>
#define SORT(x) sort((x).begin(), (x).end())
#define RSORT(x) sort((x).rbegin(), (x).rend())
#define ALL(x) (x).begin(), (x).end()
#define rep(i, n) for (ll i = 0; i < n; i++)
#define reps(i, m, n) for (ll i = m; i < n; i++)
#define repr(i, m, n) for (ll i = m; i >= n; i--)
#define de(x) cout << #x << "=" << x << endl;
#define SP << " " <<
template <class T> bool maxi(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool mini(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
#define dame \
{ \
cout << "-1" \
<< "\n"; \
return; \
}
#define INF2 1000000000000000037
#define INF 1000000007
#define MOD 1000000007
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<ll, ll>;
//--GLOBAL---------------------------------
//--MAIN-----------------------------------
void Main() {
ll X, Y, A, B, C;
cin >> X >> Y >> A >> B >> C;
vector<ll> p(A), ps(A + 1);
vector<ll> q(B), qs(B + 1);
vector<ll> r(C), rs(C + 1);
rep(i, A) cin >> p[i];
rep(i, B) cin >> q[i];
rep(i, C) cin >> r[i];
RSORT(p);
RSORT(q);
RSORT(r);
rep(i, A) ps[i + 1] += ps[i] + p[i];
rep(i, B) qs[i + 1] += qs[i] + q[i];
rep(i, C) rs[i + 1] += rs[i] + r[i];
ll ans = 0;
rep(i, X + 1) {
ll c = X - i;
if (c > C)
continue;
/*bis*/ ll low = 0, high = C - c + 1; // min-1, max+1
while (abs(high - low) > 1) {
ll mid = (high + low) / 2;
bool ok = false;
if (r[mid + c - 1] > q[Y - mid])
ok = true;
(ok ? low : high) = mid;
} // okdir : ngdir
ll buf = ps[i] + qs[Y - low] + rs[c + low];
maxi(ans, buf);
}
cout << ans << "\n";
}
//--START----------------------------------
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(15);
Main();
}
//-----------------------------------------
| #include <bits/stdc++.h>
#define SORT(x) sort((x).begin(), (x).end())
#define RSORT(x) sort((x).rbegin(), (x).rend())
#define ALL(x) (x).begin(), (x).end()
#define rep(i, n) for (ll i = 0; i < n; i++)
#define reps(i, m, n) for (ll i = m; i < n; i++)
#define repr(i, m, n) for (ll i = m; i >= n; i--)
#define de(x) cout << #x << "=" << x << endl;
#define SP << " " <<
template <class T> bool maxi(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool mini(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
#define dame \
{ \
cout << "-1" \
<< "\n"; \
return; \
}
#define INF2 1000000000000000037
#define INF 1000000007
#define MOD 1000000007
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<ll, ll>;
//--GLOBAL---------------------------------
//--MAIN-----------------------------------
void Main() {
ll X, Y, A, B, C;
cin >> X >> Y >> A >> B >> C;
vector<ll> p(A), ps(A + 1);
vector<ll> q(B), qs(B + 1);
vector<ll> r(C), rs(C + 1);
rep(i, A) cin >> p[i];
rep(i, B) cin >> q[i];
rep(i, C) cin >> r[i];
RSORT(p);
RSORT(q);
RSORT(r);
rep(i, A) ps[i + 1] += ps[i] + p[i];
rep(i, B) qs[i + 1] += qs[i] + q[i];
rep(i, C) rs[i + 1] += rs[i] + r[i];
ll ans = 0;
rep(i, X + 1) {
ll c = X - i;
if (c > C)
continue;
/*bis*/ ll low = 0, high = C - c + 1; // min-1, max+1
while (abs(high - low) > 1) {
ll mid = (high + low) / 2;
bool ok = false;
if (Y - mid >= 0 and r[mid + c - 1] > q[Y - mid])
ok = true;
(ok ? low : high) = mid;
} // okdir : ngdir
ll buf = ps[i] + qs[Y - low] + rs[c + low];
maxi(ans, buf);
}
cout << ans << "\n";
}
//--START----------------------------------
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(15);
Main();
}
//-----------------------------------------
| replace | 63 | 64 | 63 | 64 | 0 | |
p02727 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define boost \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define ll long long int
#define vi vector<int>
#define vvi vector<vi>
#define pii pair<int, int>
#define vii vector<pii>
#define pb push_back
#define B begin()
#define E end()
#define F first
#define S second
#define loop(z, v) for (auto &z : v)
#define nl "\n"
#define fat 1000000007
int main() {
boost int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vi p(a), q(b), r(c);
loop(z, p) cin >> z;
loop(z, q) cin >> z;
loop(z, r) cin >> z;
sort(p.B, p.E, greater<int>());
sort(q.B, q.E, greater<int>());
sort(r.B, r.E, greater<int>());
vi tot;
for (int i = 0; i < x; i++)
tot.pb(p[i]);
for (int i = 0; i < y; i++)
tot.pb(q[i]);
sort(tot.B, tot.E);
for (int i = 0; i < c && tot.size(); i++) {
if (tot[i] < r[i])
tot[i] = r[i];
}
cout << accumulate(tot.B, tot.E, 0LL) << nl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define boost \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define ll long long int
#define vi vector<int>
#define vvi vector<vi>
#define pii pair<int, int>
#define vii vector<pii>
#define pb push_back
#define B begin()
#define E end()
#define F first
#define S second
#define loop(z, v) for (auto &z : v)
#define nl "\n"
#define fat 1000000007
int main() {
boost int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vi p(a), q(b), r(c);
loop(z, p) cin >> z;
loop(z, q) cin >> z;
loop(z, r) cin >> z;
sort(p.B, p.E, greater<int>());
sort(q.B, q.E, greater<int>());
sort(r.B, r.E, greater<int>());
vi tot;
for (int i = 0; i < x; i++)
tot.pb(p[i]);
for (int i = 0; i < y; i++)
tot.pb(q[i]);
sort(tot.B, tot.E);
for (int i = 0; i < c && i < tot.size(); i++) {
if (tot[i] < r[i])
tot[i] = r[i];
}
cout << accumulate(tot.B, tot.E, 0LL) << nl;
return 0;
} | replace | 43 | 44 | 43 | 44 | 0 | |
p02727 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#define FOR(i, x, n) for (ll i = x; i < n; i++)
#define pb push_back
#define pf push_front
#define ll long long
#define hii cout << "hii" << endl
#define pii pair<int, int>
#define pll pair<ll, ll>
#define int ll
#define mpp make_pair
#define endl '\n'
#define ff first
#define ss second
#define vi vector<int>
#define all(s) s.begin(), s.end()
#define si size()
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (T i : v)
os << i << ' ';
return os;
}
template <class T> ostream &operator<<(ostream &os, const set<T> &v) {
for (T i : v)
os << i << ' ';
return os;
}
template <class T, class S>
ostream &operator<<(ostream &os, const pair<T, S> &v) {
os << v.first << ' ' << v.second;
return os;
}
template <class T, class S>
ostream &operator<<(ostream &os, const unordered_map<T, S> &v) {
for (auto i : v)
os << '(' << i.first << "=>" << i.second << ')' << ' ';
return os;
}
#ifndef ONLINE_JUDGE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <class Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << endl;
}
template <class Arg1, class... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *sep = strchr(names + 1, ',');
cerr.write(names, sep - names) << " : " << arg1 << " ";
__f(sep + 1, args...);
}
#else
#define trace(...) 0
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target( \
"avx2,sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define _CRT_SECURE_NO_WARNINGS
#endif // ifndef ONLINE_JUDGE
const int N = 2e5 + 5;
const int mod = 1e7 + 7;
const int INF = 1e15;
const int LG = 21;
int arr[N];
int n, m, k;
vector<string> v1, v2;
int cnt[N];
int p[N];
int q[N];
int r[N];
void solve() {
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
for (int i = 0; i < a; i++)
cin >> p[i + 1];
for (int i = 0; i < b; i++)
cin >> q[i + 1];
for (int i = 0; i < c; i++)
cin >> r[i + 1];
if (x + y > a + b + c or x > a + c or y > b + c) {
cout << 0 << endl;
return;
}
sort(p + 1, p + a + 1, [](int a, int b) { return a > b; });
sort(q + 1, q + b + 1, [](int a, int b) { return a > b; });
sort(r + 1, r + c + 1, [](int a, int b) { return a > b; });
vector<int> pref(c + 1, 0);
vector<int> lol(c + 1, 0);
for (int i = 1; i <= c; i++)
pref[i] = r[i], pref[i] += pref[i - 1];
for (int i = 1; i <= a; i++)
lol[i] = p[i], lol[i] += lol[i - 1];
priority_queue<int, vector<int>, greater<int>> pq;
int sum = 0;
for (int i = 0; i < b; i++)
pq.push(q[i + 1]), sum += q[i + 1];
for (int i = x; i < c; i++)
pq.push(r[i + 1]), sum += r[i + 1];
while (pq.size() > y) {
sum -= pq.top();
pq.pop();
}
int curr = 0;
int ret = 0;
int ptr = min(x, c);
for (int i = max(x - c, 0LL); i <= min(x, a); i++, ptr--) {
int reqd = x - i;
int temp = lol[i] + pref[reqd] + sum;
ret = max(ret, temp);
if (pq.size() and pq.top() < r[ptr]) {
sum -= pq.top();
sum += r[ptr];
pq.pop();
pq.push(r[ptr]);
}
}
cout << ret << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
// cin >> t;
while (t--)
solve();
return 0;
} | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#define FOR(i, x, n) for (ll i = x; i < n; i++)
#define pb push_back
#define pf push_front
#define ll long long
#define hii cout << "hii" << endl
#define pii pair<int, int>
#define pll pair<ll, ll>
#define int ll
#define mpp make_pair
#define endl '\n'
#define ff first
#define ss second
#define vi vector<int>
#define all(s) s.begin(), s.end()
#define si size()
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (T i : v)
os << i << ' ';
return os;
}
template <class T> ostream &operator<<(ostream &os, const set<T> &v) {
for (T i : v)
os << i << ' ';
return os;
}
template <class T, class S>
ostream &operator<<(ostream &os, const pair<T, S> &v) {
os << v.first << ' ' << v.second;
return os;
}
template <class T, class S>
ostream &operator<<(ostream &os, const unordered_map<T, S> &v) {
for (auto i : v)
os << '(' << i.first << "=>" << i.second << ')' << ' ';
return os;
}
#ifndef ONLINE_JUDGE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <class Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << endl;
}
template <class Arg1, class... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *sep = strchr(names + 1, ',');
cerr.write(names, sep - names) << " : " << arg1 << " ";
__f(sep + 1, args...);
}
#else
#define trace(...) 0
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target( \
"avx2,sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define _CRT_SECURE_NO_WARNINGS
#endif // ifndef ONLINE_JUDGE
const int N = 2e5 + 5;
const int mod = 1e7 + 7;
const int INF = 1e15;
const int LG = 21;
int arr[N];
int n, m, k;
vector<string> v1, v2;
int cnt[N];
int p[N];
int q[N];
int r[N];
void solve() {
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
for (int i = 0; i < a; i++)
cin >> p[i + 1];
for (int i = 0; i < b; i++)
cin >> q[i + 1];
for (int i = 0; i < c; i++)
cin >> r[i + 1];
if (x + y > a + b + c or x > a + c or y > b + c) {
cout << 0 << endl;
return;
}
sort(p + 1, p + a + 1, [](int a, int b) { return a > b; });
sort(q + 1, q + b + 1, [](int a, int b) { return a > b; });
sort(r + 1, r + c + 1, [](int a, int b) { return a > b; });
vector<int> pref(c + 1, 0);
vector<int> lol(a + 1, 0);
for (int i = 1; i <= c; i++)
pref[i] = r[i], pref[i] += pref[i - 1];
for (int i = 1; i <= a; i++)
lol[i] = p[i], lol[i] += lol[i - 1];
priority_queue<int, vector<int>, greater<int>> pq;
int sum = 0;
for (int i = 0; i < b; i++)
pq.push(q[i + 1]), sum += q[i + 1];
for (int i = x; i < c; i++)
pq.push(r[i + 1]), sum += r[i + 1];
while (pq.size() > y) {
sum -= pq.top();
pq.pop();
}
int curr = 0;
int ret = 0;
int ptr = min(x, c);
for (int i = max(x - c, 0LL); i <= min(x, a); i++, ptr--) {
int reqd = x - i;
int temp = lol[i] + pref[reqd] + sum;
ret = max(ret, temp);
if (pq.size() and pq.top() < r[ptr]) {
sum -= pq.top();
sum += r[ptr];
pq.pop();
pq.push(r[ptr]);
}
}
cout << ret << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
// cin >> t;
while (t--)
solve();
return 0;
} | replace | 96 | 97 | 96 | 97 | 0 | |
p02727 | C++ | Runtime Error | #include <bits/stdc++.h>
#define int long long
using namespace std;
using Graph = vector<vector<int>>;
signed main() {
int X, Y, A, B, C;
cin >> X >> Y >> A >> B >> C;
vector<int> P(A);
for (int i = 0; i < A; i++)
cin >> P.at(i);
vector<int> Q(B);
for (int i = 0; i < B; i++)
cin >> Q.at(i);
vector<int> R(A);
for (int i = 0; i < C; i++)
cin >> R.at(i);
sort(P.rbegin(), P.rend());
sort(Q.rbegin(), Q.rend());
for (int i = 0; i < X; i++)
R.push_back(P.at(i));
for (int i = 0; i < Y; i++)
R.push_back(Q.at(i));
sort(R.rbegin(), R.rend());
int ans = 0;
for (int i = 0; i < X + Y; i++)
ans += R.at(i);
cout << ans << endl;
}
| #include <bits/stdc++.h>
#define int long long
using namespace std;
using Graph = vector<vector<int>>;
signed main() {
int X, Y, A, B, C;
cin >> X >> Y >> A >> B >> C;
vector<int> P(A);
for (int i = 0; i < A; i++)
cin >> P.at(i);
vector<int> Q(B);
for (int i = 0; i < B; i++)
cin >> Q.at(i);
vector<int> R(C);
for (int i = 0; i < C; i++)
cin >> R.at(i);
sort(P.rbegin(), P.rend());
sort(Q.rbegin(), Q.rend());
for (int i = 0; i < X; i++)
R.push_back(P.at(i));
for (int i = 0; i < Y; i++)
R.push_back(Q.at(i));
sort(R.rbegin(), R.rend());
int ans = 0;
for (int i = 0; i < X + Y; i++)
ans += R.at(i);
cout << ans << endl;
} | replace | 14 | 15 | 14 | 15 | 0 | |
p02727 | C++ | Runtime Error | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <string>
#include <utility>
#include <vector>
typedef long long ll;
using namespace std;
int main(void) {
int x, y, a, b, c, i;
vector<ll> p, q, r;
cin >> x >> y >> a >> b >> c;
p.resize(a);
q.resize(b);
r.resize(c);
for (i = 0; i < a; i++) {
cin >> p[i];
}
for (i = 0; i < b; i++) {
cin >> q[i];
}
for (i = 0; i < c; i++) {
cin >> r[i];
}
sort(p.begin(), p.end());
sort(q.begin(), q.end());
sort(r.begin(), r.end());
vector<ll> s;
s.resize(x + y + c);
int j = 0;
for (i = a - x; i < a; i++) {
s[j] = p[i];
j++;
}
for (i = b - x; i < b; i++) {
s[j] = q[i];
j++;
}
for (i = 0; i < c; i++) {
s[j] = r[i];
j++;
}
sort(s.begin(), s.end());
ll sum = 0;
for (i = c; i < x + y + c; i++) {
sum += s[i];
}
cout << sum << endl;
return 0;
}
| #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <string>
#include <utility>
#include <vector>
typedef long long ll;
using namespace std;
int main(void) {
int x, y, a, b, c, i;
vector<ll> p, q, r;
cin >> x >> y >> a >> b >> c;
p.resize(a);
q.resize(b);
r.resize(c);
for (i = 0; i < a; i++) {
cin >> p[i];
}
for (i = 0; i < b; i++) {
cin >> q[i];
}
for (i = 0; i < c; i++) {
cin >> r[i];
}
sort(p.begin(), p.end());
sort(q.begin(), q.end());
sort(r.begin(), r.end());
vector<ll> s;
s.resize(x + y + c);
int j = 0;
for (i = a - x; i < a; i++) {
s[j] = p[i];
j++;
}
for (i = b - y; i < b; i++) {
s[j] = q[i];
j++;
}
for (i = 0; i < c; i++) {
s[j] = r[i];
j++;
}
sort(s.begin(), s.end());
ll sum = 0;
for (i = c; i < x + y + c; i++) {
sum += s[i];
}
cout << sum << endl;
return 0;
}
| replace | 44 | 45 | 44 | 45 | 0 | |
p02727 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (long long i = 0; i < n; i++)
#define all(v) v.begin(), v.end()
#define pq priority_queue
using vi = vector<int>; // intの1次元の型に vi という別名をつける
using vvi = vector<vi>; // intの2次元の型に vvi という別名をつける
using vvvi = vector<vvi>;
using ll = long long; // long longをllだけにした
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
using vb = vector<bool>;
using vvb = vector<vb>;
using mii = map<int, int>;
using pqls = priority_queue<long long>;
using pqlg = priority_queue<long long, vector<long long>, greater<long long>>;
using mll = map<long long, long long>;
using pll = pair<long long, long long>;
using sll = set<long long>;
long long divup(long long a, long long b);
long long kaijou(long long i);
long long P(long long n, long long k);
long long C(long long n, long long k);
long long GCD(long long a, long long b);
long long LCM(long long a, long long b);
bool prime(long long N);
double distance(vector<long long> p, vector<long long> q, long long n);
void press(vector<long long> &v);
void ranking(vector<long long> &v);
void erase(vector<long long> &v, long long i);
void unique(vector<long long> &v);
void printv(vector<long long> v);
vector<ll> keta(ll x);
long long modpow(long long a, long long n, long long mod);
long long modinv(long long a, long long mod);
// 20200416
vector<long long> inputv(long long n);
// 20200417
vector<long long> yakusuu(int n);
map<long long, long long> soinsuu(long long n);
vector<vector<long long>> maze(long long i, long long j, vector<string> &s);
// 20200423
vector<long long> eratos(long long n);
set<long long> eraset(long long n);
//////////////////////////////////////////////////////
// 端数繰りあがり割り算(検証済)
// a÷bの端数繰り上げ
// b!=0のデバグはしてないので分母に0を入れないように
// 負数対応
long long divup(long long a, long long b) {
long long x = abs(a);
long long y = abs(b);
long long z = (x + y - 1) / y;
if ((a < 0 && b > 0) || (a > 0 && b < 0))
return -z;
else if (a == 0)
return 0;
else
return z;
}
// 階乗
// 検証済み
long long kaijou(long long i) {
if (i == 0)
return 1;
long long j = 1;
for (long long k = 1; k <= i; k++) {
j *= k;
}
return j;
}
// 順列nPk(完成)
// n個の異なる要素から、取り出す順序を区別してk個取り出す場合の数
// n<kなら0を返す
// 敢えて負数時のデバグはしてない
long long P(long long n, long long k) {
if (n < k)
return 0;
long long y = 1;
for (long long i = 0; i < k; i++) {
y *= (n - i);
}
return y;
}
// 組み合わせnCk(検証済み)
// P,kaijouと併用
long long C(long long n, long long k) {
if (n < k)
return 0;
return P(n, k) / kaijou(k);
}
// nHk
// 区別しないn個の要素を、区別するk個のグループに分ける
// 0個のグループがあっ
// て良い
// C必須
// 最大公約数GCD,最小公倍数LCM
// LCMを使うときはGCDをセットで
// 検証済み
long long GCD(long long a, long long b) {
if (a < b)
swap(a, b);
long long d = a % b;
if (d == 0) {
return b;
}
return GCD(b, d);
}
long long LCM(long long a, long long b) { return (a / GCD(a, b)) * b; }
// 素数判定
// 素数ならばtrue、素数以外の整数にはfalse
// 負数は全てfalse
// 検証済み
bool prime(long long N) {
if (N == 1) {
return false;
}
if (N < 0)
return false;
long long p = sqrt(N);
for (long long i = 2; i <= p; i++) {
if (N % i == 0) {
return false;
}
}
return true;
}
// ユークリッド距離
// 検証済み
// 位置ベクトル1,位置ベクトル2,ベクトルの次元(2または3が一般的)
double distance(vector<long long> p, vector<long long> q, long long n) {
double x = 0;
for (long long i = 0; i < n; i++) {
x += pow((p.at(i) - q.at(i)), 2);
}
return sqrt(x);
}
// 配列圧縮(検証済)
//{1,36,1,3,8,-2,-92}を
//{2, 5,2,3,4, 1, 0}にする
void press(vector<long long> &v) {
long long n = v.size();
vector<long long> w(n);
map<long long, long long> m;
for (auto &p : v) {
m[p] = 0;
}
long long i = 0;
for (auto &p : m) {
p.second = i;
i++;
}
for (long long i = 0; i < n; i++) {
w.at(i) = m[v.at(i)];
}
v = w;
return;
}
// 配列のi番目の要素がj番目に小さいとき、j番目の数がiであるベクトルを返す関数
// 配列の要素が全て異なるときにしか正常に動作しない
// 配列の要素に同じものが含まれても見かけ上動作はするが意味のない値を戻し、
// エラーも起きないので注意
// 検証済
//{2,4,1,6,0,3,8,9,5}を
//{4,2,0,5,1,8,3,6,7}にして返す
//"rank"という名前にするとSTLの関数(配列の次元を返す関数)になるので注意
void ranking(vector<long long> &v) {
long long n = v.size();
map<long long, long long> m;
long long i;
for (i = 0; i < n; i++) {
m[v.at(i)] = i;
}
vector<long long> w(n);
i = 0;
for (auto &p : m) {
v.at(i) = p.second;
i++;
}
return;
}
// 部分削除(未検証)
// ベクトルのi番目(i=0,1,2,...,n-1)の要素を削除し、
// 以降の要素を全て前に1ずらして参照返し
// ベクトル長は1小さくなって返る
// i>n-1の時は変化しない
void erase(vector<long long> &v, long long i) {
long long n = v.size();
if (i > n - 1)
return;
for (long long j = i; j < n - 1; j++) {
v.at(j) = v.at(j + 1);
}
v.pop_back();
return;
}
// 重複削除(未完成)
// 引数ベクトルに同一要素が複数あるとき、先頭を残し他は削除
// 参照返し
// ベクトル長も変化する
// O(logn)くらい
void unique(vector<long long> &v) {
long long n = v.size();
set<long long> s;
long long i = 0;
while (i < n) {
if (s.count(v.at(i))) {
erase(v, i);
n--;
} else {
s.insert(v.at(i));
i++;
}
}
return;
}
// ベクトルの出力(検証済)
// debug用にvectorの中身を出力する
void printv(vector<long long> v) {
cout << "{ ";
for (auto &p : v) {
cout << p << ",";
}
cout << "}" << endl;
}
// 10進法でn桁の整数xに対して、大きい方の位から、その位の1桁の数字を
// 収納した長さnのベクトルを返す
// 0に対しては{0}を返す
// 検証済み
vector<ll> keta(ll x) {
if (x == 0)
return {0};
ll n = log10(x) + 1; // xの桁数
vll w(n, 0);
for (ll i = 0; i < n; i++) {
ll p;
p = x % 10;
x = x / 10;
w[n - 1 - i] = p;
}
return w;
}
// 20200415
// 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 を計算する
// modとaが互いに素のときのみ有効(数学的に逆元が一意に定まるのがそのときのみ)
long long modinv(long long a, long long mod) { return modpow(a, mod - 2, mod); }
// 整数n個の入力を受け取ってベクトルに突っ込んで返す
// チェック済み
vector<long long> inputv(long long n) {
vector<long long> v(n);
for (long long i = 0; i < n; i++) {
cin >> v[i];
}
return v;
}
vector<long long> yakusuu(long long n) // nの約数を列挙
{
vector<long long> ret;
for (long long i = 1; i <= sqrt(n); ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) {
ret.push_back(n / i);
}
}
}
sort(ret.begin(), ret.end());
return ret;
}
map<long long, long long> soinsuu(long long n) {
map<long long, long long> m;
long long p = sqrt(n);
while (n % 2 == 0) {
n /= 2;
if (m.count(2)) {
m[2]++;
} else {
m[2] = 1;
}
}
for (long long i = 3; i * i <= n; i += 2) {
while (n % i == 0) {
n /= i;
if (m.count(i)) {
m[i]++;
} else {
m[i] = 1;
}
}
}
if (n != 1)
m[n] = 1;
return m;
}
// スタートが(i,j)の迷路の全ての地点までの距離を幅優先探索で解く
// スタートから何マス離れているか(辿り着けない場合は-1)を入れたベクトルを返す
// 壁からスタートしても正常に動作するので注意(この関数の外で処理が必要)
// 検証済み 一応O(地図の広さ)くらい
vector<vector<long long>> maze(ll i, ll j, vector<string> &s) {
ll h = s.size();
ll w = s[0].size();
queue<vector<long long>> q;
vector<vector<long long>> dis(h, vll(w, -1));
q.push({i, j});
dis[i][j] = 0;
while (!q.empty()) {
auto v = q.front();
q.pop();
if (v[0] > 0 && s[v[0] - 1][v[1]] == '.' && dis[v[0] - 1][v[1]] == -1) {
dis[v[0] - 1][v[1]] = dis[v[0]][v[1]] + 1;
q.push({v[0] - 1, v[1]});
}
if (v[1] > 0 && s[v[0]][v[1] - 1] == '.' && dis[v[0]][v[1] - 1] == -1) {
dis[v[0]][v[1] - 1] = dis[v[0]][v[1]] + 1;
q.push({v[0], v[1] - 1});
}
if (v[0] < h - 1 && s[v[0] + 1][v[1]] == '.' && dis[v[0] + 1][v[1]] == -1) {
dis[v[0] + 1][v[1]] = dis[v[0]][v[1]] + 1;
q.push({v[0] + 1, v[1]});
}
if (v[1] < w - 1 && s[v[0]][v[1] + 1] == '.' && dis[v[0]][v[1] + 1] == -1) {
dis[v[0]][v[1] + 1] = dis[v[0]][v[1]] + 1;
q.push({v[0], v[1] + 1});
}
}
return dis; // スタートから何マス離れているか(辿り着けない場合は-1)
}
// エラトステネスのふるいによりn以下の素数を全てベクトルに入れて返す
// vector<long long> eratos(long long n){
// }
// 二項係数の剰余を求める
// 引数は剰余の形ではなくもとの数そのものである
// 未検証(検証サンプルがない)
long long modC(long long n, long long k, long long mod) {
if (n < k)
return 0;
long long p = 1, q = 1;
for (long long i = 0; i < k; i++) {
p = p * (n - i) % mod;
q = q * (i + 1) % mod;
}
return p * modinv(q, mod) % mod;
}
// 20200418
// 整数のとき限定の普通のPOW関数
// 標準機能のpow(a,n)は整数だとバグるのでこちらを使う
long long POW(long long a, long long n) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a;
a = a * a;
n >>= 1;
}
return res;
}
// 20200423
// エラトステネスのふるいによりn以下の素数を全てベクトルに入れて返す
vector<long long> eratos(long long n) {
if (n < 2)
return {};
vll v(n - 1);
rep(i, n - 1) {
v[i] = i + 2; // 2からnまで
}
ll i = 0;
while (i < n - 1) {
ll p = v[i];
for (ll j = i + 1; j < n - 1; j++) {
if (v[j] % p == 0) {
v.erase(v.begin() + j);
n--;
}
}
i++;
}
v.resize(n - 1);
return v;
}
// n以下の素数を全て詰めたset
set<long long> eraset(long long n) {
set<long long> s;
vll v = eratos(n);
for (auto &t : v) {
s.insert(t);
}
return s;
}
// cout<<fixed<<setprecision(10);
//////////////////////////////////////////////////
int main() {
ll x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
auto p = inputv(a);
auto q = inputv(b);
auto r = inputv(c);
sort(all(p));
sort(all(q));
sort(all(r));
reverse(all(p));
reverse(all(q));
reverse(all(r));
vll g(x), h(y);
rep(i, x) { g[i] = p[i]; }
rep(i, y) { h[i] = q[i]; }
ll e = x - 1;
ll f = y - 1;
rep(i, c) {
if (e < 0 && f < 0)
break;
if (e < 0 || g[e] > h[f]) {
if (h[f] >= r[i])
break;
h[f] = r[i];
f--;
} else {
if (g[e] >= r[i])
break;
g[e] = r[i];
e--;
}
}
ll res = 0;
rep(i, x) { res += g[i]; }
rep(i, y) { res += h[i]; }
cout << res << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (long long i = 0; i < n; i++)
#define all(v) v.begin(), v.end()
#define pq priority_queue
using vi = vector<int>; // intの1次元の型に vi という別名をつける
using vvi = vector<vi>; // intの2次元の型に vvi という別名をつける
using vvvi = vector<vvi>;
using ll = long long; // long longをllだけにした
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
using vb = vector<bool>;
using vvb = vector<vb>;
using mii = map<int, int>;
using pqls = priority_queue<long long>;
using pqlg = priority_queue<long long, vector<long long>, greater<long long>>;
using mll = map<long long, long long>;
using pll = pair<long long, long long>;
using sll = set<long long>;
long long divup(long long a, long long b);
long long kaijou(long long i);
long long P(long long n, long long k);
long long C(long long n, long long k);
long long GCD(long long a, long long b);
long long LCM(long long a, long long b);
bool prime(long long N);
double distance(vector<long long> p, vector<long long> q, long long n);
void press(vector<long long> &v);
void ranking(vector<long long> &v);
void erase(vector<long long> &v, long long i);
void unique(vector<long long> &v);
void printv(vector<long long> v);
vector<ll> keta(ll x);
long long modpow(long long a, long long n, long long mod);
long long modinv(long long a, long long mod);
// 20200416
vector<long long> inputv(long long n);
// 20200417
vector<long long> yakusuu(int n);
map<long long, long long> soinsuu(long long n);
vector<vector<long long>> maze(long long i, long long j, vector<string> &s);
// 20200423
vector<long long> eratos(long long n);
set<long long> eraset(long long n);
//////////////////////////////////////////////////////
// 端数繰りあがり割り算(検証済)
// a÷bの端数繰り上げ
// b!=0のデバグはしてないので分母に0を入れないように
// 負数対応
long long divup(long long a, long long b) {
long long x = abs(a);
long long y = abs(b);
long long z = (x + y - 1) / y;
if ((a < 0 && b > 0) || (a > 0 && b < 0))
return -z;
else if (a == 0)
return 0;
else
return z;
}
// 階乗
// 検証済み
long long kaijou(long long i) {
if (i == 0)
return 1;
long long j = 1;
for (long long k = 1; k <= i; k++) {
j *= k;
}
return j;
}
// 順列nPk(完成)
// n個の異なる要素から、取り出す順序を区別してk個取り出す場合の数
// n<kなら0を返す
// 敢えて負数時のデバグはしてない
long long P(long long n, long long k) {
if (n < k)
return 0;
long long y = 1;
for (long long i = 0; i < k; i++) {
y *= (n - i);
}
return y;
}
// 組み合わせnCk(検証済み)
// P,kaijouと併用
long long C(long long n, long long k) {
if (n < k)
return 0;
return P(n, k) / kaijou(k);
}
// nHk
// 区別しないn個の要素を、区別するk個のグループに分ける
// 0個のグループがあっ
// て良い
// C必須
// 最大公約数GCD,最小公倍数LCM
// LCMを使うときはGCDをセットで
// 検証済み
long long GCD(long long a, long long b) {
if (a < b)
swap(a, b);
long long d = a % b;
if (d == 0) {
return b;
}
return GCD(b, d);
}
long long LCM(long long a, long long b) { return (a / GCD(a, b)) * b; }
// 素数判定
// 素数ならばtrue、素数以外の整数にはfalse
// 負数は全てfalse
// 検証済み
bool prime(long long N) {
if (N == 1) {
return false;
}
if (N < 0)
return false;
long long p = sqrt(N);
for (long long i = 2; i <= p; i++) {
if (N % i == 0) {
return false;
}
}
return true;
}
// ユークリッド距離
// 検証済み
// 位置ベクトル1,位置ベクトル2,ベクトルの次元(2または3が一般的)
double distance(vector<long long> p, vector<long long> q, long long n) {
double x = 0;
for (long long i = 0; i < n; i++) {
x += pow((p.at(i) - q.at(i)), 2);
}
return sqrt(x);
}
// 配列圧縮(検証済)
//{1,36,1,3,8,-2,-92}を
//{2, 5,2,3,4, 1, 0}にする
void press(vector<long long> &v) {
long long n = v.size();
vector<long long> w(n);
map<long long, long long> m;
for (auto &p : v) {
m[p] = 0;
}
long long i = 0;
for (auto &p : m) {
p.second = i;
i++;
}
for (long long i = 0; i < n; i++) {
w.at(i) = m[v.at(i)];
}
v = w;
return;
}
// 配列のi番目の要素がj番目に小さいとき、j番目の数がiであるベクトルを返す関数
// 配列の要素が全て異なるときにしか正常に動作しない
// 配列の要素に同じものが含まれても見かけ上動作はするが意味のない値を戻し、
// エラーも起きないので注意
// 検証済
//{2,4,1,6,0,3,8,9,5}を
//{4,2,0,5,1,8,3,6,7}にして返す
//"rank"という名前にするとSTLの関数(配列の次元を返す関数)になるので注意
void ranking(vector<long long> &v) {
long long n = v.size();
map<long long, long long> m;
long long i;
for (i = 0; i < n; i++) {
m[v.at(i)] = i;
}
vector<long long> w(n);
i = 0;
for (auto &p : m) {
v.at(i) = p.second;
i++;
}
return;
}
// 部分削除(未検証)
// ベクトルのi番目(i=0,1,2,...,n-1)の要素を削除し、
// 以降の要素を全て前に1ずらして参照返し
// ベクトル長は1小さくなって返る
// i>n-1の時は変化しない
void erase(vector<long long> &v, long long i) {
long long n = v.size();
if (i > n - 1)
return;
for (long long j = i; j < n - 1; j++) {
v.at(j) = v.at(j + 1);
}
v.pop_back();
return;
}
// 重複削除(未完成)
// 引数ベクトルに同一要素が複数あるとき、先頭を残し他は削除
// 参照返し
// ベクトル長も変化する
// O(logn)くらい
void unique(vector<long long> &v) {
long long n = v.size();
set<long long> s;
long long i = 0;
while (i < n) {
if (s.count(v.at(i))) {
erase(v, i);
n--;
} else {
s.insert(v.at(i));
i++;
}
}
return;
}
// ベクトルの出力(検証済)
// debug用にvectorの中身を出力する
void printv(vector<long long> v) {
cout << "{ ";
for (auto &p : v) {
cout << p << ",";
}
cout << "}" << endl;
}
// 10進法でn桁の整数xに対して、大きい方の位から、その位の1桁の数字を
// 収納した長さnのベクトルを返す
// 0に対しては{0}を返す
// 検証済み
vector<ll> keta(ll x) {
if (x == 0)
return {0};
ll n = log10(x) + 1; // xの桁数
vll w(n, 0);
for (ll i = 0; i < n; i++) {
ll p;
p = x % 10;
x = x / 10;
w[n - 1 - i] = p;
}
return w;
}
// 20200415
// 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 を計算する
// modとaが互いに素のときのみ有効(数学的に逆元が一意に定まるのがそのときのみ)
long long modinv(long long a, long long mod) { return modpow(a, mod - 2, mod); }
// 整数n個の入力を受け取ってベクトルに突っ込んで返す
// チェック済み
vector<long long> inputv(long long n) {
vector<long long> v(n);
for (long long i = 0; i < n; i++) {
cin >> v[i];
}
return v;
}
vector<long long> yakusuu(long long n) // nの約数を列挙
{
vector<long long> ret;
for (long long i = 1; i <= sqrt(n); ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) {
ret.push_back(n / i);
}
}
}
sort(ret.begin(), ret.end());
return ret;
}
map<long long, long long> soinsuu(long long n) {
map<long long, long long> m;
long long p = sqrt(n);
while (n % 2 == 0) {
n /= 2;
if (m.count(2)) {
m[2]++;
} else {
m[2] = 1;
}
}
for (long long i = 3; i * i <= n; i += 2) {
while (n % i == 0) {
n /= i;
if (m.count(i)) {
m[i]++;
} else {
m[i] = 1;
}
}
}
if (n != 1)
m[n] = 1;
return m;
}
// スタートが(i,j)の迷路の全ての地点までの距離を幅優先探索で解く
// スタートから何マス離れているか(辿り着けない場合は-1)を入れたベクトルを返す
// 壁からスタートしても正常に動作するので注意(この関数の外で処理が必要)
// 検証済み 一応O(地図の広さ)くらい
vector<vector<long long>> maze(ll i, ll j, vector<string> &s) {
ll h = s.size();
ll w = s[0].size();
queue<vector<long long>> q;
vector<vector<long long>> dis(h, vll(w, -1));
q.push({i, j});
dis[i][j] = 0;
while (!q.empty()) {
auto v = q.front();
q.pop();
if (v[0] > 0 && s[v[0] - 1][v[1]] == '.' && dis[v[0] - 1][v[1]] == -1) {
dis[v[0] - 1][v[1]] = dis[v[0]][v[1]] + 1;
q.push({v[0] - 1, v[1]});
}
if (v[1] > 0 && s[v[0]][v[1] - 1] == '.' && dis[v[0]][v[1] - 1] == -1) {
dis[v[0]][v[1] - 1] = dis[v[0]][v[1]] + 1;
q.push({v[0], v[1] - 1});
}
if (v[0] < h - 1 && s[v[0] + 1][v[1]] == '.' && dis[v[0] + 1][v[1]] == -1) {
dis[v[0] + 1][v[1]] = dis[v[0]][v[1]] + 1;
q.push({v[0] + 1, v[1]});
}
if (v[1] < w - 1 && s[v[0]][v[1] + 1] == '.' && dis[v[0]][v[1] + 1] == -1) {
dis[v[0]][v[1] + 1] = dis[v[0]][v[1]] + 1;
q.push({v[0], v[1] + 1});
}
}
return dis; // スタートから何マス離れているか(辿り着けない場合は-1)
}
// エラトステネスのふるいによりn以下の素数を全てベクトルに入れて返す
// vector<long long> eratos(long long n){
// }
// 二項係数の剰余を求める
// 引数は剰余の形ではなくもとの数そのものである
// 未検証(検証サンプルがない)
long long modC(long long n, long long k, long long mod) {
if (n < k)
return 0;
long long p = 1, q = 1;
for (long long i = 0; i < k; i++) {
p = p * (n - i) % mod;
q = q * (i + 1) % mod;
}
return p * modinv(q, mod) % mod;
}
// 20200418
// 整数のとき限定の普通のPOW関数
// 標準機能のpow(a,n)は整数だとバグるのでこちらを使う
long long POW(long long a, long long n) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a;
a = a * a;
n >>= 1;
}
return res;
}
// 20200423
// エラトステネスのふるいによりn以下の素数を全てベクトルに入れて返す
vector<long long> eratos(long long n) {
if (n < 2)
return {};
vll v(n - 1);
rep(i, n - 1) {
v[i] = i + 2; // 2からnまで
}
ll i = 0;
while (i < n - 1) {
ll p = v[i];
for (ll j = i + 1; j < n - 1; j++) {
if (v[j] % p == 0) {
v.erase(v.begin() + j);
n--;
}
}
i++;
}
v.resize(n - 1);
return v;
}
// n以下の素数を全て詰めたset
set<long long> eraset(long long n) {
set<long long> s;
vll v = eratos(n);
for (auto &t : v) {
s.insert(t);
}
return s;
}
// cout<<fixed<<setprecision(10);
//////////////////////////////////////////////////
int main() {
ll x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
auto p = inputv(a);
auto q = inputv(b);
auto r = inputv(c);
sort(all(p));
sort(all(q));
sort(all(r));
reverse(all(p));
reverse(all(q));
reverse(all(r));
vll g(x), h(y);
rep(i, x) { g[i] = p[i]; }
rep(i, y) { h[i] = q[i]; }
ll e = x - 1;
ll f = y - 1;
rep(i, c) {
if (e < 0 && f < 0)
break;
if (e < 0 || (f > -1 && g[e] > h[f])) {
if (h[f] >= r[i])
break;
h[f] = r[i];
f--;
} else {
if (g[e] >= r[i])
break;
g[e] = r[i];
e--;
}
}
ll res = 0;
rep(i, x) { res += g[i]; }
rep(i, y) { res += h[i]; }
cout << res << endl;
}
| replace | 449 | 450 | 449 | 450 | 0 | |
p02727 | C++ | Runtime Error | /*
Author: Babin Dutta
*/
#include <bits/stdc++.h>
using namespace std;
#define mod 1000000007
#define ll long long int
#define pb push_back
#define mp make_pair
#define boost \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define f(i, n) for (int i = 0; i < n; i++)
#define ff(i, a, b) for (int i = a; i <= b; i++)
#define all(v) v.begin(), v.end()
#define endl "\n"
#define inf 1e18
void solve() {
int r, g, a, b, c;
cin >> r >> g >> a >> b >> c;
ll arr1[a], arr2[b], arr3[c];
f(i, a) cin >> arr1[i];
f(i, b) cin >> arr2[i];
f(i, c) cin >> arr3[i];
sort(arr1, arr1 + a);
sort(arr2, arr2 + b);
sort(arr3, arr3 + c);
ll ans = 0;
vector<ll> v;
int cnt = 0;
for (int i = a - 1; i >= 0; i--) {
cnt++;
ans += arr1[i];
v.pb(arr1[i]);
if (cnt == r)
break;
}
cnt = 0;
for (int i = b - 1; i >= 0; i--) {
cnt++;
ans += arr2[i];
v.pb(arr2[i]);
if (cnt == g)
break;
}
sort(all(v));
int j = 0;
for (int i = c - 1; i >= 0; i--) {
if (arr3[i] >= v[j]) {
ans += arr3[i] - v[j];
j++;
} else
break;
}
cout << ans << endl;
}
int main() {
#ifdef JUDGE
freopen("input.txt", "rt", stdin);
freopen("output.txt", "wt", stdout);
#endif
boost;
int t = 1; // cin>>t;
for (int i = 1; i <= t; i++)
solve();
return 0;
} | /*
Author: Babin Dutta
*/
#include <bits/stdc++.h>
using namespace std;
#define mod 1000000007
#define ll long long int
#define pb push_back
#define mp make_pair
#define boost \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define f(i, n) for (int i = 0; i < n; i++)
#define ff(i, a, b) for (int i = a; i <= b; i++)
#define all(v) v.begin(), v.end()
#define endl "\n"
#define inf 1e18
void solve() {
int r, g, a, b, c;
cin >> r >> g >> a >> b >> c;
ll arr1[a], arr2[b], arr3[c];
f(i, a) cin >> arr1[i];
f(i, b) cin >> arr2[i];
f(i, c) cin >> arr3[i];
sort(arr1, arr1 + a);
sort(arr2, arr2 + b);
sort(arr3, arr3 + c);
ll ans = 0;
vector<ll> v;
int cnt = 0;
for (int i = a - 1; i >= 0; i--) {
cnt++;
ans += arr1[i];
v.pb(arr1[i]);
if (cnt == r)
break;
}
cnt = 0;
for (int i = b - 1; i >= 0; i--) {
cnt++;
ans += arr2[i];
v.pb(arr2[i]);
if (cnt == g)
break;
}
sort(all(v));
int j = 0;
for (int i = c - 1; i >= 0; i--) {
if (j == v.size())
break;
if (arr3[i] >= v[j]) {
ans += arr3[i] - v[j];
j++;
} else
break;
}
cout << ans << endl;
}
int main() {
#ifdef JUDGE
freopen("input.txt", "rt", stdin);
freopen("output.txt", "wt", stdout);
#endif
boost;
int t = 1; // cin>>t;
for (int i = 1; i <= t; i++)
solve();
return 0;
} | insert | 51 | 51 | 51 | 53 | 0 | |
p02727 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rrep(i, n) for (int i = n - 1; i >= 0; --i)
#define fi first
#define se second
using namespace std;
using lint = long long;
using uint = unsigned int;
using ulint = unsigned long long;
using ldouble = long double;
using pii = pair<int, int>;
using pli = pair<lint, lint>;
using pdd = pair<double, double>;
using pld = pair<ldouble, ldouble>;
using v1i = vector<int>;
using v1li = vector<lint>;
using v2i = vector<vector<int>>;
using v2li = vector<vector<lint>>;
using v3i = vector<vector<vector<int>>>;
using v3li = vector<vector<vector<lint>>>;
using v1b = vector<bool>;
using v2b = vector<vector<bool>>;
using v3b = vector<vector<vector<bool>>>;
using v1c = vector<char>;
using v2c = vector<vector<char>>;
using v3c = vector<vector<vector<char>>>;
constexpr lint mod1 = 1e9 + 7;
constexpr lint mod2 = 998244353;
int main() {
lint s = 0, x, y, a, b, c, k = 0;
cin >> x >> y >> a >> b >> c;
v1i t(a), u(b), v(c);
rep(i, a) cin >> t[i];
rep(i, b) cin >> u[i];
rep(i, c) cin >> v[i];
sort(t.begin(), t.end());
reverse(t.begin(), t.end());
sort(u.begin(), u.end());
reverse(u.begin(), u.end());
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
while (x > 0 || y > 0) {
if (v[k] - t[x - 1] > v[k] - u[y - 1] && x > 0) {
if (v[k] > t[x - 1] && k < c) {
s += v[k];
++k;
} else
s += t[x - 1];
--x;
} else {
if (v[k] > u[y - 1] && k < c) {
s += v[k];
++k;
} else
s += u[y - 1];
--y;
}
}
cout << s << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rrep(i, n) for (int i = n - 1; i >= 0; --i)
#define fi first
#define se second
using namespace std;
using lint = long long;
using uint = unsigned int;
using ulint = unsigned long long;
using ldouble = long double;
using pii = pair<int, int>;
using pli = pair<lint, lint>;
using pdd = pair<double, double>;
using pld = pair<ldouble, ldouble>;
using v1i = vector<int>;
using v1li = vector<lint>;
using v2i = vector<vector<int>>;
using v2li = vector<vector<lint>>;
using v3i = vector<vector<vector<int>>>;
using v3li = vector<vector<vector<lint>>>;
using v1b = vector<bool>;
using v2b = vector<vector<bool>>;
using v3b = vector<vector<vector<bool>>>;
using v1c = vector<char>;
using v2c = vector<vector<char>>;
using v3c = vector<vector<vector<char>>>;
constexpr lint mod1 = 1e9 + 7;
constexpr lint mod2 = 998244353;
int main() {
lint s = 0, x, y, a, b, c, k = 0;
cin >> x >> y >> a >> b >> c;
v1i t(a), u(b), v(c);
rep(i, a) cin >> t[i];
rep(i, b) cin >> u[i];
rep(i, c) cin >> v[i];
sort(t.begin(), t.end());
reverse(t.begin(), t.end());
sort(u.begin(), u.end());
reverse(u.begin(), u.end());
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
while (x > 0 || y > 0) {
if ((v[k] - t[x - 1] > v[k] - u[y - 1] && x > 0) || y == 0) {
if (v[k] > t[x - 1] && k < c) {
s += v[k];
++k;
} else
s += t[x - 1];
--x;
} else {
if (v[k] > u[y - 1] && k < c) {
s += v[k];
++k;
} else
s += u[y - 1];
--y;
}
}
cout << s << endl;
return 0;
} | replace | 43 | 44 | 43 | 44 | 0 | |
p02727 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#include <chrono>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace std::chrono;
using namespace __gnu_pbds;
#define fastio \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define fi first
#define se second
#define int long long
#define pb push_back
#define emp emplace_back
#define vv(x) vector<x>
#define mp(x, y) map<x, y>
#define dq(x) deque<x>
#define pql(x) priority_queue<x>
#define pqs(x) priority_queue<x, vv(x), greater<x>>
#define mod 1000000007
#define forf(i, a, b) for (int i = a; i < b; i++)
#define it(x) x::iterator
#define ll long long
#define debug(...) fprintf(stderr, __VA_ARGS__), fflush(stderr)
#define time__(d) \
for (long blockTime = 0; \
(blockTime == 0 ? (blockTime = clock()) != 0 : false); \
debug("%s time : %.4fs", d, \
(double)(clock() - blockTime) / CLOCKS_PER_SEC))
#define vii vector<int>
#define big 2e18
#define sm -1e9
#define mkr make_pair
#define vpi vector<pair<int, int>>
#define pii pair<int, int>
#define rng 500005
#define sz(x) (int)x.size()
#define rv(x) reverse(x.begin(), x.end())
#define out(x) cout << x.fi << " " << x.se << endl;
#define ordered_set \
tree<pii, null_type, less<pii>, rb_tree_tag, \
tree_order_statistics_node_update>
void pr_init() {
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
#endif
}
int p[100001], q[100001], r[100001];
void solve() {
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
forf(i, 0, a) cin >> p[i];
forf(i, 0, b) cin >> q[i];
forf(i, 0, c) cin >> r[i];
sort(p, p + a, greater<int>());
sort(q, q + b, greater<int>());
sort(r, r + c, greater<int>());
int i = x - 1, j = y - 1, k = 0;
int sw = 0;
for (int l = 0; l < x + y; l++) {
if (i < 0) {
if (k < c && q[j] < r[k]) {
swap(q[j], r[k]);
k++;
}
j--;
} else if (j < 0) {
if (k < c && p[i] < r[k]) {
swap(p[i], r[k]);
k++;
}
i--;
} else {
if (p[i] < q[j]) {
if (k < c && p[i] < r[k]) {
swap(p[i], r[k]);
k++;
}
i--;
} else {
if (k < c && q[j] < r[k]) {
swap(q[j], r[k]);
k++;
}
j--;
}
}
}
forf(i, 0, x) sw += p[i];
forf(i, 0, y) sw += q[i];
cout << sw << endl;
}
int32_t main() {
pr_init();
// fastio;
auto start = high_resolution_clock::now();
solve();
auto stop = high_resolution_clock::now();
auto duration = duration_cast<microseconds>(stop - start);
// cout << "Time taken by function: "
// << duration.count() << " microseconds" << endl;
}
| #include <bits/stdc++.h>
#include <chrono>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace std::chrono;
using namespace __gnu_pbds;
#define fastio \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define fi first
#define se second
#define int long long
#define pb push_back
#define emp emplace_back
#define vv(x) vector<x>
#define mp(x, y) map<x, y>
#define dq(x) deque<x>
#define pql(x) priority_queue<x>
#define pqs(x) priority_queue<x, vv(x), greater<x>>
#define mod 1000000007
#define forf(i, a, b) for (int i = a; i < b; i++)
#define it(x) x::iterator
#define ll long long
#define debug(...) fprintf(stderr, __VA_ARGS__), fflush(stderr)
#define time__(d) \
for (long blockTime = 0; \
(blockTime == 0 ? (blockTime = clock()) != 0 : false); \
debug("%s time : %.4fs", d, \
(double)(clock() - blockTime) / CLOCKS_PER_SEC))
#define vii vector<int>
#define big 2e18
#define sm -1e9
#define mkr make_pair
#define vpi vector<pair<int, int>>
#define pii pair<int, int>
#define rng 500005
#define sz(x) (int)x.size()
#define rv(x) reverse(x.begin(), x.end())
#define out(x) cout << x.fi << " " << x.se << endl;
#define ordered_set \
tree<pii, null_type, less<pii>, rb_tree_tag, \
tree_order_statistics_node_update>
void pr_init() {
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
#endif
}
int p[100001], q[100001], r[100001];
void solve() {
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
forf(i, 0, a) cin >> p[i];
forf(i, 0, b) cin >> q[i];
forf(i, 0, c) cin >> r[i];
sort(p, p + a, greater<int>());
sort(q, q + b, greater<int>());
sort(r, r + c, greater<int>());
int i = x - 1, j = y - 1, k = 0;
int sw = 0;
for (int l = 0; l < x + y; l++) {
if (i < 0) {
if (k < c && q[j] < r[k]) {
swap(q[j], r[k]);
k++;
}
j--;
} else if (j < 0) {
if (k < c && p[i] < r[k]) {
swap(p[i], r[k]);
k++;
}
i--;
} else {
if (p[i] < q[j]) {
if (k < c && p[i] < r[k]) {
swap(p[i], r[k]);
k++;
}
i--;
} else {
if (k < c && q[j] < r[k]) {
swap(q[j], r[k]);
k++;
}
j--;
}
}
}
forf(i, 0, x) sw += p[i];
forf(i, 0, y) sw += q[i];
cout << sw << endl;
}
int32_t main() {
// pr_init();
// fastio;
auto start = high_resolution_clock::now();
solve();
auto stop = high_resolution_clock::now();
auto duration = duration_cast<microseconds>(stop - start);
// cout << "Time taken by function: "
// << duration.count() << " microseconds" << endl;
}
| replace | 111 | 112 | 111 | 112 | TLE | |
p02727 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep1(i, n) for (ll i = 1; i <= (ll)(n); i++)
#define INF 1000000000000
#define MOD 1000000007
using ll = long long;
int main() {
ll X, Y, A, B, C;
cin >> X >> Y >> A >> B >> C; // red,green,r,g,rg
vector<ll> P(A), Q(B), R(C);
rep(i, A) cin >> P.at(i);
rep(i, B) cin >> Q.at(i);
rep(i, C) cin >> R.at(i);
sort(begin(P), end(P));
sort(begin(Q), end(Q));
sort(begin(R), end(R));
reverse(begin(R), end(R));
queue<ll> queP, queQ;
rep(i, X) queP.push(P.at(i - X + A));
rep(i, Y) queQ.push(Q.at(i - Y + B));
ll res = 0;
rep(i, C) {
ll p = queP.front();
ll q = queQ.front();
ll r = R.at(i);
if (p < q) {
if (r >= p) {
res += r;
queP.pop();
} else
break;
} else {
// p>=q
if (r >= q) {
res += r;
queQ.pop();
} else
break;
}
}
while (!queP.empty()) {
res += queP.front();
queP.pop();
}
while (!queQ.empty()) {
res += queQ.front();
queQ.pop();
}
cout << res << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep1(i, n) for (ll i = 1; i <= (ll)(n); i++)
#define INF 1000000000000
#define MOD 1000000007
using ll = long long;
int main() {
ll X, Y, A, B, C;
cin >> X >> Y >> A >> B >> C; // red,green,r,g,rg
vector<ll> P(A), Q(B), R(C);
rep(i, A) cin >> P.at(i);
rep(i, B) cin >> Q.at(i);
rep(i, C) cin >> R.at(i);
sort(begin(P), end(P));
sort(begin(Q), end(Q));
sort(begin(R), end(R));
reverse(begin(R), end(R));
queue<ll> queP, queQ;
rep(i, X) queP.push(P.at(i - X + A));
rep(i, Y) queQ.push(Q.at(i - Y + B));
ll res = 0;
rep(i, C) {
ll p;
ll q;
if (queP.empty())
p = MOD;
else
p = queP.front();
if (queQ.empty())
q = MOD;
else
q = queQ.front();
ll r = R.at(i);
if (p < q) {
if (r >= p) {
res += r;
queP.pop();
} else
break;
} else {
// p>=q
if (r >= q) {
res += r;
queQ.pop();
} else
break;
}
}
while (!queP.empty()) {
res += queP.front();
queP.pop();
}
while (!queQ.empty()) {
res += queQ.front();
queQ.pop();
}
cout << res << endl;
}
| replace | 25 | 27 | 25 | 35 | 0 | |
p02727 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef vector<char> vc;
typedef vector<vector<int>> vvi;
typedef vector<vector<string>> vvs;
typedef vector<vector<char>> vvc;
typedef vector<vector<bool>> vvb;
typedef pair<int, int> P;
#define vrep(v, n) \
for (int i = 0; i < n; i++) { \
cin >> v.at(i); \
} // 配列vにn個の要素を入力する
#define rep(i, l, n) for (int i = l; i < (int)(n); i++)
#define repn(i, l, n) for (int i = l; i <= (int)(n); i++)
#define pb push_back
const int mod = 1000000007;
const int inf = 1e9;
int main() {
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<ll> p(a), q(b), r(c);
rep(i, 0, a) { cin >> p[i]; }
rep(i, 0, b) { cin >> q[i]; }
rep(i, 0, c) { cin >> r[i]; }
sort(p.begin(), p.end(), greater<int>());
sort(q.begin(), q.end(), greater<int>());
sort(r.begin(), r.end(), greater<int>());
int sum_x = 0, sum_y = 0;
vector<ll> tmp;
rep(i, 0, x) { tmp.pb(p[i]); }
rep(i, 0, y) { tmp.pb(q[i]); }
sort(tmp.begin(), tmp.end());
for (auto &e : tmp) {
if (e < r[0]) {
e = r[0];
r.erase(r.begin());
}
}
ll sum = accumulate(tmp.begin(), tmp.end(), 0);
cout << sum << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef vector<char> vc;
typedef vector<vector<int>> vvi;
typedef vector<vector<string>> vvs;
typedef vector<vector<char>> vvc;
typedef vector<vector<bool>> vvb;
typedef pair<int, int> P;
#define vrep(v, n) \
for (int i = 0; i < n; i++) { \
cin >> v.at(i); \
} // 配列vにn個の要素を入力する
#define rep(i, l, n) for (int i = l; i < (int)(n); i++)
#define repn(i, l, n) for (int i = l; i <= (int)(n); i++)
#define pb push_back
const int mod = 1000000007;
const int inf = 1e9;
int main() {
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<ll> p(a), q(b), r(c);
rep(i, 0, a) { cin >> p[i]; }
rep(i, 0, b) { cin >> q[i]; }
rep(i, 0, c) { cin >> r[i]; }
sort(p.rbegin(), p.rend());
sort(q.rbegin(), q.rend());
vi d;
rep(i, 0, x) d.pb(p[i]);
rep(i, 0, y) d.pb(q[i]);
rep(i, 0, c) d.pb(r[i]);
sort(d.rbegin(), d.rend());
ll ans = 0;
rep(i, 0, x + y) ans += d[i];
cout << ans << endl;
} | replace | 30 | 46 | 30 | 40 | 0 | |
p02727 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = 1001001001;
const ll LINF = 1001001001001001;
const int MOD = 1000000007;
template <typename T> void print(const T &v);
int main() {
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<ll> p(a), q(b), r(c);
for (int i = 0; i < a; i++) {
cin >> p[i];
}
for (int i = 0; i < b; i++) {
cin >> q[i];
}
for (int i = 0; i < c; i++) {
cin >> r[i];
}
sort(p.begin(), p.end());
reverse(p.begin(), p.end());
sort(q.begin(), q.end());
reverse(q.begin(), q.end());
sort(r.begin(), r.end());
reverse(r.begin(), r.end());
vector<ll> picks;
for (int i = 0; i < x; i++) {
picks.push_back(p[i]);
}
for (int i = 0; i < y; i++) {
picks.push_back(q[i]);
}
sort(picks.begin(), picks.end());
for (int i = 0; i < c; i++) {
picks[i] = max(picks[i], r[i]);
}
ll ans = 0;
for (int i = 0; i < x + y; i++) {
ans += picks[i];
}
cout << ans << endl;
return 0;
}
// Use For Debug
template <typename T> void print(T const &v) {
for (int i = 0; i < v.size(); i++) {
if (i)
cout << ' ';
cout << v[i];
}
cout << endl;
}; | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = 1001001001;
const ll LINF = 1001001001001001;
const int MOD = 1000000007;
template <typename T> void print(const T &v);
int main() {
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<ll> p(a), q(b), r(c);
for (int i = 0; i < a; i++) {
cin >> p[i];
}
for (int i = 0; i < b; i++) {
cin >> q[i];
}
for (int i = 0; i < c; i++) {
cin >> r[i];
}
sort(p.begin(), p.end());
reverse(p.begin(), p.end());
sort(q.begin(), q.end());
reverse(q.begin(), q.end());
sort(r.begin(), r.end());
reverse(r.begin(), r.end());
vector<ll> picks;
for (int i = 0; i < x; i++) {
picks.push_back(p[i]);
}
for (int i = 0; i < y; i++) {
picks.push_back(q[i]);
}
sort(picks.begin(), picks.end());
for (int i = 0; i < c && i < x + y; i++) {
picks[i] = max(picks[i], r[i]);
}
ll ans = 0;
for (int i = 0; i < x + y; i++) {
ans += picks[i];
}
cout << ans << endl;
return 0;
}
// Use For Debug
template <typename T> void print(T const &v) {
for (int i = 0; i < v.size(); i++) {
if (i)
cout << ' ';
cout << v[i];
}
cout << endl;
}; | replace | 38 | 39 | 38 | 39 | 0 | |
p02727 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define dforsn(i, s, n) for (int i = int(n - 1); i >= int(s); i--)
#define forsn(i, s, n) for (int i = int(s); i < int(n); i++)
#define dforn(i, n) for (int i = int(n - 1); i >= 0; i--)
#define forn(i, n) for (int i = 0; i < int(n); i++)
#define D(a) cerr << #a << " = " << a << endl
#define all(a) a.begin(), a.end()
#define si(a) int((a).size())
typedef pair<int, int> pii;
typedef long long int ll;
typedef vector<int> vi;
#define pb emplace_back
#define mp make_pair
#define snd second
#define fst first
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int x, y, ca, cb, cc;
cin >> x >> y >> ca >> cb >> cc;
vi a(ca), b(cb), c(cb);
forn(i, ca) cin >> a[i];
forn(i, cb) cin >> b[i];
forn(i, cc) cin >> c[i];
sort(all(a), greater<int>());
sort(all(b), greater<int>());
sort(all(c), greater<int>());
priority_queue<int> q;
forn(i, x) q.push(a[i]);
forn(i, y) q.push(b[i]);
forn(i, cc) q.push(c[i]);
ll ans = 0;
int t = x + y;
forn(i, t) ans += q.top(), q.pop();
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define dforsn(i, s, n) for (int i = int(n - 1); i >= int(s); i--)
#define forsn(i, s, n) for (int i = int(s); i < int(n); i++)
#define dforn(i, n) for (int i = int(n - 1); i >= 0; i--)
#define forn(i, n) for (int i = 0; i < int(n); i++)
#define D(a) cerr << #a << " = " << a << endl
#define all(a) a.begin(), a.end()
#define si(a) int((a).size())
typedef pair<int, int> pii;
typedef long long int ll;
typedef vector<int> vi;
#define pb emplace_back
#define mp make_pair
#define snd second
#define fst first
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int x, y, ca, cb, cc;
cin >> x >> y >> ca >> cb >> cc;
vi a(ca), b(cb), c(cc);
forn(i, ca) cin >> a[i];
forn(i, cb) cin >> b[i];
forn(i, cc) cin >> c[i];
sort(all(a), greater<int>());
sort(all(b), greater<int>());
sort(all(c), greater<int>());
priority_queue<int> q;
forn(i, x) q.push(a[i]);
forn(i, y) q.push(b[i]);
forn(i, cc) q.push(c[i]);
ll ans = 0;
int t = x + y;
forn(i, t) ans += q.top(), q.pop();
cout << ans << endl;
return 0;
}
| replace | 23 | 24 | 23 | 24 | 0 | |
p02727 | C++ | Runtime Error | #include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
int main() {
long X, Y, A, B, C;
std::cin >> X >> Y >> A >> B >> C;
std::vector<long> p, q, r;
long temp;
for (long i = 0; i < A; i++) {
std::cin >> temp;
p.push_back(temp);
}
for (long i = 0; i < B; i++) {
std::cin >> temp;
q.push_back(temp);
}
for (long i = 0; i < C; i++) {
std::cin >> temp;
r.push_back(temp);
}
std::sort(p.begin(), p.end());
std::sort(q.begin(), q.end());
std::sort(r.begin(), r.end());
std::vector<long> result;
for (long i = 0; i < X; i++) {
result.push_back(p[A - 1 - i]);
}
for (long i = 0; i < Y; i++) {
result.push_back(q[B - 1 - i]);
}
std::sort(result.begin(), result.end());
long kouho = 0;
long result2 = 0;
for (long i = 0; i < X + Y - C; i++) {
result2 += result[X + Y - 1 - i];
}
for (long i = 0; i < C; i++) {
if (result[i] < r[C - 1 - kouho]) {
result2 += r[C - 1 - kouho];
kouho++;
} else {
result2 += result[i];
}
}
std::cout << result2 << std::endl;
return 0;
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
int main() {
long X, Y, A, B, C;
std::cin >> X >> Y >> A >> B >> C;
std::vector<long> p, q, r;
long temp;
for (long i = 0; i < A; i++) {
std::cin >> temp;
p.push_back(temp);
}
for (long i = 0; i < B; i++) {
std::cin >> temp;
q.push_back(temp);
}
for (long i = 0; i < C; i++) {
std::cin >> temp;
r.push_back(temp);
}
std::sort(p.begin(), p.end());
std::sort(q.begin(), q.end());
std::sort(r.begin(), r.end());
std::vector<long> result;
for (long i = 0; i < X; i++) {
result.push_back(p[A - 1 - i]);
}
for (long i = 0; i < Y; i++) {
result.push_back(q[B - 1 - i]);
}
std::sort(result.begin(), result.end());
long kouho = 0;
long result2 = 0;
for (long i = 0; i < X + Y - C; i++) {
result2 += result[X + Y - 1 - i];
}
for (long i = 0; i < std::min(C, X + Y); i++) {
if (result[i] < r[C - 1 - kouho]) {
result2 += r[C - 1 - kouho];
kouho++;
} else {
result2 += result[i];
}
}
std::cout << result2 << std::endl;
return 0;
} | replace | 46 | 47 | 46 | 47 | 0 | |
p02727 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pii> vii;
typedef vector<pll> vll;
typedef map<int, int> mii;
typedef vector<char> vc;
typedef vector<bool> vb;
#define endl '\n'
#define forn(i, n) for (int i = 0; i < n; i++)
#define rforn(i, n) for (int i = n - 1; i >= 0; i--)
#define forne(i, n) for (int i = 1; i <= n; i++)
#define rforne(i, n) for (int i = n; i >= 1; i--)
#define forse(i, s, e) for (int i = s; i < e; i++)
#define rforse(i, s, e) for (int i = e - 1; i >= s; i--)
#define all(x) x.begin(), x.end()
#define sz(x) (ll) x.size()
#define MOD 1000000007
#define F first
#define S second
#define pb push_back
#define in insert
#define mp(a, b) make_pair(a, b)
#define fill(a, x) memset(a, x, sizeof a);
#define trav(a, x) for (auto &a : x)
#define min3(a, b, c) min(min(a, b), c)
#define min4(a, b, c, d) min(min(a, b), min(c, d))
#define max3(a, b, c) max(max(a, b), c)
#define max4(a, b, c, d) max(max(a, b), max(c, d))
#define INF INT_MAX
#ifdef KARAN
#include "../../trace.h"
#else
#define trace(args...)
#endif
ll modpow(ll a, ll b, ll m = MOD) {
a %= m;
ll res = 1;
while (b) {
if (b & 1)
res = (res * a) % m;
a = (a * a) % m;
b >>= 1;
}
return res;
}
ll bpow(ll a, ll b) {
ll res = 1;
while (b) {
if (b & 1)
res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
ll modinv(ll a, ll m = MOD) { return modpow(a, m - 2, m); }
void graph(vvi &adj, int m) {
int x, y;
forn(i, m) {
cin >> x >> y;
adj[--x].pb(--y);
adj[y].pb(x);
}
}
void solve() {
ll x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vl p(a), q(b), r(c);
forn(i, a) cin >> p[i];
forn(i, b) cin >> q[i];
forn(i, c) cin >> r[i];
sort(all(p), greater<ll>());
sort(all(q), greater<ll>());
sort(all(r), greater<ll>());
vl app;
forn(i, x) app.pb(p[i]);
forn(i, y) app.pb(q[i]);
sort(all(app), greater<ll>());
vl pref(x + y + 1, 0);
forne(i, x + y) pref[i] = pref[i - 1] + app[i - 1];
vl prefc(c + 1, 0);
forne(i, c) prefc[i] = prefc[i - 1] + r[i - 1];
trace(app, pref, prefc);
ll answer = 0;
forn(i, min(c + 1, x + y + 1)) answer =
max(answer, pref[x + y - i] + prefc[i]);
cout << answer << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
#ifdef KARAN
freopen("inp.txt", "r", stdin);
freopen("out.txt", "w", stdout);
freopen("err.txt", "w", stderr);
#endif
int t = 1;
cin >> t;
while (t--)
solve();
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pii> vii;
typedef vector<pll> vll;
typedef map<int, int> mii;
typedef vector<char> vc;
typedef vector<bool> vb;
#define endl '\n'
#define forn(i, n) for (int i = 0; i < n; i++)
#define rforn(i, n) for (int i = n - 1; i >= 0; i--)
#define forne(i, n) for (int i = 1; i <= n; i++)
#define rforne(i, n) for (int i = n; i >= 1; i--)
#define forse(i, s, e) for (int i = s; i < e; i++)
#define rforse(i, s, e) for (int i = e - 1; i >= s; i--)
#define all(x) x.begin(), x.end()
#define sz(x) (ll) x.size()
#define MOD 1000000007
#define F first
#define S second
#define pb push_back
#define in insert
#define mp(a, b) make_pair(a, b)
#define fill(a, x) memset(a, x, sizeof a);
#define trav(a, x) for (auto &a : x)
#define min3(a, b, c) min(min(a, b), c)
#define min4(a, b, c, d) min(min(a, b), min(c, d))
#define max3(a, b, c) max(max(a, b), c)
#define max4(a, b, c, d) max(max(a, b), max(c, d))
#define INF INT_MAX
#ifdef KARAN
#include "../../trace.h"
#else
#define trace(args...)
#endif
ll modpow(ll a, ll b, ll m = MOD) {
a %= m;
ll res = 1;
while (b) {
if (b & 1)
res = (res * a) % m;
a = (a * a) % m;
b >>= 1;
}
return res;
}
ll bpow(ll a, ll b) {
ll res = 1;
while (b) {
if (b & 1)
res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
ll modinv(ll a, ll m = MOD) { return modpow(a, m - 2, m); }
void graph(vvi &adj, int m) {
int x, y;
forn(i, m) {
cin >> x >> y;
adj[--x].pb(--y);
adj[y].pb(x);
}
}
void solve() {
ll x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vl p(a), q(b), r(c);
forn(i, a) cin >> p[i];
forn(i, b) cin >> q[i];
forn(i, c) cin >> r[i];
sort(all(p), greater<ll>());
sort(all(q), greater<ll>());
sort(all(r), greater<ll>());
vl app;
forn(i, x) app.pb(p[i]);
forn(i, y) app.pb(q[i]);
sort(all(app), greater<ll>());
vl pref(x + y + 1, 0);
forne(i, x + y) pref[i] = pref[i - 1] + app[i - 1];
vl prefc(c + 1, 0);
forne(i, c) prefc[i] = prefc[i - 1] + r[i - 1];
trace(app, pref, prefc);
ll answer = 0;
forn(i, min(c + 1, x + y + 1)) answer =
max(answer, pref[x + y - i] + prefc[i]);
cout << answer << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
#ifdef KARAN
freopen("inp.txt", "r", stdin);
freopen("out.txt", "w", stdout);
freopen("err.txt", "w", stderr);
#endif
int t = 1;
while (t--)
solve();
} | delete | 113 | 114 | 113 | 113 | 0 | |
p02727 | C++ | Runtime Error | // AnkitCode99 here....
#include <bits/stdc++.h>
#define endl "\n"
typedef long long int ll;
#define MOD 1000000007
#define mp make_pair
#define pll pair<ll, ll>
#define pb push_back
// max xor btw range of two numbers..
#define max_XOR(a, b) (1 << int(log2(a ^ b) + 1)) - 1
#define vl vector<ll>
#define inf ll(1e18)
#define all(v) v.begin(), v.end()
#define fast \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define rep(i, a, b) for (long long int i = a; i < b; i++)
#define nrep(i, a, b) for (long long int i = a; i >= b; i--)
#define ceil(a, b) a / b + ((a % b == 0) ? 0 : 1)
using namespace std;
const ll sz = 100005;
const ll szz = 1000006;
int main() {
fast;
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("op.txt", "w", stdout);
#endif
ll x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<pll> v;
rep(i, 0, a) {
ll ele;
cin >> ele;
v.pb({ele, 1});
}
rep(i, 0, b) {
ll ele;
cin >> ele;
v.pb({ele, 2});
}
rep(i, 0, c) {
ll ele;
cin >> ele;
v.pb({ele, 3});
}
sort(all(v));
reverse(all(v));
ll extra = 0, ans = 0;
for (auto aut : v) {
if (extra == (x + y))
break;
if (aut.second == 1) {
if (x > 0) {
ans += aut.first;
x--;
}
} else if (aut.second == 2) {
if (y > 0) {
ans += aut.first;
y--;
}
} else {
ans += aut.first;
extra++;
}
}
cout << ans << endl;
}
// Goodbye... | // AnkitCode99 here....
#include <bits/stdc++.h>
#define endl "\n"
typedef long long int ll;
#define MOD 1000000007
#define mp make_pair
#define pll pair<ll, ll>
#define pb push_back
// max xor btw range of two numbers..
#define max_XOR(a, b) (1 << int(log2(a ^ b) + 1)) - 1
#define vl vector<ll>
#define inf ll(1e18)
#define all(v) v.begin(), v.end()
#define fast \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define rep(i, a, b) for (long long int i = a; i < b; i++)
#define nrep(i, a, b) for (long long int i = a; i >= b; i--)
#define ceil(a, b) a / b + ((a % b == 0) ? 0 : 1)
using namespace std;
const ll sz = 100005;
const ll szz = 1000006;
int main() {
fast;
ll x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<pll> v;
rep(i, 0, a) {
ll ele;
cin >> ele;
v.pb({ele, 1});
}
rep(i, 0, b) {
ll ele;
cin >> ele;
v.pb({ele, 2});
}
rep(i, 0, c) {
ll ele;
cin >> ele;
v.pb({ele, 3});
}
sort(all(v));
reverse(all(v));
ll extra = 0, ans = 0;
for (auto aut : v) {
if (extra == (x + y))
break;
if (aut.second == 1) {
if (x > 0) {
ans += aut.first;
x--;
}
} else if (aut.second == 2) {
if (y > 0) {
ans += aut.first;
y--;
}
} else {
ans += aut.first;
extra++;
}
}
cout << ans << endl;
}
// Goodbye...
| delete | 27 | 31 | 27 | 27 | -6 | terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
|
p02727 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> P;
typedef pair<int, int> Pi;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define fi first
#define se second
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> ostream &operator<<(ostream &s, const complex<T> &d) {
return s << "(" << d.real() << ", " << d.imag() << ")";
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &d) {
return s << "(" << d.first << ", " << d.second << ")";
}
template <typename T> ostream &operator<<(ostream &s, const vector<T> &d) {
int len = d.size();
rep(i, len) {
s << d[i];
if (i < len - 1)
s << " ";
}
return s;
}
template <typename T>
ostream &operator<<(ostream &s, const vector<vector<T>> &d) {
int len = d.size();
rep(i, len) { s << d[i] << endl; }
return s;
}
template <typename T> ostream &operator<<(ostream &s, const set<T> &v) {
s << "{ ";
for (auto itr = v.begin(); itr != v.end(); ++itr) {
if (itr != v.begin()) {
s << ", ";
}
s << (*itr);
}
s << " }";
return s;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const map<T1, T2> &m) {
s << "{" << endl;
for (auto itr = m.begin(); itr != m.end(); ++itr) {
s << " " << (*itr).first << " : " << (*itr).second << endl;
}
s << "}" << endl;
return s;
}
const ll mod = 1e9 + 7;
const ll inf = 1e17;
const int INF = 1e9;
const double PI = acos(-1);
const double EPS = 1e-10;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<ll> p(a), q(b), r(c);
// set<ll> r;
vector<ll> g;
rep(i, a) { cin >> p[i]; }
rep(i, b) { cin >> q[i]; }
rep(i, c) { cin >> r[i]; }
sort(begin(p), end(p), greater<ll>());
sort(begin(q), end(q), greater<ll>());
rep(i, x) { g.push_back(p[i]); }
rep(i, y) { g.push_back(q[i]); }
sort(begin(g), end(g));
ll ans = 0;
rep(i, g.size()) { ans += g[i]; }
sort(begin(r), end(r), greater<ll>());
ll now = ans;
rep(i, c) {
now -= g[i];
now += r[i];
chmax(ans, now);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> P;
typedef pair<int, int> Pi;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define fi first
#define se second
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> ostream &operator<<(ostream &s, const complex<T> &d) {
return s << "(" << d.real() << ", " << d.imag() << ")";
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &d) {
return s << "(" << d.first << ", " << d.second << ")";
}
template <typename T> ostream &operator<<(ostream &s, const vector<T> &d) {
int len = d.size();
rep(i, len) {
s << d[i];
if (i < len - 1)
s << " ";
}
return s;
}
template <typename T>
ostream &operator<<(ostream &s, const vector<vector<T>> &d) {
int len = d.size();
rep(i, len) { s << d[i] << endl; }
return s;
}
template <typename T> ostream &operator<<(ostream &s, const set<T> &v) {
s << "{ ";
for (auto itr = v.begin(); itr != v.end(); ++itr) {
if (itr != v.begin()) {
s << ", ";
}
s << (*itr);
}
s << " }";
return s;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const map<T1, T2> &m) {
s << "{" << endl;
for (auto itr = m.begin(); itr != m.end(); ++itr) {
s << " " << (*itr).first << " : " << (*itr).second << endl;
}
s << "}" << endl;
return s;
}
const ll mod = 1e9 + 7;
const ll inf = 1e17;
const int INF = 1e9;
const double PI = acos(-1);
const double EPS = 1e-10;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<ll> p(a), q(b), r(c);
// set<ll> r;
vector<ll> g;
rep(i, a) { cin >> p[i]; }
rep(i, b) { cin >> q[i]; }
rep(i, c) { cin >> r[i]; }
sort(begin(p), end(p), greater<ll>());
sort(begin(q), end(q), greater<ll>());
rep(i, x) { g.push_back(p[i]); }
rep(i, y) { g.push_back(q[i]); }
sort(begin(g), end(g));
ll ans = 0;
rep(i, g.size()) { ans += g[i]; }
sort(begin(r), end(r), greater<ll>());
ll now = ans;
rep(i, min(c, x + y)) {
now -= g[i];
now += r[i];
chmax(ans, now);
}
cout << ans << endl;
} | replace | 94 | 95 | 94 | 95 | 0 | |
p02727 | C++ | Runtime Error | //============================================================================
// Name : e.cpp
// Author :
// Version :
// Copyright : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<ll> p(a), q(b), r(c);
for (int i = 0; i < a; i++) {
cin >> p[i];
}
for (int i = 0; i < b; i++) {
cin >> q[i];
}
for (int i = 0; i < c; i++) {
cin >> r[i];
}
vector<ll> ab;
sort(p.begin(), p.end());
reverse(p.begin(), p.end());
sort(q.begin(), q.end());
reverse(q.begin(), q.end());
for (int i = 0; i < x; i++) {
ab.push_back(p[i]);
}
for (int i = 0; i < y; i++) {
ab.push_back(q[i]);
}
sort(ab.begin(), ab.end());
sort(r.begin(), r.end());
reverse(r.begin(), r.end());
for (int i = 0; i < c; i++) {
if (ab[i] < r[i]) {
ab[i] = r[i];
}
}
ll ans = 0;
for (int i = 0; i < ab.size(); i++) {
ans += ab[i];
}
cout << ans << endl;
return 0;
}
| //============================================================================
// Name : e.cpp
// Author :
// Version :
// Copyright : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<ll> p(a), q(b), r(c);
for (int i = 0; i < a; i++) {
cin >> p[i];
}
for (int i = 0; i < b; i++) {
cin >> q[i];
}
for (int i = 0; i < c; i++) {
cin >> r[i];
}
vector<ll> ab;
sort(p.begin(), p.end());
reverse(p.begin(), p.end());
sort(q.begin(), q.end());
reverse(q.begin(), q.end());
for (int i = 0; i < x; i++) {
ab.push_back(p[i]);
}
for (int i = 0; i < y; i++) {
ab.push_back(q[i]);
}
sort(ab.begin(), ab.end());
sort(r.begin(), r.end());
reverse(r.begin(), r.end());
for (int i = 0; i < c; i++) {
if (ab[i] < r[i]) {
ab[i] = r[i];
}
if (i == ab.size() - 1)
break;
}
ll ans = 0;
for (int i = 0; i < ab.size(); i++) {
ans += ab[i];
}
cout << ans << endl;
return 0;
} | insert | 44 | 44 | 44 | 46 | 0 | |
p02727 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
int main() {
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<int> p(a), q(b), r(c);
for (int i = 0; i < a; ++i)
cin >> p.at(i);
for (int i = 0; i < b; ++i)
cin >> q.at(i);
for (int i = 0; i < c; ++i)
cin >> r.at(i);
sort(p.begin(), p.end());
sort(q.begin(), q.end());
sort(r.begin(), r.end());
priority_queue<int, vector<int>, greater<int>> s, t;
for (int i = 0; i < x; ++i) {
s.push(p.at(a - i - 1));
}
for (int i = 0; i < y; ++i) {
t.push(q.at(a - i - 1));
}
for (auto ri : r) {
int si = s.top();
int ti = t.top();
if (si < ti) {
if (ri > si) {
s.pop();
s.push(ri);
}
} else {
if (ri > ti) {
t.pop();
t.push(ri);
}
}
}
long long ans = 0;
while (!s.empty()) {
ans += s.top();
s.pop();
}
while (!t.empty()) {
ans += t.top();
t.pop();
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
int main() {
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<int> p(a), q(b), r(c);
for (int i = 0; i < a; ++i)
cin >> p.at(i);
for (int i = 0; i < b; ++i)
cin >> q.at(i);
for (int i = 0; i < c; ++i)
cin >> r.at(i);
sort(p.begin(), p.end());
sort(q.begin(), q.end());
sort(r.begin(), r.end());
priority_queue<int, vector<int>, greater<int>> s, t;
for (int i = 0; i < x; ++i) {
s.push(p.at(a - i - 1));
}
for (int i = 0; i < y; ++i) {
t.push(q.at(b - i - 1));
}
for (auto ri : r) {
int si = s.top();
int ti = t.top();
if (si < ti) {
if (ri > si) {
s.pop();
s.push(ri);
}
} else {
if (ri > ti) {
t.pop();
t.push(ri);
}
}
}
long long ans = 0;
while (!s.empty()) {
ans += s.top();
s.pop();
}
while (!t.empty()) {
ans += t.top();
t.pop();
}
cout << ans << endl;
return 0;
}
| replace | 23 | 24 | 23 | 24 | 0 | |
p02727 | C++ | Runtime Error | #include <bits/stdc++.h>
#define int long long
using namespace std;
int X, Y, A, B, C;
int red[100005], green[100005], color[100005];
vector<int> best;
long long ans;
int32_t main() {
scanf("%lld %lld %lld %lld %lld", &X, &Y, &A, &B, &C);
for (int i = 0; i < A; i++) {
scanf("%lld", &red[i]);
}
sort(red, red + A, greater<int>());
for (int i = 0; i < B; i++) {
scanf("%lld", &green[i]);
}
sort(green, green + B, greater<int>());
for (int i = 0; i < C; i++) {
scanf("%lld", &color[i]);
}
sort(color, color + C, greater<int>());
for (int i = 0; i < max(X, Y); i++) {
if (i < X) {
best.push_back(red[i]);
ans += red[i];
}
if (i < Y) {
best.push_back(green[i]);
ans += green[i];
}
}
sort(best.begin(), best.end());
for (int i = 0; i < C; i++) {
if (color[i] > best[i]) {
ans += color[i] - best[i];
}
}
cout << ans << "\n";
}
| #include <bits/stdc++.h>
#define int long long
using namespace std;
int X, Y, A, B, C;
int red[100005], green[100005], color[100005];
vector<int> best;
long long ans;
int32_t main() {
scanf("%lld %lld %lld %lld %lld", &X, &Y, &A, &B, &C);
for (int i = 0; i < A; i++) {
scanf("%lld", &red[i]);
}
sort(red, red + A, greater<int>());
for (int i = 0; i < B; i++) {
scanf("%lld", &green[i]);
}
sort(green, green + B, greater<int>());
for (int i = 0; i < C; i++) {
scanf("%lld", &color[i]);
}
sort(color, color + C, greater<int>());
for (int i = 0; i < max(X, Y); i++) {
if (i < X) {
best.push_back(red[i]);
ans += red[i];
}
if (i < Y) {
best.push_back(green[i]);
ans += green[i];
}
}
sort(best.begin(), best.end());
for (int i = 0; i < min(C, X + Y) && color[i] > best[i]; i++) {
ans += color[i] - best[i];
}
cout << ans << "\n";
}
| replace | 34 | 38 | 34 | 36 | 0 | |
p02727 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef vector<vector<vector<ll>>> vvvll;
typedef vector<bool> vb;
typedef vector<vector<bool>> vvb;
typedef vector<vector<vector<bool>>> vvvb;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef vector<vpll> vvpll;
typedef vector<double> vd;
typedef vector<vd> vdd;
#define FOR(i, x, y) for (ll i = (ll)x; i < (ll)y; ++i)
#define REP(i, y) FOR(i, 0, y)
#define RFOR(i, x, y) for (ll i = (ll)x; i >= (ll)y; --i)
#define RREP(i, x) RFOR(i, x, 0)
#define ALL(a) a.begin(), a.end()
#define pb push_back
#define debug_print(x...) \
cerr << "line " << __LINE__ << " : "; \
debug_print_in(x);
template <typename First> void debug_print_in(First first) {
cerr << first << endl;
return;
}
template <typename First, typename... Rest>
void debug_print_in(First first, Rest... rest) {
cerr << first << " ";
debug_print_in(rest...);
return;
}
void IN(void) { return; }
template <typename First, typename... Rest>
void IN(First &first, Rest &...rest) {
cin >> first;
IN(rest...);
return;
}
template <typename First> void OUT(First first) {
cout << first << endl;
return;
}
template <typename First, typename... Rest>
void OUT(First first, Rest... rest) {
cout << first << " ";
OUT(rest...);
return;
}
template <class t, class u> void chmax(t &a, u b) {
if (a < b)
a = b;
};
template <class t, class u> void chmin(t &a, u b) {
if (a > b)
a = b;
};
int popcount(int t) { return __builtin_popcount(t); } // GCC
int popcount(ll t) { return __builtin_popcountll(t); } // GCC
template <typename T> void vec_print(vector<T> VEC) {
REP(i, VEC.size()) { cerr << VEC[i] << " "; }
cerr << endl;
};
template <typename T>
void mat_print(vector<vector<T>> MAT){
REP(i, MAT.size()){REP(j, MAT[i].size()){cerr << MAT[i][j] << " ";
}
cerr << endl;
}
}
;
constexpr int INF = (1 << 30);
constexpr ll INFLL = 1LL << 62;
constexpr long double EPS = 1e-12;
constexpr ll MOD = (ll)((1E+9) + 7);
int main() {
cin.tie(0); // cut the cin and cout (default, std::flush is performed after
// std::cin)
ios::sync_with_stdio(
false); // cut the iostream and stdio (DON'T endl; BUT "\n";)
ll X, Y, A, B, C;
IN(X, Y, A, B, C);
vll p(A), q(B), r(C);
REP(i, A) IN(p[i]);
REP(i, B) IN(q[i]);
REP(i, C) IN(r[i]);
sort(ALL(p));
reverse(ALL(p));
sort(ALL(q));
reverse(ALL(q));
sort(ALL(r));
reverse(ALL(r));
vll ans(X + Y);
REP(i, X) ans[i] = p[i];
REP(i, Y) ans[i + Y] = q[i];
sort(ALL(ans));
reverse(ALL(ans));
ll h1 = 0, h2 = 0;
while (h1 + h2 < X + Y) {
if (h1 == X + Y)
h2++;
else if (h2 == C)
h1++;
else if (ans[h1] > r[h2])
h1++;
else
h2++;
}
ll hoge = 0;
REP(i, h1) hoge += ans[i];
REP(i, h2) hoge += r[i];
OUT(hoge);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef vector<vector<vector<ll>>> vvvll;
typedef vector<bool> vb;
typedef vector<vector<bool>> vvb;
typedef vector<vector<vector<bool>>> vvvb;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef vector<vpll> vvpll;
typedef vector<double> vd;
typedef vector<vd> vdd;
#define FOR(i, x, y) for (ll i = (ll)x; i < (ll)y; ++i)
#define REP(i, y) FOR(i, 0, y)
#define RFOR(i, x, y) for (ll i = (ll)x; i >= (ll)y; --i)
#define RREP(i, x) RFOR(i, x, 0)
#define ALL(a) a.begin(), a.end()
#define pb push_back
#define debug_print(x...) \
cerr << "line " << __LINE__ << " : "; \
debug_print_in(x);
template <typename First> void debug_print_in(First first) {
cerr << first << endl;
return;
}
template <typename First, typename... Rest>
void debug_print_in(First first, Rest... rest) {
cerr << first << " ";
debug_print_in(rest...);
return;
}
void IN(void) { return; }
template <typename First, typename... Rest>
void IN(First &first, Rest &...rest) {
cin >> first;
IN(rest...);
return;
}
template <typename First> void OUT(First first) {
cout << first << endl;
return;
}
template <typename First, typename... Rest>
void OUT(First first, Rest... rest) {
cout << first << " ";
OUT(rest...);
return;
}
template <class t, class u> void chmax(t &a, u b) {
if (a < b)
a = b;
};
template <class t, class u> void chmin(t &a, u b) {
if (a > b)
a = b;
};
int popcount(int t) { return __builtin_popcount(t); } // GCC
int popcount(ll t) { return __builtin_popcountll(t); } // GCC
template <typename T> void vec_print(vector<T> VEC) {
REP(i, VEC.size()) { cerr << VEC[i] << " "; }
cerr << endl;
};
template <typename T>
void mat_print(vector<vector<T>> MAT){
REP(i, MAT.size()){REP(j, MAT[i].size()){cerr << MAT[i][j] << " ";
}
cerr << endl;
}
}
;
constexpr int INF = (1 << 30);
constexpr ll INFLL = 1LL << 62;
constexpr long double EPS = 1e-12;
constexpr ll MOD = (ll)((1E+9) + 7);
int main() {
cin.tie(0); // cut the cin and cout (default, std::flush is performed after
// std::cin)
ios::sync_with_stdio(
false); // cut the iostream and stdio (DON'T endl; BUT "\n";)
ll X, Y, A, B, C;
IN(X, Y, A, B, C);
vll p(A), q(B), r(C);
REP(i, A) IN(p[i]);
REP(i, B) IN(q[i]);
REP(i, C) IN(r[i]);
sort(ALL(p));
reverse(ALL(p));
sort(ALL(q));
reverse(ALL(q));
sort(ALL(r));
reverse(ALL(r));
vll ans(X + Y);
REP(i, X) ans[i] = p[i];
REP(i, Y) ans[i + X] = q[i];
sort(ALL(ans));
reverse(ALL(ans));
ll h1 = 0, h2 = 0;
while (h1 + h2 < X + Y) {
if (h1 == X + Y)
h2++;
else if (h2 == C)
h1++;
else if (ans[h1] > r[h2])
h1++;
else
h2++;
}
ll hoge = 0;
REP(i, h1) hoge += ans[i];
REP(i, h2) hoge += r[i];
OUT(hoge);
return 0;
} | replace | 110 | 111 | 110 | 111 | 0 | |
p02727 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
typedef long long ll;
int x, n, y, a, b, c, cnt[maxn];
struct node {
int v, c;
bool operator<(const node &rhs) const { return v > rhs.v; }
} p[maxn];
int main() {
scanf("%d%d%d%d%d", &x, &y, &a, &b, &c);
for (int i = 1; i <= a; i++) {
scanf("%d", &p[i].v);
p[i].c = 1;
}
for (int i = 1; i <= b; i++) {
scanf("%d", &p[a + i].v);
p[a + i].c = 2;
}
for (int i = 1; i <= c; i++) {
scanf("%d", &p[a + b + i].v);
p[a + b + i].c = 0;
}
sort(p + 1, p + a + b + c + 1);
int cx = 0, cy = 0, tot = 0;
ll ans = 0;
for (int i = 1; i <= a + b + c && tot < x + y; i++) {
if (p[i].c == 1 && cx < x) {
ans += p[i].v;
cx++;
tot++;
} else if (p[i].c == 2 && cy < y) {
ans += p[i].v;
cy++;
tot++;
} else if (p[i].c == 0) {
ans += p[i].v;
tot++;
}
}
printf("%lld\n", ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
typedef long long ll;
int x, n, y, a, b, c, cnt[maxn];
struct node {
int v, c;
bool operator<(const node &rhs) const { return v > rhs.v; }
} p[maxn];
int main() {
scanf("%d%d%d%d%d", &x, &y, &a, &b, &c);
for (int i = 1; i <= a; i++) {
scanf("%d", &p[i].v);
p[i].c = 1;
}
for (int i = 1; i <= b; i++) {
scanf("%d", &p[a + i].v);
p[a + i].c = 2;
}
for (int i = 1; i <= c; i++) {
scanf("%d", &p[a + b + i].v);
p[a + b + i].c = 0;
}
sort(p + 1, p + a + b + c + 1);
int cx = 0, cy = 0, tot = 0;
ll ans = 0;
for (int i = 1; i <= a + b + c && tot < x + y; i++) {
if (p[i].c == 1 && cx < x) {
ans += p[i].v;
cx++;
tot++;
} else if (p[i].c == 2 && cy < y) {
ans += p[i].v;
cy++;
tot++;
} else if (p[i].c == 0) {
ans += p[i].v;
tot++;
}
}
printf("%lld\n", ans);
return 0;
} | replace | 2 | 3 | 2 | 3 | 0 | |
p02727 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define loop(n, i, a) for (ll i = a; i < n; i++)
#define loopR(n, i, a) for (ll i = n - 1; i >= a; i--)
#define all(arr, n) arr, arr + n
#define allv(v) (v).begin(), (v).end()
#define rallv(v) (v).rbegin(), (v).rend()
#define m_p make_pair
#define ll long long
#define pii pair<ll, ll>
#define vi vector<int>
#define vll vector<ll>
#define vii vector<pair<ll, ll>>
#define sz(x) (int)x.size()
#define pb push_back
#define endl "\n"
#define Endl "\n"
#define f first
#define s second
#define mem(dp, n) memset(dp, n, sizeof dp)
int dx[] = {1, 0, -1, 0, -1, -1, 1, 1};
int dy[] = {0, 1, 0, -1, -1, 1, -1, 1};
int KnightI[] = {2, 1, -1, -2, -2, -1, 1, 2};
int KnightJ[] = {1, 2, 2, 1, -1, -2, -2, -1};
template <typename T> void max_self(T &a, T b) { a = max(a, b); }
template <typename T> void min_self(T &a, T b) { a = min(a, b); }
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
vector<string> vec_splitter(string s) {
s += ',';
vector<string> res;
while (!s.empty()) {
res.push_back(s.substr(0, s.find(',')));
s = s.substr(s.find(',') + 1);
}
return res;
}
void debug_out(vector<string> __attribute__((unused)) args,
__attribute__((unused)) int idx,
__attribute__((unused)) int LINE_NUM) {
cerr << endl;
}
template <typename Head, typename... Tail>
void debug_out(vector<string> args, int idx, int LINE_NUM, Head H, Tail... T) {
if (idx > 0)
cerr << ", ";
else
cerr << "Line(" << LINE_NUM << ") ";
stringstream ss;
ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, LINE_NUM, T...);
}
#define debug(...) \
debug_out(vec_splitter(#__VA_ARGS__), 0, __LINE__, __VA_ARGS__)
const ll mxN = 2e4 + 10, oo = 0x3f3f3f3f, MOD = 998244353;
const double PI = acos(-1);
void solve() {
ll x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
ll red[a], green[b];
vll ans;
loop(a, i, 0) cin >> red[i];
loop(b, i, 0) cin >> green[i];
sort(all(red, a), greater<ll>());
sort(all(green, b), greater<ll>());
loop(x, i, 0) ans.pb(red[i]);
loop(y, i, 0) ans.pb(green[i]);
loop(c, i, 0) {
ll z;
cin >> x;
ans.pb(z);
}
ll res = 0;
sort(allv(ans), greater<ll>());
loop(x + y, i, 0) res += ans[i];
cout << res << endl;
}
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
fast();
solve();
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define loop(n, i, a) for (ll i = a; i < n; i++)
#define loopR(n, i, a) for (ll i = n - 1; i >= a; i--)
#define all(arr, n) arr, arr + n
#define allv(v) (v).begin(), (v).end()
#define rallv(v) (v).rbegin(), (v).rend()
#define m_p make_pair
#define ll long long
#define pii pair<ll, ll>
#define vi vector<int>
#define vll vector<ll>
#define vii vector<pair<ll, ll>>
#define sz(x) (int)x.size()
#define pb push_back
#define endl "\n"
#define Endl "\n"
#define f first
#define s second
#define mem(dp, n) memset(dp, n, sizeof dp)
int dx[] = {1, 0, -1, 0, -1, -1, 1, 1};
int dy[] = {0, 1, 0, -1, -1, 1, -1, 1};
int KnightI[] = {2, 1, -1, -2, -2, -1, 1, 2};
int KnightJ[] = {1, 2, 2, 1, -1, -2, -2, -1};
template <typename T> void max_self(T &a, T b) { a = max(a, b); }
template <typename T> void min_self(T &a, T b) { a = min(a, b); }
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
vector<string> vec_splitter(string s) {
s += ',';
vector<string> res;
while (!s.empty()) {
res.push_back(s.substr(0, s.find(',')));
s = s.substr(s.find(',') + 1);
}
return res;
}
void debug_out(vector<string> __attribute__((unused)) args,
__attribute__((unused)) int idx,
__attribute__((unused)) int LINE_NUM) {
cerr << endl;
}
template <typename Head, typename... Tail>
void debug_out(vector<string> args, int idx, int LINE_NUM, Head H, Tail... T) {
if (idx > 0)
cerr << ", ";
else
cerr << "Line(" << LINE_NUM << ") ";
stringstream ss;
ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, LINE_NUM, T...);
}
#define debug(...) \
debug_out(vec_splitter(#__VA_ARGS__), 0, __LINE__, __VA_ARGS__)
const ll mxN = 2e4 + 10, oo = 0x3f3f3f3f, MOD = 998244353;
const double PI = acos(-1);
void solve() {
ll x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
ll red[a], green[b];
vll ans;
loop(a, i, 0) cin >> red[i];
loop(b, i, 0) cin >> green[i];
sort(all(red, a), greater<ll>());
sort(all(green, b), greater<ll>());
loop(x, i, 0) ans.pb(red[i]);
loop(y, i, 0) ans.pb(green[i]);
loop(c, i, 0) {
ll z;
cin >> z;
ans.pb(z);
}
ll res = 0;
sort(allv(ans), greater<ll>());
loop(x + y, i, 0) res += ans[i];
cout << res << endl;
}
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
fast();
solve();
} | replace | 93 | 94 | 93 | 94 | -11 | |
p02727 | C++ | Runtime Error | #include <bits/stdc++.h>
// clang-format off
using namespace std; using ll = int64_t; using ull = uint64_t; const ll INF = 9e18;
void print() { cout << endl; }
template<typename Head,typename... Tail> void print(Head head,Tail... tail){cout<<head;if(sizeof...(Tail)>0)cout<<" ";print(tail...);}
void print0() {}
template<typename Head,typename... Tail> void print0(Head head,Tail... tail){cout<<head;print0(tail...);}
// clang-format on
int main() {
ll X, Y, A, B, C;
cin >> X >> Y >> A >> B >> C;
vector<ll> p(A);
vector<ll> q(B);
vector<ll> r(B);
for (ll i = 0; i < A; i++) {
cin >> p[i];
}
for (ll i = 0; i < B; i++) {
cin >> q[i];
}
for (ll i = 0; i < C; i++) {
cin >> r[i];
}
vector<ll> aka(X);
sort(p.begin(), p.end(), [](ll a, ll b) { return a > b; });
for (ll i = 0; i < X; i++) {
aka[X - i - 1] = p[i];
}
vector<ll> midori(Y);
sort(q.begin(), q.end(), [](ll a, ll b) { return a > b; });
for (ll i = 0; i < Y; i++) {
midori[Y - i - 1] = q[i];
}
// sort(r.begin(), r.end());
sort(r.begin(), r.end(), [](ll a, ll b) { return a > b; });
ll ai = 0;
ll mi = 0;
for (ll ri = 0; ri < r.size(); ri++) {
ll ax = aka[ai];
ll mx = midori[mi];
ll rx = r[ri];
// if (ax > rx && ai < aka.size() - 1) {
// ai++;
// }
// if (mx > rx && mi < midori.size() - 1) {
// mi++;
// }
if (ax < mx && ax < rx) {
aka[ai] = rx;
if (ai < aka.size() - 1) {
ai++;
}
} else if (mx < rx) {
midori[mi] = rx;
if (mi < midori.size() - 1) {
mi++;
}
}
}
ll total = 0;
for (ll ak : aka) {
total += ak;
}
for (ll md : midori) {
total += md;
}
print(total);
}
| #include <bits/stdc++.h>
// clang-format off
using namespace std; using ll = int64_t; using ull = uint64_t; const ll INF = 9e18;
void print() { cout << endl; }
template<typename Head,typename... Tail> void print(Head head,Tail... tail){cout<<head;if(sizeof...(Tail)>0)cout<<" ";print(tail...);}
void print0() {}
template<typename Head,typename... Tail> void print0(Head head,Tail... tail){cout<<head;print0(tail...);}
// clang-format on
int main() {
ll X, Y, A, B, C;
cin >> X >> Y >> A >> B >> C;
vector<ll> p(A);
vector<ll> q(B);
vector<ll> r(C);
for (ll i = 0; i < A; i++) {
cin >> p[i];
}
for (ll i = 0; i < B; i++) {
cin >> q[i];
}
for (ll i = 0; i < C; i++) {
cin >> r[i];
}
vector<ll> aka(X);
sort(p.begin(), p.end(), [](ll a, ll b) { return a > b; });
for (ll i = 0; i < X; i++) {
aka[X - i - 1] = p[i];
}
vector<ll> midori(Y);
sort(q.begin(), q.end(), [](ll a, ll b) { return a > b; });
for (ll i = 0; i < Y; i++) {
midori[Y - i - 1] = q[i];
}
// sort(r.begin(), r.end());
sort(r.begin(), r.end(), [](ll a, ll b) { return a > b; });
ll ai = 0;
ll mi = 0;
for (ll ri = 0; ri < r.size(); ri++) {
ll ax = aka[ai];
ll mx = midori[mi];
ll rx = r[ri];
// if (ax > rx && ai < aka.size() - 1) {
// ai++;
// }
// if (mx > rx && mi < midori.size() - 1) {
// mi++;
// }
if (ax < mx && ax < rx) {
aka[ai] = rx;
if (ai < aka.size() - 1) {
ai++;
}
} else if (mx < rx) {
midori[mi] = rx;
if (mi < midori.size() - 1) {
mi++;
}
}
}
ll total = 0;
for (ll ak : aka) {
total += ak;
}
for (ll md : midori) {
total += md;
}
print(total);
}
| replace | 14 | 15 | 14 | 15 | 0 | |
p02727 | C++ | Runtime Error | #include <memory.h>
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#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 mod 1000000007
int main() {
int x, y;
int abc[3];
cin >> x >> y;
for (int i = 0; i < 3; i++) {
cin >> abc[i];
}
int pqr[3][100000];
for (int i = 0; i < 3; i++) {
for (int j = 0; j < abc[i]; j++) {
cin >> pqr[i][j];
}
}
for (int i = 0; i < 3; i++) {
sort(pqr[i], pqr[i] + abc[i]);
reverse(pqr[i], pqr[i] + abc[i]);
}
vector<int> tmp;
for (int i = 0; i < x; i++) {
tmp.push_back(pqr[0][i]);
}
for (int i = 0; i < y; i++) {
tmp.push_back(pqr[1][i]);
}
for (int i = 0; i < x + y; i++) {
tmp.push_back(pqr[2][i]);
}
sort(tmp.begin(), tmp.end());
reverse(tmp.begin(), tmp.end());
long long int ans = 0;
for (int i = 0; i < x + y; i++) {
ans += tmp[i];
}
cout << ans << endl;
} | #include <memory.h>
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#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 mod 1000000007
int main() {
int x, y;
int abc[3];
cin >> x >> y;
for (int i = 0; i < 3; i++) {
cin >> abc[i];
}
int pqr[3][100000];
for (int i = 0; i < 3; i++) {
for (int j = 0; j < abc[i]; j++) {
cin >> pqr[i][j];
}
}
for (int i = 0; i < 3; i++) {
sort(pqr[i], pqr[i] + abc[i]);
reverse(pqr[i], pqr[i] + abc[i]);
}
vector<int> tmp;
for (int i = 0; i < x; i++) {
tmp.push_back(pqr[0][i]);
}
for (int i = 0; i < y; i++) {
tmp.push_back(pqr[1][i]);
}
for (int i = 0; i < min(x + y, abc[2]); i++) {
tmp.push_back(pqr[2][i]);
}
sort(tmp.begin(), tmp.end());
reverse(tmp.begin(), tmp.end());
long long int ans = 0;
for (int i = 0; i < x + y; i++) {
ans += tmp[i];
}
cout << ans << endl;
} | replace | 49 | 50 | 49 | 50 | 0 | |
p02727 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const int maxn = 2e3 + 5;
int red[maxn], green[maxn], white[maxn];
priority_queue<int, vector<int>, greater<int>> r, g, w;
bool cmp(int a, int b) { return a > b; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
for (int i = 1; i <= a; i++) {
cin >> red[i];
}
for (int i = 1; i <= b; i++) {
cin >> green[i];
}
for (int i = 1; i <= c; i++) {
cin >> white[i];
}
sort(red + 1, red + 1 + a, cmp);
sort(green + 1, green + 1 + b, cmp);
sort(white + 1, white + 1 + c, cmp);
for (int i = 1; i <= x; i++)
r.push(red[i]);
for (int i = 1; i <= y; i++)
g.push(green[i]);
int cnt;
for (int i = c; i >= 1; i--) {
cnt = white[i];
if (r.top() > g.top()) {
g.push(cnt);
g.pop();
} else {
r.push(cnt);
r.pop();
}
}
long long ans = 0;
while (!r.empty()) {
ans += r.top();
r.pop();
}
while (!g.empty()) {
ans += g.top();
g.pop();
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int red[maxn], green[maxn], white[maxn];
priority_queue<int, vector<int>, greater<int>> r, g, w;
bool cmp(int a, int b) { return a > b; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
for (int i = 1; i <= a; i++) {
cin >> red[i];
}
for (int i = 1; i <= b; i++) {
cin >> green[i];
}
for (int i = 1; i <= c; i++) {
cin >> white[i];
}
sort(red + 1, red + 1 + a, cmp);
sort(green + 1, green + 1 + b, cmp);
sort(white + 1, white + 1 + c, cmp);
for (int i = 1; i <= x; i++)
r.push(red[i]);
for (int i = 1; i <= y; i++)
g.push(green[i]);
int cnt;
for (int i = c; i >= 1; i--) {
cnt = white[i];
if (r.top() > g.top()) {
g.push(cnt);
g.pop();
} else {
r.push(cnt);
r.pop();
}
}
long long ans = 0;
while (!r.empty()) {
ans += r.top();
r.pop();
}
while (!g.empty()) {
ans += g.top();
g.pop();
}
cout << ans << endl;
} | replace | 2 | 3 | 2 | 3 | 0 | |
p02727 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<int> p(a);
for (int i = 0; i < a; i++)
cin >> p[i];
vector<int> q(b);
for (int i = 0; i < b; i++)
cin >> q[i];
vector<int> r(c);
for (int i = 0; i < c; i++)
cin >> r[i];
sort(p.begin(), p.end());
sort(q.begin(), q.end());
sort(r.begin(), r.end());
reverse(r.begin(), r.end());
ll sum = 0;
vector<int> s;
for (int i = a - x; i < a; i++) {
sum += p[i];
s.push_back(p[i]);
}
for (int i = b - y; i < b; i++) {
sum += q[i];
s.push_back(q[i]);
}
sort(s.begin(), s.end());
int i = 0;
while (i < c || i < x + y) {
sum += max(s[i], r[i]) - s[i];
i++;
}
cout << sum << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<int> p(a);
for (int i = 0; i < a; i++)
cin >> p[i];
vector<int> q(b);
for (int i = 0; i < b; i++)
cin >> q[i];
vector<int> r(c);
for (int i = 0; i < c; i++)
cin >> r[i];
sort(p.begin(), p.end());
sort(q.begin(), q.end());
sort(r.begin(), r.end());
reverse(r.begin(), r.end());
ll sum = 0;
vector<int> s;
for (int i = a - x; i < a; i++) {
sum += p[i];
s.push_back(p[i]);
}
for (int i = b - y; i < b; i++) {
sum += q[i];
s.push_back(q[i]);
}
sort(s.begin(), s.end());
int i = 0;
while (i < c && i < x + y) {
sum += max(s[i], r[i]) - s[i];
i++;
}
cout << sum << endl;
return 0;
} | replace | 35 | 36 | 35 | 36 | 0 | |
p02727 | C++ | Runtime Error | #include <bits/stdc++.h>
#define CFS \
cin.tie(nullptr); \
ios::sync_with_stdio(false);
#define CST(x) cout << fixed << setprecision(x);
using namespace std;
const int IINF = 1 << 30;
const long LINF = 1LL << 60;
const int MOD = (int)1e9 + 7;
// const int MOD = 998244353;
int main() {
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<long> va(a);
vector<long> vb(b);
for (size_t i = 0; i < a; i++) {
cin >> va[i];
}
for (size_t i = 0; i < a; i++) {
cin >> vb[i];
}
sort(va.rbegin(), va.rend());
sort(vb.rbegin(), vb.rend());
priority_queue<long> pq;
for (size_t i = 0; i < x; i++) {
pq.push(va[i]);
}
for (size_t i = 0; i < y; i++) {
pq.push(vb[i]);
}
for (size_t i = 0; i < c; i++) {
int t;
cin >> t;
pq.push(t);
}
long ans = 0;
for (size_t i = 0; i < x + y; i++) {
ans += pq.top();
pq.pop();
}
cout << ans << "\n";
} | #include <bits/stdc++.h>
#define CFS \
cin.tie(nullptr); \
ios::sync_with_stdio(false);
#define CST(x) cout << fixed << setprecision(x);
using namespace std;
const int IINF = 1 << 30;
const long LINF = 1LL << 60;
const int MOD = (int)1e9 + 7;
// const int MOD = 998244353;
int main() {
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<long> va(a);
vector<long> vb(b);
for (size_t i = 0; i < a; i++) {
cin >> va[i];
}
for (size_t i = 0; i < b; i++) {
cin >> vb[i];
}
sort(va.rbegin(), va.rend());
sort(vb.rbegin(), vb.rend());
priority_queue<long> pq;
for (size_t i = 0; i < x; i++) {
pq.push(va[i]);
}
for (size_t i = 0; i < y; i++) {
pq.push(vb[i]);
}
for (size_t i = 0; i < c; i++) {
int t;
cin >> t;
pq.push(t);
}
long ans = 0;
for (size_t i = 0; i < x + y; i++) {
ans += pq.top();
pq.pop();
}
cout << ans << "\n";
} | replace | 19 | 20 | 19 | 20 | 0 | |
p02727 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INCANT \
cin.tie(0), ios::sync_with_stdio(false), cout << fixed << setprecision(20)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) FOR(i, 0, n)
#define all(x) (x).begin(), (x).end()
#define out(a) cout << a << endl
#define PRINT(V) \
for (auto v : (V)) \
cout << v << " "
const int MOD = 1000000007;
const double PI = acos(-1.0);
void solve() {
ll X, Y, A, B, C;
ll ans = 0;
cin >> X >> Y >> A >> B >> C;
vector<ll> p(A), q(B), r(C);
rep(i, A) cin >> p.at(i);
rep(i, B) cin >> q.at(i);
rep(i, C) cin >> r.at(i);
sort(all(p), greater<ll>());
sort(all(q), greater<ll>());
rep(i, A - X) p.pop_back();
rep(i, B - Y) q.pop_back();
r.insert(r.end(), all(p));
r.insert(r.end(), all(q));
sort(all(r), greater<ll>());
rep(i, A + B + C - X - Y) r.pop_back();
out(accumulate(all(r), 0));
}
int main() {
INCANT;
solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INCANT \
cin.tie(0), ios::sync_with_stdio(false), cout << fixed << setprecision(20)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) FOR(i, 0, n)
#define all(x) (x).begin(), (x).end()
#define out(a) cout << a << endl
#define PRINT(V) \
for (auto v : (V)) \
cout << v << " "
const int MOD = 1000000007;
const double PI = acos(-1.0);
void solve() {
ll X, Y, A, B, C;
ll ans = 0;
cin >> X >> Y >> A >> B >> C;
vector<ll> p(A), q(B), r(C);
rep(i, A) cin >> p.at(i);
rep(i, B) cin >> q.at(i);
rep(i, C) cin >> r.at(i);
sort(all(p), greater<ll>());
sort(all(q), greater<ll>());
rep(i, A - X) p.pop_back();
rep(i, B - Y) q.pop_back();
r.insert(r.end(), all(p));
r.insert(r.end(), all(q));
sort(all(r), greater<ll>());
rep(i, C) r.pop_back();
out(accumulate(all(r), ans));
}
int main() {
INCANT;
solve();
return 0;
}
| replace | 32 | 34 | 32 | 34 | 0 | |
p02727 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
ll X, Y, A, B, C;
ll p[100005];
ll q[100005];
ll r[100005];
vector<ll> pq;
int main() {
cin >> X >> Y >> A >> B >> C;
for (ll i = 0; i < A; i++)
cin >> p[i];
for (ll i = 0; i < B; i++)
cin >> q[i];
for (ll i = 0; i < C; i++)
cin >> r[i];
sort(p, p + A, std::greater<ll>());
sort(q, q + B, std::greater<ll>());
sort(r, r + C, std::greater<ll>());
ll tans = 0;
for (ll i = 0; i < X; i++) {
tans += p[i];
pq.push_back(p[i]);
}
for (ll i = 0; i < Y; i++) {
tans += q[i];
pq.push_back(q[i]);
}
sort(pq.begin(), pq.end());
int pqi = 0;
for (int i = 0; i < C && pqi < X + Y; i++) {
if (pq[pqi] < r[i]) {
tans -= pq[pqi];
pqi--;
tans += r[i];
} else {
break;
}
}
cout << tans << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
ll X, Y, A, B, C;
ll p[100005];
ll q[100005];
ll r[100005];
vector<ll> pq;
int main() {
cin >> X >> Y >> A >> B >> C;
for (ll i = 0; i < A; i++)
cin >> p[i];
for (ll i = 0; i < B; i++)
cin >> q[i];
for (ll i = 0; i < C; i++)
cin >> r[i];
sort(p, p + A, std::greater<ll>());
sort(q, q + B, std::greater<ll>());
sort(r, r + C, std::greater<ll>());
ll tans = 0;
for (ll i = 0; i < X; i++) {
tans += p[i];
pq.push_back(p[i]);
}
for (ll i = 0; i < Y; i++) {
tans += q[i];
pq.push_back(q[i]);
}
sort(pq.begin(), pq.end());
int pqi = 0;
for (int i = 0; i < C && pqi < X + Y; i++) {
if (pq[pqi] < r[i]) {
tans -= pq[pqi];
pqi++;
tans += r[i];
} else {
break;
}
}
cout << tans << endl;
return 0;
} | replace | 44 | 45 | 44 | 45 | 0 | |
p02727 | C++ | Runtime Error | #include <algorithm>
#include <functional>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int red, green, numa, numb, numc;
cin >> red >> green >> numa >> numb >> numc;
vector<int> v_red;
vector<int> v_green;
vector<int> v_white;
int current;
for (int i = 0; i < numa; i++) {
cin >> current;
v_red.push_back(current);
}
for (int i = 0; i < numb; i++) {
cin >> current;
v_green.push_back(current);
}
for (int i = 0; i < numc; i++) {
cin >> current;
v_white.push_back(current);
}
sort(v_red.begin(), v_red.end(), greater<int>());
sort(v_green.begin(), v_green.end(), greater<int>());
sort(v_white.begin(), v_white.end(), greater<int>());
long long ans = 0;
vector<int> eat;
for (int i = 0; i < red; i++) {
ans += v_red[i];
eat.push_back(v_red[i]);
}
for (int i = 0; i < green; i++) {
ans += v_green[i];
eat.push_back(v_green[i]);
}
sort(eat.begin(), eat.end());
int index_eat = 0;
int index_white = 0;
while (eat[index_eat] <= v_white[index_white]) {
ans -= eat[index_eat];
ans += v_white[index_white];
index_eat++;
index_white++;
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <functional>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int red, green, numa, numb, numc;
cin >> red >> green >> numa >> numb >> numc;
vector<int> v_red;
vector<int> v_green;
vector<int> v_white;
int current;
for (int i = 0; i < numa; i++) {
cin >> current;
v_red.push_back(current);
}
for (int i = 0; i < numb; i++) {
cin >> current;
v_green.push_back(current);
}
for (int i = 0; i < numc; i++) {
cin >> current;
v_white.push_back(current);
}
sort(v_red.begin(), v_red.end(), greater<int>());
sort(v_green.begin(), v_green.end(), greater<int>());
sort(v_white.begin(), v_white.end(), greater<int>());
long long ans = 0;
vector<int> eat;
for (int i = 0; i < red; i++) {
ans += v_red[i];
eat.push_back(v_red[i]);
}
for (int i = 0; i < green; i++) {
ans += v_green[i];
eat.push_back(v_green[i]);
}
sort(eat.begin(), eat.end());
int index_eat = 0;
int index_white = 0;
while (eat[index_eat] <= v_white[index_white]) {
ans -= eat[index_eat];
ans += v_white[index_white];
index_eat++;
index_white++;
if (index_eat >= eat.size()) {
break;
}
if (index_white >= v_white.size()) {
break;
}
}
cout << ans << endl;
return 0;
} | insert | 46 | 46 | 46 | 52 | 0 | |
p02727 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int X, Y, A, B, C;
cin >> X >> Y >> A >> B >> C;
long long p[100010] = {0};
long long q[100010] = {0};
long long r[100010] = {0};
for (int i = 0; i < A; i++)
cin >> p[i];
for (int i = 0; i < B; i++)
cin >> q[i];
for (int i = 0; i < C; i++)
cin >> r[i];
sort(p, p + A, greater<>());
sort(q, q + B, greater<>());
sort(r, r + C, greater<>());
long long z[300030] = {0};
for (int i = 0; i < X; i++) {
z[i] = p[i];
}
for (int i = 0; i < Y; i++) {
z[i + X] = q[i];
}
for (long long i = 0; i < (X + Y); i++) {
z[i + X + Y] = r[i];
}
sort(z, z + 300030, greater<>());
long long sum = 0;
for (long long i = 0; i < (X + Y); i++) {
sum += z[i];
}
cout << sum << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int X, Y, A, B, C;
cin >> X >> Y >> A >> B >> C;
long long p[100010] = {0};
long long q[100010] = {0};
long long r[100010] = {0};
for (int i = 0; i < A; i++)
cin >> p[i];
for (int i = 0; i < B; i++)
cin >> q[i];
for (int i = 0; i < C; i++)
cin >> r[i];
sort(p, p + A, greater<>());
sort(q, q + B, greater<>());
sort(r, r + C, greater<>());
long long z[300030] = {0};
for (int i = 0; i < X; i++) {
z[i] = p[i];
}
for (int i = 0; i < Y; i++) {
z[i + X] = q[i];
}
for (long long i = 0; i < C; i++) {
z[i + X + Y] = r[i];
}
sort(z, z + 300030, greater<>());
long long sum = 0;
for (long long i = 0; i < (X + Y); i++) {
sum += z[i];
}
cout << sum << endl;
return 0;
} | replace | 28 | 29 | 28 | 29 | 0 | |
p02727 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<long long> p(a), q(b), r(c);
for (int i = 0; i < a; i++)
cin >> p.at(i);
for (int i = 0; i < b; i++)
cin >> q.at(i);
for (int i = 0; i < c; i++)
cin >> r.at(i);
sort(p.begin(), p.end());
sort(q.begin(), q.end());
sort(r.begin(), r.end());
vector<long long> A(x), B(y);
for (int i = 0; i < x; i++)
A.at(i) = p.at(a - x + i);
for (int i = 0; i < y; i++)
B.at(i) = q.at(b - y + i);
if (c != 0)
reverse(r.begin(), r.end());
// for(int i=0;i<x;i++)
// cout<<A.at(i);
// cout<<endl;
// for(int i=0;i<y;i++)
// cout<<B.at(i);
// cout<<endl;
int count_a = 0, count_b = 0;
for (int i = 0; i < c; i++) { // 1
int x;
if (A.at(count_a) > B.at(count_b)) { // 2
x = B.at(count_b);
if (r.at(i) > B.at(count_b)) { // 3
B.at(count_b) = r.at(i);
if (count_b < y)
count_b++;
// break;
} // 3
} // 2
else { // 4
x = A.at(count_a);
if (r.at(i) > A.at(count_a)) { // 5
A.at(count_a) = r.at(i);
if (count_a < x - 1)
count_a++;
// break;
} // 5
} // 4
}
long long sum = 0;
for (int i = 0; i < x; i++) {
sum += A.at(i);
// cout<<A.at(i)<<" ";
}
// cout<<endl;
for (int i = 0; i < y; i++) {
sum += B.at(i);
// cout<<B.at(i)<<" ";
}
// cout<<endl;
cout << sum << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<long long> p(a), q(b), r(c);
for (int i = 0; i < a; i++)
cin >> p.at(i);
for (int i = 0; i < b; i++)
cin >> q.at(i);
for (int i = 0; i < c; i++)
cin >> r.at(i);
sort(p.begin(), p.end());
sort(q.begin(), q.end());
sort(r.begin(), r.end());
vector<long long> A(x), B(y);
for (int i = 0; i < x; i++)
A.at(i) = p.at(a - x + i);
for (int i = 0; i < y; i++)
B.at(i) = q.at(b - y + i);
if (c != 0)
reverse(r.begin(), r.end());
// for(int i=0;i<x;i++)
// cout<<A.at(i);
// cout<<endl;
// for(int i=0;i<y;i++)
// cout<<B.at(i);
// cout<<endl;
int count_a = 0, count_b = 0;
for (int i = 0; i < c; i++) { // 1
int x;
if (A.at(count_a) > B.at(count_b)) { // 2
x = B.at(count_b);
if (r.at(i) > B.at(count_b)) { // 3
B.at(count_b) = r.at(i);
if (count_b < y - 1)
count_b++;
// break;
} // 3
} // 2
else { // 4
x = A.at(count_a);
if (r.at(i) > A.at(count_a)) { // 5
A.at(count_a) = r.at(i);
if (count_a < x - 1)
count_a++;
// break;
} // 5
} // 4
}
long long sum = 0;
for (int i = 0; i < x; i++) {
sum += A.at(i);
// cout<<A.at(i)<<" ";
}
// cout<<endl;
for (int i = 0; i < y; i++) {
sum += B.at(i);
// cout<<B.at(i)<<" ";
}
// cout<<endl;
cout << sum << endl;
} | replace | 42 | 43 | 42 | 43 | 0 | |
p02727 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(a) (a).begin(), (a).end()
#define VI vector<int>
#define MOD 1000000007
typedef long long int ll;
const ll INF = (ll)1e19;
// const int INF=(1<<30);
int main() {
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<ll> p(a), q(b), r(c);
vector<ll> sp(x + 1, 0), sq(y + 1, 0), sr(c + 1, 0);
REP(i, a) cin >> p[i];
REP(i, b) cin >> q[i];
REP(i, c) cin >> r[i];
sort(ALL(p));
reverse(ALL(p));
sort(ALL(q));
reverse(ALL(q));
sort(ALL(r));
reverse(ALL(r));
REP(i, x) { sp[i + 1] = sp[i] + p[i]; }
REP(i, y) { sq[i + 1] = sq[i] + q[i]; }
REP(i, c) { sr[i + 1] = sr[i] + r[i]; }
ll ans = -1;
REP(i, x + 1) {
REP(j, y + 1) {
if (x - i + y - j > c)
continue;
ans = max(ans, sp[i] + sq[j] + sr[x - i + y - j]);
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(a) (a).begin(), (a).end()
#define VI vector<int>
#define MOD 1000000007
typedef long long int ll;
const ll INF = (ll)1e19;
// const int INF=(1<<30);
int main() {
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<ll> p(a), q(b), r(c);
vector<ll> sp(x + 1, 0), sq(y + 1, 0), sr(c + 1, 0);
REP(i, a) cin >> p[i];
REP(i, b) cin >> q[i];
REP(i, c) cin >> r[i];
sort(ALL(p));
reverse(ALL(p));
sort(ALL(q));
reverse(ALL(q));
sort(ALL(r));
reverse(ALL(r));
REP(i, x) { sp[i + 1] = sp[i] + p[i]; }
REP(i, y) { sq[i + 1] = sq[i] + q[i]; }
REP(i, c) { sr[i + 1] = sr[i] + r[i]; }
vector<ll> nn;
REP(i, x) nn.push_back(p[i]);
REP(i, y) nn.push_back(q[i]);
REP(i, c) nn.push_back(r[i]);
sort(ALL(nn));
reverse(ALL(nn));
ll ans = 0;
REP(i, x + y) ans += nn[i];
cout << ans << endl;
}
| replace | 36 | 44 | 36 | 46 | TLE | |
p02727 | C++ | Runtime Error | #include <algorithm>
#include <cfloat>
#include <complex>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <sys/time.h>
#include <unordered_map>
#include <vector>
#define fs first
#define sc second
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef pair<ll, ll> P;
int main() {
ll x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<ll> p(a), q(b), r(c);
vector<P> apple;
for (int i = 0; i < a; i++) {
cin >> p[i];
}
p.push_back(0);
for (int i = 0; i < b; i++) {
cin >> q[i];
}
q.push_back(0);
for (int i = 0; i < c; i++) {
cin >> r[i];
}
r.push_back(0);
sort(p.begin(), p.end());
reverse(p.begin(), p.end());
sort(q.begin(), q.end());
reverse(q.begin(), q.end());
sort(r.begin(), r.end());
reverse(r.begin(), r.end());
ll num = 0;
ll pSum = 0, qSum = 0, rSum = 0;
for (int i = 0; i < x; i++) {
pSum += p[i];
num++;
}
ll qNext = 0, rNext = 0;
ll greenNum = 0;
while (num < x + y) {
if (q[qNext] < r[rNext]) {
rSum += r[rNext++];
greenNum++;
} else {
qSum += q[qNext++];
}
num++;
}
ll res = pSum + qSum + rSum;
ll aLast = x - 1;
while (aLast >= 0) {
pSum -= p[aLast--];
if (q[qNext] < r[rNext] || greenNum == 0) {
rSum += r[rNext++];
} else {
greenNum--;
qSum += q[qNext++];
}
res = max(res, pSum + qSum + rSum);
}
cout << res << endl;
return 0;
} | #include <algorithm>
#include <cfloat>
#include <complex>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <sys/time.h>
#include <unordered_map>
#include <vector>
#define fs first
#define sc second
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef pair<ll, ll> P;
int main() {
ll x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<ll> p(a), q(b), r(c);
vector<P> apple;
for (int i = 0; i < a; i++) {
cin >> p[i];
}
p.push_back(0);
for (int i = 0; i < b; i++) {
cin >> q[i];
}
q.push_back(0);
for (int i = 0; i < c; i++) {
cin >> r[i];
}
r.push_back(0);
sort(p.begin(), p.end());
reverse(p.begin(), p.end());
sort(q.begin(), q.end());
reverse(q.begin(), q.end());
sort(r.begin(), r.end());
reverse(r.begin(), r.end());
ll num = 0;
ll pSum = 0, qSum = 0, rSum = 0;
for (int i = 0; i < x; i++) {
pSum += p[i];
num++;
}
ll qNext = 0, rNext = 0;
ll greenNum = 0;
while (num < x + y) {
if (q[qNext] < r[rNext]) {
rSum += r[rNext++];
greenNum++;
} else {
qSum += q[qNext++];
}
num++;
}
ll res = pSum + qSum + rSum;
ll aLast = x - 1;
while (aLast >= 0) {
if (greenNum == 0 && rNext == c) {
break;
}
pSum -= p[aLast--];
if (q[qNext] < r[rNext] || greenNum == 0) {
rSum += r[rNext++];
} else {
greenNum--;
qSum += q[qNext++];
}
res = max(res, pSum + qSum + rSum);
}
cout << res << endl;
return 0;
} | insert | 76 | 76 | 76 | 79 | 0 | |
p02727 | C++ | Runtime Error | #pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef int in;
#define int long long
#define pb push_back
#define f first
#define s second
#define double long double
const int MAX = 2e3 + 5;
const int MAX2 = 2e5 + 4;
const int MAAX = 1e10;
const int MOD = 1e9 + 7;
int x, y, a, b, c;
int r[MAX], g[MAX], nc[MAX];
in main() {
cin >> x >> y >> a >> b >> c;
for (int i = 0; i < a; i++) {
scanf("%lld", &r[i]);
r[i] *= -1;
}
for (int i = 0; i < b; i++) {
scanf("%lld", &g[i]);
g[i] *= -1;
}
for (int i = 0; i < c; i++) {
scanf("%lld", &nc[i]);
nc[i] *= -1;
}
sort(r, r + a);
sort(g, g + b);
sort(nc, nc + c);
vector<int> ans;
for (int i = 0; i < x; i++) {
ans.pb(-r[i]);
}
for (int i = 0; i < y; i++) {
ans.pb(-g[i]);
}
sort(ans.begin(), ans.end());
int idx = 0;
for (int i = 0; i < c; i++) {
if (idx < ans.size() && ans[idx] < -nc[i]) {
ans[idx++] = -nc[i];
}
}
int anss = 0;
for (int i = 0; i < ans.size(); i++)
anss += ans[i];
cout << anss << endl;
return 0;
}
| #pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef int in;
#define int long long
#define pb push_back
#define f first
#define s second
#define double long double
const int MAX = 2e5 + 5;
const int MAX2 = 2e5 + 4;
const int MAAX = 1e10;
const int MOD = 1e9 + 7;
int x, y, a, b, c;
int r[MAX], g[MAX], nc[MAX];
in main() {
cin >> x >> y >> a >> b >> c;
for (int i = 0; i < a; i++) {
scanf("%lld", &r[i]);
r[i] *= -1;
}
for (int i = 0; i < b; i++) {
scanf("%lld", &g[i]);
g[i] *= -1;
}
for (int i = 0; i < c; i++) {
scanf("%lld", &nc[i]);
nc[i] *= -1;
}
sort(r, r + a);
sort(g, g + b);
sort(nc, nc + c);
vector<int> ans;
for (int i = 0; i < x; i++) {
ans.pb(-r[i]);
}
for (int i = 0; i < y; i++) {
ans.pb(-g[i]);
}
sort(ans.begin(), ans.end());
int idx = 0;
for (int i = 0; i < c; i++) {
if (idx < ans.size() && ans[idx] < -nc[i]) {
ans[idx++] = -nc[i];
}
}
int anss = 0;
for (int i = 0; i < ans.size(); i++)
anss += ans[i];
cout << anss << endl;
return 0;
}
| replace | 12 | 13 | 12 | 13 | 0 | |
p02727 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<string> vs;
typedef unordered_set<int> si;
typedef pair<int, int> pp;
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename T> void printV(vector<T> A) {
if (A.empty())
cerr << "EMTPY\n";
else {
cerr << "[";
for (int i = 0; i < A.size() - 1; ++i) {
cerr << A[i] << ", ";
}
if (A.size())
cerr << A.back() << "]\n";
}
}
template <typename T> void printVV(vector<vector<T>> A) {
cerr << "[";
for (auto v : A) {
printV<T>(v);
}
cerr << "]";
}
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << ": " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << ": " << arg1 << " |";
__f(comma + 1, args...);
}
int main(int argc, char **argv) {
ios::sync_with_stdio(false);
cin.tie(0);
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<ll> reds(a), greens(b), colorless(c);
for (int i = 0; i < a; ++i)
cin >> reds[i];
for (int i = 0; i < b; ++i)
cin >> greens[i];
for (int i = 0; i < c; ++i)
cin >> colorless[i];
ll ans = 0;
sort(reds.begin(), reds.end(), greater<ll>());
sort(greens.begin(), greens.end(), greater<ll>());
sort(colorless.begin(), colorless.end());
vector<ll> ar(reds.begin(), reds.begin() + x);
vector<ll> ag(greens.begin(), greens.begin() + y);
int r = x - 1, g = y - 1;
--c;
while (c >= 0 && (r >= 0 || g >= 0)) {
int v = colorless[c];
int aa = r >= 0 ? ar[r] : LLONG_MAX;
int bb = g >= 0 ? ag[g] : LLONG_MAX;
if (min(aa, bb) > v)
break;
if (aa < bb)
ar[r--] = v;
else
ag[g--] = v;
c--;
}
cout << accumulate(ar.begin(), ar.end(), 0LL) +
accumulate(ag.begin(), ag.end(), 0LL)
<< endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<string> vs;
typedef unordered_set<int> si;
typedef pair<int, int> pp;
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename T> void printV(vector<T> A) {
if (A.empty())
cerr << "EMTPY\n";
else {
cerr << "[";
for (int i = 0; i < A.size() - 1; ++i) {
cerr << A[i] << ", ";
}
if (A.size())
cerr << A.back() << "]\n";
}
}
template <typename T> void printVV(vector<vector<T>> A) {
cerr << "[";
for (auto v : A) {
printV<T>(v);
}
cerr << "]";
}
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << ": " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << ": " << arg1 << " |";
__f(comma + 1, args...);
}
int main(int argc, char **argv) {
ios::sync_with_stdio(false);
cin.tie(0);
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<ll> reds(a), greens(b), colorless(c);
for (int i = 0; i < a; ++i)
cin >> reds[i];
for (int i = 0; i < b; ++i)
cin >> greens[i];
for (int i = 0; i < c; ++i)
cin >> colorless[i];
ll ans = 0;
sort(reds.begin(), reds.end(), greater<ll>());
sort(greens.begin(), greens.end(), greater<ll>());
sort(colorless.begin(), colorless.end());
vector<ll> ar(reds.begin(), reds.begin() + x);
vector<ll> ag(greens.begin(), greens.begin() + y);
int r = x - 1, g = y - 1;
--c;
while (c >= 0 && (r >= 0 || g >= 0)) {
int v = colorless[c];
ll aa = r >= 0 ? ar[r] : 1e10;
ll bb = g >= 0 ? ag[g] : 1e10;
if (min(aa, bb) > v)
break;
if (aa < bb)
ar[r--] = v;
else
ag[g--] = v;
c--;
}
cout << accumulate(ar.begin(), ar.end(), 0LL) +
accumulate(ag.begin(), ag.end(), 0LL)
<< endl;
return 0;
}
| replace | 73 | 75 | 73 | 75 | 0 | |
p02727 | C++ | Runtime Error | #define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
#include <unordered_map>
// #include"testlib.h"
#define endl "\n"
#define all(v) v.begin(), v.end()
#define allr(s) s.rbegin(), s.rend()
#define RT(s) return cout << s, 0
#define watch(x) cout << (#x) << " = " << x << endl
#define sz(s) (int)(s.size())
#define PI acos(-1)
#define EPS 1e-8
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<ii> vii;
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
void file() {
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
// freopen("out.txt", "w", stdout);
#else
// freopen("street.in", "r", stdin);
// freopen("out.txt", "w", stdout);
#endif
}
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
}
int main() {
// file();
fast();
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<ll> v1(a), v2(b), v3(c + 1);
for (auto &it : v1)
cin >> it;
for (auto &it : v2)
cin >> it;
for (int i = 1; i <= c; i++)
cin >> v3[i];
sort(v3.begin() + 1, v3.end());
reverse(v3.begin() + 1, v3.end());
for (int i = 1; i <= c; i++)
v3[i] += v3[i - 1];
vector<ll> All(1);
sort(allr(v1)), sort(allr(v2));
for (int i = 0; i < x; i++)
All.push_back(v1[i]);
for (int i = 0; i < y; i++)
All.push_back(v2[i]);
sort(All.begin() + 1, All.end());
for (int i = 1; i < sz(All); i++)
All[i] += All[i - 1];
ll ans = All.back();
for (int i = 1; i <= c; i++) {
if (v3[i] + All.back() - All[i] > ans)
ans = v3[i] + All.back() - All[i];
}
cout << ans << endl;
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
#include <unordered_map>
// #include"testlib.h"
#define endl "\n"
#define all(v) v.begin(), v.end()
#define allr(s) s.rbegin(), s.rend()
#define RT(s) return cout << s, 0
#define watch(x) cout << (#x) << " = " << x << endl
#define sz(s) (int)(s.size())
#define PI acos(-1)
#define EPS 1e-8
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<ii> vii;
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
void file() {
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
// freopen("out.txt", "w", stdout);
#else
// freopen("street.in", "r", stdin);
// freopen("out.txt", "w", stdout);
#endif
}
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
}
int main() {
// file();
fast();
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<ll> v1(a), v2(b), v3(c + 1);
for (auto &it : v1)
cin >> it;
for (auto &it : v2)
cin >> it;
for (int i = 1; i <= c; i++)
cin >> v3[i];
sort(v3.begin() + 1, v3.end());
reverse(v3.begin() + 1, v3.end());
for (int i = 1; i <= c; i++)
v3[i] += v3[i - 1];
vector<ll> All(1);
sort(allr(v1)), sort(allr(v2));
for (int i = 0; i < x; i++)
All.push_back(v1[i]);
for (int i = 0; i < y; i++)
All.push_back(v2[i]);
sort(All.begin() + 1, All.end());
for (int i = 1; i < sz(All); i++)
All[i] += All[i - 1];
ll ans = All.back();
for (int i = 1; i < min(sz(v3), sz(All)); i++) {
if (v3[i] + All.back() - All[i] > ans)
ans = v3[i] + All.back() - All[i];
}
cout << ans << endl;
return 0;
} | replace | 64 | 65 | 64 | 65 | 0 | |
p02727 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef uint64_t u64;
typedef int64_t s64;
typedef uint32_t u32;
typedef int32_t s32;
typedef vector<s32> vs32;
typedef vector<u32> vu32;
typedef vector<s64> vs64;
typedef vector<u64> vu64;
const double PI = 3.14159265358979323846;
#define MAX(x, y) ((x) < (y) ? (y) : (x))
#define MIN(x, y) ((x) > (y) ? (y) : (x))
#define rep(i, N) for (int i = 0; i < N; ++i)
#define CEIL(x, y) (((x) + (y)-1) / (y))
#define MOD 1000000007ULL
#define IN(l, r, x) ((l) <= (x) && (x) < (r))
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vs64 A(a), B(b), C(c);
rep(i, a) cin >> A[i];
rep(i, b) cin >> B[i];
rep(i, c) cin >> C[i];
sort(A.begin(), A.end(), greater<s64>());
sort(B.begin(), B.end(), greater<s64>());
sort(C.begin(), C.end(), greater<s64>());
s64 ans = 0;
rep(i, x) ans += A[i];
rep(i, y) ans += B[i];
int aidx = x - 1;
int bidx = y - 1;
rep(i, c) {
if (aidx >= 0 && bidx >= 0 && C[i] > A[aidx] && C[i] > B[bidx]) {
if (A[aidx] > B[bidx]) {
ans += C[i] - B[bidx];
--bidx;
} else if (A[aidx] <= B[bidx]) {
ans += C[i] - A[aidx];
--aidx;
}
} else if (C[i] > A[aidx] && aidx >= 0) {
ans += C[i] - A[aidx];
--aidx;
} else if (C[i] > B[bidx]) {
ans += C[i] - B[bidx];
--bidx;
} else {
break;
}
}
cout << ans << "\n";
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef uint64_t u64;
typedef int64_t s64;
typedef uint32_t u32;
typedef int32_t s32;
typedef vector<s32> vs32;
typedef vector<u32> vu32;
typedef vector<s64> vs64;
typedef vector<u64> vu64;
const double PI = 3.14159265358979323846;
#define MAX(x, y) ((x) < (y) ? (y) : (x))
#define MIN(x, y) ((x) > (y) ? (y) : (x))
#define rep(i, N) for (int i = 0; i < N; ++i)
#define CEIL(x, y) (((x) + (y)-1) / (y))
#define MOD 1000000007ULL
#define IN(l, r, x) ((l) <= (x) && (x) < (r))
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vs64 A(a), B(b), C(c);
rep(i, a) cin >> A[i];
rep(i, b) cin >> B[i];
rep(i, c) cin >> C[i];
sort(A.begin(), A.end(), greater<s64>());
sort(B.begin(), B.end(), greater<s64>());
sort(C.begin(), C.end(), greater<s64>());
s64 ans = 0;
rep(i, x) ans += A[i];
rep(i, y) ans += B[i];
int aidx = x - 1;
int bidx = y - 1;
rep(i, c) {
if (aidx >= 0 && bidx >= 0 && C[i] > A[aidx] && C[i] > B[bidx]) {
if (A[aidx] > B[bidx]) {
ans += C[i] - B[bidx];
--bidx;
} else if (A[aidx] <= B[bidx]) {
ans += C[i] - A[aidx];
--aidx;
}
} else if (C[i] > A[aidx] && aidx >= 0) {
ans += C[i] - A[aidx];
--aidx;
} else if (C[i] > B[bidx] && bidx >= 0) {
ans += C[i] - B[bidx];
--bidx;
} else {
break;
}
}
cout << ans << "\n";
return 0;
}
| replace | 74 | 75 | 74 | 75 | 0 | |
p02727 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
// clang-format off
#define range(i, l, r) for (int i = (int)(l); i < (int)(r); ++(i))
#define rrange(i, l, r) for (int i = (int)(r) - 1; i >= (int)(l); --(i))
#define whole(f, x, ...) ([&](decltype((x)) container) { return (f)( begin(container), end(container), ## __VA_ARGS__); })(x)
#define rwhole(f, x, ...) ([&](decltype((x)) container) { return (f)( rbegin(container), rend(container), ## __VA_ARGS__); })(x)
#define endl '\n'
#define debug(x) cerr << "(" << __LINE__ << ")" << #x << ": " << (x) << endl
using i32 = int;
using u32 = unsigned int;
using i64 = long long;
using u64 = unsigned long long;
// constexpr i32 mod = 998244353;
constexpr i32 mod = 1e9 + 7;
constexpr i32 inf = 1001001001;
constexpr i64 infll = 1001001001001001001ll;
constexpr int dx[] = {0, -1, 1, 0, -1, 1, -1, 1};
constexpr int dy[] = {-1, 0, 0, 1, -1, -1, 1, 1};
struct IoSetup { IoSetup(int x = 15){ cin.tie(0); ios::sync_with_stdio(0); cout << fixed << setprecision(x); cerr << fixed << setprecision(x); } } iosetup;
template <typename T = i64> T input() { T x; cin >> x; return x; }
template <typename T> ostream &operator<<(ostream &os, vector<T> &v) { range(i, 0, v.size()) { os << v[i] << (i + 1 != v.size() ? " " : ""); } return os; }
template <typename T> istream &operator>>(istream &is, vector<T> &v) { for (T &in : v) is >> in; return is; }
template <typename T1, typename T2> ostream &operator<<(ostream &os, pair<T1, T2> p) { os << "(" << p.first << ", " << p.second << ")"; return os; }
template <typename T1, typename T2> istream &operator>>(istream &is, pair<T1, T2> &p) { is >> p.first >> p.second; return is; }
template <typename T> vector<T> make_vector(size_t a, T b) { return vector<T>(a, b); }
template <typename... Ts> auto make_vector(size_t a, Ts... ts) { return vector<decltype(make_vector(ts...))>(a, make_vector(ts...)); }
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) { return a > b && (a = b, true); }
// clang-format on
void solver() {
int x = input(), y = input();
int a = input(), b = input(), c = input();
vector<int> p(a), q(b), r(c);
cin >> p >> q >> r;
rwhole(sort, p);
rwhole(sort, q);
rwhole(sort, r);
i64 ans = 0;
vector<i64> apple;
range(i, 0, x) {
ans += p[i];
apple.push_back(p[i]);
}
range(i, 0, y) {
ans += q[i];
apple.push_back(q[i]);
}
whole(sort, apple);
i64 sum = ans;
range(i, 0, c) {
sum += r[i] - apple[i];
chmax(ans, sum);
}
cout << ans << endl;
}
signed main(int argc, char *argv[]) { solver(); }
| #include <bits/stdc++.h>
using namespace std;
// clang-format off
#define range(i, l, r) for (int i = (int)(l); i < (int)(r); ++(i))
#define rrange(i, l, r) for (int i = (int)(r) - 1; i >= (int)(l); --(i))
#define whole(f, x, ...) ([&](decltype((x)) container) { return (f)( begin(container), end(container), ## __VA_ARGS__); })(x)
#define rwhole(f, x, ...) ([&](decltype((x)) container) { return (f)( rbegin(container), rend(container), ## __VA_ARGS__); })(x)
#define endl '\n'
#define debug(x) cerr << "(" << __LINE__ << ")" << #x << ": " << (x) << endl
using i32 = int;
using u32 = unsigned int;
using i64 = long long;
using u64 = unsigned long long;
// constexpr i32 mod = 998244353;
constexpr i32 mod = 1e9 + 7;
constexpr i32 inf = 1001001001;
constexpr i64 infll = 1001001001001001001ll;
constexpr int dx[] = {0, -1, 1, 0, -1, 1, -1, 1};
constexpr int dy[] = {-1, 0, 0, 1, -1, -1, 1, 1};
struct IoSetup { IoSetup(int x = 15){ cin.tie(0); ios::sync_with_stdio(0); cout << fixed << setprecision(x); cerr << fixed << setprecision(x); } } iosetup;
template <typename T = i64> T input() { T x; cin >> x; return x; }
template <typename T> ostream &operator<<(ostream &os, vector<T> &v) { range(i, 0, v.size()) { os << v[i] << (i + 1 != v.size() ? " " : ""); } return os; }
template <typename T> istream &operator>>(istream &is, vector<T> &v) { for (T &in : v) is >> in; return is; }
template <typename T1, typename T2> ostream &operator<<(ostream &os, pair<T1, T2> p) { os << "(" << p.first << ", " << p.second << ")"; return os; }
template <typename T1, typename T2> istream &operator>>(istream &is, pair<T1, T2> &p) { is >> p.first >> p.second; return is; }
template <typename T> vector<T> make_vector(size_t a, T b) { return vector<T>(a, b); }
template <typename... Ts> auto make_vector(size_t a, Ts... ts) { return vector<decltype(make_vector(ts...))>(a, make_vector(ts...)); }
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) { return a > b && (a = b, true); }
// clang-format on
void solver() {
int x = input(), y = input();
int a = input(), b = input(), c = input();
vector<int> p(a), q(b), r(c);
cin >> p >> q >> r;
rwhole(sort, p);
rwhole(sort, q);
rwhole(sort, r);
i64 ans = 0;
vector<i64> apple;
range(i, 0, x) {
ans += p[i];
apple.push_back(p[i]);
}
range(i, 0, y) {
ans += q[i];
apple.push_back(q[i]);
}
whole(sort, apple);
i64 sum = ans;
range(i, 0, c) {
if (apple.size() == i)
break;
sum += r[i] - apple[i];
chmax(ans, sum);
}
cout << ans << endl;
}
signed main(int argc, char *argv[]) { solver(); }
| insert | 68 | 68 | 68 | 70 | 0 | |
p02727 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i < (n + 1); ++i)
using namespace std;
using ll = long long;
const int INF = -100100100;
typedef pair<int, int> P;
int main() {
ll x, y, a, b, c, ans;
cin >> x >> y >> a >> b >> c;
vector<ll> p(a), q(b), r(c), qp, dp(c + 10);
rep(i, a) cin >> p[i];
rep(i, b) cin >> q[i];
rep(i, c) cin >> r[i];
sort(p.begin(), p.end(), greater<ll>());
sort(q.begin(), q.end(), greater<ll>());
sort(r.begin(), r.end(), greater<ll>());
rep(i, x) {
qp.push_back(p[i]);
ans += p[i];
}
rep(i, y) {
qp.push_back(q[i]);
ans += q[i];
}
sort(qp.begin(), qp.end());
dp[0] = ans;
// for(int i=1; i<=c; ++i){
// dp[i] = max(dp[i-1], dp[i-1]-qp[i-1]+r[i-1]);
// }
rep(i, c) {
if (qp[i] < r[i])
ans += r[i] - qp[i];
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i < (n + 1); ++i)
using namespace std;
using ll = long long;
const int INF = -100100100;
typedef pair<int, int> P;
int main() {
ll x, y, a, b, c, ans;
cin >> x >> y >> a >> b >> c;
vector<ll> p(a), q(b), r(c), qp, dp(c + 10);
rep(i, a) cin >> p[i];
rep(i, b) cin >> q[i];
rep(i, c) cin >> r[i];
sort(p.begin(), p.end(), greater<ll>());
sort(q.begin(), q.end(), greater<ll>());
sort(r.begin(), r.end(), greater<ll>());
rep(i, x) { qp.push_back(p[i]); }
rep(i, y) { qp.push_back(q[i]); }
rep(i, c) qp.push_back(r[i]);
sort(qp.begin(), qp.end(), greater<ll>());
rep(i, x + y) { ans += qp[i]; }
cout << ans << endl;
return 0;
} | replace | 18 | 35 | 18 | 23 | 0 | |
p02727 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
// #define cerr if(false) cerr
#ifdef DEBUG
#define show(...) cerr << #__VA_ARGS__ << " = ", debug(__VA_ARGS__);
#else
#define show(...) 42
#endif
using namespace std;
using ll = long long;
using pii = pair<int, int>;
template <typename T, typename S>
ostream &operator<<(ostream &os, pair<T, S> a) {
os << '(' << a.first << ',' << a.second << ')';
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> v) {
for (auto x : v)
os << x << ' ';
return os;
}
void debug() { cerr << '\n'; }
template <typename H, typename... T> void debug(H a, T... b) {
cerr << a;
if (sizeof...(b))
cerr << ", ";
debug(b...);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int X, Y, a, b, c;
cin >> X >> Y >> a >> b >> c;
multiset<int> st;
multiset<int> st2;
rep(i, a) {
int x;
cin >> x;
st.insert(x);
}
while (st.size() > X)
st.erase(st.begin());
rep(i, b) {
int x;
cin >> x;
st2.insert(x);
}
while (st2.size() > Y)
st2.erase(st2.begin());
vector<int> d(c);
rep(i, c) { cin >> d[i]; }
sort(d.rbegin(), d.rend());
for (auto x : d) {
if (*st.begin() > x and *st2.begin() > x)
break;
if (*st.begin() < *st2.begin()) {
st.erase(st.begin());
st.insert(x);
} else {
st2.erase(st2.begin());
st.insert(x);
}
}
ll ans = 0;
for (auto x : st)
ans += x;
for (auto x : st2)
ans += x;
cout << ans << endl;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
// #define cerr if(false) cerr
#ifdef DEBUG
#define show(...) cerr << #__VA_ARGS__ << " = ", debug(__VA_ARGS__);
#else
#define show(...) 42
#endif
using namespace std;
using ll = long long;
using pii = pair<int, int>;
template <typename T, typename S>
ostream &operator<<(ostream &os, pair<T, S> a) {
os << '(' << a.first << ',' << a.second << ')';
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> v) {
for (auto x : v)
os << x << ' ';
return os;
}
void debug() { cerr << '\n'; }
template <typename H, typename... T> void debug(H a, T... b) {
cerr << a;
if (sizeof...(b))
cerr << ", ";
debug(b...);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int X, Y, a, b, c;
cin >> X >> Y >> a >> b >> c;
multiset<int> st;
multiset<int> st2;
rep(i, a) {
int x;
cin >> x;
st.insert(x);
}
while (st.size() > X)
st.erase(st.begin());
rep(i, b) {
int x;
cin >> x;
st2.insert(x);
}
while (st2.size() > Y)
st2.erase(st2.begin());
vector<int> d(c);
rep(i, c) { cin >> d[i]; }
sort(d.rbegin(), d.rend());
for (auto x : d) {
if (*st.begin() > x and *st2.begin() > x)
break;
if (*st.begin() < *st2.begin()) {
st.erase(st.begin());
st.insert(x);
} else {
st2.erase(st2.begin());
st2.insert(x);
}
}
ll ans = 0;
for (auto x : st)
ans += x;
for (auto x : st2)
ans += x;
cout << ans << endl;
}
| replace | 82 | 83 | 82 | 83 | TLE | |
p02727 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
#define rep(i, n) for (int i = 0; i < n; i++)
#define repl(i, s, e) for (int i = s; i < e; i++)
#define reple(i, s, e) for (int i = s; i <= e; i++)
#define revrep(i, n) for (int i = n - 1; i >= 0; i--)
#define vll vector<ll>
#define vvll vector<vector<ll>>
#define all(x) (x).begin(), (x).end()
int main() {
int X, Y, A, B, C;
cin >> X >> Y >> A >> B >> C;
vector<ll> p(A);
rep(i, A) cin >> p[i];
vector<ll> q(A);
rep(i, B) cin >> q[i];
priority_queue<ll> r;
rep(i, C) {
ll tmp;
cin >> tmp;
r.push(tmp);
}
// pの大きい方からX個、qの大きい方からY個とって降順に並べる
sort(all(p), greater<ll>());
sort(all(q), greater<ll>());
priority_queue<ll, vector<ll>, greater<ll>> pq;
rep(i, X) pq.push(p[i]);
rep(i, Y) pq.push(q[i]);
// 貪欲法で小さい方から処理（大きいりんごを残した方が有利）
ll ans = 0;
while (!pq.empty()) {
auto x = pq.top();
pq.pop();
if (!r.empty() && x < r.top()) {
x = r.top();
r.pop();
}
ans += x;
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
#define rep(i, n) for (int i = 0; i < n; i++)
#define repl(i, s, e) for (int i = s; i < e; i++)
#define reple(i, s, e) for (int i = s; i <= e; i++)
#define revrep(i, n) for (int i = n - 1; i >= 0; i--)
#define vll vector<ll>
#define vvll vector<vector<ll>>
#define all(x) (x).begin(), (x).end()
int main() {
int X, Y, A, B, C;
cin >> X >> Y >> A >> B >> C;
vector<ll> p(A);
rep(i, A) cin >> p[i];
vector<ll> q(B);
rep(i, B) cin >> q[i];
priority_queue<ll> r;
rep(i, C) {
ll tmp;
cin >> tmp;
r.push(tmp);
}
// pの大きい方からX個、qの大きい方からY個とって降順に並べる
sort(all(p), greater<ll>());
sort(all(q), greater<ll>());
priority_queue<ll, vector<ll>, greater<ll>> pq;
rep(i, X) pq.push(p[i]);
rep(i, Y) pq.push(q[i]);
// 貪欲法で小さい方から処理（大きいりんごを残した方が有利）
ll ans = 0;
while (!pq.empty()) {
auto x = pq.top();
pq.pop();
if (!r.empty() && x < r.top()) {
x = r.top();
r.pop();
}
ans += x;
}
cout << ans << endl;
return 0;
} | replace | 32 | 33 | 32 | 33 | 0 | |
p02728 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <ciso646>
#include <cmath>
#include <complex>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
// #define int long long
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
ll mod = 1000000007;
const ll INF = mod * mod;
typedef pair<int, int> P;
#define stop \
char nyaa; \
cin >> nyaa;
#define rep(i, n) for (int i = 0; i < n; i++)
#define per(i, n) for (int i = n - 1; i >= 0; i--)
#define Rep(i, sta, n) for (int i = sta; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define per1(i, n) for (int i = n; i >= 1; i--)
#define Rep1(i, sta, n) for (int i = sta; i <= n; i++)
#define all(v) (v).begin(), (v).end()
typedef pair<ll, ll> LP;
typedef long double ld;
typedef pair<ld, ld> LDP;
const ld eps = 1e-12;
const ld pi = acos(-1.0);
ll mod_pow(ll a, ll n, ll m = mod) {
ll res = 1;
while (n) {
if (n & 1)
res = res * a % m;
a = a * a % m;
n >>= 1;
}
return res;
}
struct modint {
ll n;
modint() : n(0) { ; }
modint(ll m) : n(m) {
if (n >= mod)
n %= mod;
else if (n < 0)
n = (n % mod + mod) % mod;
}
operator int() { return n; }
};
bool operator==(modint a, modint b) { return a.n == b.n; }
modint operator+=(modint &a, modint b) {
a.n += b.n;
if (a.n >= mod)
a.n -= mod;
return a;
}
modint operator-=(modint &a, modint b) {
a.n -= b.n;
if (a.n < 0)
a.n += mod;
return a;
}
modint operator*=(modint &a, modint b) {
a.n = ((ll)a.n * b.n) % mod;
return a;
}
modint operator+(modint a, modint b) { return a += b; }
modint operator-(modint a, modint b) { return a -= b; }
modint operator*(modint a, modint b) { return a *= b; }
modint operator^(modint a, int n) {
if (n == 0)
return modint(1);
modint 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); }
modint operator/(modint a, modint b) { return a * modint(inv(b, mod)); }
const int max_n = 1 << 18;
modint fact[max_n], factinv[max_n];
void init_f() {
fact[0] = modint(1);
for (int i = 0; i < max_n - 1; i++) {
fact[i + 1] = fact[i] * modint(i + 1);
}
factinv[max_n - 1] = modint(1) / fact[max_n - 1];
for (int i = max_n - 2; i >= 0; i--) {
factinv[i] = factinv[i + 1] * modint(i + 1);
}
}
modint comb(int a, int b) {
if (a < 0 || b < 0 || a < b)
return 0;
return fact[a] * factinv[b] * factinv[a - b];
}
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
using Data = pair<int, modint>;
Data merge(Data a, Data b) {
Data res;
//
res.first = a.first + b.first;
res.second = a.second * b.second * comb(a.first + b.first, a.first);
//
return res;
}
const int mn = 1 << 18;
struct edge {
int to;
};
vector<edge> G[mn];
vector<int> ids[mn];
vector<Data> memo[mn];
int root;
Data dfs(int id, int fr) {
Data res;
//
// initialize
res.first = 0, res.second = 1;
//
for (edge e : G[id]) {
if (e.to == fr)
continue;
Data nex = dfs(e.to, id);
//
// update with edge
//
res = merge(res, nex);
ids[id].push_back(e.to);
memo[id].push_back(nex);
}
//
// update for return
res.first++;
//
return res;
}
modint ans[1 << 17];
void invdfs(int id, int fr, Data pre) {
vector<Data> v;
for (Data d : memo[id])
v.push_back(d);
if (fr >= 0)
v.push_back(pre);
int len = v.size();
//
// calcurate id's ans
Data tans = {0, 1};
rep(i, v.size()) { tans = merge(tans, v[i]); }
ans[id] = tans.second;
//
vector<Data> le(len + 1);
vector<Data> ri(len + 1);
//
Data init_c = {0, 1};
//
le[0] = init_c;
rep(i, len) { le[i + 1] = merge(le[i], v[i]); }
ri[len] = init_c;
per(i, len) { ri[i] = merge(ri[i + 1], v[i]); }
rep(i, ids[id].size()) {
int to = ids[id][i];
Data d = merge(le[i], ri[i + 1]);
//
// update for return
d.first++;
//
invdfs(to, id, d);
}
}
void yaru() {
dfs(root, -1);
invdfs(root, -1, {0, 1});
}
void solve() {
int n;
cin >> n;
rep(i, n - 1) {
int a, b;
cin >> a >> b;
a--;
b--;
G[a].push_back({b});
G[b].push_back({a});
}
yaru();
rep(i, n) { cout << ans[i] << "\n"; }
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
// cout << fixed << setprecision(7);
init_f();
// init();
// int t; cin >> t; rep(i, t)solve();
solve();
stop return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <ciso646>
#include <cmath>
#include <complex>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
// #define int long long
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
ll mod = 1000000007;
const ll INF = mod * mod;
typedef pair<int, int> P;
#define stop \
char nyaa; \
cin >> nyaa;
#define rep(i, n) for (int i = 0; i < n; i++)
#define per(i, n) for (int i = n - 1; i >= 0; i--)
#define Rep(i, sta, n) for (int i = sta; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define per1(i, n) for (int i = n; i >= 1; i--)
#define Rep1(i, sta, n) for (int i = sta; i <= n; i++)
#define all(v) (v).begin(), (v).end()
typedef pair<ll, ll> LP;
typedef long double ld;
typedef pair<ld, ld> LDP;
const ld eps = 1e-12;
const ld pi = acos(-1.0);
ll mod_pow(ll a, ll n, ll m = mod) {
ll res = 1;
while (n) {
if (n & 1)
res = res * a % m;
a = a * a % m;
n >>= 1;
}
return res;
}
struct modint {
ll n;
modint() : n(0) { ; }
modint(ll m) : n(m) {
if (n >= mod)
n %= mod;
else if (n < 0)
n = (n % mod + mod) % mod;
}
operator int() { return n; }
};
bool operator==(modint a, modint b) { return a.n == b.n; }
modint operator+=(modint &a, modint b) {
a.n += b.n;
if (a.n >= mod)
a.n -= mod;
return a;
}
modint operator-=(modint &a, modint b) {
a.n -= b.n;
if (a.n < 0)
a.n += mod;
return a;
}
modint operator*=(modint &a, modint b) {
a.n = ((ll)a.n * b.n) % mod;
return a;
}
modint operator+(modint a, modint b) { return a += b; }
modint operator-(modint a, modint b) { return a -= b; }
modint operator*(modint a, modint b) { return a *= b; }
modint operator^(modint a, int n) {
if (n == 0)
return modint(1);
modint 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); }
modint operator/(modint a, modint b) { return a * modint(inv(b, mod)); }
const int max_n = 1 << 18;
modint fact[max_n], factinv[max_n];
void init_f() {
fact[0] = modint(1);
for (int i = 0; i < max_n - 1; i++) {
fact[i + 1] = fact[i] * modint(i + 1);
}
factinv[max_n - 1] = modint(1) / fact[max_n - 1];
for (int i = max_n - 2; i >= 0; i--) {
factinv[i] = factinv[i + 1] * modint(i + 1);
}
}
modint comb(int a, int b) {
if (a < 0 || b < 0 || a < b)
return 0;
return fact[a] * factinv[b] * factinv[a - b];
}
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
using Data = pair<int, modint>;
Data merge(Data a, Data b) {
Data res;
//
res.first = a.first + b.first;
res.second = a.second * b.second * comb(a.first + b.first, a.first);
//
return res;
}
const int mn = 1 << 18;
struct edge {
int to;
};
vector<edge> G[mn];
vector<int> ids[mn];
vector<Data> memo[mn];
int root;
Data dfs(int id, int fr) {
Data res;
//
// initialize
res.first = 0, res.second = 1;
//
for (edge e : G[id]) {
if (e.to == fr)
continue;
Data nex = dfs(e.to, id);
//
// update with edge
//
res = merge(res, nex);
ids[id].push_back(e.to);
memo[id].push_back(nex);
}
//
// update for return
res.first++;
//
return res;
}
modint ans[1 << 18];
void invdfs(int id, int fr, Data pre) {
vector<Data> v;
for (Data d : memo[id])
v.push_back(d);
if (fr >= 0)
v.push_back(pre);
int len = v.size();
//
// calcurate id's ans
Data tans = {0, 1};
rep(i, v.size()) { tans = merge(tans, v[i]); }
ans[id] = tans.second;
//
vector<Data> le(len + 1);
vector<Data> ri(len + 1);
//
Data init_c = {0, 1};
//
le[0] = init_c;
rep(i, len) { le[i + 1] = merge(le[i], v[i]); }
ri[len] = init_c;
per(i, len) { ri[i] = merge(ri[i + 1], v[i]); }
rep(i, ids[id].size()) {
int to = ids[id][i];
Data d = merge(le[i], ri[i + 1]);
//
// update for return
d.first++;
//
invdfs(to, id, d);
}
}
void yaru() {
dfs(root, -1);
invdfs(root, -1, {0, 1});
}
void solve() {
int n;
cin >> n;
rep(i, n - 1) {
int a, b;
cin >> a >> b;
a--;
b--;
G[a].push_back({b});
G[b].push_back({a});
}
yaru();
rep(i, n) { cout << ans[i] << "\n"; }
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
// cout << fixed << setprecision(7);
init_f();
// init();
// int t; cin >> t; rep(i, t)solve();
solve();
stop return 0;
}
| replace | 161 | 162 | 161 | 162 | 0 | |
p02728 | C++ | Runtime Error | #pragma GCC optimize(2)
#include <bits/stdc++.h>
#define ll long long
#define maxn 100005
#define inf 1e9
#define eps 1e-10
using namespace std;
inline int read() {
int x = 0, w = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
w = -1;
c = getchar();
}
while (c <= '9' && c >= '0') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return w == 1 ? x : -x;
}
const ll mod = 1000000007;
vector<int> mp[maxn];
ll fac[maxn], inv[maxn], siz[maxn], n, ans[maxn];
inline ll pw(ll a, ll b) {
ll ans = 1, base = a;
while (b) {
if (b & 1)
ans = (ans * base) % mod;
base = (base * base) % mod;
b >>= 1;
}
return ans;
}
inline void dfs1(int u, int fa) {
siz[u] = 1;
for (int i = 0; i < mp[u].size(); i++) {
int v = mp[u][i];
if (v == fa)
continue;
dfs1(v, u);
siz[u] += siz[v];
}
}
inline void dfs2(int u, int fa) {
for (int i = 0; i < mp[u].size(); i++) {
int v = mp[u][i];
if (v == fa)
continue;
ans[v] = (ans[u] * pw(n - siz[v], mod - 2) % mod) * siz[v] % mod;
dfs2(v, u);
}
}
int main() {
n = read();
fac[0] = 1;
inv[0] = 1;
for (int i = 1; i <= maxn - 5; i++)
fac[i] = (fac[i - 1] * i) % mod;
for (int i = 1; i <= maxn - 5; i++)
inv[i] = pw(fac[i], mod - 2);
for (int i = 1; i < n; i++) {
int u = read(), v = read();
mp[u].push_back(v), mp[v].push_back(u);
}
dfs1(1, 0);
ll tmp = fac[n];
for (int i = 1; i <= n; i++)
tmp = (tmp * pw(siz[i], mod - 2)) % mod;
ans[1] = tmp;
dfs2(1, 0);
for (int i = 1; i <= n; i++)
printf("%lld\n", ans[i]);
return 0;
} | #pragma GCC optimize(2)
#include <bits/stdc++.h>
#define ll long long
#define maxn 200005
#define inf 1e9
#define eps 1e-10
using namespace std;
inline int read() {
int x = 0, w = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
w = -1;
c = getchar();
}
while (c <= '9' && c >= '0') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return w == 1 ? x : -x;
}
const ll mod = 1000000007;
vector<int> mp[maxn];
ll fac[maxn], inv[maxn], siz[maxn], n, ans[maxn];
inline ll pw(ll a, ll b) {
ll ans = 1, base = a;
while (b) {
if (b & 1)
ans = (ans * base) % mod;
base = (base * base) % mod;
b >>= 1;
}
return ans;
}
inline void dfs1(int u, int fa) {
siz[u] = 1;
for (int i = 0; i < mp[u].size(); i++) {
int v = mp[u][i];
if (v == fa)
continue;
dfs1(v, u);
siz[u] += siz[v];
}
}
inline void dfs2(int u, int fa) {
for (int i = 0; i < mp[u].size(); i++) {
int v = mp[u][i];
if (v == fa)
continue;
ans[v] = (ans[u] * pw(n - siz[v], mod - 2) % mod) * siz[v] % mod;
dfs2(v, u);
}
}
int main() {
n = read();
fac[0] = 1;
inv[0] = 1;
for (int i = 1; i <= maxn - 5; i++)
fac[i] = (fac[i - 1] * i) % mod;
for (int i = 1; i <= maxn - 5; i++)
inv[i] = pw(fac[i], mod - 2);
for (int i = 1; i < n; i++) {
int u = read(), v = read();
mp[u].push_back(v), mp[v].push_back(u);
}
dfs1(1, 0);
ll tmp = fac[n];
for (int i = 1; i <= n; i++)
tmp = (tmp * pw(siz[i], mod - 2)) % mod;
ans[1] = tmp;
dfs2(1, 0);
for (int i = 1; i <= n; i++)
printf("%lld\n", ans[i]);
return 0;
} | replace | 3 | 4 | 3 | 4 | 0 | |
p02728 | C++ | Runtime Error | /*input
*/
#include <bits/stdc++.h>
#define up(i, a, b) for (int(i) = (a); (i) <= (b); ++(i))
#define down(i, b, a) for (int(i) = (b); i >= (a); --i)
#define debug(x) cerr << (x) << '\n';
#define bits(x, i) ((x >> i) & 1)
#define mid ((l + r) / 2)
#define pr pair<int, int>
#define long long long
using namespace std;
const int N = 100005;
const int mod = 1e9 + 7;
vector<int> G[N];
int children[N], pchildren[N];
long ans[N], dp[N], pDp[N];
long fact[N];
int n;
void init() {
up(i, 1, n) dp[i] = children[i] = 1;
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = (fact[i - 1] * i * 1LL) % mod;
}
long power(long x, long n) {
long ans = 1;
for (int i = 0; i < 31; ++i) {
if (bits(n, i))
ans = (ans * x) % mod;
x = (x * x) % mod;
}
return ans;
}
long inv(long num, long den) { return (num * power(den, mod - 2)) % mod; }
long C(int k, int n) {
int num = fact[n];
int den = (fact[k] * fact[n - k]) % mod;
return inv(num, den);
}
void precal(int u, int par) {
for (auto v : G[u]) {
if (v == par)
continue;
precal(v, u);
children[u] += children[v];
}
int remaider = children[u] - 1;
for (auto v : G[u]) {
if (v == par)
continue;
// cout << children[v] << ' ' << remaider << '\n';
long cur = (1LL * dp[v] * C(children[v], remaider)) % mod;
dp[u] = (dp[u] * cur) % mod;
remaider -= children[v];
}
}
void rollback(int u, int v) {
pDp[u] = dp[u];
pDp[v] = dp[v];
pchildren[u] = children[u];
pchildren[v] = children[v];
}
void dfs(int u, int par) {
ans[u] = dp[u];
for (auto v : G[u]) {
if (v == par)
continue;
rollback(u, v);
dp[u] = inv(dp[u], (dp[v] * C(children[v], children[u] - 1)) % mod);
children[u] -= children[v];
children[v] += children[u];
long mul = (dp[u] * C(children[u], children[v] - 1)) % mod;
dp[v] = (dp[v] * mul) % mod;
dfs(v, u);
dp[u] = pDp[u];
dp[v] = pDp[v];
children[u] = pchildren[u];
children[v] = pchildren[v];
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
up(i, 1, n - 1) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
init();
precal(1, 0);
// solve
dfs(1, 0);
for (int i = 1; i <= n; ++i)
cout << ans[i] << '\n';
} | /*input
*/
#include <bits/stdc++.h>
#define up(i, a, b) for (int(i) = (a); (i) <= (b); ++(i))
#define down(i, b, a) for (int(i) = (b); i >= (a); --i)
#define debug(x) cerr << (x) << '\n';
#define bits(x, i) ((x >> i) & 1)
#define mid ((l + r) / 2)
#define pr pair<int, int>
#define long long long
using namespace std;
const int N = 200005;
const int mod = 1e9 + 7;
vector<int> G[N];
int children[N], pchildren[N];
long ans[N], dp[N], pDp[N];
long fact[N];
int n;
void init() {
up(i, 1, n) dp[i] = children[i] = 1;
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = (fact[i - 1] * i * 1LL) % mod;
}
long power(long x, long n) {
long ans = 1;
for (int i = 0; i < 31; ++i) {
if (bits(n, i))
ans = (ans * x) % mod;
x = (x * x) % mod;
}
return ans;
}
long inv(long num, long den) { return (num * power(den, mod - 2)) % mod; }
long C(int k, int n) {
int num = fact[n];
int den = (fact[k] * fact[n - k]) % mod;
return inv(num, den);
}
void precal(int u, int par) {
for (auto v : G[u]) {
if (v == par)
continue;
precal(v, u);
children[u] += children[v];
}
int remaider = children[u] - 1;
for (auto v : G[u]) {
if (v == par)
continue;
// cout << children[v] << ' ' << remaider << '\n';
long cur = (1LL * dp[v] * C(children[v], remaider)) % mod;
dp[u] = (dp[u] * cur) % mod;
remaider -= children[v];
}
}
void rollback(int u, int v) {
pDp[u] = dp[u];
pDp[v] = dp[v];
pchildren[u] = children[u];
pchildren[v] = children[v];
}
void dfs(int u, int par) {
ans[u] = dp[u];
for (auto v : G[u]) {
if (v == par)
continue;
rollback(u, v);
dp[u] = inv(dp[u], (dp[v] * C(children[v], children[u] - 1)) % mod);
children[u] -= children[v];
children[v] += children[u];
long mul = (dp[u] * C(children[u], children[v] - 1)) % mod;
dp[v] = (dp[v] * mul) % mod;
dfs(v, u);
dp[u] = pDp[u];
dp[v] = pDp[v];
children[u] = pchildren[u];
children[v] = pchildren[v];
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
up(i, 1, n - 1) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
init();
precal(1, 0);
// solve
dfs(1, 0);
for (int i = 1; i <= n; ++i)
cout << ans[i] << '\n';
} | replace | 12 | 13 | 12 | 13 | 0 | |
p02728 | C++ | Runtime Error | #pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
template <class T> using V = vector<T>;
#define fi first
#define se second
#define all(v) (v).begin(), (v).end()
const ll inf = (1e18);
// const ll mod=998244353;
const ll mod = 1000000007;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll c, ll d) { return c / gcd(c, d) * d; }
struct __INIT {
__INIT() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
}
} __init;
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 (a > b) {
a = b;
return 1;
}
return 0;
}
struct mint {
using ull = unsigned long long int;
ull v;
mint(ll vv = 0) { s(vv % mod + mod); }
mint &s(ull vv) {
v = vv < mod ? vv : vv - mod;
return *this;
}
// オーバーロード
mint operator-() const { return mint() - *this; } // 符号反転
mint &operator+=(const mint &val) { return s(v + val.v); }
mint &operator-=(const mint &val) { return s(v + mod - val.v); }
mint &operator*=(const mint &val) {
v = ull(v) * val.v % mod;
return *this;
}
mint &operator/=(const mint &val) { return *this *= val.inv(); }
mint operator+(const mint &val) { return mint(*this) += val; }
mint operator-(const mint &val) { return mint(*this) -= val; }
mint operator*(const mint &val) { return mint(*this) *= val; }
mint operator/(const mint &val) { return mint(*this) /= val; }
mint pow(ll n) const {
mint res(1), x(*this);
while (n) {
if (n & 1)
res *= x;
x *= x;
n >>= 1;
}
return res;
}
mint inv() const { return pow(mod - 2); }
// 拡張ユークリッドの互除法
/* mint inv()const{
int x,y;
int g=extgcd(v,mod,x,y);
assert(g==1);
if(x<0)x+=mod;
return mint(x);
}*/
friend ostream &operator<<(ostream &os, const mint &val) {
return os << val.v;
} // 出力
bool operator<(const mint &val) const { return v < val.v; }
bool operator==(const mint &val) const { return v == val.v; }
bool operator>(const mint &val) const { return v > val.v; }
};
const ll MAX = 2000010; // 設定
mint fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void init() {
fac[0] = fac[1] = 1;
for (int i = 1; i < MAX; i++)
fac[i] = fac[i - 1] * i;
finv[MAX - 1] = fac[MAX - 1].inv();
for (int i = MAX - 2; i >= 0; i--)
finv[i] = finv[i + 1] * (i + 1);
for (int i = MAX - 2; i >= 1; i--)
inv[i] = finv[i] + fac[i - 1];
}
// 階乗
mint factor(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * finv[k];
}
// 二項係数計算
mint 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];
}
V<V<int>> graph;
mint dp[200005];
int tree[20005];
void dfs1(int now, int par) {
dp[now] = 1;
tree[now]++;
if (graph[now].size() == 1 && par != -1)
return;
for (int v : graph[now]) {
if (par == v)
continue;
dfs1(v, now);
tree[now] += tree[v];
}
dp[now] = fac[tree[now] - 1];
for (int v : graph[now]) {
if (par == v)
continue;
dp[now] /= fac[tree[v]];
dp[now] *= dp[v];
}
}
V<mint> ans;
void dfs2(int now, int par) {
ans[now] = dp[now];
if (par != -1) {
int t = tree[par] - tree[now];
ans[now] *=
dp[par] / dp[now] * fac[tree[now]] / fac[tree[par] - 1] * fac[t - 1];
ans[now] /= fac[tree[now] - 1];
tree[now] = tree[par];
ans[now] *= fac[tree[now] - 1] / fac[t];
dp[now] = ans[now];
}
for (int v : graph[now]) {
if (v == par)
continue;
dfs2(v, now);
}
}
int main() {
int n;
cin >> n;
init();
graph.resize(n);
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
graph[--a].emplace_back(--b);
graph[b].emplace_back(a);
}
dfs1(0, -1);
ans.resize(n);
dfs2(0, -1);
for (int i = 0; i < n; i++)
cout << ans[i] << "\n";
}
| #pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
template <class T> using V = vector<T>;
#define fi first
#define se second
#define all(v) (v).begin(), (v).end()
const ll inf = (1e18);
// const ll mod=998244353;
const ll mod = 1000000007;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll c, ll d) { return c / gcd(c, d) * d; }
struct __INIT {
__INIT() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
}
} __init;
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 (a > b) {
a = b;
return 1;
}
return 0;
}
struct mint {
using ull = unsigned long long int;
ull v;
mint(ll vv = 0) { s(vv % mod + mod); }
mint &s(ull vv) {
v = vv < mod ? vv : vv - mod;
return *this;
}
// オーバーロード
mint operator-() const { return mint() - *this; } // 符号反転
mint &operator+=(const mint &val) { return s(v + val.v); }
mint &operator-=(const mint &val) { return s(v + mod - val.v); }
mint &operator*=(const mint &val) {
v = ull(v) * val.v % mod;
return *this;
}
mint &operator/=(const mint &val) { return *this *= val.inv(); }
mint operator+(const mint &val) { return mint(*this) += val; }
mint operator-(const mint &val) { return mint(*this) -= val; }
mint operator*(const mint &val) { return mint(*this) *= val; }
mint operator/(const mint &val) { return mint(*this) /= val; }
mint pow(ll n) const {
mint res(1), x(*this);
while (n) {
if (n & 1)
res *= x;
x *= x;
n >>= 1;
}
return res;
}
mint inv() const { return pow(mod - 2); }
// 拡張ユークリッドの互除法
/* mint inv()const{
int x,y;
int g=extgcd(v,mod,x,y);
assert(g==1);
if(x<0)x+=mod;
return mint(x);
}*/
friend ostream &operator<<(ostream &os, const mint &val) {
return os << val.v;
} // 出力
bool operator<(const mint &val) const { return v < val.v; }
bool operator==(const mint &val) const { return v == val.v; }
bool operator>(const mint &val) const { return v > val.v; }
};
const ll MAX = 2000010; // 設定
mint fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void init() {
fac[0] = fac[1] = 1;
for (int i = 1; i < MAX; i++)
fac[i] = fac[i - 1] * i;
finv[MAX - 1] = fac[MAX - 1].inv();
for (int i = MAX - 2; i >= 0; i--)
finv[i] = finv[i + 1] * (i + 1);
for (int i = MAX - 2; i >= 1; i--)
inv[i] = finv[i] + fac[i - 1];
}
// 階乗
mint factor(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * finv[k];
}
// 二項係数計算
mint 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];
}
V<V<int>> graph;
mint dp[200005];
int tree[200005];
void dfs1(int now, int par) {
dp[now] = 1;
tree[now]++;
if (graph[now].size() == 1 && par != -1)
return;
for (int v : graph[now]) {
if (par == v)
continue;
dfs1(v, now);
tree[now] += tree[v];
}
dp[now] = fac[tree[now] - 1];
for (int v : graph[now]) {
if (par == v)
continue;
dp[now] /= fac[tree[v]];
dp[now] *= dp[v];
}
}
V<mint> ans;
void dfs2(int now, int par) {
ans[now] = dp[now];
if (par != -1) {
int t = tree[par] - tree[now];
ans[now] *=
dp[par] / dp[now] * fac[tree[now]] / fac[tree[par] - 1] * fac[t - 1];
ans[now] /= fac[tree[now] - 1];
tree[now] = tree[par];
ans[now] *= fac[tree[now] - 1] / fac[t];
dp[now] = ans[now];
}
for (int v : graph[now]) {
if (v == par)
continue;
dfs2(v, now);
}
}
int main() {
int n;
cin >> n;
init();
graph.resize(n);
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
graph[--a].emplace_back(--b);
graph[b].emplace_back(a);
}
dfs1(0, -1);
ans.resize(n);
dfs2(0, -1);
for (int i = 0; i < n; i++)
cout << ans[i] << "\n";
} | replace | 113 | 114 | 113 | 114 | 0 | |
p02728 | C++ | Runtime Error | // includes {{{
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
// #include<deque>
// #include<multiset>
// #include<cstring>
// #include<bits/stdc++.h>
// }}}
using namespace std;
using ll = long long;
// #undef DEBUG
// #define DEBUG
// DEBUG {{{
#include <array>
#include <deque>
#include <iostream>
#include <list>
#include <queue>
#include <stack>
#include <tuple>
#include <valarray>
#include <vector>
template <int n, class... T>
typename std::enable_if<(n >= sizeof...(T))>::type
__output_tuple(std::ostream &, std::tuple<T...> const &) {}
template <int n, class... T>
typename std::enable_if<(n < sizeof...(T))>::type
__output_tuple(std::ostream &os, std::tuple<T...> const &t) {
os << (n == 0 ? "" : ", ") << std::get<n>(t);
__output_tuple<n + 1>(os, t);
}
template <class... T>
std::ostream &operator<<(std::ostream &os, std::tuple<T...> const &t) {
os << "(";
__output_tuple<0>(os, t);
os << ")";
return os;
}
template <class T, class U>
std::ostream &operator<<(std::ostream &os, std::pair<T, U> const &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, const std::stack<T> &a) {
os << "{";
for (auto tmp = a; tmp.size(); tmp.pop())
os << (a.size() == tmp.size() ? "" : ", ") << tmp.top();
os << "}";
return os;
}
template <class T, class Container, class Compare>
std::ostream &operator<<(std::ostream &os,
std::priority_queue<T, Container, Compare> a) {
os << "{ (top) ";
while (a.size())
os << a.top() << (a.size() == 1 ? "" : ", "), a.pop();
os << " }";
return os;
}
template <class T, class Container>
std::ostream &operator<<(std::ostream &os, std::queue<T, Container> a) {
os << "{ ";
while (a.size())
os << a.front() << (a.size() == 1 ? "" : ", "), a.pop();
os << " }";
return os;
}
#ifdef DEBUG
#if !defined(DEBUG_OUT)
#define DEBUG_OUT std::cerr
#endif
#define dump(...) \
[&]() { \
auto __debug_tap = std::make_tuple(__VA_ARGS__); \
DEBUG_OUT << "[" << __LINE__ << "] " << #__VA_ARGS__ << " = " \
<< __debug_tap << std::endl; \
}()
template <class T> inline void dump2D(T &d, size_t sizey, size_t sizex) {
for (size_t i = 0; i < sizey; i++) {
DEBUG_OUT << "\t";
for (size_t j = 0; j < sizex; j++)
DEBUG_OUT << d[i][j] << (j + 1 == sizex ? "" : "\t");
DEBUG_OUT << std::endl;
}
}
template <class T> inline void dump1D(T &d, size_t sizey) {
for (size_t i = 0; i < sizey; i++) {
DEBUG_OUT << d[i] << (i + 1 == sizey ? "" : " ");
}
DEBUG_OUT << std::endl;
}
template <
class T,
class = typename std::iterator_traits<decltype(begin(T()))>::value_type,
class = typename std::enable_if<!std::is_same<T, std::string>::value>::type>
std::ostream &operator<<(std::ostream &os, const T &a) {
os << "{";
for (auto ite = begin(a); ite != end(a); ++ite)
os << (ite == begin(a) ? "" : ", ") << *ite;
os << "}";
return os;
}
#else
#define dump(...) ((void)42)
#define dump2D(...) ((void)42)
#define dump1D(...) ((void)42)
template <
class T,
class = typename std::iterator_traits<decltype(begin(T()))>::value_type,
class = typename std::enable_if<!std::is_same<T, std::string>::value>::type>
std::ostream &operator<<(std::ostream &os, const T &a) {
for (auto ite = begin(a); ite != end(a); ++ite)
os << (ite == begin(a) ? "" : " ") << *ite;
return os;
}
#endif
// }}}
/// --- Modulo Integer {{{ ///
#include <ostream>
template <long long mod = static_cast<long long>(1e9 + 7)>
struct ModuloInteger {
static_assert(mod > 0, "mod must be positive");
static_assert(mod <= 3037000499, "mod is too big");
using integer = long long;
static ModuloInteger unused;
// math {{{
static inline integer extgcd(integer a, integer b, integer &x, integer &y) {
integer d;
return b == 0 ? (x = a < 0 ? -1 : 1, y = 0, a < 0 ? -a : a)
: (d = extgcd(b, a % b, y, x), y -= a / b * x, d);
}
static inline integer modinv(integer a) {
integer x = 0, y = 0;
extgcd(a, mod, x, y);
if (x < 0)
x += mod;
else if (x == mod)
x = 0;
return x;
}
static inline integer modpow(integer a, long long b) {
if (b < 0)
b = -b, a = modinv(a);
integer r = 1;
a %= mod;
while (b) {
if (b & 1)
r = r * a % mod;
a = a * a % mod;
b >>= 1;
}
return r;
}
// }}}
integer val;
constexpr ModuloInteger() : val(0) {}
constexpr ModuloInteger(integer t) {
val = t % mod;
if (val < 0)
val += mod;
}
private:
// strict constructor
constexpr ModuloInteger(integer t, int) : val(t) {}
public:
template <class T> explicit operator T() { return T(val); }
// operator bool() { return bool(val); }
// ModuloInteger <arithmetic-operator>[=] ModuloInteger {{{
ModuloInteger operator+(ModuloInteger const &rhs) const {
ModuloInteger tmp = *this;
tmp += rhs;
return tmp;
}
ModuloInteger operator-(ModuloInteger const &rhs) const {
ModuloInteger tmp = *this;
tmp -= rhs;
return tmp;
}
ModuloInteger operator*(ModuloInteger const &rhs) const {
ModuloInteger tmp = *this;
tmp *= rhs;
return tmp;
}
ModuloInteger operator/(ModuloInteger const &rhs) const {
ModuloInteger tmp = *this;
tmp /= rhs;
return tmp;
}
ModuloInteger &operator+=(ModuloInteger const &rhs) {
val = val + rhs.val;
if (val >= mod)
val -= mod;
return *this;
}
ModuloInteger &operator-=(ModuloInteger const &rhs) { return *this += -rhs; }
ModuloInteger &operator*=(ModuloInteger const &rhs) {
val = val * rhs.val % mod;
return *this;
}
ModuloInteger &operator/=(ModuloInteger const &rhs) {
return *this *= rhs.inv();
}
// }}}
// increment, decrement {{{
ModuloInteger operator++(int) {
ModuloInteger tmp = *this;
val = val + 1;
if (val >= mod)
val = 0;
return tmp;
}
ModuloInteger operator--(int) {
ModuloInteger tmp = *this;
val = val == 0 ? mod - 1 : val - 1;
return tmp;
}
ModuloInteger &operator++() {
val = val + 1;
if (val >= mod)
val = 0;
return *this;
}
ModuloInteger &operator--() {
val = val == 0 ? mod - 1 : val - 1;
return *this;
}
// }}}
ModuloInteger operator-() const {
return ModuloInteger(val == 0 ? 0 : mod - val, 0);
}
// ModuloInteger <arithmetic-operator>[=] T {{{
template <typename T> ModuloInteger operator+(T const &rhs) const {
return ModuloInteger(val + rhs % mod);
}
template <typename T> ModuloInteger operator-(T const &rhs) const {
return ModuloInteger(mod + val - rhs % mod);
}
template <typename T> ModuloInteger operator*(T const &rhs) const {
return ModuloInteger(val * (rhs % mod));
}
template <typename T> ModuloInteger operator/(T const &rhs) const {
return ModuloInteger(val * modinv(rhs));
}
template <typename T> ModuloInteger &operator+=(T const &rhs) {
val = (mod + val + rhs % mod) % mod;
return *this;
}
template <typename T> ModuloInteger &operator-=(T const &rhs) {
val = (mod + val - rhs % mod) % mod;
return *this;
}
template <typename T> ModuloInteger &operator*=(T const &rhs) {
val = val * (mod + rhs % mod) % mod;
return *this;
}
template <typename T> ModuloInteger &operator/=(T const &rhs) {
val = val * modinv(rhs) % mod;
return *this;
}
// }}}
ModuloInteger inv() const { return ModuloInteger(modinv(val), 0); }
ModuloInteger operator~() const { return inv(); }
friend std::ostream &operator<<(std::ostream &os, ModuloInteger const &mv) {
os << mv.val;
return os;
}
// equality operator {{{
ModuloInteger operator==(const ModuloInteger &a) const {
return val == a.val;
}
ModuloInteger operator!=(const ModuloInteger &a) const {
return val != a.val;
}
ModuloInteger operator==(const integer &a) const {
return val == ModuloInteger(a);
}
ModuloInteger operator!=(const integer &a) const {
return val != ModuloInteger(a);
}
// }}}
// T <arithmetic-operator> ModuloInteger {{{
friend constexpr ModuloInteger operator+(integer a, ModuloInteger const &mv) {
return ModuloInteger(a % mod + mv.val);
}
friend constexpr ModuloInteger operator-(integer a, ModuloInteger const &mv) {
return ModuloInteger(a % mod - mv.val);
}
friend constexpr ModuloInteger operator*(integer a, ModuloInteger const &mv) {
return ModuloInteger((mod + a % mod) * mv.val % mod, 0);
}
friend constexpr ModuloInteger operator/(integer a, ModuloInteger const &mv) {
return ModuloInteger((mod + a % mod) * modinv(mv.val) % mod, 0);
}
// }}}
// power {{{
ModuloInteger operator^(integer x) const { return pow(*this, x); }
ModuloInteger &operator^=(integer x) {
val = modpow(val, x);
return *this;
}
friend ModuloInteger pow(ModuloInteger x, integer y) {
return ModuloInteger(modpow(x.val, y), 0);
}
// }}}
};
template <long long mod> ModuloInteger<mod> ModuloInteger<mod>::unused(mod, 0);
/// }}}--- ///
using modint = ModuloInteger<>;
// NOTE : use H with larger N
/// --- Modulo Factorial {{{ ///
#include <cassert>
#include <cstddef>
template <std::size_t N, int mod = static_cast<int>(1e9 + 7)> struct Factorial {
using integer = long long;
constexpr integer extgcd(integer a, integer b, integer &x, integer &y) {
integer d = 0;
return b == 0 ? (x = a < 0 ? -1 : 1, y = 0, a < 0 ? -a : a)
: (d = extgcd(b, a % b, y, x), y -= a / b * x, d);
}
constexpr integer modinv(integer a) {
integer x = 0, y = 0;
extgcd(a, mod, x, y);
if (x < 0)
x += mod;
else if (x == mod)
x = 0;
return x;
}
int arr[N + 1], inv[N + 1];
integer operator[](int i) const { return arr[i]; }
Factorial() : arr(), inv() {
arr[0] = 1;
for (std::size_t i = 1; i <= N; i++) {
arr[i] = (integer)i * arr[i - 1] % mod;
}
inv[N] = modinv(arr[N]);
for (int i = N - 1; i >= 0; i--) {
inv[i] = (integer)(i + 1) * inv[i + 1] % mod;
}
}
integer C(int n, int r) const {
if (n < 0 || r < 0 || n < r)
return 0;
assert(n <= N);
return (integer)arr[n] * inv[r] % mod * inv[n - r] % mod;
}
integer H(int n, int r) const { return C(n + r - 1, r); }
};
/// }}}--- ///
constexpr int mod = 1e9 + 7;
const int N = 1e5 + 10;
Factorial<N * 2, mod> fact;
vector<vector<int>> g(N);
using Value = tuple<int, modint, modint>; // sum, rev-sum
map<int, Value> dp[N];
Value dfs(int i, int p, int f) {
if (dp[i].count(p))
return dp[i][p];
int deg = g[i].size() - (p != -1);
Value res = Value(0, 1, 1);
if (f || p == -1) {
// O(deg)
// go only child
for (int j : g[i])
if (j != p) {
int k;
modint x, y;
tie(k, x, y) = dfs(j, i, f);
get<0>(res) += k;
get<1>(res) *= fact.inv[k];
get<2>(res) *= y;
}
get<2>(res) *= fact[get<0>(res)] * get<1>(res);
get<0>(res) += 1;
} else {
// O(1)
auto A = dfs(i, -1, f), B = dfs(p, i, f);
res = Value(get<0>(A) - get<0>(B), get<1>(A) * fact[get<0>(B)],
get<2>(A) / fact[get<0>(A) - 1] *
fact[get<0>(A) - 1 - get<0>(B)] * fact[get<0>(B)] /
get<2>(B));
dump(A);
dump(B);
dump(0, i, p, res);
}
return dp[i][p] = res;
}
int n;
int main() {
std::ios::sync_with_stdio(false), std::cin.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].emplace_back(b);
g[b].emplace_back(a);
}
dfs(0, -1, 1);
for (int i = 0; i < n; i++) {
auto A = dfs(i, -1, 0);
dump(A);
cout << get<2>(A) << "\n";
}
return 0;
}
| // includes {{{
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
// #include<deque>
// #include<multiset>
// #include<cstring>
// #include<bits/stdc++.h>
// }}}
using namespace std;
using ll = long long;
// #undef DEBUG
// #define DEBUG
// DEBUG {{{
#include <array>
#include <deque>
#include <iostream>
#include <list>
#include <queue>
#include <stack>
#include <tuple>
#include <valarray>
#include <vector>
template <int n, class... T>
typename std::enable_if<(n >= sizeof...(T))>::type
__output_tuple(std::ostream &, std::tuple<T...> const &) {}
template <int n, class... T>
typename std::enable_if<(n < sizeof...(T))>::type
__output_tuple(std::ostream &os, std::tuple<T...> const &t) {
os << (n == 0 ? "" : ", ") << std::get<n>(t);
__output_tuple<n + 1>(os, t);
}
template <class... T>
std::ostream &operator<<(std::ostream &os, std::tuple<T...> const &t) {
os << "(";
__output_tuple<0>(os, t);
os << ")";
return os;
}
template <class T, class U>
std::ostream &operator<<(std::ostream &os, std::pair<T, U> const &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, const std::stack<T> &a) {
os << "{";
for (auto tmp = a; tmp.size(); tmp.pop())
os << (a.size() == tmp.size() ? "" : ", ") << tmp.top();
os << "}";
return os;
}
template <class T, class Container, class Compare>
std::ostream &operator<<(std::ostream &os,
std::priority_queue<T, Container, Compare> a) {
os << "{ (top) ";
while (a.size())
os << a.top() << (a.size() == 1 ? "" : ", "), a.pop();
os << " }";
return os;
}
template <class T, class Container>
std::ostream &operator<<(std::ostream &os, std::queue<T, Container> a) {
os << "{ ";
while (a.size())
os << a.front() << (a.size() == 1 ? "" : ", "), a.pop();
os << " }";
return os;
}
#ifdef DEBUG
#if !defined(DEBUG_OUT)
#define DEBUG_OUT std::cerr
#endif
#define dump(...) \
[&]() { \
auto __debug_tap = std::make_tuple(__VA_ARGS__); \
DEBUG_OUT << "[" << __LINE__ << "] " << #__VA_ARGS__ << " = " \
<< __debug_tap << std::endl; \
}()
template <class T> inline void dump2D(T &d, size_t sizey, size_t sizex) {
for (size_t i = 0; i < sizey; i++) {
DEBUG_OUT << "\t";
for (size_t j = 0; j < sizex; j++)
DEBUG_OUT << d[i][j] << (j + 1 == sizex ? "" : "\t");
DEBUG_OUT << std::endl;
}
}
template <class T> inline void dump1D(T &d, size_t sizey) {
for (size_t i = 0; i < sizey; i++) {
DEBUG_OUT << d[i] << (i + 1 == sizey ? "" : " ");
}
DEBUG_OUT << std::endl;
}
template <
class T,
class = typename std::iterator_traits<decltype(begin(T()))>::value_type,
class = typename std::enable_if<!std::is_same<T, std::string>::value>::type>
std::ostream &operator<<(std::ostream &os, const T &a) {
os << "{";
for (auto ite = begin(a); ite != end(a); ++ite)
os << (ite == begin(a) ? "" : ", ") << *ite;
os << "}";
return os;
}
#else
#define dump(...) ((void)42)
#define dump2D(...) ((void)42)
#define dump1D(...) ((void)42)
template <
class T,
class = typename std::iterator_traits<decltype(begin(T()))>::value_type,
class = typename std::enable_if<!std::is_same<T, std::string>::value>::type>
std::ostream &operator<<(std::ostream &os, const T &a) {
for (auto ite = begin(a); ite != end(a); ++ite)
os << (ite == begin(a) ? "" : " ") << *ite;
return os;
}
#endif
// }}}
/// --- Modulo Integer {{{ ///
#include <ostream>
template <long long mod = static_cast<long long>(1e9 + 7)>
struct ModuloInteger {
static_assert(mod > 0, "mod must be positive");
static_assert(mod <= 3037000499, "mod is too big");
using integer = long long;
static ModuloInteger unused;
// math {{{
static inline integer extgcd(integer a, integer b, integer &x, integer &y) {
integer d;
return b == 0 ? (x = a < 0 ? -1 : 1, y = 0, a < 0 ? -a : a)
: (d = extgcd(b, a % b, y, x), y -= a / b * x, d);
}
static inline integer modinv(integer a) {
integer x = 0, y = 0;
extgcd(a, mod, x, y);
if (x < 0)
x += mod;
else if (x == mod)
x = 0;
return x;
}
static inline integer modpow(integer a, long long b) {
if (b < 0)
b = -b, a = modinv(a);
integer r = 1;
a %= mod;
while (b) {
if (b & 1)
r = r * a % mod;
a = a * a % mod;
b >>= 1;
}
return r;
}
// }}}
integer val;
constexpr ModuloInteger() : val(0) {}
constexpr ModuloInteger(integer t) {
val = t % mod;
if (val < 0)
val += mod;
}
private:
// strict constructor
constexpr ModuloInteger(integer t, int) : val(t) {}
public:
template <class T> explicit operator T() { return T(val); }
// operator bool() { return bool(val); }
// ModuloInteger <arithmetic-operator>[=] ModuloInteger {{{
ModuloInteger operator+(ModuloInteger const &rhs) const {
ModuloInteger tmp = *this;
tmp += rhs;
return tmp;
}
ModuloInteger operator-(ModuloInteger const &rhs) const {
ModuloInteger tmp = *this;
tmp -= rhs;
return tmp;
}
ModuloInteger operator*(ModuloInteger const &rhs) const {
ModuloInteger tmp = *this;
tmp *= rhs;
return tmp;
}
ModuloInteger operator/(ModuloInteger const &rhs) const {
ModuloInteger tmp = *this;
tmp /= rhs;
return tmp;
}
ModuloInteger &operator+=(ModuloInteger const &rhs) {
val = val + rhs.val;
if (val >= mod)
val -= mod;
return *this;
}
ModuloInteger &operator-=(ModuloInteger const &rhs) { return *this += -rhs; }
ModuloInteger &operator*=(ModuloInteger const &rhs) {
val = val * rhs.val % mod;
return *this;
}
ModuloInteger &operator/=(ModuloInteger const &rhs) {
return *this *= rhs.inv();
}
// }}}
// increment, decrement {{{
ModuloInteger operator++(int) {
ModuloInteger tmp = *this;
val = val + 1;
if (val >= mod)
val = 0;
return tmp;
}
ModuloInteger operator--(int) {
ModuloInteger tmp = *this;
val = val == 0 ? mod - 1 : val - 1;
return tmp;
}
ModuloInteger &operator++() {
val = val + 1;
if (val >= mod)
val = 0;
return *this;
}
ModuloInteger &operator--() {
val = val == 0 ? mod - 1 : val - 1;
return *this;
}
// }}}
ModuloInteger operator-() const {
return ModuloInteger(val == 0 ? 0 : mod - val, 0);
}
// ModuloInteger <arithmetic-operator>[=] T {{{
template <typename T> ModuloInteger operator+(T const &rhs) const {
return ModuloInteger(val + rhs % mod);
}
template <typename T> ModuloInteger operator-(T const &rhs) const {
return ModuloInteger(mod + val - rhs % mod);
}
template <typename T> ModuloInteger operator*(T const &rhs) const {
return ModuloInteger(val * (rhs % mod));
}
template <typename T> ModuloInteger operator/(T const &rhs) const {
return ModuloInteger(val * modinv(rhs));
}
template <typename T> ModuloInteger &operator+=(T const &rhs) {
val = (mod + val + rhs % mod) % mod;
return *this;
}
template <typename T> ModuloInteger &operator-=(T const &rhs) {
val = (mod + val - rhs % mod) % mod;
return *this;
}
template <typename T> ModuloInteger &operator*=(T const &rhs) {
val = val * (mod + rhs % mod) % mod;
return *this;
}
template <typename T> ModuloInteger &operator/=(T const &rhs) {
val = val * modinv(rhs) % mod;
return *this;
}
// }}}
ModuloInteger inv() const { return ModuloInteger(modinv(val), 0); }
ModuloInteger operator~() const { return inv(); }
friend std::ostream &operator<<(std::ostream &os, ModuloInteger const &mv) {
os << mv.val;
return os;
}
// equality operator {{{
ModuloInteger operator==(const ModuloInteger &a) const {
return val == a.val;
}
ModuloInteger operator!=(const ModuloInteger &a) const {
return val != a.val;
}
ModuloInteger operator==(const integer &a) const {
return val == ModuloInteger(a);
}
ModuloInteger operator!=(const integer &a) const {
return val != ModuloInteger(a);
}
// }}}
// T <arithmetic-operator> ModuloInteger {{{
friend constexpr ModuloInteger operator+(integer a, ModuloInteger const &mv) {
return ModuloInteger(a % mod + mv.val);
}
friend constexpr ModuloInteger operator-(integer a, ModuloInteger const &mv) {
return ModuloInteger(a % mod - mv.val);
}
friend constexpr ModuloInteger operator*(integer a, ModuloInteger const &mv) {
return ModuloInteger((mod + a % mod) * mv.val % mod, 0);
}
friend constexpr ModuloInteger operator/(integer a, ModuloInteger const &mv) {
return ModuloInteger((mod + a % mod) * modinv(mv.val) % mod, 0);
}
// }}}
// power {{{
ModuloInteger operator^(integer x) const { return pow(*this, x); }
ModuloInteger &operator^=(integer x) {
val = modpow(val, x);
return *this;
}
friend ModuloInteger pow(ModuloInteger x, integer y) {
return ModuloInteger(modpow(x.val, y), 0);
}
// }}}
};
template <long long mod> ModuloInteger<mod> ModuloInteger<mod>::unused(mod, 0);
/// }}}--- ///
using modint = ModuloInteger<>;
// NOTE : use H with larger N
/// --- Modulo Factorial {{{ ///
#include <cassert>
#include <cstddef>
template <std::size_t N, int mod = static_cast<int>(1e9 + 7)> struct Factorial {
using integer = long long;
constexpr integer extgcd(integer a, integer b, integer &x, integer &y) {
integer d = 0;
return b == 0 ? (x = a < 0 ? -1 : 1, y = 0, a < 0 ? -a : a)
: (d = extgcd(b, a % b, y, x), y -= a / b * x, d);
}
constexpr integer modinv(integer a) {
integer x = 0, y = 0;
extgcd(a, mod, x, y);
if (x < 0)
x += mod;
else if (x == mod)
x = 0;
return x;
}
int arr[N + 1], inv[N + 1];
integer operator[](int i) const { return arr[i]; }
Factorial() : arr(), inv() {
arr[0] = 1;
for (std::size_t i = 1; i <= N; i++) {
arr[i] = (integer)i * arr[i - 1] % mod;
}
inv[N] = modinv(arr[N]);
for (int i = N - 1; i >= 0; i--) {
inv[i] = (integer)(i + 1) * inv[i + 1] % mod;
}
}
integer C(int n, int r) const {
if (n < 0 || r < 0 || n < r)
return 0;
assert(n <= N);
return (integer)arr[n] * inv[r] % mod * inv[n - r] % mod;
}
integer H(int n, int r) const { return C(n + r - 1, r); }
};
/// }}}--- ///
constexpr int mod = 1e9 + 7;
const int N = 2e5 + 10;
Factorial<N * 2, mod> fact;
vector<vector<int>> g(N);
using Value = tuple<int, modint, modint>; // sum, rev-sum
map<int, Value> dp[N];
Value dfs(int i, int p, int f) {
if (dp[i].count(p))
return dp[i][p];
int deg = g[i].size() - (p != -1);
Value res = Value(0, 1, 1);
if (f || p == -1) {
// O(deg)
// go only child
for (int j : g[i])
if (j != p) {
int k;
modint x, y;
tie(k, x, y) = dfs(j, i, f);
get<0>(res) += k;
get<1>(res) *= fact.inv[k];
get<2>(res) *= y;
}
get<2>(res) *= fact[get<0>(res)] * get<1>(res);
get<0>(res) += 1;
} else {
// O(1)
auto A = dfs(i, -1, f), B = dfs(p, i, f);
res = Value(get<0>(A) - get<0>(B), get<1>(A) * fact[get<0>(B)],
get<2>(A) / fact[get<0>(A) - 1] *
fact[get<0>(A) - 1 - get<0>(B)] * fact[get<0>(B)] /
get<2>(B));
dump(A);
dump(B);
dump(0, i, p, res);
}
return dp[i][p] = res;
}
int n;
int main() {
std::ios::sync_with_stdio(false), std::cin.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].emplace_back(b);
g[b].emplace_back(a);
}
dfs(0, -1, 1);
for (int i = 0; i < n; i++) {
auto A = dfs(i, -1, 0);
dump(A);
cout << get<2>(A) << "\n";
}
return 0;
}
| replace | 371 | 372 | 371 | 372 | 0 | |
p02728 | C++ | Runtime Error | #include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
typedef long long ll;
const ll MAXN = 2e5 + 10;
const ll MOD = 1e9 + 7;
struct Node {
ll ind, nxt;
} node[MAXN];
ll n, head[MAXN], cnt;
ll sz[MAXN], dp[MAXN], ans[MAXN];
ll fac[MAXN] = {1};
void add(ll x, ll y) {
node[++cnt].ind = y;
node[cnt].nxt = head[x];
head[x] = cnt;
}
ll inv(ll a, ll m) {
if (a == 1)
return 1;
return inv(m % a, m) * (m - m / a) % m;
}
void DFS1(ll cur, ll pre) {
sz[cur] = dp[cur] = 1;
for (ll i = head[cur]; i; i = node[i].nxt) {
ll ind = node[i].ind;
if (ind == pre)
continue;
DFS1(ind, cur);
sz[cur] += sz[ind];
dp[cur] = dp[cur] * inv(fac[sz[ind]], MOD) % MOD * dp[ind] % MOD;
}
dp[cur] = dp[cur] * fac[sz[cur] - 1] % MOD;
}
void DFS2(ll cur, ll pre) {
ans[cur] = dp[cur];
for (ll i = head[cur]; i; i = node[i].nxt) {
ll ind = node[i].ind;
if (ind == pre)
continue;
dp[cur] = dp[cur] * inv(dp[ind], MOD) % MOD * fac[sz[ind]] % MOD *
fac[sz[cur] - sz[ind] - 1] % MOD * inv(fac[sz[cur] - 1], MOD) %
MOD;
sz[cur] -= sz[ind];
sz[ind] += sz[cur];
dp[ind] = dp[ind] * dp[cur] % MOD * inv(fac[sz[cur]], MOD) % MOD *
fac[sz[ind] - 1] % MOD * inv(fac[sz[ind] - sz[cur] - 1], MOD) %
MOD;
DFS2(ind, cur);
dp[ind] = dp[ind] * inv(dp[cur], MOD) % MOD * fac[sz[cur]] % MOD *
inv(fac[sz[ind] - 1], MOD) % MOD * fac[sz[ind] - sz[cur] - 1] %
MOD;
sz[ind] -= sz[cur];
sz[cur] += sz[ind];
dp[cur] = dp[cur] * dp[ind] % MOD * inv(fac[sz[ind]], MOD) % MOD *
inv(fac[sz[cur] - sz[ind] - 1], MOD) % MOD * fac[sz[cur] - 1] %
MOD;
}
}
int main() {
for (ll i = 1; i < MAXN; i++)
fac[i] = fac[i - 1] * i % MOD;
scanf("%lld", &n);
for (ll i = 1; i < n; i++) {
ll x, y;
scanf("%lld %lld", &x, &y);
add(x, y);
add(y, x);
}
DFS1(1, 0);
DFS2(1, 0);
for (ll i = 1; i <= n; i++) {
printf("%lld\n", ans[i]);
}
return 0;
}
| #include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
typedef long long ll;
const ll MAXN = 2e5 + 10;
const ll MOD = 1e9 + 7;
struct Node {
ll ind, nxt;
} node[MAXN * 2];
ll n, head[MAXN], cnt;
ll sz[MAXN], dp[MAXN], ans[MAXN];
ll fac[MAXN] = {1};
void add(ll x, ll y) {
node[++cnt].ind = y;
node[cnt].nxt = head[x];
head[x] = cnt;
}
ll inv(ll a, ll m) {
if (a == 1)
return 1;
return inv(m % a, m) * (m - m / a) % m;
}
void DFS1(ll cur, ll pre) {
sz[cur] = dp[cur] = 1;
for (ll i = head[cur]; i; i = node[i].nxt) {
ll ind = node[i].ind;
if (ind == pre)
continue;
DFS1(ind, cur);
sz[cur] += sz[ind];
dp[cur] = dp[cur] * inv(fac[sz[ind]], MOD) % MOD * dp[ind] % MOD;
}
dp[cur] = dp[cur] * fac[sz[cur] - 1] % MOD;
}
void DFS2(ll cur, ll pre) {
ans[cur] = dp[cur];
for (ll i = head[cur]; i; i = node[i].nxt) {
ll ind = node[i].ind;
if (ind == pre)
continue;
dp[cur] = dp[cur] * inv(dp[ind], MOD) % MOD * fac[sz[ind]] % MOD *
fac[sz[cur] - sz[ind] - 1] % MOD * inv(fac[sz[cur] - 1], MOD) %
MOD;
sz[cur] -= sz[ind];
sz[ind] += sz[cur];
dp[ind] = dp[ind] * dp[cur] % MOD * inv(fac[sz[cur]], MOD) % MOD *
fac[sz[ind] - 1] % MOD * inv(fac[sz[ind] - sz[cur] - 1], MOD) %
MOD;
DFS2(ind, cur);
dp[ind] = dp[ind] * inv(dp[cur], MOD) % MOD * fac[sz[cur]] % MOD *
inv(fac[sz[ind] - 1], MOD) % MOD * fac[sz[ind] - sz[cur] - 1] %
MOD;
sz[ind] -= sz[cur];
sz[cur] += sz[ind];
dp[cur] = dp[cur] * dp[ind] % MOD * inv(fac[sz[ind]], MOD) % MOD *
inv(fac[sz[cur] - sz[ind] - 1], MOD) % MOD * fac[sz[cur] - 1] %
MOD;
}
}
int main() {
for (ll i = 1; i < MAXN; i++)
fac[i] = fac[i - 1] * i % MOD;
scanf("%lld", &n);
for (ll i = 1; i < n; i++) {
ll x, y;
scanf("%lld %lld", &x, &y);
add(x, y);
add(y, x);
}
DFS1(1, 0);
DFS2(1, 0);
for (ll i = 1; i <= n; i++) {
printf("%lld\n", ans[i]);
}
return 0;
}
| replace | 9 | 10 | 9 | 10 | 0 | |
p02728 | C++ | Runtime Error | #include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
#define MX 200005
#define MOD 1'000'000'007
#define invmod(x) bigmod(x, MOD - 2)
#define br '\n'
ll bigmod(ll base, ll pw) {
ll ret = 1;
while (pw) {
if (pw & 1)
ret = ret * base % MOD;
base = base * base % MOD;
pw >>= 1;
}
return ret;
}
int n;
ll fact[MX], inv[MX];
void calc() {
fact[0] = 1;
inv[0] = invmod(1);
for (int i = 1; i < MX; i++) {
fact[i] = i * fact[i - 1] % MOD;
inv[i] = invmod(fact[i]);
}
}
void treedp(int u, int p, const vector<vi> &adj, vi &sz, vector<ll> &dp) {
dp[u] = 1;
sz[u] = 1;
for (auto v : adj[u]) {
if (v != p) {
treedp(v, u, adj, sz, dp);
dp[u] = dp[u] * (dp[v] * inv[sz[v]] % MOD) % MOD;
sz[u] += sz[v];
}
}
dp[u] = dp[u] * fact[sz[u] - 1] % MOD;
}
void reroot(int u, int p, const vector<vi> &adj, vi &sz, vector<ll> &dp) {
dp[u] = dp[p] * invmod(dp[u] * inv[sz[u]] % MOD) % MOD;
dp[u] = dp[u] * invmod(n - sz[u]) % MOD;
for (auto v : adj[u]) {
if (v != p) {
dp[u] = dp[u] * (dp[v] * inv[sz[v]] % MOD) % MOD;
}
}
for (auto v : adj[u]) {
if (v != p) {
reroot(v, u, adj, sz, dp);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
#endif
calc();
while (cin >> n) {
vector<vi> adj(n);
vi sz(n);
vector<ll> dp(n);
int u, v;
for (int i = 1; i < n; i++) {
cin >> u >> v;
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
treedp(0, -1, adj, sz, dp);
for (auto u : adj[0])
reroot(u, 0, adj, sz, dp);
for (auto x : dp)
cout << x << br;
}
return 0;
}
| #include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
#define MX 200005
#define MOD 1'000'000'007
#define invmod(x) bigmod(x, MOD - 2)
#define br '\n'
ll bigmod(ll base, ll pw) {
ll ret = 1;
while (pw) {
if (pw & 1)
ret = ret * base % MOD;
base = base * base % MOD;
pw >>= 1;
}
return ret;
}
int n;
ll fact[MX], inv[MX];
void calc() {
fact[0] = 1;
inv[0] = invmod(1);
for (int i = 1; i < MX; i++) {
fact[i] = i * fact[i - 1] % MOD;
inv[i] = invmod(fact[i]);
}
}
void treedp(int u, int p, const vector<vi> &adj, vi &sz, vector<ll> &dp) {
dp[u] = 1;
sz[u] = 1;
for (auto v : adj[u]) {
if (v != p) {
treedp(v, u, adj, sz, dp);
dp[u] = dp[u] * (dp[v] * inv[sz[v]] % MOD) % MOD;
sz[u] += sz[v];
}
}
dp[u] = dp[u] * fact[sz[u] - 1] % MOD;
}
void reroot(int u, int p, const vector<vi> &adj, vi &sz, vector<ll> &dp) {
dp[u] = dp[p] * invmod(dp[u] * inv[sz[u]] % MOD) % MOD;
dp[u] = dp[u] * invmod(n - sz[u]) % MOD;
for (auto v : adj[u]) {
if (v != p) {
dp[u] = dp[u] * (dp[v] * inv[sz[v]] % MOD) % MOD;
}
}
for (auto v : adj[u]) {
if (v != p) {
reroot(v, u, adj, sz, dp);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
calc();
while (cin >> n) {
vector<vi> adj(n);
vi sz(n);
vector<ll> dp(n);
int u, v;
for (int i = 1; i < n; i++) {
cin >> u >> v;
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
treedp(0, -1, adj, sz, dp);
for (auto u : adj[0])
reroot(u, 0, adj, sz, dp);
for (auto x : dp)
cout << x << br;
}
return 0;
}
| delete | 67 | 70 | 67 | 67 | 0 | |
p02728 | C++ | Runtime Error | #define LOCAL
#ifdef LOCAL
#define _GLIBCXX_DEBUG
#endif
#include <bits/stdc++.h>
using namespace std;
#define rep(i, x) for (ll i = 0; i < (ll)(x); i++)
#define rrep(i, x) for (ll i = (ll)(x)-1; 0 <= i; i--)
#define reps(i, x) for (ll i = 1; i < (ll)(x) + 1; i++)
#define rreps(i, x) for (ll i = (ll)(x); 1 <= i; i--)
#define all(x) (x).begin(), (x).end()
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> Pll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<vvl> vvvl;
constexpr ll INF = numeric_limits<ll>::max() / 4;
constexpr ll n_max = 1200;
#define int ll
template <typename A, typename B> string to_string(pair<A, B> p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char c) { return to_string((string)&c); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <size_t N> string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++)
res += static_cast<char>('0' + v[i]);
return res;
}
template <typename A> string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first)
res += ", ";
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <std::int_fast64_t Modulus> class modint {
using i64 = int_fast64_t;
public:
i64 a;
constexpr modint(const i64 x = 0) noexcept {
this->a = x % Modulus;
if (a < 0) {
a += Modulus;
}
}
constexpr int getmod() { return Modulus; }
constexpr modint operator-() const noexcept { return a ? Modulus - a : 0; }
constexpr const i64 &value() const noexcept { return a; }
constexpr modint operator+(const modint rhs) const noexcept {
return modint(*this) += rhs;
}
constexpr modint operator-(const modint rhs) const noexcept {
return modint(*this) -= rhs;
}
constexpr modint operator*(const modint rhs) const noexcept {
return modint(*this) *= rhs;
}
constexpr modint operator/(const modint rhs) const noexcept {
return modint(*this) /= rhs;
}
constexpr modint &operator+=(const modint rhs) noexcept {
a += rhs.a;
if (a >= Modulus) {
a -= Modulus;
}
return *this;
}
constexpr modint &operator-=(const modint rhs) noexcept {
if (a < rhs.a) {
a += Modulus;
}
a -= rhs.a;
return *this;
}
constexpr modint &operator*=(const modint rhs) noexcept {
a = a * rhs.a % Modulus;
return *this;
}
constexpr modint &operator/=(modint rhs) noexcept {
i64 a_ = rhs.a, b = Modulus, u = 1, v = 0;
while (b) {
i64 t = a_ / b;
a_ -= t * b;
swap(a_, b);
u -= t * v;
swap(u, v);
}
a = a * u % Modulus;
if (a < 0)
a += Modulus;
return *this;
}
// 自前実装
constexpr bool operator==(const modint rhs) noexcept { return a == rhs.a; }
constexpr bool operator!=(const modint rhs) noexcept { return a != rhs.a; }
constexpr bool operator>(const modint rhs) noexcept { return a > rhs.a; }
constexpr bool operator>=(const modint rhs) noexcept { return a >= rhs.a; }
constexpr bool operator<(const modint rhs) noexcept { return a < rhs.a; }
constexpr bool operator<=(const modint rhs) noexcept { return a <= rhs.a; }
constexpr modint &operator++() noexcept { return (*this) += modint(1); }
// constexpr modint operator++(int) {
// modint tmp(*this);
// operator++();
// return tmp;
// }
constexpr modint &operator--() noexcept { return (*this) -= modint(1); }
// constexpr modint operator--(int) {
// modint tmp(*this);
// operator--();
// return tmp;
// }
template <typename T>
friend constexpr modint modpow(const modint &mt, T n) noexcept {
if (n < 0) {
modint t = (modint(1) / mt);
return modpow(t, -n);
}
modint res = 1, tmp = mt;
while (n) {
if (n & 1)
res *= tmp;
tmp *= tmp;
n /= 2;
}
return res;
}
};
const ll MOD = 1e9 + 7;
using mint = modint<MOD>;
// 標準入出力対応
std::ostream &operator<<(std::ostream &out, const modint<MOD> &m) {
out << m.a;
return out;
}
std::istream &operator>>(std::istream &in, modint<MOD> &m) {
ll a;
in >> a;
m = mint(a);
return in;
}
string to_string(mint m) { return to_string(m.a); }
template <class T> struct BiCoef {
vector<T> fact_, inv_, finv_;
constexpr BiCoef() {}
constexpr BiCoef(int n) noexcept : fact_(n, 1), inv_(n, 1), finv_(n, 1) {
init(n);
}
constexpr void init(int n) noexcept {
fact_.assign(n, 1), inv_.assign(n, 1), finv_.assign(n, 1);
int MOD = fact_[0].getmod();
for (int i = 2; i < n; i++) {
fact_[i] = fact_[i - 1] * i;
inv_[i] = -inv_[MOD % i] * (MOD / i);
finv_[i] = finv_[i - 1] * inv_[i];
}
}
constexpr T com(int n, int k) const noexcept {
if (n < k || n < 0 || k < 0)
return 0;
return fact_[n] * finv_[k] * finv_[n - k];
}
constexpr T fact(int n) const noexcept {
if (n < 0)
return 0;
return fact_[n];
}
constexpr T inv(int n) const noexcept {
if (n < 0)
return 0;
return inv_[n];
}
constexpr T finv(int n) const noexcept {
if (n < 0)
return 0;
return finv_[n];
}
};
BiCoef<mint> bc(n_max);
template <class T> void print(vector<T> &vec, ll k) {
ll n = vec.size();
k = min(k, n);
rep(i, k - 1) cout << vec[i] << " ";
cout << vec[k - 1] << endl;
}
template <class T> void print(vector<vector<T>> &vec, ll k) {
ll n = vec[0].size();
k = min(k, n);
for (auto &i : vec)
print(i, k);
}
vector<vector<ll>> graph(n_max);
vector<ll> parent(n_max);
vector<mint> sub(n_max);
vector<ll> cnt(n_max);
vector<mint> dp(n_max);
ll n;
void dfs(ll now, ll par = -1) {
ll c = 1;
mint ret = 1;
parent[now] = par;
for (auto &to : graph[now]) {
if (to == par)
continue;
dfs(to, now);
c += cnt[to];
ret *= sub[to];
ret /= bc.fact(cnt[to]);
}
ret *= bc.fact(c - 1);
sub[now] = ret;
cnt[now] = c;
}
void dfs2(ll now, ll par = -1) {
if (par == -1) {
dp[now] = sub[now];
}
for (auto &to : graph[now]) {
if (to == par)
continue;
dp[to] = dp[now] * mint(cnt[to]) / mint(n - cnt[to]);
dfs2(to, now);
}
}
signed main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cin >> n;
rep(i, n - 1) {
ll a, b;
cin >> a >> b;
a--;
b--;
graph[a].emplace_back(b);
graph[b].emplace_back(a);
}
dfs(0);
// print(sub, 10);
// print(cnt, 10);
dfs2(0);
// print(dp, 10);
// mint ans = 0;
// rep(i,n)ans += dp[i];
// cout << ans / mint(2) << endl;
rep(i, n) cout << dp[i] << "\n";
} | #define LOCAL
#ifdef LOCAL
#define _GLIBCXX_DEBUG
#endif
#include <bits/stdc++.h>
using namespace std;
#define rep(i, x) for (ll i = 0; i < (ll)(x); i++)
#define rrep(i, x) for (ll i = (ll)(x)-1; 0 <= i; i--)
#define reps(i, x) for (ll i = 1; i < (ll)(x) + 1; i++)
#define rreps(i, x) for (ll i = (ll)(x); 1 <= i; i--)
#define all(x) (x).begin(), (x).end()
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> Pll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<vvl> vvvl;
constexpr ll INF = numeric_limits<ll>::max() / 4;
constexpr ll n_max = 2e5 + 10;
#define int ll
template <typename A, typename B> string to_string(pair<A, B> p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char c) { return to_string((string)&c); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <size_t N> string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++)
res += static_cast<char>('0' + v[i]);
return res;
}
template <typename A> string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first)
res += ", ";
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <std::int_fast64_t Modulus> class modint {
using i64 = int_fast64_t;
public:
i64 a;
constexpr modint(const i64 x = 0) noexcept {
this->a = x % Modulus;
if (a < 0) {
a += Modulus;
}
}
constexpr int getmod() { return Modulus; }
constexpr modint operator-() const noexcept { return a ? Modulus - a : 0; }
constexpr const i64 &value() const noexcept { return a; }
constexpr modint operator+(const modint rhs) const noexcept {
return modint(*this) += rhs;
}
constexpr modint operator-(const modint rhs) const noexcept {
return modint(*this) -= rhs;
}
constexpr modint operator*(const modint rhs) const noexcept {
return modint(*this) *= rhs;
}
constexpr modint operator/(const modint rhs) const noexcept {
return modint(*this) /= rhs;
}
constexpr modint &operator+=(const modint rhs) noexcept {
a += rhs.a;
if (a >= Modulus) {
a -= Modulus;
}
return *this;
}
constexpr modint &operator-=(const modint rhs) noexcept {
if (a < rhs.a) {
a += Modulus;
}
a -= rhs.a;
return *this;
}
constexpr modint &operator*=(const modint rhs) noexcept {
a = a * rhs.a % Modulus;
return *this;
}
constexpr modint &operator/=(modint rhs) noexcept {
i64 a_ = rhs.a, b = Modulus, u = 1, v = 0;
while (b) {
i64 t = a_ / b;
a_ -= t * b;
swap(a_, b);
u -= t * v;
swap(u, v);
}
a = a * u % Modulus;
if (a < 0)
a += Modulus;
return *this;
}
// 自前実装
constexpr bool operator==(const modint rhs) noexcept { return a == rhs.a; }
constexpr bool operator!=(const modint rhs) noexcept { return a != rhs.a; }
constexpr bool operator>(const modint rhs) noexcept { return a > rhs.a; }
constexpr bool operator>=(const modint rhs) noexcept { return a >= rhs.a; }
constexpr bool operator<(const modint rhs) noexcept { return a < rhs.a; }
constexpr bool operator<=(const modint rhs) noexcept { return a <= rhs.a; }
constexpr modint &operator++() noexcept { return (*this) += modint(1); }
// constexpr modint operator++(int) {
// modint tmp(*this);
// operator++();
// return tmp;
// }
constexpr modint &operator--() noexcept { return (*this) -= modint(1); }
// constexpr modint operator--(int) {
// modint tmp(*this);
// operator--();
// return tmp;
// }
template <typename T>
friend constexpr modint modpow(const modint &mt, T n) noexcept {
if (n < 0) {
modint t = (modint(1) / mt);
return modpow(t, -n);
}
modint res = 1, tmp = mt;
while (n) {
if (n & 1)
res *= tmp;
tmp *= tmp;
n /= 2;
}
return res;
}
};
const ll MOD = 1e9 + 7;
using mint = modint<MOD>;
// 標準入出力対応
std::ostream &operator<<(std::ostream &out, const modint<MOD> &m) {
out << m.a;
return out;
}
std::istream &operator>>(std::istream &in, modint<MOD> &m) {
ll a;
in >> a;
m = mint(a);
return in;
}
string to_string(mint m) { return to_string(m.a); }
template <class T> struct BiCoef {
vector<T> fact_, inv_, finv_;
constexpr BiCoef() {}
constexpr BiCoef(int n) noexcept : fact_(n, 1), inv_(n, 1), finv_(n, 1) {
init(n);
}
constexpr void init(int n) noexcept {
fact_.assign(n, 1), inv_.assign(n, 1), finv_.assign(n, 1);
int MOD = fact_[0].getmod();
for (int i = 2; i < n; i++) {
fact_[i] = fact_[i - 1] * i;
inv_[i] = -inv_[MOD % i] * (MOD / i);
finv_[i] = finv_[i - 1] * inv_[i];
}
}
constexpr T com(int n, int k) const noexcept {
if (n < k || n < 0 || k < 0)
return 0;
return fact_[n] * finv_[k] * finv_[n - k];
}
constexpr T fact(int n) const noexcept {
if (n < 0)
return 0;
return fact_[n];
}
constexpr T inv(int n) const noexcept {
if (n < 0)
return 0;
return inv_[n];
}
constexpr T finv(int n) const noexcept {
if (n < 0)
return 0;
return finv_[n];
}
};
BiCoef<mint> bc(n_max);
template <class T> void print(vector<T> &vec, ll k) {
ll n = vec.size();
k = min(k, n);
rep(i, k - 1) cout << vec[i] << " ";
cout << vec[k - 1] << endl;
}
template <class T> void print(vector<vector<T>> &vec, ll k) {
ll n = vec[0].size();
k = min(k, n);
for (auto &i : vec)
print(i, k);
}
vector<vector<ll>> graph(n_max);
vector<ll> parent(n_max);
vector<mint> sub(n_max);
vector<ll> cnt(n_max);
vector<mint> dp(n_max);
ll n;
void dfs(ll now, ll par = -1) {
ll c = 1;
mint ret = 1;
parent[now] = par;
for (auto &to : graph[now]) {
if (to == par)
continue;
dfs(to, now);
c += cnt[to];
ret *= sub[to];
ret /= bc.fact(cnt[to]);
}
ret *= bc.fact(c - 1);
sub[now] = ret;
cnt[now] = c;
}
void dfs2(ll now, ll par = -1) {
if (par == -1) {
dp[now] = sub[now];
}
for (auto &to : graph[now]) {
if (to == par)
continue;
dp[to] = dp[now] * mint(cnt[to]) / mint(n - cnt[to]);
dfs2(to, now);
}
}
signed main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cin >> n;
rep(i, n - 1) {
ll a, b;
cin >> a >> b;
a--;
b--;
graph[a].emplace_back(b);
graph[b].emplace_back(a);
}
dfs(0);
// print(sub, 10);
// print(cnt, 10);
dfs2(0);
// print(dp, 10);
// mint ans = 0;
// rep(i,n)ans += dp[i];
// cout << ans / mint(2) << endl;
rep(i, n) cout << dp[i] << "\n";
} | replace | 18 | 19 | 18 | 19 | 0 | |
p02728 | C++ | Runtime Error | #include <bits/stdc++.h>
#define del(a, i) memset(a, i, sizeof(a))
#define ll long long
#define inl inline
#define il inl void
#define it inl int
#define ill inl ll
#define re register
#define ri re int
#define rl re ll
#define mid ((l + r) >> 1)
#define lowbit(x) (x & (-x))
#define INF 0x3f3f3f3f
using namespace std;
template <class T> il read(T &x) {
int f = 1;
char k = getchar();
x = 0;
for (; k > '9' || k < '0'; k = getchar())
if (k == '-')
f = -1;
for (; k >= '0' && k <= '9'; k = getchar())
x = x * 10 + k - '0';
x *= f;
}
template <class T> il _print(T x) {
if (x >= 10)
_print(x / 10);
putchar(x % 10 + '0');
}
template <class T> il print(T x) {
if (x < 0)
putchar('-'), x = -x;
_print(x);
}
ll mul(ll a, ll b, ll mod) {
long double c = 1.;
return (a * b - (ll)(c * a * b / mod) * mod) % mod;
}
it qpow(int x, int k, int mod) {
int res = 1, bas = x;
while (k) {
if (k & 1)
res = 1ll * res * bas % mod;
bas = 1ll * bas * bas % mod, k >>= 1;
}
return res;
}
const int N = 1e5 + 5, mod = 1e9 + 7;
it add(int x, int y) { return x + y >= mod ? x + y - mod : x + y; }
it mul(int x, int y) { return 1ll * x * y % mod; }
il inc(int &x, int y) { x = add(x, y); }
int n, u, v, dp[N], ans[N], sz[N], fac[N], ifac[N];
vector<int> G[N];
il DFS1(int u, int fa) {
dp[u] = 1, sz[u] = 1;
for (auto v : G[u]) {
if (v == fa)
continue;
DFS1(v, u), dp[u] = mul(dp[u], dp[v]);
sz[u] += sz[v], dp[u] = mul(dp[u], ifac[sz[v]]);
}
dp[u] = mul(dp[u], fac[sz[u] - 1]);
}
il DFS2(int u, int fa) {
ans[u] = dp[u];
for (auto v : G[u]) {
if (v == fa)
continue;
int tu = dp[u];
dp[u] = mul(dp[u], ifac[n - 1]);
dp[u] = mul(dp[u], qpow(dp[v], mod - 2, mod));
dp[u] = mul(dp[u], fac[sz[v]]);
dp[u] = mul(dp[u], fac[n - sz[v] - 1]);
dp[v] = mul(dp[v], ifac[sz[v] - 1]);
dp[v] = mul(dp[v], dp[u]);
dp[v] = mul(dp[v], ifac[n - sz[v]]);
dp[v] = mul(dp[v], fac[n - 1]);
DFS2(v, u), dp[u] = tu;
}
}
int main() {
// freopen(".in","r",stdin);
// freopen(".out","w",stdout);
read(n), fac[0] = 1;
for (ri i = 1; i < n; ++i) {
read(u), read(v);
G[u].push_back(v);
G[v].push_back(u);
}
for (ri i = 1; i <= n; ++i)
fac[i] = mul(fac[i - 1], i);
ifac[n] = qpow(fac[n], mod - 2, mod);
for (ri i = n - 1; i >= 0; --i)
ifac[i] = mul(ifac[i + 1], i + 1);
DFS1(1, 0), DFS2(1, 0);
for (ri i = 1; i <= n; ++i)
printf("%d\n", ans[i]);
return 0;
} | #include <bits/stdc++.h>
#define del(a, i) memset(a, i, sizeof(a))
#define ll long long
#define inl inline
#define il inl void
#define it inl int
#define ill inl ll
#define re register
#define ri re int
#define rl re ll
#define mid ((l + r) >> 1)
#define lowbit(x) (x & (-x))
#define INF 0x3f3f3f3f
using namespace std;
template <class T> il read(T &x) {
int f = 1;
char k = getchar();
x = 0;
for (; k > '9' || k < '0'; k = getchar())
if (k == '-')
f = -1;
for (; k >= '0' && k <= '9'; k = getchar())
x = x * 10 + k - '0';
x *= f;
}
template <class T> il _print(T x) {
if (x >= 10)
_print(x / 10);
putchar(x % 10 + '0');
}
template <class T> il print(T x) {
if (x < 0)
putchar('-'), x = -x;
_print(x);
}
ll mul(ll a, ll b, ll mod) {
long double c = 1.;
return (a * b - (ll)(c * a * b / mod) * mod) % mod;
}
it qpow(int x, int k, int mod) {
int res = 1, bas = x;
while (k) {
if (k & 1)
res = 1ll * res * bas % mod;
bas = 1ll * bas * bas % mod, k >>= 1;
}
return res;
}
const int N = 2e5 + 5, mod = 1e9 + 7;
it add(int x, int y) { return x + y >= mod ? x + y - mod : x + y; }
it mul(int x, int y) { return 1ll * x * y % mod; }
il inc(int &x, int y) { x = add(x, y); }
int n, u, v, dp[N], ans[N], sz[N], fac[N], ifac[N];
vector<int> G[N];
il DFS1(int u, int fa) {
dp[u] = 1, sz[u] = 1;
for (auto v : G[u]) {
if (v == fa)
continue;
DFS1(v, u), dp[u] = mul(dp[u], dp[v]);
sz[u] += sz[v], dp[u] = mul(dp[u], ifac[sz[v]]);
}
dp[u] = mul(dp[u], fac[sz[u] - 1]);
}
il DFS2(int u, int fa) {
ans[u] = dp[u];
for (auto v : G[u]) {
if (v == fa)
continue;
int tu = dp[u];
dp[u] = mul(dp[u], ifac[n - 1]);
dp[u] = mul(dp[u], qpow(dp[v], mod - 2, mod));
dp[u] = mul(dp[u], fac[sz[v]]);
dp[u] = mul(dp[u], fac[n - sz[v] - 1]);
dp[v] = mul(dp[v], ifac[sz[v] - 1]);
dp[v] = mul(dp[v], dp[u]);
dp[v] = mul(dp[v], ifac[n - sz[v]]);
dp[v] = mul(dp[v], fac[n - 1]);
DFS2(v, u), dp[u] = tu;
}
}
int main() {
// freopen(".in","r",stdin);
// freopen(".out","w",stdout);
read(n), fac[0] = 1;
for (ri i = 1; i < n; ++i) {
read(u), read(v);
G[u].push_back(v);
G[v].push_back(u);
}
for (ri i = 1; i <= n; ++i)
fac[i] = mul(fac[i - 1], i);
ifac[n] = qpow(fac[n], mod - 2, mod);
for (ri i = n - 1; i >= 0; --i)
ifac[i] = mul(ifac[i + 1], i + 1);
DFS1(1, 0), DFS2(1, 0);
for (ri i = 1; i <= n; ++i)
printf("%d\n", ans[i]);
return 0;
} | replace | 48 | 49 | 48 | 49 | 0 | |
p02728 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define li long long int
#define rep(i, to) for (li i = 0; i < ((li)(to)); i++)
#define repp(i, start, to) for (li i = (li)(start); i < ((li)(to)); i++)
#define pb push_back
#define sz(v) ((li)(v).size())
#define bgn(v) ((v).begin())
#define eend(v) ((v).end())
#define allof(v) (v).begin(), (v).end()
#define dodp(v, n) memset(v, (li)n, sizeof(v))
#define bit(n) (1ll << (li)(n))
#define mp(a, b) make_pair(a, b)
#define rin rep(i, n)
#define EPS 1e-12
#define ETOL 1e-8
#define MOD 1000000007
typedef pair<li, li> PI;
#define INF bit(60)
#define DBGP 1
#define idp if (DBGP)
#define F first
#define S second
#define p2(a, b) idp cout << a << "\t" << b << endl
#define p3(a, b, c) idp cout << a << "\t" << b << "\t" << c << endl
#define p4(a, b, c, d) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << endl
#define p5(a, b, c, d, e) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << endl
#define p6(a, b, c, d, e, f) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << endl
#define p7(a, b, c, d, e, f, g) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << endl
#define p8(a, b, c, d, e, f, g, h) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << "\t" << h << endl
#define p9(a, b, c, d, e, f, g, h, i) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << "\t" << h << "\t" << i << endl
#define p10(a, b, c, d, e, f, g, h, i, j) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << "\t" << h << "\t" << i << "\t" << j << endl
#define foreach(it, v) \
for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); ++it)
#define p2p(x) idp p2((x).F, (x).S)
#define dump(x, n) \
idp { \
rep(i, n) { cout << x[i] << " "; } \
puts(""); \
}
#define dump2(x, n) \
idp { \
rep(i, n) { cout << "[" << x[i].F << " , " << x[i].S << "] "; } \
puts(""); \
}
#define dumpi(x) \
idp { \
foreach (it, x) { \
cout << (*it) << " "; \
} \
puts(""); \
}
#define dumpi2(x) \
idp { \
foreach (it, x) { \
cout << "[" << (it)->F << " , " << (it)->S << "] "; \
} \
puts(""); \
}
#define read2d(a, w, h) rep(i, h) rep(j, w) cin >> a[i][j]
#define dump2d(a, w, h) \
rep(i, h) { \
rep(j, w) cout << a[i][j] << " "; \
puts(""); \
}
typedef pair<li, li> PI;
li fact_mod[200100];
inline void init() {
fact_mod[0] = 1;
fact_mod[1] = 1;
repp(i, 2, 200100) { fact_mod[i] = (fact_mod[i - 1] * i) % MOD; }
}
inline li gcd(li a, li b) { return b != 0 ? gcd(b, a % b) : a; }
// a x + b y = gcd(a, b)
inline li extgcd(li a, li b, li &x, li &y) {
li g = a;
x = 1;
y = 0;
if (b != 0)
g = extgcd(b, a % b, y, x), y -= (a / b) * x;
return g;
}
inline li invMod(li a) {
li x, y;
if (extgcd(a, MOD, x, y) == 1)
return (x + MOD) % MOD;
else
return 0; // unsolvable
}
inline li combi(li n, li k) {
return (((fact_mod[n] * invMod(fact_mod[k])) % MOD) *
invMod(fact_mod[n - k])) %
MOD;
}
vector<li> edge[200100];
// {from, to} -> node_num, order_num
unordered_map<li, PI> m[200100];
inline PI calc(li from, li now) {
li res = 1;
li vnum = 1;
li vvp = 1;
for (auto &&next : edge[now]) {
if (next == from) {
continue;
}
if (m[next].count(now) == 0) {
m[next][now] = calc(now, next);
}
PI tmp = m[next][now];
res = (res * tmp.S) % MOD;
vnum += tmp.F;
vvp = (vvp * combi(vnum - 1, tmp.F)) % MOD;
}
res = (res * vvp) % MOD;
if (from == -1) {
for (auto &&next : edge[now]) {
if (m[now].count(next) > 0) {
continue;
}
// いっこダメだった場合を計算する
PI tmp = m[next][now];
li tres = res;
tres = (tres * invMod(combi(vnum - 1, tmp.F))) % MOD;
tres = (tres * invMod(m[next][now].S)) % MOD;
m[now][next] = {vnum - tmp.F, tres};
}
}
return {vnum, res};
}
int main() {
init();
li n;
cin >> n;
rep(i, n - 1) {
li a, b;
cin >> a >> b;
a--;
b--;
edge[a].pb(b);
edge[b].pb(a);
}
rin { cout << calc(-1, i).S << endl; }
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define li long long int
#define rep(i, to) for (li i = 0; i < ((li)(to)); i++)
#define repp(i, start, to) for (li i = (li)(start); i < ((li)(to)); i++)
#define pb push_back
#define sz(v) ((li)(v).size())
#define bgn(v) ((v).begin())
#define eend(v) ((v).end())
#define allof(v) (v).begin(), (v).end()
#define dodp(v, n) memset(v, (li)n, sizeof(v))
#define bit(n) (1ll << (li)(n))
#define mp(a, b) make_pair(a, b)
#define rin rep(i, n)
#define EPS 1e-12
#define ETOL 1e-8
#define MOD 1000000007
typedef pair<li, li> PI;
#define INF bit(60)
#define DBGP 1
#define idp if (DBGP)
#define F first
#define S second
#define p2(a, b) idp cout << a << "\t" << b << endl
#define p3(a, b, c) idp cout << a << "\t" << b << "\t" << c << endl
#define p4(a, b, c, d) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << endl
#define p5(a, b, c, d, e) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << endl
#define p6(a, b, c, d, e, f) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << endl
#define p7(a, b, c, d, e, f, g) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << endl
#define p8(a, b, c, d, e, f, g, h) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << "\t" << h << endl
#define p9(a, b, c, d, e, f, g, h, i) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << "\t" << h << "\t" << i << endl
#define p10(a, b, c, d, e, f, g, h, i, j) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << "\t" << h << "\t" << i << "\t" << j << endl
#define foreach(it, v) \
for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); ++it)
#define p2p(x) idp p2((x).F, (x).S)
#define dump(x, n) \
idp { \
rep(i, n) { cout << x[i] << " "; } \
puts(""); \
}
#define dump2(x, n) \
idp { \
rep(i, n) { cout << "[" << x[i].F << " , " << x[i].S << "] "; } \
puts(""); \
}
#define dumpi(x) \
idp { \
foreach (it, x) { \
cout << (*it) << " "; \
} \
puts(""); \
}
#define dumpi2(x) \
idp { \
foreach (it, x) { \
cout << "[" << (it)->F << " , " << (it)->S << "] "; \
} \
puts(""); \
}
#define read2d(a, w, h) rep(i, h) rep(j, w) cin >> a[i][j]
#define dump2d(a, w, h) \
rep(i, h) { \
rep(j, w) cout << a[i][j] << " "; \
puts(""); \
}
typedef pair<li, li> PI;
li fact_mod[200100];
inline void init() {
fact_mod[0] = 1;
fact_mod[1] = 1;
repp(i, 2, 200100) { fact_mod[i] = (fact_mod[i - 1] * i) % MOD; }
}
inline li gcd(li a, li b) { return b != 0 ? gcd(b, a % b) : a; }
// a x + b y = gcd(a, b)
inline li extgcd(li a, li b, li &x, li &y) {
li g = a;
x = 1;
y = 0;
if (b != 0)
g = extgcd(b, a % b, y, x), y -= (a / b) * x;
return g;
}
inline li invMod(li a) {
li x, y;
if (extgcd(a, MOD, x, y) == 1)
return (x + MOD) % MOD;
else
return 0; // unsolvable
}
inline li combi(li n, li k) {
return (((fact_mod[n] * invMod(fact_mod[k])) % MOD) *
invMod(fact_mod[n - k])) %
MOD;
}
vector<li> edge[200100];
// {from, to} -> node_num, order_num
unordered_map<li, PI> m[200100];
inline PI calc(li from, li now) {
li res = 1;
li vnum = 1;
li vvp = 1;
for (auto &&next : edge[now]) {
if (next == from) {
continue;
}
if (m[next].count(now) == 0) {
m[next][now] = calc(now, next);
}
PI tmp = m[next][now];
res = (res * tmp.S) % MOD;
vnum += tmp.F;
vvp = (vvp * combi(vnum - 1, tmp.F)) % MOD;
}
res = (res * vvp) % MOD;
if (from == -1) {
for (auto &&next : edge[now]) {
if (m[now].count(next) > 0) {
continue;
}
// いっこダメだった場合を計算する
PI tmp = m[next][now];
li tres = res;
tres = (tres * invMod(combi(vnum - 1, tmp.F))) % MOD;
tres = (tres * invMod(m[next][now].S)) % MOD;
m[now][next] = {vnum - tmp.F, tres};
}
}
return {vnum, res};
}
int main() {
init();
li n;
cin >> n;
rep(i, n - 1) {
li a, b;
cin >> a >> b;
a--;
b--;
edge[a].pb(b);
edge[b].pb(a);
}
rin {
if (sz(edge[i]) == n - 1) {
// star graph
rep(j, n) {
if (i == j) {
cout << fact_mod[n - 1] << endl;
} else {
cout << fact_mod[n - 2] << endl;
}
}
return 0;
}
}
rin { cout << calc(-1, i).S << endl; }
return 0;
} | insert | 169 | 169 | 169 | 183 | TLE | |
p02728 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define li long long int
#define rep(i, to) for (li i = 0; i < ((li)(to)); i++)
#define repp(i, start, to) for (li i = (li)(start); i < ((li)(to)); i++)
#define pb push_back
#define sz(v) ((li)(v).size())
#define bgn(v) ((v).begin())
#define eend(v) ((v).end())
#define allof(v) (v).begin(), (v).end()
#define dodp(v, n) memset(v, (li)n, sizeof(v))
#define bit(n) (1ll << (li)(n))
#define mp(a, b) make_pair(a, b)
#define rin rep(i, n)
#define EPS 1e-12
#define ETOL 1e-8
#define MOD 1000000007
typedef pair<li, li> PI;
#define INF bit(60)
#define DBGP 1
#define idp if (DBGP)
#define F first
#define S second
#define p2(a, b) idp cout << a << "\t" << b << endl
#define p3(a, b, c) idp cout << a << "\t" << b << "\t" << c << endl
#define p4(a, b, c, d) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << endl
#define p5(a, b, c, d, e) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << endl
#define p6(a, b, c, d, e, f) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << endl
#define p7(a, b, c, d, e, f, g) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << endl
#define p8(a, b, c, d, e, f, g, h) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << "\t" << h << endl
#define p9(a, b, c, d, e, f, g, h, i) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << "\t" << h << "\t" << i << endl
#define p10(a, b, c, d, e, f, g, h, i, j) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << "\t" << h << "\t" << i << "\t" << j << endl
#define foreach(it, v) \
for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); ++it)
#define p2p(x) idp p2((x).F, (x).S)
#define dump(x, n) \
idp { \
rep(i, n) { cout << x[i] << " "; } \
puts(""); \
}
#define dump2(x, n) \
idp { \
rep(i, n) { cout << "[" << x[i].F << " , " << x[i].S << "] "; } \
puts(""); \
}
#define dumpi(x) \
idp { \
foreach (it, x) { \
cout << (*it) << " "; \
} \
puts(""); \
}
#define dumpi2(x) \
idp { \
foreach (it, x) { \
cout << "[" << (it)->F << " , " << (it)->S << "] "; \
} \
puts(""); \
}
#define read2d(a, w, h) rep(i, h) rep(j, w) cin >> a[i][j]
#define dump2d(a, w, h) \
rep(i, h) { \
rep(j, w) cout << a[i][j] << " "; \
puts(""); \
}
typedef pair<li, li> PI;
li fact_mod[200100];
inline void init() {
fact_mod[0] = 1;
fact_mod[1] = 1;
repp(i, 2, 200100) { fact_mod[i] = (fact_mod[i - 1] * i) % MOD; }
}
inline li gcd(li a, li b) { return b != 0 ? gcd(b, a % b) : a; }
// a x + b y = gcd(a, b)
inline li extgcd(li a, li b, li &x, li &y) {
li g = a;
x = 1;
y = 0;
if (b != 0)
g = extgcd(b, a % b, y, x), y -= (a / b) * x;
return g;
}
inline li invMod(li a) {
li x, y;
if (extgcd(a, MOD, x, y) == 1)
return (x + MOD) % MOD;
else
return 0; // unsolvable
}
inline li combi(li n, li k) {
return (((fact_mod[n] * invMod(fact_mod[k])) % MOD) *
invMod(fact_mod[n - k])) %
MOD;
}
vector<li> edge[200100];
// {from, to} -> node_num, order_num
unordered_map<li, PI> m[200100];
inline PI calc(li from, li now) {
li res = 1;
li vnum = 1;
li vvp = 1;
for (auto &&next : edge[now]) {
if (next == from) {
continue;
}
if (m[next].count(now) == 0) {
m[next][now] = calc(now, next);
}
PI tmp = m[next][now];
res = (res * tmp.S) % MOD;
vnum += tmp.F;
vvp = (vvp * combi(vnum - 1, tmp.F)) % MOD;
}
res = (res * vvp) % MOD;
if (from == -1) {
for (auto &&next : edge[now]) {
if (m[now].count(next) > 0) {
continue;
}
// いっこダメだった場合を計算する
PI tmp = m[next][now];
li tres = res;
tres = (tres * invMod(combi(vnum - 1, tmp.F))) % MOD;
tres = (tres * invMod(m[next][now].S)) % MOD;
m[now][next] = {vnum - tmp.F, tres};
}
}
return {vnum, res};
}
int main() {
init();
li n;
cin >> n;
rep(i, n - 1) {
li a, b;
cin >> a >> b;
a--;
b--;
edge[a].pb(b);
edge[b].pb(a);
}
vector<PI> order;
rin { order.pb({sz(edge[i]), i}); }
sort(allof(order));
reverse(allof(order));
rin { cout << calc(-1, i).S << endl; }
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define li long long int
#define rep(i, to) for (li i = 0; i < ((li)(to)); i++)
#define repp(i, start, to) for (li i = (li)(start); i < ((li)(to)); i++)
#define pb push_back
#define sz(v) ((li)(v).size())
#define bgn(v) ((v).begin())
#define eend(v) ((v).end())
#define allof(v) (v).begin(), (v).end()
#define dodp(v, n) memset(v, (li)n, sizeof(v))
#define bit(n) (1ll << (li)(n))
#define mp(a, b) make_pair(a, b)
#define rin rep(i, n)
#define EPS 1e-12
#define ETOL 1e-8
#define MOD 1000000007
typedef pair<li, li> PI;
#define INF bit(60)
#define DBGP 1
#define idp if (DBGP)
#define F first
#define S second
#define p2(a, b) idp cout << a << "\t" << b << endl
#define p3(a, b, c) idp cout << a << "\t" << b << "\t" << c << endl
#define p4(a, b, c, d) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << endl
#define p5(a, b, c, d, e) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << endl
#define p6(a, b, c, d, e, f) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << endl
#define p7(a, b, c, d, e, f, g) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << endl
#define p8(a, b, c, d, e, f, g, h) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << "\t" << h << endl
#define p9(a, b, c, d, e, f, g, h, i) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << "\t" << h << "\t" << i << endl
#define p10(a, b, c, d, e, f, g, h, i, j) \
idp cout << a << "\t" << b << "\t" << c << "\t" << d << "\t" << e << "\t" \
<< f << "\t" << g << "\t" << h << "\t" << i << "\t" << j << endl
#define foreach(it, v) \
for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); ++it)
#define p2p(x) idp p2((x).F, (x).S)
#define dump(x, n) \
idp { \
rep(i, n) { cout << x[i] << " "; } \
puts(""); \
}
#define dump2(x, n) \
idp { \
rep(i, n) { cout << "[" << x[i].F << " , " << x[i].S << "] "; } \
puts(""); \
}
#define dumpi(x) \
idp { \
foreach (it, x) { \
cout << (*it) << " "; \
} \
puts(""); \
}
#define dumpi2(x) \
idp { \
foreach (it, x) { \
cout << "[" << (it)->F << " , " << (it)->S << "] "; \
} \
puts(""); \
}
#define read2d(a, w, h) rep(i, h) rep(j, w) cin >> a[i][j]
#define dump2d(a, w, h) \
rep(i, h) { \
rep(j, w) cout << a[i][j] << " "; \
puts(""); \
}
typedef pair<li, li> PI;
li fact_mod[200100];
inline void init() {
fact_mod[0] = 1;
fact_mod[1] = 1;
repp(i, 2, 200100) { fact_mod[i] = (fact_mod[i - 1] * i) % MOD; }
}
inline li gcd(li a, li b) { return b != 0 ? gcd(b, a % b) : a; }
// a x + b y = gcd(a, b)
inline li extgcd(li a, li b, li &x, li &y) {
li g = a;
x = 1;
y = 0;
if (b != 0)
g = extgcd(b, a % b, y, x), y -= (a / b) * x;
return g;
}
inline li invMod(li a) {
li x, y;
if (extgcd(a, MOD, x, y) == 1)
return (x + MOD) % MOD;
else
return 0; // unsolvable
}
inline li combi(li n, li k) {
return (((fact_mod[n] * invMod(fact_mod[k])) % MOD) *
invMod(fact_mod[n - k])) %
MOD;
}
vector<li> edge[200100];
// {from, to} -> node_num, order_num
unordered_map<li, PI> m[200100];
inline PI calc(li from, li now) {
li res = 1;
li vnum = 1;
li vvp = 1;
for (auto &&next : edge[now]) {
if (next == from) {
continue;
}
if (m[next].count(now) == 0) {
m[next][now] = calc(now, next);
}
PI tmp = m[next][now];
res = (res * tmp.S) % MOD;
vnum += tmp.F;
vvp = (vvp * combi(vnum - 1, tmp.F)) % MOD;
}
res = (res * vvp) % MOD;
if (from == -1) {
for (auto &&next : edge[now]) {
if (m[now].count(next) > 0) {
continue;
}
// いっこダメだった場合を計算する
PI tmp = m[next][now];
li tres = res;
tres = (tres * invMod(combi(vnum - 1, tmp.F))) % MOD;
tres = (tres * invMod(m[next][now].S)) % MOD;
m[now][next] = {vnum - tmp.F, tres};
}
}
return {vnum, res};
}
int main() {
init();
li n;
cin >> n;
rep(i, n - 1) {
li a, b;
cin >> a >> b;
a--;
b--;
edge[a].pb(b);
edge[b].pb(a);
}
vector<PI> order;
rin { order.pb({sz(edge[i]), i}); }
sort(allof(order));
reverse(allof(order));
vector<li> res(n);
rin { res[order[i].S] = calc(-1, order[i].S).S; }
rin { cout << res[i] << endl; }
return 0;
} | replace | 174 | 175 | 174 | 177 | TLE | |
p02728 | C++ | Runtime Error | #include <bits/stdc++.h>
#define MAXN 100010
#define ll long long
using namespace std;
const int mod = 1e9 + 7;
int n, tot;
ll product = 1;
int head[MAXN], siz[MAXN];
ll f[MAXN];
struct edge {
int to, next;
} e[MAXN * 2];
void add_edge(int x, int y) {
e[++tot].to = y;
e[tot].next = head[x];
head[x] = tot;
return;
}
ll qp(ll a, ll b) {
ll res = 1, base = a;
while (b) {
if (b & 1)
res = (res * base) % mod;
base = (base * base) % mod;
b >>= 1;
}
return res;
}
void dfs1(int x, int fa) {
siz[x] = 1;
for (int i = head[x]; i; i = e[i].next) {
int v = e[i].to;
if (v == fa)
continue;
dfs1(v, x);
siz[x] += siz[v];
}
f[1] = (1ll * f[1] * siz[x]) % mod;
return;
}
void dfs2(int x, int fa) {
for (int i = head[x]; i; i = e[i].next) {
int v = e[i].to;
if (v == fa)
continue;
f[v] =
(1ll * f[x] * (1ll * (n - siz[v]) * qp(siz[v], mod - 2) % mod)) % mod;
dfs2(v, x);
}
return;
}
int main() {
scanf("%d", &n);
for (int i = 1, u, v; i < n; i++) {
scanf("%d%d", &u, &v);
add_edge(u, v);
add_edge(v, u);
}
f[1] = 1;
dfs1(1, 0);
dfs2(1, 0);
for (int i = 1; i <= n; i++) {
product = (1ll * product * i) % mod;
}
for (int i = 1; i <= n; i++) {
printf("%lld\n", (ll)(1ll * product * qp(f[i], mod - 2)) % mod);
}
return 0;
} | #include <bits/stdc++.h>
#define MAXN 200010
#define ll long long
using namespace std;
const int mod = 1e9 + 7;
int n, tot;
ll product = 1;
int head[MAXN], siz[MAXN];
ll f[MAXN];
struct edge {
int to, next;
} e[MAXN * 2];
void add_edge(int x, int y) {
e[++tot].to = y;
e[tot].next = head[x];
head[x] = tot;
return;
}
ll qp(ll a, ll b) {
ll res = 1, base = a;
while (b) {
if (b & 1)
res = (res * base) % mod;
base = (base * base) % mod;
b >>= 1;
}
return res;
}
void dfs1(int x, int fa) {
siz[x] = 1;
for (int i = head[x]; i; i = e[i].next) {
int v = e[i].to;
if (v == fa)
continue;
dfs1(v, x);
siz[x] += siz[v];
}
f[1] = (1ll * f[1] * siz[x]) % mod;
return;
}
void dfs2(int x, int fa) {
for (int i = head[x]; i; i = e[i].next) {
int v = e[i].to;
if (v == fa)
continue;
f[v] =
(1ll * f[x] * (1ll * (n - siz[v]) * qp(siz[v], mod - 2) % mod)) % mod;
dfs2(v, x);
}
return;
}
int main() {
scanf("%d", &n);
for (int i = 1, u, v; i < n; i++) {
scanf("%d%d", &u, &v);
add_edge(u, v);
add_edge(v, u);
}
f[1] = 1;
dfs1(1, 0);
dfs2(1, 0);
for (int i = 1; i <= n; i++) {
product = (1ll * product * i) % mod;
}
for (int i = 1; i <= n; i++) {
printf("%lld\n", (ll)(1ll * product * qp(f[i], mod - 2)) % mod);
}
return 0;
} | replace | 2 | 3 | 2 | 3 | 0 | |
p02728 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repr(i, n) for (int i = (n - 1); i >= 0; --i)
typedef long long ll;
typedef pair<int, int> P;
// const int MAX = 200005;
const int MAX = 40;
const int INF = 1001001001;
const int MOD = 1000000007;
struct mint {
long long x;
mint(long long x = 0) : x(x % MOD + (0 <= x ? 0 : 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 -= a.x) < 0)
x += MOD;
return *this;
}
mint &operator*=(const mint &a) {
(x *= a.x) %= MOD;
return *this;
}
mint operator+(const mint &a) const { return mint(x) += a; }
mint operator-(const mint &a) const { return mint(x) -= a; }
mint operator*(const mint &a) const { return mint(x) *= a; }
// for prime mod
mint inv() const {
long long a = x, 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);
}
return mint(u);
}
mint &operator/=(const mint &a) { return *this *= a.inv(); }
mint operator/(const mint &a) const { return mint(x) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
ll fac[MAX], finv[MAX], inv[MAX];
void init() {
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;
}
}
// グラフ
vector<int> G[MAX];
// データの構造体
struct Data {
mint a;
int s;
};
Data f(Data x, Data y) {
mint res = x.a * y.a;
res *= fac[x.s + y.s];
res /= fac[x.s] * fac[y.s];
return Data{res, x.s + y.s};
}
// dp[i][j]:=頂点iの結果
vector<Data> dp[MAX];
// deg[i]:=頂点iの子の数
int deg[MAX];
// pi[i]:=頂点iの親の index
int pi[MAX];
// ans[i]:=頂点iの解
mint ans[MAX];
Data dfs1(int v, int p = -1) {
deg[v] = G[v].size();
dp[v].resize(deg[v]);
Data res = {1, 0};
rep(i, deg[v]) {
int u = G[v][i];
if (u == p) {
pi[v] = i;
continue;
}
dp[v][i] = dfs1(u, v);
res = f(res, dp[v][i]);
}
res.s++;
return res;
}
void dfs2(int v, Data p_res = Data{1, 0}, int p = -1) {
if (p != -1)
dp[v][pi[v]] = p_res;
vector<Data> dpl(deg[v] + 1);
dpl[0].a = 1;
rep(i, deg[v]) dpl[i + 1] = f(dpl[i], dp[v][i]);
vector<Data> dpr(deg[v] + 1);
dpr[deg[v]].a = 1;
repr(i, deg[v]) dpr[i] = f(dpr[i + 1], dp[v][i]);
ans[v] = dpr[0].a;
rep(i, deg[v]) {
int u = G[v][i];
if (u == p)
continue;
Data d = f(dpl[i], dpr[i + 1]);
d.s++;
dfs2(u, d, v);
}
}
int main() {
int N;
cin >> N;
rep(i, N - 1) {
int a, b;
cin >> a >> b;
a--, b--;
G[a].push_back(b);
G[b].push_back(a);
}
init();
dfs1(0);
dfs2(0);
rep(i, N) { cout << ans[i] << endl; }
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repr(i, n) for (int i = (n - 1); i >= 0; --i)
typedef long long ll;
typedef pair<int, int> P;
const int MAX = 200005;
const int INF = 1001001001;
const int MOD = 1000000007;
struct mint {
long long x;
mint(long long x = 0) : x(x % MOD + (0 <= x ? 0 : 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 -= a.x) < 0)
x += MOD;
return *this;
}
mint &operator*=(const mint &a) {
(x *= a.x) %= MOD;
return *this;
}
mint operator+(const mint &a) const { return mint(x) += a; }
mint operator-(const mint &a) const { return mint(x) -= a; }
mint operator*(const mint &a) const { return mint(x) *= a; }
// for prime mod
mint inv() const {
long long a = x, 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);
}
return mint(u);
}
mint &operator/=(const mint &a) { return *this *= a.inv(); }
mint operator/(const mint &a) const { return mint(x) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
ll fac[MAX], finv[MAX], inv[MAX];
void init() {
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;
}
}
// グラフ
vector<int> G[MAX];
// データの構造体
struct Data {
mint a;
int s;
};
Data f(Data x, Data y) {
mint res = x.a * y.a;
res *= fac[x.s + y.s];
res /= fac[x.s] * fac[y.s];
return Data{res, x.s + y.s};
}
// dp[i][j]:=頂点iの結果
vector<Data> dp[MAX];
// deg[i]:=頂点iの子の数
int deg[MAX];
// pi[i]:=頂点iの親の index
int pi[MAX];
// ans[i]:=頂点iの解
mint ans[MAX];
Data dfs1(int v, int p = -1) {
deg[v] = G[v].size();
dp[v].resize(deg[v]);
Data res = {1, 0};
rep(i, deg[v]) {
int u = G[v][i];
if (u == p) {
pi[v] = i;
continue;
}
dp[v][i] = dfs1(u, v);
res = f(res, dp[v][i]);
}
res.s++;
return res;
}
void dfs2(int v, Data p_res = Data{1, 0}, int p = -1) {
if (p != -1)
dp[v][pi[v]] = p_res;
vector<Data> dpl(deg[v] + 1);
dpl[0].a = 1;
rep(i, deg[v]) dpl[i + 1] = f(dpl[i], dp[v][i]);
vector<Data> dpr(deg[v] + 1);
dpr[deg[v]].a = 1;
repr(i, deg[v]) dpr[i] = f(dpr[i + 1], dp[v][i]);
ans[v] = dpr[0].a;
rep(i, deg[v]) {
int u = G[v][i];
if (u == p)
continue;
Data d = f(dpl[i], dpr[i + 1]);
d.s++;
dfs2(u, d, v);
}
}
int main() {
int N;
cin >> N;
rep(i, N - 1) {
int a, b;
cin >> a >> b;
a--, b--;
G[a].push_back(b);
G[b].push_back(a);
}
init();
dfs1(0);
dfs2(0);
rep(i, N) { cout << ans[i] << endl; }
} | replace | 9 | 11 | 9 | 10 | 0 | |
p02728 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define int long long
const int mod = 1e9 + 7;
const int N = 2e5 + 444;
int re() {
int x;
scanf("%lld", &x);
return x;
}
int val[N];
int tot;
int ans[N];
int fir[N], nxt[N], to[N];
int siz[N];
int jie[N];
int c[N], d[N];
void addedge(int x, int y) {
nxt[++tot] = fir[x];
fir[x] = tot;
to[tot] = y;
swap(x, y);
nxt[++tot] = fir[x];
fir[x] = tot;
to[tot] = y;
}
int quick(int a, int b) {
int ha = 1;
while (b) {
if (b & 1)
ha = ha * a % mod;
b >>= 1;
a = a * a % mod;
}
return ha;
}
int ni(int a) { return quick(a, mod - 2); }
int cata(int n, int m) {
if (n < m)
return 0;
return c[n] * d[m] % mod * d[n - m] % mod;
}
void Dfs1(int x, int fa) {
val[x] = 1;
siz[x] = 1;
for (int e = fir[x]; e; e = nxt[e]) {
int y = to[e];
if (y == fa)
continue;
Dfs1(y, x);
siz[x] += siz[y];
val[x] = val[x] * val[y] % mod;
}
val[x] = val[x] * c[siz[x] - 1] % mod;
for (int e = fir[x]; e; e = nxt[e]) {
int y = to[e];
if (y == fa)
continue;
val[x] = val[x] * d[siz[y]] % mod;
}
}
int n;
void Dfs2(int x, int fa, int value) {
if (x == 1) {
ans[x] = val[x];
value = value * d[siz[x] - 1] % mod * val[x] % mod;
for (int e = fir[x]; e; e = nxt[e]) {
int y = to[e];
Dfs2(y, x,
value * c[siz[y]] % mod * (c[siz[x] - 1 - siz[y]]) % mod *
ni(val[y]) % mod);
}
} else {
ans[x] = val[x] * d[siz[x] - 1] % mod * d[n - siz[x]] % mod * c[n - 1] %
mod * value % mod;
value = value * val[x] % mod * d[siz[x] - 1] % mod * d[n - siz[x]] % mod;
for (int e = fir[x]; e; e = nxt[e]) {
int y = to[e];
if (y == fa)
continue;
Dfs2(y, x,
value * c[siz[y]] % mod * c[n - siz[y] - 1] % mod * ni(val[y]) %
mod);
}
}
}
signed main() {
n = re();
c[0] = 1;
for (int i = 1; i <= n; i++)
c[i] = c[i - 1] * i % mod;
d[1] = 1;
d[0] = 1;
for (int i = 2; i <= n; i++)
d[i] = d[mod % i] * (mod - mod / i) % mod;
for (int i = 1; i <= n; i++)
d[i] = d[i - 1] * d[i] % mod;
for (int i = 1; i < n; i++) {
int x = re(), y = re();
addedge(x, y);
}
Dfs1(1, 0);
Dfs2(1, 0, 1);
for (int i = 1; i <= n; i++)
printf("%lld\n", ans[i]);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
const int mod = 1e9 + 7;
const int N = 1e6 + 444;
int re() {
int x;
scanf("%lld", &x);
return x;
}
int val[N];
int tot;
int ans[N];
int fir[N], nxt[N], to[N];
int siz[N];
int jie[N];
int c[N], d[N];
void addedge(int x, int y) {
nxt[++tot] = fir[x];
fir[x] = tot;
to[tot] = y;
swap(x, y);
nxt[++tot] = fir[x];
fir[x] = tot;
to[tot] = y;
}
int quick(int a, int b) {
int ha = 1;
while (b) {
if (b & 1)
ha = ha * a % mod;
b >>= 1;
a = a * a % mod;
}
return ha;
}
int ni(int a) { return quick(a, mod - 2); }
int cata(int n, int m) {
if (n < m)
return 0;
return c[n] * d[m] % mod * d[n - m] % mod;
}
void Dfs1(int x, int fa) {
val[x] = 1;
siz[x] = 1;
for (int e = fir[x]; e; e = nxt[e]) {
int y = to[e];
if (y == fa)
continue;
Dfs1(y, x);
siz[x] += siz[y];
val[x] = val[x] * val[y] % mod;
}
val[x] = val[x] * c[siz[x] - 1] % mod;
for (int e = fir[x]; e; e = nxt[e]) {
int y = to[e];
if (y == fa)
continue;
val[x] = val[x] * d[siz[y]] % mod;
}
}
int n;
void Dfs2(int x, int fa, int value) {
if (x == 1) {
ans[x] = val[x];
value = value * d[siz[x] - 1] % mod * val[x] % mod;
for (int e = fir[x]; e; e = nxt[e]) {
int y = to[e];
Dfs2(y, x,
value * c[siz[y]] % mod * (c[siz[x] - 1 - siz[y]]) % mod *
ni(val[y]) % mod);
}
} else {
ans[x] = val[x] * d[siz[x] - 1] % mod * d[n - siz[x]] % mod * c[n - 1] %
mod * value % mod;
value = value * val[x] % mod * d[siz[x] - 1] % mod * d[n - siz[x]] % mod;
for (int e = fir[x]; e; e = nxt[e]) {
int y = to[e];
if (y == fa)
continue;
Dfs2(y, x,
value * c[siz[y]] % mod * c[n - siz[y] - 1] % mod * ni(val[y]) %
mod);
}
}
}
signed main() {
n = re();
c[0] = 1;
for (int i = 1; i <= n; i++)
c[i] = c[i - 1] * i % mod;
d[1] = 1;
d[0] = 1;
for (int i = 2; i <= n; i++)
d[i] = d[mod % i] * (mod - mod / i) % mod;
for (int i = 1; i <= n; i++)
d[i] = d[i - 1] * d[i] % mod;
for (int i = 1; i < n; i++) {
int x = re(), y = re();
addedge(x, y);
}
Dfs1(1, 0);
Dfs2(1, 0, 1);
for (int i = 1; i <= n; i++)
printf("%lld\n", ans[i]);
return 0;
} | replace | 4 | 5 | 4 | 5 | 0 | |
p02728 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
struct modular_num {
int d, md = 1e9 + 7;
modular_num(int x = 0, int _mod = 1e9 + 7) {
d = normal(x);
md = _mod;
}
int normal(int x) {
x %= md;
while (x < 0)
x += md;
return x;
}
modular_num inverse(modular_num t) { return t ^ (md - 2); }
friend istream &operator>>(istream &in, modular_num &t) {
in >> t();
return in;
}
friend ostream &operator<<(ostream &out, modular_num t) {
out << t();
return out;
}
int &operator()() { return d; }
modular_num operator+(modular_num t) { return normal(d + t()); }
modular_num &operator+=(modular_num t) { return *this = *this + t; }
modular_num operator-(modular_num t) { return normal(d - t()); }
modular_num &operator-=(modular_num t) { return *this = *this - t; }
modular_num operator*(modular_num t) { return 1ll * d * t() % md; }
modular_num &operator*=(modular_num t) { return *this = *this * t; }
modular_num operator^(int power) {
modular_num base = *this, res = 1;
power %= md - 1;
while (power > 0) {
if (power & 1)
res *= base;
base *= base;
power >>= 1;
}
return res;
}
modular_num &operator^=(int power) { return *this = *this ^ power; }
modular_num operator/(modular_num t) { return 1ll * d * inverse(t)() % md; }
modular_num &operator/=(modular_num t) { return *this = *this / t; }
modular_num &operator=(modular_num t) {
d = t();
return *this;
}
bool operator==(modular_num t) { return d == t(); }
bool operator!=(modular_num t) { return d != t(); }
};
using mint = modular_num;
const int maxn = 5000;
int sz[maxn], n;
vector<int> adj[maxn];
mint dp[maxn], pd[maxn], fac[maxn];
void precalc() {
fac[0] = 1;
for (int i = 1; i < maxn; i++)
fac[i] = fac[i - 1] * i;
}
void dfs(int u, int par = -1) {
sz[u] = 1;
for (int v : adj[u]) {
if (v != par) {
dfs(v, u);
sz[u] += sz[v];
}
}
pd[u] = fac[sz[u] - 1];
for (int v : adj[u]) {
if (v != par) {
(pd[u] *= pd[v]) /= fac[sz[v]];
}
}
}
void ufs(int u, int par = -1) {
if (par == -1) {
dp[u] = pd[u];
} else {
dp[u] = mint(1) / fac[n - sz[u]];
for (int v : adj[u])
if (v != par)
(dp[u] *= pd[v]) /= fac[sz[v]];
dp[u] *= dp[par];
dp[u] *= fac[n - 1 - sz[u]];
(dp[u] /= pd[u]) *= fac[sz[u]];
}
for (int v : adj[u])
if (v != par)
ufs(v, u);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
precalc();
for (int i = 0, u, v; i < n - 1; i++) {
cin >> u >> v;
--u, --v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(0);
ufs(0);
for (int i = 0; i < n; i++) {
cout << dp[i] << '\n';
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
struct modular_num {
int d, md = 1e9 + 7;
modular_num(int x = 0, int _mod = 1e9 + 7) {
d = normal(x);
md = _mod;
}
int normal(int x) {
x %= md;
while (x < 0)
x += md;
return x;
}
modular_num inverse(modular_num t) { return t ^ (md - 2); }
friend istream &operator>>(istream &in, modular_num &t) {
in >> t();
return in;
}
friend ostream &operator<<(ostream &out, modular_num t) {
out << t();
return out;
}
int &operator()() { return d; }
modular_num operator+(modular_num t) { return normal(d + t()); }
modular_num &operator+=(modular_num t) { return *this = *this + t; }
modular_num operator-(modular_num t) { return normal(d - t()); }
modular_num &operator-=(modular_num t) { return *this = *this - t; }
modular_num operator*(modular_num t) { return 1ll * d * t() % md; }
modular_num &operator*=(modular_num t) { return *this = *this * t; }
modular_num operator^(int power) {
modular_num base = *this, res = 1;
power %= md - 1;
while (power > 0) {
if (power & 1)
res *= base;
base *= base;
power >>= 1;
}
return res;
}
modular_num &operator^=(int power) { return *this = *this ^ power; }
modular_num operator/(modular_num t) { return 1ll * d * inverse(t)() % md; }
modular_num &operator/=(modular_num t) { return *this = *this / t; }
modular_num &operator=(modular_num t) {
d = t();
return *this;
}
bool operator==(modular_num t) { return d == t(); }
bool operator!=(modular_num t) { return d != t(); }
};
using mint = modular_num;
const int maxn = 2e5 + 10;
int sz[maxn], n;
vector<int> adj[maxn];
mint dp[maxn], pd[maxn], fac[maxn];
void precalc() {
fac[0] = 1;
for (int i = 1; i < maxn; i++)
fac[i] = fac[i - 1] * i;
}
void dfs(int u, int par = -1) {
sz[u] = 1;
for (int v : adj[u]) {
if (v != par) {
dfs(v, u);
sz[u] += sz[v];
}
}
pd[u] = fac[sz[u] - 1];
for (int v : adj[u]) {
if (v != par) {
(pd[u] *= pd[v]) /= fac[sz[v]];
}
}
}
void ufs(int u, int par = -1) {
if (par == -1) {
dp[u] = pd[u];
} else {
dp[u] = mint(1) / fac[n - sz[u]];
for (int v : adj[u])
if (v != par)
(dp[u] *= pd[v]) /= fac[sz[v]];
dp[u] *= dp[par];
dp[u] *= fac[n - 1 - sz[u]];
(dp[u] /= pd[u]) *= fac[sz[u]];
}
for (int v : adj[u])
if (v != par)
ufs(v, u);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
precalc();
for (int i = 0, u, v; i < n - 1; i++) {
cin >> u >> v;
--u, --v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(0);
ufs(0);
for (int i = 0; i < n; i++) {
cout << dp[i] << '\n';
}
return 0;
}
| replace | 75 | 76 | 75 | 76 | 0 | |
p02728 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define rep(i, n) for (int i = 0; i < (n); ++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;
}
const ll INF = 1LL << 60;
const int inf = (1 << 30) - 1;
const int mod = 1e9 + 7;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
class mint {
public:
long long x;
constexpr mint(long long _x = 0) : x((_x % mod + mod) % mod) {}
constexpr mint operator-() const { return mint(-x); }
constexpr mint &operator+=(const mint &a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
constexpr mint &operator-=(const mint &a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
constexpr mint &operator*=(const mint &a) {
(x *= a.x) %= mod;
return *this;
}
constexpr mint operator+(const mint &a) const {
mint res(*this);
return res += a;
}
constexpr mint operator-(const mint &a) const {
mint res(*this);
return res -= a;
}
constexpr mint operator*(const mint &a) const {
mint res(*this);
return res *= a;
}
constexpr mint pow(long long x) const {
if (!x)
return 1;
mint a = pow(x >> 1);
a *= a;
if (x & 1)
a *= *this;
return a;
}
constexpr mint inv() const { return pow(mod - 2); }
constexpr mint &operator/=(const mint &a) { return (*this) *= a.inv(); }
constexpr mint operator/(const mint &a) const {
mint res(*this);
return res /= a;
}
friend ostream &operator<<(ostream &os, const mint &m) {
os << m.x;
return os;
}
};
const int nmax = 1005;
ll fac[nmax], finv[nmax], inv[nmax];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < nmax; 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;
}
}
// modintを使うときはllをmintに
mint com(int n, int k) {
if (n < k || n < 0 || k < 0) {
return 0;
}
return fac[n] * (finv[k] * finv[n - k] % mod) % mod;
}
vector<vector<int>> g(nmax);
vector<mint> dp(nmax), ans(nmax);
vector<int> c(nmax);
void dfs1(int cur, int pre = -1) {
c[cur] = 0;
dp[cur] = 1;
for (int to : g[cur]) {
if (to == pre) {
continue;
}
dfs1(to, cur);
dp[cur] *= dp[to] * com(c[cur] + c[to], c[to]);
c[cur] += c[to];
}
c[cur]++;
}
int n;
void dfs2(int cur, int pre = -1, mint res = 1) {
dp[cur] *= res * com(n - 1, n - c[cur]);
for (int to : g[cur]) {
if (to == pre) {
continue;
}
res = dp[cur] / dp[to] / com(n - 1, c[to]);
dfs2(to, cur, res);
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n;
COMinit();
rep(i, n - 1) {
int a, b;
cin >> a >> b;
a--, b--;
g[a].push_back(b);
g[b].push_back(a);
}
dfs1(0);
dfs2(0);
mint ans = 0;
rep(i, n) { cout << dp[i] << endl; }
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define rep(i, n) for (int i = 0; i < (n); ++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;
}
const ll INF = 1LL << 60;
const int inf = (1 << 30) - 1;
const int mod = 1e9 + 7;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
class mint {
public:
long long x;
constexpr mint(long long _x = 0) : x((_x % mod + mod) % mod) {}
constexpr mint operator-() const { return mint(-x); }
constexpr mint &operator+=(const mint &a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
constexpr mint &operator-=(const mint &a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
constexpr mint &operator*=(const mint &a) {
(x *= a.x) %= mod;
return *this;
}
constexpr mint operator+(const mint &a) const {
mint res(*this);
return res += a;
}
constexpr mint operator-(const mint &a) const {
mint res(*this);
return res -= a;
}
constexpr mint operator*(const mint &a) const {
mint res(*this);
return res *= a;
}
constexpr mint pow(long long x) const {
if (!x)
return 1;
mint a = pow(x >> 1);
a *= a;
if (x & 1)
a *= *this;
return a;
}
constexpr mint inv() const { return pow(mod - 2); }
constexpr mint &operator/=(const mint &a) { return (*this) *= a.inv(); }
constexpr mint operator/(const mint &a) const {
mint res(*this);
return res /= a;
}
friend ostream &operator<<(ostream &os, const mint &m) {
os << m.x;
return os;
}
};
const int nmax = 200005;
ll fac[nmax], finv[nmax], inv[nmax];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < nmax; 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;
}
}
// modintを使うときはllをmintに
mint com(int n, int k) {
if (n < k || n < 0 || k < 0) {
return 0;
}
return fac[n] * (finv[k] * finv[n - k] % mod) % mod;
}
vector<vector<int>> g(nmax);
vector<mint> dp(nmax), ans(nmax);
vector<int> c(nmax);
void dfs1(int cur, int pre = -1) {
c[cur] = 0;
dp[cur] = 1;
for (int to : g[cur]) {
if (to == pre) {
continue;
}
dfs1(to, cur);
dp[cur] *= dp[to] * com(c[cur] + c[to], c[to]);
c[cur] += c[to];
}
c[cur]++;
}
int n;
void dfs2(int cur, int pre = -1, mint res = 1) {
dp[cur] *= res * com(n - 1, n - c[cur]);
for (int to : g[cur]) {
if (to == pre) {
continue;
}
res = dp[cur] / dp[to] / com(n - 1, c[to]);
dfs2(to, cur, res);
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n;
COMinit();
rep(i, n - 1) {
int a, b;
cin >> a >> b;
a--, b--;
g[a].push_back(b);
g[b].push_back(a);
}
dfs1(0);
dfs2(0);
mint ans = 0;
rep(i, n) { cout << dp[i] << endl; }
} | replace | 76 | 77 | 76 | 77 | 0 | |
p02728 | C++ | Runtime Error |
#include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <deque>
#include <float.h>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
// #include<assert.h>
#include <random>
using namespace std;
#define int long long
#define I32_MAX 2147483647
#define I64_MAX 9223372036854775807LL
#define I64_MAX2 1223372036854775807LL
#define INF I64_MAX2
#define MOD 1000000007
// #define MOD 998244353
#define MEM_SIZE 100010
#define DEBUG_OUT true
#define ALL(x) (x).begin(), (x).end()
template <typename T> void DEBUG(T e) {
if (DEBUG_OUT == false)
return;
std::cout << e << " ";
}
template <typename T> void DEBUG(const std::vector<T> &v) {
if (DEBUG_OUT == false)
return;
for (const auto &e : v) {
std::cout << e << " ";
}
std::cout << std::endl;
}
template <typename T> void DEBUG(const std::vector<std::vector<T>> &vv) {
if (DEBUG_OUT == false)
return;
for (const auto &v : vv) {
DEBUG(v);
}
}
template <class T, class... Ts> void DEBUG(T d, Ts... e) {
if (DEBUG_OUT == false)
return;
DEBUG(d);
DEBUG(e...);
}
template <class T> void corner(bool flg, T hoge) {
if (flg) {
cout << hoge << endl;
abort();
}
}
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// https://www.youtube.com/watch?v=zG1L4vYuGrg&feature=youtu.be
// BELOW
struct mint {
int x; // typedef long long int;
mint(int x = 0) : x((x % MOD + MOD) % MOD) {}
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(int 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;
}
};
const int MAX = 510000;
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;
}
}
int COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int PERM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[n - k] % MOD) % MOD;
}
int MCOM(int n, int k) {
// n個のものから重複を許してr個選ぶ。
// Choose R from N types of things, allowing for duplication.
return COM(n + k - 1, k);
}
// solve
//-----CODE------//
struct DP {
mint dp;
int t;
DP(mint dp = 1, int t = 0) : dp(dp), t(t) {}
DP &operator+=(const DP &a) {
dp *= a.dp;
dp *= COM(t + a.t, t);
t += a.t;
return *this;
}
DP operator-(const DP &a) const {
DP res(*this);
res.t -= a.t;
res.dp /= COM(res.t + a.t, res.t);
res.dp /= a.dp;
return res;
}
DP addRoot() const {
DP res(*this);
res.t++;
return res;
}
};
DP dp[MEM_SIZE];
DP dfs(int v, int p, vector<vector<int>> &GRAPH) {
for (auto &&u : GRAPH[v]) {
if (u == p)
continue;
dp[v] += dfs(u, v, GRAPH).addRoot();
}
return dp[v];
}
void bfs(int v, int p, vector<vector<int>> &GRAPH) {
for (auto &&u : GRAPH[v]) {
if (u == p)
continue;
// 根を離して
DP d = dp[v] - dp[u].addRoot();
// つける
dp[u] += d.addRoot();
bfs(u, v, GRAPH);
}
}
void solve(void) {
int n;
cin >> n;
COMinit();
vector<vector<int>> GRAPH(n);
for (int i = 0; i < n - 1; i++) {
int A, B;
cin >> A >> B;
A--;
B--;
GRAPH[A].push_back(B);
GRAPH[B].push_back(A);
}
dfs(0, -1, GRAPH);
bfs(0, -1, GRAPH);
for (int i = 0; i < n; i++) {
cout << dp[i].addRoot().dp.x << endl;
}
return;
}
int32_t main(int32_t argc, const char *argv[]) {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout << std::fixed;
std::cout << std::setprecision(11);
solve();
return 0;
}
|
#include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <deque>
#include <float.h>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
// #include<assert.h>
#include <random>
using namespace std;
#define int long long
#define I32_MAX 2147483647
#define I64_MAX 9223372036854775807LL
#define I64_MAX2 1223372036854775807LL
#define INF I64_MAX2
#define MOD 1000000007
// #define MOD 998244353
#define MEM_SIZE 200010
#define DEBUG_OUT true
#define ALL(x) (x).begin(), (x).end()
template <typename T> void DEBUG(T e) {
if (DEBUG_OUT == false)
return;
std::cout << e << " ";
}
template <typename T> void DEBUG(const std::vector<T> &v) {
if (DEBUG_OUT == false)
return;
for (const auto &e : v) {
std::cout << e << " ";
}
std::cout << std::endl;
}
template <typename T> void DEBUG(const std::vector<std::vector<T>> &vv) {
if (DEBUG_OUT == false)
return;
for (const auto &v : vv) {
DEBUG(v);
}
}
template <class T, class... Ts> void DEBUG(T d, Ts... e) {
if (DEBUG_OUT == false)
return;
DEBUG(d);
DEBUG(e...);
}
template <class T> void corner(bool flg, T hoge) {
if (flg) {
cout << hoge << endl;
abort();
}
}
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// https://www.youtube.com/watch?v=zG1L4vYuGrg&feature=youtu.be
// BELOW
struct mint {
int x; // typedef long long int;
mint(int x = 0) : x((x % MOD + MOD) % MOD) {}
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(int 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;
}
};
const int MAX = 510000;
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;
}
}
int COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int PERM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[n - k] % MOD) % MOD;
}
int MCOM(int n, int k) {
// n個のものから重複を許してr個選ぶ。
// Choose R from N types of things, allowing for duplication.
return COM(n + k - 1, k);
}
// solve
//-----CODE------//
struct DP {
mint dp;
int t;
DP(mint dp = 1, int t = 0) : dp(dp), t(t) {}
DP &operator+=(const DP &a) {
dp *= a.dp;
dp *= COM(t + a.t, t);
t += a.t;
return *this;
}
DP operator-(const DP &a) const {
DP res(*this);
res.t -= a.t;
res.dp /= COM(res.t + a.t, res.t);
res.dp /= a.dp;
return res;
}
DP addRoot() const {
DP res(*this);
res.t++;
return res;
}
};
DP dp[MEM_SIZE];
DP dfs(int v, int p, vector<vector<int>> &GRAPH) {
for (auto &&u : GRAPH[v]) {
if (u == p)
continue;
dp[v] += dfs(u, v, GRAPH).addRoot();
}
return dp[v];
}
void bfs(int v, int p, vector<vector<int>> &GRAPH) {
for (auto &&u : GRAPH[v]) {
if (u == p)
continue;
// 根を離して
DP d = dp[v] - dp[u].addRoot();
// つける
dp[u] += d.addRoot();
bfs(u, v, GRAPH);
}
}
void solve(void) {
int n;
cin >> n;
COMinit();
vector<vector<int>> GRAPH(n);
for (int i = 0; i < n - 1; i++) {
int A, B;
cin >> A >> B;
A--;
B--;
GRAPH[A].push_back(B);
GRAPH[B].push_back(A);
}
dfs(0, -1, GRAPH);
bfs(0, -1, GRAPH);
for (int i = 0; i < n; i++) {
cout << dp[i].addRoot().dp.x << endl;
}
return;
}
int32_t main(int32_t argc, const char *argv[]) {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout << std::fixed;
std::cout << std::setprecision(11);
solve();
return 0;
}
| replace | 37 | 38 | 37 | 38 | 0 | |
p02728 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using lint = long long int;
long long int INF = 1001001001001001LL;
int inf = 1000000007;
long long int MOD = 1000000007LL;
double PI = 3.1415926535897932;
template <typename T1, typename T2> inline void chmin(T1 &a, const T2 &b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, const T2 &b) {
if (a < b)
a = b;
}
#define ALL(a) a.begin(), a.end()
#define RALL(a) a.rbegin(), a.rend()
/* do your best */
const long long MAXN = 1001024;
// a, b の最大公約数を返す O( log max(a, b) )
long long gcd(long long a, long long b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
// ax + by = 1 となるような (x, y) と gcd(a, b) を返す. gcd(a, b) = 1
// の時、解が存在する.
long long extgcd(long long a, long long b, long long &x, long long &y) {
long long d = a;
if (b != 0) {
d = extgcd(b, a, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return d;
}
// 区間 [a, b) に存在する素数の個数を返す関数
long long prime[MAXN]; // [a,b) の素数のうち i 番目の素数
bool is_prime[MAXN]; // 整数 i が素数であるかどうか
bool is_prime_ab[MAXN]; // 整数 i+a が素数であるかどうか
long long sieve(long long n) {
long long res = 0;
fill(is_prime, is_prime + MAXN, true);
is_prime[0] = is_prime[1] = false; // 0 と 1 は素数ではない。
for (long long i = 2; i <= n; ++i) {
if (!is_prime[i])
continue;
prime[res++] = i;
for (long long j = 2 * i; j <= n; j += i)
is_prime[j] = false; // 素数 i の倍数は素数ではない (ふるい(篩)にかける)
}
return res;
}
/*
long long segment_sieve(long long a, long long b){
fill(is_prime, is_prime + MAXN, true);
fill(is_prime_ab, is_prime_ab + MAXN, true);
for(long long i = 2; i * i <= b - 1; i++) {
if(!is_prime[i]) continue;
for(long long j = 2 * i; j * j <= b - 1; j += i) is_prime[j] = false; //
素数 i で篩にかける for(long long j = a - a % i; j < b; j += i) { if(j < a)
continue; if(is_prime_ab[j-a]) is_prime_ab[j-a] = false; // 素数 i で篩にかける
}
}
long long res = 0;
for(long long i = a; i < b; i++) if(is_prime_ab[i - a]) prime[res++] = i;
return res;
}
*/
// ある整数の約数列挙
vector<long long> divisors(long long n) {
vector<long long> res;
for (long long i = 1; i * i <= n; ++i) {
if (n % i != 0)
continue;
res.push_back(i);
if (n / i == i)
continue; // 上の行で追加済み。
res.push_back(n / i);
}
sort(res.begin(), res.end());
return res;
}
// 素因数分解
map<long long, long long> prime_factors(long long n) {
map<long long, long long> res;
if (n == 1) { // n=1 の素因数分解は n^1
res[n] = 1;
return res;
}
for (long long i = 2, _n = n; i * i <= _n; ++i) {
while (n % i == 0) {
++res[i]; // 素数i^{res[i]}
n /= i;
}
}
if (n != 1)
res[n] = 1;
return res;
}
// 繰り返し 2 乗法
long long modpow(long long a, long long n) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return res;
}
// 逆元を求める. a と m は互いに素であることが要請される.
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
long long fac[MAXN], finv[MAXN], inv[MAXN];
// 前処理 O(n)
void math_init() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (long long i = 2; i < MAXN; 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;
}
}
// 二項係数計算 O(1)
long long COM(long long n, long long k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
// before your coding, you have to write a line "math_init()"
void dfs1(int cur, int par, vector<vector<int>> &g, vector<lint> &sz,
vector<lint> &dp1) {
for (auto nxt : g[cur]) {
if (nxt == par)
continue;
dfs1(nxt, cur, g, sz, dp1);
}
int s = 1;
int ccnt = 0;
for (auto nxt : g[cur]) {
if (nxt == par)
continue;
s += sz[nxt];
ccnt += sz[nxt];
}
sz[cur] = s;
if (ccnt == 0) {
dp1[cur] = 1;
return;
}
lint val = 1;
for (auto nxt : g[cur]) {
if (nxt == par)
continue;
val *= dp1[nxt];
val %= MOD;
val *= COM(ccnt, sz[nxt]);
val %= MOD;
ccnt -= sz[nxt];
}
dp1[cur] = val;
}
void dfs2(int cur, int par, vector<vector<int>> &g, vector<lint> &sz,
vector<lint> &dp1, vector<lint> &ans, lint D) {
// cout << cur + 1 << " : " << ", Dpar = " << D << endl;
int n = g.size();
if (D == -1) {
ans[cur] = dp1[cur];
} else {
// ans を計算
// 子供と Dpar の情報を使う
lint val = D;
lint cnt = n - 1;
for (auto nxt : g[cur]) {
if (nxt == par)
continue;
val *= dp1[nxt];
val %= MOD;
val *= COM(cnt, sz[nxt]);
val %= MOD;
cnt -= sz[nxt];
}
ans[cur] = val;
}
// Dpar を計算しつつ潜る
for (auto nxt : g[cur]) {
if (nxt == par)
continue;
// D は，nxt 以外の子供の情報から得られるもの
lint nxtD = ans[cur];
nxtD %= MOD;
nxtD *= inv[dp1[nxt]];
nxtD %= MOD;
nxtD *= finv[n - 1];
nxtD %= MOD;
nxtD *= fac[n - 1 - sz[nxt]];
nxtD %= MOD;
nxtD *= fac[sz[nxt]];
nxtD %= MOD;
dfs2(nxt, cur, g, sz, dp1, ans, nxtD);
}
}
int main() {
math_init();
int n;
cin >> n;
vector<vector<int>> g(n);
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
vector<lint> sz(n, -1);
vector<lint> dp1(n, -1);
dfs1(0, -1, g, sz, dp1);
vector<lint> ans(n, -1);
dfs2(0, -1, g, sz, dp1, ans, -1);
for (auto x : ans)
cout << x << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using lint = long long int;
long long int INF = 1001001001001001LL;
int inf = 1000000007;
long long int MOD = 1000000007LL;
double PI = 3.1415926535897932;
template <typename T1, typename T2> inline void chmin(T1 &a, const T2 &b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, const T2 &b) {
if (a < b)
a = b;
}
#define ALL(a) a.begin(), a.end()
#define RALL(a) a.rbegin(), a.rend()
/* do your best */
const long long MAXN = 1001024;
// a, b の最大公約数を返す O( log max(a, b) )
long long gcd(long long a, long long b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
// ax + by = 1 となるような (x, y) と gcd(a, b) を返す. gcd(a, b) = 1
// の時、解が存在する.
long long extgcd(long long a, long long b, long long &x, long long &y) {
long long d = a;
if (b != 0) {
d = extgcd(b, a, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return d;
}
// 区間 [a, b) に存在する素数の個数を返す関数
long long prime[MAXN]; // [a,b) の素数のうち i 番目の素数
bool is_prime[MAXN]; // 整数 i が素数であるかどうか
bool is_prime_ab[MAXN]; // 整数 i+a が素数であるかどうか
long long sieve(long long n) {
long long res = 0;
fill(is_prime, is_prime + MAXN, true);
is_prime[0] = is_prime[1] = false; // 0 と 1 は素数ではない。
for (long long i = 2; i <= n; ++i) {
if (!is_prime[i])
continue;
prime[res++] = i;
for (long long j = 2 * i; j <= n; j += i)
is_prime[j] = false; // 素数 i の倍数は素数ではない (ふるい(篩)にかける)
}
return res;
}
/*
long long segment_sieve(long long a, long long b){
fill(is_prime, is_prime + MAXN, true);
fill(is_prime_ab, is_prime_ab + MAXN, true);
for(long long i = 2; i * i <= b - 1; i++) {
if(!is_prime[i]) continue;
for(long long j = 2 * i; j * j <= b - 1; j += i) is_prime[j] = false; //
素数 i で篩にかける for(long long j = a - a % i; j < b; j += i) { if(j < a)
continue; if(is_prime_ab[j-a]) is_prime_ab[j-a] = false; // 素数 i で篩にかける
}
}
long long res = 0;
for(long long i = a; i < b; i++) if(is_prime_ab[i - a]) prime[res++] = i;
return res;
}
*/
// ある整数の約数列挙
vector<long long> divisors(long long n) {
vector<long long> res;
for (long long i = 1; i * i <= n; ++i) {
if (n % i != 0)
continue;
res.push_back(i);
if (n / i == i)
continue; // 上の行で追加済み。
res.push_back(n / i);
}
sort(res.begin(), res.end());
return res;
}
// 素因数分解
map<long long, long long> prime_factors(long long n) {
map<long long, long long> res;
if (n == 1) { // n=1 の素因数分解は n^1
res[n] = 1;
return res;
}
for (long long i = 2, _n = n; i * i <= _n; ++i) {
while (n % i == 0) {
++res[i]; // 素数i^{res[i]}
n /= i;
}
}
if (n != 1)
res[n] = 1;
return res;
}
// 繰り返し 2 乗法
long long modpow(long long a, long long n) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return res;
}
// 逆元を求める. a と m は互いに素であることが要請される.
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
long long fac[MAXN], finv[MAXN], inv[MAXN];
// 前処理 O(n)
void math_init() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (long long i = 2; i < MAXN; 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;
}
}
// 二項係数計算 O(1)
long long COM(long long n, long long k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
// before your coding, you have to write a line "math_init()"
void dfs1(int cur, int par, vector<vector<int>> &g, vector<lint> &sz,
vector<lint> &dp1) {
for (auto nxt : g[cur]) {
if (nxt == par)
continue;
dfs1(nxt, cur, g, sz, dp1);
}
int s = 1;
int ccnt = 0;
for (auto nxt : g[cur]) {
if (nxt == par)
continue;
s += sz[nxt];
ccnt += sz[nxt];
}
sz[cur] = s;
if (ccnt == 0) {
dp1[cur] = 1;
return;
}
lint val = 1;
for (auto nxt : g[cur]) {
if (nxt == par)
continue;
val *= dp1[nxt];
val %= MOD;
val *= COM(ccnt, sz[nxt]);
val %= MOD;
ccnt -= sz[nxt];
}
dp1[cur] = val;
}
void dfs2(int cur, int par, vector<vector<int>> &g, vector<lint> &sz,
vector<lint> &dp1, vector<lint> &ans, lint D) {
// cout << cur + 1 << " : " << ", Dpar = " << D << endl;
int n = g.size();
if (D == -1) {
ans[cur] = dp1[cur];
} else {
// ans を計算
// 子供と Dpar の情報を使う
lint val = D;
lint cnt = n - 1;
for (auto nxt : g[cur]) {
if (nxt == par)
continue;
val *= dp1[nxt];
val %= MOD;
val *= COM(cnt, sz[nxt]);
val %= MOD;
cnt -= sz[nxt];
}
ans[cur] = val;
}
// Dpar を計算しつつ潜る
for (auto nxt : g[cur]) {
if (nxt == par)
continue;
// D は，nxt 以外の子供の情報から得られるもの
lint nxtD = ans[cur];
nxtD %= MOD;
nxtD *= modinv(dp1[nxt], MOD);
nxtD %= MOD;
nxtD *= finv[n - 1];
nxtD %= MOD;
nxtD *= fac[n - 1 - sz[nxt]];
nxtD %= MOD;
nxtD *= fac[sz[nxt]];
nxtD %= MOD;
dfs2(nxt, cur, g, sz, dp1, ans, nxtD);
}
}
int main() {
math_init();
int n;
cin >> n;
vector<vector<int>> g(n);
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
vector<lint> sz(n, -1);
vector<lint> dp1(n, -1);
dfs1(0, -1, g, sz, dp1);
vector<lint> ans(n, -1);
dfs2(0, -1, g, sz, dp1, ans, -1);
for (auto x : ans)
cout << x << endl;
return 0;
}
| replace | 262 | 263 | 262 | 263 | 0 | |
p02728 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define Int int64_t
using namespace std;
struct Combination {
vector<int64_t> _fact, _rfact, _inv;
int64_t MOD;
Combination(size_t sz, int64_t mod)
: _fact(sz + 1), _rfact(sz + 1), _inv(sz + 1), MOD(mod) {
_fact[0] = _rfact[sz] = _inv[0] = 1;
for (int i = 1; i <= sz; ++i) {
_fact[i] = _fact[i - 1] * i % MOD;
}
_rfact[sz] = inverse(_fact[sz]);
for (int i = sz - 1; i >= 0; --i) {
_rfact[i] = _rfact[i + 1] * (i + 1) % MOD;
}
for (int i = 1; i <= sz; ++i) {
_inv[i] = _rfact[i] * _fact[i - 1] % MOD;
}
}
inline int64_t fact(int k) const { return _fact[k]; }
inline int64_t rfact(int k) const { return _rfact[k]; }
inline int64_t inv(int k) const { return _inv[k]; }
int64_t inverse(int64_t x) const { return pow(x, MOD - 2); }
int64_t pow(int64_t x, int64_t n) const {
int64_t ret = 1;
while (n > 0) {
if (n & 1) {
(ret *= x) %= MOD;
}
(x *= x) %= MOD;
n >>= 1;
}
return ret;
}
int64_t P(int n, int r) const {
if (r < 0 || n < r) {
return 0;
}
return fact(n) * rfact(n - r) % MOD;
}
int64_t C(int n, int r) const {
if (r < 0 || n < r) {
return 0;
}
return fact(n) * rfact(r) % MOD * rfact(n - r) % MOD;
}
int64_t H(int n, int r) const {
if (n < 0 || r < 0) {
return 0;
}
return r == 0 ? 1 : C(n + r - 1, r);
}
};
constexpr Int MOD = 1e9 + 7;
Combination cb(200010, MOD);
vector<vector<int>> g(200010);
vector<pair<Int, Int>> d(200010);
vector<Int> ans(200010, 0);
void tapu(int now, int par) {
Int a = 0, b = 1, cnt = 1;
for (int u : g[now]) {
if (u == par) {
continue;
}
tapu(u, now);
Int n = d[u].first;
a += n;
(b *= cb.rfact(n)) %= MOD;
(cnt *= d[u].second) %= MOD;
}
Int x = cb.fact(a) * b % MOD * cnt % MOD;
d[now] = {a + 1, x};
}
void tapi(int now, int par, Int n_par, Int c_par) {
Int a = 0, b = 1, cnt = 1;
for (int u : g[now]) {
if (u == par) {
a += n_par;
(b *= cb.rfact(n_par)) %= MOD;
(cnt *= c_par) %= MOD;
continue;
}
Int n = d[u].first;
a += n;
(b *= cb.rfact(n)) %= MOD;
(cnt *= d[u].second) %= MOD;
}
ans[now] = cb.fact(a) * b % MOD * cnt % MOD;
for (int u : g[now]) {
if (u == par) {
continue;
}
a = 0, b = 1, cnt = 1;
for (int v : g[now]) {
if (v == u) {
continue;
}
if (v == par) {
a += n_par;
(b *= cb.rfact(n_par)) %= MOD;
(cnt *= c_par) %= MOD;
continue;
}
Int n = d[v].first;
a += n;
(b *= cb.rfact(n)) %= MOD;
(cnt *= d[v].second) %= MOD;
}
Int x = cb.fact(a) * b % MOD * cnt % MOD;
tapi(u, now, a + 1, x);
}
}
int main() {
const Int MOD = 1e9 + 7;
int N;
cin >> N;
for (int i = 0; i < N - 1; ++i) {
int a, b;
cin >> a >> b;
--a;
--b;
g[a].emplace_back(b);
g[b].emplace_back(a);
}
tapu(0, -1);
tapi(0, -1, 0, 1);
for (int i = 0; i < N; ++i) {
cout << ans[i] << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define Int int64_t
using namespace std;
struct Combination {
vector<int64_t> _fact, _rfact, _inv;
int64_t MOD;
Combination(size_t sz, int64_t mod)
: _fact(sz + 1), _rfact(sz + 1), _inv(sz + 1), MOD(mod) {
_fact[0] = _rfact[sz] = _inv[0] = 1;
for (int i = 1; i <= sz; ++i) {
_fact[i] = _fact[i - 1] * i % MOD;
}
_rfact[sz] = inverse(_fact[sz]);
for (int i = sz - 1; i >= 0; --i) {
_rfact[i] = _rfact[i + 1] * (i + 1) % MOD;
}
for (int i = 1; i <= sz; ++i) {
_inv[i] = _rfact[i] * _fact[i - 1] % MOD;
}
}
inline int64_t fact(int k) const { return _fact[k]; }
inline int64_t rfact(int k) const { return _rfact[k]; }
inline int64_t inv(int k) const { return _inv[k]; }
int64_t inverse(int64_t x) const { return pow(x, MOD - 2); }
int64_t pow(int64_t x, int64_t n) const {
int64_t ret = 1;
while (n > 0) {
if (n & 1) {
(ret *= x) %= MOD;
}
(x *= x) %= MOD;
n >>= 1;
}
return ret;
}
int64_t P(int n, int r) const {
if (r < 0 || n < r) {
return 0;
}
return fact(n) * rfact(n - r) % MOD;
}
int64_t C(int n, int r) const {
if (r < 0 || n < r) {
return 0;
}
return fact(n) * rfact(r) % MOD * rfact(n - r) % MOD;
}
int64_t H(int n, int r) const {
if (n < 0 || r < 0) {
return 0;
}
return r == 0 ? 1 : C(n + r - 1, r);
}
};
constexpr Int MOD = 1e9 + 7;
Combination cb(200010, MOD);
vector<vector<int>> g(200010);
vector<pair<Int, Int>> d(200010);
vector<Int> ans(200010, 0);
void tapu(int now, int par) {
Int a = 0, b = 1, cnt = 1;
for (int u : g[now]) {
if (u == par) {
continue;
}
tapu(u, now);
Int n = d[u].first;
a += n;
(b *= cb.rfact(n)) %= MOD;
(cnt *= d[u].second) %= MOD;
}
Int x = cb.fact(a) * b % MOD * cnt % MOD;
d[now] = {a + 1, x};
}
void tapi(int now, int par, Int n_par, Int c_par) {
Int a = 0, b = 1, cnt = 1;
for (int u : g[now]) {
if (u == par) {
a += n_par;
(b *= cb.rfact(n_par)) %= MOD;
(cnt *= c_par) %= MOD;
continue;
}
Int n = d[u].first;
a += n;
(b *= cb.rfact(n)) %= MOD;
(cnt *= d[u].second) %= MOD;
}
ans[now] = cb.fact(a) * b % MOD * cnt % MOD;
for (int u : g[now]) {
if (u == par) {
continue;
}
Int n = d[u].first;
Int u_a = a - n;
Int u_b = b * cb.fact(n) % MOD;
Int u_c = cnt * cb.inverse(d[u].second) % MOD;
Int x = cb.fact(u_a) * u_b % MOD * u_c % MOD;
tapi(u, now, u_a + 1, x);
}
}
int main() {
const Int MOD = 1e9 + 7;
int N;
cin >> N;
for (int i = 0; i < N - 1; ++i) {
int a, b;
cin >> a >> b;
--a;
--b;
g[a].emplace_back(b);
g[b].emplace_back(a);
}
tapu(0, -1);
tapi(0, -1, 0, 1);
for (int i = 0; i < N; ++i) {
cout << ans[i] << endl;
}
return 0;
}
| replace | 103 | 121 | 103 | 109 | TLE | |
p02728 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define all(x) x.begin(), x.end()
template <typename T1, typename T2> inline void chkmin(T1 &x, const T2 &y) {
if (x > y)
x = y;
}
template <typename T1, typename T2> inline void chkmax(T1 &x, const T2 &y) {
if (x < y)
x = y;
}
const int MOD = 1e9 + 7;
int add(int a, int b) {
a += b;
if (a >= MOD)
a -= MOD;
return a;
}
int sub(int a, int b) {
a -= b;
if (a < 0)
a += MOD;
return a;
}
int mul(int a, int b) { return (ll)a * b % MOD; }
int binpow(int a, int n) {
if (n == 0)
return 1;
if (n & 1) {
return mul(a, binpow(a, n - 1));
} else {
return binpow(mul(a, a), n / 2);
}
}
int inv(int a) { return binpow(a, MOD - 2); }
const int MAXN = 1e5 + 10;
int fact[MAXN], rfact[MAXN];
void build() {
fact[0] = rfact[0] = 1;
for (int i = 1; i < MAXN; i++) {
fact[i] = mul(fact[i - 1], i);
rfact[i] = inv(fact[i]);
}
}
int c_n_k(int n, int k) { return mul(fact[n], mul(rfact[n - k], rfact[k])); }
int n;
vector<int> g[MAXN];
void read() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
g[u].push_back(v);
g[v].push_back(u);
}
}
int merge(int a, int sz_a, int b, int sz_b) {
int ans = mul(a, b);
ans = mul(ans, c_n_k(sz_a + sz_b, sz_a));
return ans;
}
int dp[MAXN];
int sz[MAXN];
void dfs_down(int v, int p) {
sz[v] = 1;
for (auto i : g[v]) {
if (i == p)
continue;
dfs_down(i, v);
sz[v] += sz[i];
}
int sz_now = 0;
dp[v] = 1;
for (auto i : g[v]) {
if (i == p)
continue;
dp[v] = merge(dp[v], sz_now, dp[i], sz[i]);
sz_now += sz[i];
}
}
int ans[MAXN];
void dfs_up(int v, int p) {
if (p != -1) {
int val_p = dp[p];
int sz_p = n - sz[v] - 1;
val_p = mul(val_p, inv(dp[v]));
// cout << inv(dp[v]) << endl;
val_p = mul(val_p, inv(c_n_k(n - 1, sz[v])));
// cout << inv(c_n_k(sz_p + sz[v, sz[v]))
// cout << "help = " << endl;
// cout << val_p << " " << sz_p << endl;
dp[v] = merge(dp[v], sz_p + 1, val_p, sz[v] - 1);
}
for (auto i : g[v]) {
if (i != p) {
dfs_up(i, v);
}
}
}
void run() {
build();
dfs_down(0, 0);
// cout << dp[0] << endl;
// exit(0);
dfs_up(0, -1);
}
void write() {
for (int i = 0; i < n; i++) {
cout << dp[i] << "\n";
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
read();
run();
write();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define all(x) x.begin(), x.end()
template <typename T1, typename T2> inline void chkmin(T1 &x, const T2 &y) {
if (x > y)
x = y;
}
template <typename T1, typename T2> inline void chkmax(T1 &x, const T2 &y) {
if (x < y)
x = y;
}
const int MOD = 1e9 + 7;
int add(int a, int b) {
a += b;
if (a >= MOD)
a -= MOD;
return a;
}
int sub(int a, int b) {
a -= b;
if (a < 0)
a += MOD;
return a;
}
int mul(int a, int b) { return (ll)a * b % MOD; }
int binpow(int a, int n) {
if (n == 0)
return 1;
if (n & 1) {
return mul(a, binpow(a, n - 1));
} else {
return binpow(mul(a, a), n / 2);
}
}
int inv(int a) { return binpow(a, MOD - 2); }
const int MAXN = 1e6 + 10;
int fact[MAXN], rfact[MAXN];
void build() {
fact[0] = rfact[0] = 1;
for (int i = 1; i < MAXN; i++) {
fact[i] = mul(fact[i - 1], i);
rfact[i] = inv(fact[i]);
}
}
int c_n_k(int n, int k) { return mul(fact[n], mul(rfact[n - k], rfact[k])); }
int n;
vector<int> g[MAXN];
void read() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
g[u].push_back(v);
g[v].push_back(u);
}
}
int merge(int a, int sz_a, int b, int sz_b) {
int ans = mul(a, b);
ans = mul(ans, c_n_k(sz_a + sz_b, sz_a));
return ans;
}
int dp[MAXN];
int sz[MAXN];
void dfs_down(int v, int p) {
sz[v] = 1;
for (auto i : g[v]) {
if (i == p)
continue;
dfs_down(i, v);
sz[v] += sz[i];
}
int sz_now = 0;
dp[v] = 1;
for (auto i : g[v]) {
if (i == p)
continue;
dp[v] = merge(dp[v], sz_now, dp[i], sz[i]);
sz_now += sz[i];
}
}
int ans[MAXN];
void dfs_up(int v, int p) {
if (p != -1) {
int val_p = dp[p];
int sz_p = n - sz[v] - 1;
val_p = mul(val_p, inv(dp[v]));
// cout << inv(dp[v]) << endl;
val_p = mul(val_p, inv(c_n_k(n - 1, sz[v])));
// cout << inv(c_n_k(sz_p + sz[v, sz[v]))
// cout << "help = " << endl;
// cout << val_p << " " << sz_p << endl;
dp[v] = merge(dp[v], sz_p + 1, val_p, sz[v] - 1);
}
for (auto i : g[v]) {
if (i != p) {
dfs_up(i, v);
}
}
}
void run() {
build();
dfs_down(0, 0);
// cout << dp[0] << endl;
// exit(0);
dfs_up(0, -1);
}
void write() {
for (int i = 0; i < n; i++) {
cout << dp[i] << "\n";
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
read();
run();
write();
return 0;
} | replace | 47 | 48 | 47 | 48 | 0 | |
p02728 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define int long long
const int INF = 1001001001;
template <class T, class U> bool chmax(T &a, const U &b) {
return a < b ? a = b, 1 : 0;
}
template <class T, class U> bool chmin(T &a, const U &b) {
return a > b ? a = b, 1 : 0;
}
template <int mod> class ModInt {
public:
ModInt() : v(0) {}
ModInt(int x) : v((x + mod) % mod) {}
int value() const { return v; }
const ModInt operator+(const ModInt &r) const {
return ModInt(this->v + r.v);
}
const ModInt operator-(const ModInt &r) const {
return ModInt(this->v + mod - r.v);
}
const ModInt operator*(const ModInt &r) const {
return ModInt(this->v * r.v);
}
const ModInt operator/(const ModInt &r) const { return (*this * (~r)); }
const ModInt operator^(int k) const { return ModInt(bpow(this->v, k)); }
const ModInt operator~() const { return ModInt(bpow(this->v, mod - 2)); }
bool operator==(const ModInt &r) const { return this->v == r.v; }
bool operator!=(const ModInt &r) const { return this->v != r.v; }
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); }
private:
int v;
int bpow(int a, int b) const {
int ret = 1;
while (b > 0) {
if (b & 1)
ret = (ret * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ret;
}
};
using Mint = ModInt<1000000007>;
struct Factorial {
vector<Mint> fact, fact_inv;
Factorial(size_t size) : fact(size), fact_inv(size) {
fact[0] = fact_inv[0] = 1;
for (int i = 1; i < size; ++i) {
fact[i] = fact[i - 1] * i;
fact_inv[i] = ~fact[i];
}
}
Mint combination(int N, int R) {
if (N < R)
return 0;
return fact[N] * fact_inv[N - R] * fact_inv[R];
}
static Mint bin_pow(Mint x, int p) {
if (x.value() == 0)
return x;
Mint prod = 1;
while (p > 0) {
if (p & 1)
prod *= x;
x *= x;
p >>= 1;
}
return prod;
}
} fact(100005);
signed main() {
int N;
cin >> N;
vector<vector<int>> G(N);
for (int i = 0; i < N - 1; ++i) {
int a, b;
cin >> a >> b;
a--, b--;
G[a].push_back(b);
G[b].push_back(a);
}
vector<Mint> dp(N);
vector<int> sz(N);
auto dfs = [&](auto &self, int v, int p) -> void {
dp[v] = 1;
sz[v] = 1;
for (int w : G[v]) {
if (w == p)
continue;
self(self, w, v);
sz[v] += sz[w];
dp[v] *= dp[w];
}
dp[v] *= fact.fact[sz[v] - 1];
for (int w : G[v]) {
if (w == p)
continue;
dp[v] *= fact.fact_inv[sz[w]];
}
};
dfs(dfs, 0, -1);
vector<Mint> ans(N);
auto dfs2 = [&](auto &self, int v, int p, Mint prop) -> void {
ans[v] = dp[v];
ans[v] *= fact.fact_inv[sz[v] - 1] * fact.fact[N - 1];
ans[v] *= prop;
ans[v] *= fact.fact_inv[N - sz[v]];
for (int w : G[v]) {
if (w == p)
continue;
Mint tmp = ans[v] * (~dp[w]) * fact.fact[sz[w]];
tmp *= fact.fact_inv[N - 1] * fact.fact[N - 1 - sz[w]];
self(self, w, v, tmp);
}
};
dfs2(dfs2, 0, -1, 1);
for (auto x : ans) {
cout << x.value() << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
const int INF = 1001001001;
template <class T, class U> bool chmax(T &a, const U &b) {
return a < b ? a = b, 1 : 0;
}
template <class T, class U> bool chmin(T &a, const U &b) {
return a > b ? a = b, 1 : 0;
}
template <int mod> class ModInt {
public:
ModInt() : v(0) {}
ModInt(int x) : v((x + mod) % mod) {}
int value() const { return v; }
const ModInt operator+(const ModInt &r) const {
return ModInt(this->v + r.v);
}
const ModInt operator-(const ModInt &r) const {
return ModInt(this->v + mod - r.v);
}
const ModInt operator*(const ModInt &r) const {
return ModInt(this->v * r.v);
}
const ModInt operator/(const ModInt &r) const { return (*this * (~r)); }
const ModInt operator^(int k) const { return ModInt(bpow(this->v, k)); }
const ModInt operator~() const { return ModInt(bpow(this->v, mod - 2)); }
bool operator==(const ModInt &r) const { return this->v == r.v; }
bool operator!=(const ModInt &r) const { return this->v != r.v; }
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); }
private:
int v;
int bpow(int a, int b) const {
int ret = 1;
while (b > 0) {
if (b & 1)
ret = (ret * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ret;
}
};
using Mint = ModInt<1000000007>;
struct Factorial {
vector<Mint> fact, fact_inv;
Factorial(size_t size) : fact(size), fact_inv(size) {
fact[0] = fact_inv[0] = 1;
for (int i = 1; i < size; ++i) {
fact[i] = fact[i - 1] * i;
fact_inv[i] = ~fact[i];
}
}
Mint combination(int N, int R) {
if (N < R)
return 0;
return fact[N] * fact_inv[N - R] * fact_inv[R];
}
static Mint bin_pow(Mint x, int p) {
if (x.value() == 0)
return x;
Mint prod = 1;
while (p > 0) {
if (p & 1)
prod *= x;
x *= x;
p >>= 1;
}
return prod;
}
} fact(200005);
signed main() {
int N;
cin >> N;
vector<vector<int>> G(N);
for (int i = 0; i < N - 1; ++i) {
int a, b;
cin >> a >> b;
a--, b--;
G[a].push_back(b);
G[b].push_back(a);
}
vector<Mint> dp(N);
vector<int> sz(N);
auto dfs = [&](auto &self, int v, int p) -> void {
dp[v] = 1;
sz[v] = 1;
for (int w : G[v]) {
if (w == p)
continue;
self(self, w, v);
sz[v] += sz[w];
dp[v] *= dp[w];
}
dp[v] *= fact.fact[sz[v] - 1];
for (int w : G[v]) {
if (w == p)
continue;
dp[v] *= fact.fact_inv[sz[w]];
}
};
dfs(dfs, 0, -1);
vector<Mint> ans(N);
auto dfs2 = [&](auto &self, int v, int p, Mint prop) -> void {
ans[v] = dp[v];
ans[v] *= fact.fact_inv[sz[v] - 1] * fact.fact[N - 1];
ans[v] *= prop;
ans[v] *= fact.fact_inv[N - sz[v]];
for (int w : G[v]) {
if (w == p)
continue;
Mint tmp = ans[v] * (~dp[w]) * fact.fact[sz[w]];
tmp *= fact.fact_inv[N - 1] * fact.fact[N - 1 - sz[w]];
self(self, w, v, tmp);
}
};
dfs2(dfs2, 0, -1, 1);
for (auto x : ans) {
cout << x.value() << endl;
}
}
| replace | 77 | 78 | 77 | 78 | 0 | |
p02728 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <map>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rep1(i, n) for (int i = 1; i <= n; ++i)
using namespace std;
typedef long long ll;
const ll MOD = 1e+9 + 7;
struct mint {
ll x;
mint(ll x = 0) : x(x % MOD) {}
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;
}
};
const int M = 210000;
mint per[M];
class Tree {
private:
int n;
vector<vector<int>> edge;
map<pair<int, int>, int> index;
map<pair<int, int>, int> index_root;
vector<int> size;
vector<vector<int>> par;
vector<mint> dp;
vector<vector<mint>> lsumdp;
vector<vector<mint>> lsumrev;
vector<vector<int>> lsumsize;
vector<bool> f;
public:
Tree(int _n, vector<int> a, vector<int> b) {
n = _n;
edge.resize(n);
rep(i, n - 1) {
add_edge(a[i], b[i], i);
add_edge(b[i], a[i], i + n - 1);
}
}
void add_edge(int from, int to, int num) {
edge[from].push_back(to);
index[{from, to}] = num;
}
int dfs_init(int v, int p) {
par[v][0] = p;
int res = 1;
for (auto w : edge[v]) {
if (w == p)
continue;
res += dfs_init(w, v);
}
return size[v] = res;
}
void init(int s) {
par.resize(n, vector<int>(1));
size.resize(n);
dfs_init(s, -1);
rep(root, n) {
rep(i, edge[root].size()) { index_root[{root, edge[root][i]}] = i; }
}
}
mint dfs(int p, int root) {
int in;
if (p != -1) {
in = index[{p, root}];
if (dp[in].x > 0)
return dp[in];
}
mint res(1);
int cnt = 0;
if (f[root]) {
int inro = index_root[{root, p}];
res *= lsumdp[root][inro] *
(lsumdp[root][edge[root].size()] / lsumdp[root][inro + 1]);
res /= lsumrev[root][inro] *
(lsumrev[root][edge[root].size()] / lsumrev[root][inro + 1]);
res *= per[lsumsize[root][inro] + lsumsize[root][edge[root].size()] -
lsumsize[root][inro + 1]];
return res;
}
rep(i, edge[root].size()) {
int v = edge[root][i];
if (v == p)
continue;
mint tmp = dfs(root, v);
res *= tmp;
if (p == -1)
lsumdp[root][i + 1] = lsumdp[root][i] * tmp;
if (par[root][0] == v) {
res /= (mint)per[n - size[root]];
cnt += n - size[root];
if (p == -1) {
lsumrev[root][i + 1] = lsumrev[root][i] * per[n - size[root]];
lsumsize[root][i + 1] = lsumsize[root][i] + n - size[root];
}
} else {
res /= (mint)per[size[v]];
cnt += size[v];
if (p == -1) {
lsumrev[root][i + 1] = lsumrev[root][i] * per[size[v]];
lsumsize[root][i + 1] = lsumsize[root][i] + size[v];
}
}
}
res *= per[cnt];
if (p == -1) {
f[root] = true;
return res;
}
return dp[in] = res;
}
void lrsum_init() {
lsumdp.resize(n);
rep(i, n) {
lsumdp[i].resize((int)edge[i].size() + 1);
lsumdp[i][0].x = 1;
}
lsumrev.resize(n);
rep(i, n) {
lsumrev[i].resize((int)edge[i].size() + 1);
lsumrev[i][0].x = 1;
}
lsumsize.resize(n);
rep(i, n) {
lsumsize[i].resize((int)edge[i].size() + 1);
lsumsize[i][0] = 0;
}
}
void solve() {
dp.resize(2 * (n - 1));
lrsum_init();
f.resize(n, false);
rep(i, n) { cout << dfs(-1, i).x << "\n"; }
}
void show() { rep(i, n) cout << i << ":" << size[i] << "\n"; }
};
int main() {
per[0].x = 1;
rep(i, M) per[i + 1] = per[i] * (mint)(i + 1);
int n;
cin >> n;
vector<int> a(n - 1), b(n - 1);
rep(i, n - 1) {
cin >> a[i] >> b[i];
a[i]--;
b[i]--;
}
Tree tr(n, a, b);
tr.init(0);
// tr.show();
tr.solve();
return 0;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rep1(i, n) for (int i = 1; i <= n; ++i)
using namespace std;
typedef long long ll;
const ll MOD = 1e+9 + 7;
struct mint {
ll x;
mint(ll x = 0) : x(x % MOD) {}
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;
}
};
const int M = 210000;
mint per[M];
class Tree {
private:
int n;
vector<vector<int>> edge;
map<pair<int, int>, int> index;
map<pair<int, int>, int> index_root;
vector<int> size;
vector<vector<int>> par;
vector<mint> dp;
vector<vector<mint>> lsumdp;
vector<vector<mint>> lsumrev;
vector<vector<int>> lsumsize;
vector<bool> f;
public:
Tree(int _n, vector<int> a, vector<int> b) {
n = _n;
edge.resize(n);
rep(i, n - 1) {
add_edge(a[i], b[i], i);
add_edge(b[i], a[i], i + n - 1);
}
}
void add_edge(int from, int to, int num) {
edge[from].push_back(to);
index[{from, to}] = num;
}
int dfs_init(int v, int p) {
par[v][0] = p;
int res = 1;
for (auto w : edge[v]) {
if (w == p)
continue;
res += dfs_init(w, v);
}
return size[v] = res;
}
void init(int s) {
par.resize(n, vector<int>(1));
size.resize(n);
dfs_init(s, -1);
rep(root, n) {
rep(i, edge[root].size()) { index_root[{root, edge[root][i]}] = i; }
}
}
mint dfs(int p, int root) {
int in;
if (p != -1) {
in = index[{p, root}];
if (dp[in].x > 0)
return dp[in];
}
mint res(1);
int cnt = 0;
if (f[root]) {
int inro = index_root[{root, p}];
res *= lsumdp[root][inro] *
(lsumdp[root][edge[root].size()] / lsumdp[root][inro + 1]);
res /= lsumrev[root][inro] *
(lsumrev[root][edge[root].size()] / lsumrev[root][inro + 1]);
res *= per[lsumsize[root][inro] + lsumsize[root][edge[root].size()] -
lsumsize[root][inro + 1]];
return res;
}
rep(i, edge[root].size()) {
int v = edge[root][i];
if (v == p)
continue;
mint tmp = dfs(root, v);
res *= tmp;
if (p == -1)
lsumdp[root][i + 1] = lsumdp[root][i] * tmp;
if (par[root][0] == v) {
res /= (mint)per[n - size[root]];
cnt += n - size[root];
if (p == -1) {
lsumrev[root][i + 1] = lsumrev[root][i] * per[n - size[root]];
lsumsize[root][i + 1] = lsumsize[root][i] + n - size[root];
}
} else {
res /= (mint)per[size[v]];
cnt += size[v];
if (p == -1) {
lsumrev[root][i + 1] = lsumrev[root][i] * per[size[v]];
lsumsize[root][i + 1] = lsumsize[root][i] + size[v];
}
}
}
res *= per[cnt];
if (p == -1) {
f[root] = true;
return res;
}
return dp[in] = res;
}
void lrsum_init() {
lsumdp.resize(n);
rep(i, n) {
lsumdp[i].resize((int)edge[i].size() + 1);
lsumdp[i][0].x = 1;
}
lsumrev.resize(n);
rep(i, n) {
lsumrev[i].resize((int)edge[i].size() + 1);
lsumrev[i][0].x = 1;
}
lsumsize.resize(n);
rep(i, n) {
lsumsize[i].resize((int)edge[i].size() + 1);
lsumsize[i][0] = 0;
}
}
void solve() {
dp.resize(2 * (n - 1));
lrsum_init();
f.resize(n, false);
vector<ll> res(n);
vector<int> perm(n);
rep(i, n) perm[i] = i;
sort(perm.begin(), perm.end(),
[&](int a, int b) { return edge[a].size() > edge[b].size(); });
rep(i, n) { res[perm[i]] = dfs(-1, perm[i]).x; }
rep(i, n) cout << res[i] << "\n";
}
void show() { rep(i, n) cout << i << ":" << size[i] << "\n"; }
};
int main() {
per[0].x = 1;
rep(i, M) per[i + 1] = per[i] * (mint)(i + 1);
int n;
cin >> n;
vector<int> a(n - 1), b(n - 1);
rep(i, n - 1) {
cin >> a[i] >> b[i];
a[i]--;
b[i]--;
}
Tree tr(n, a, b);
tr.init(0);
// tr.show();
tr.solve();
return 0;
}
| replace | 181 | 182 | 181 | 188 | TLE | |
p02728 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <vector>
using namespace std;
using ll = long long;
#define fst first
#define snd second
/* clang-format off */
template <class T, size_t D> struct _vec { using type = vector<typename _vec<T, D - 1>::type>; };
template <class T> struct _vec<T, 0> { using type = T; };
template <class T, size_t D> using vec = typename _vec<T, D>::type;
template <class T> vector<T> make_v(size_t size, const T& init) { return vector<T>(size, init); }
template <class... Ts> auto make_v(size_t size, Ts... rest) { return vector<decltype(make_v(rest...))>(size, make_v(rest...)); }
template <class T> inline void chmin(T &a, const T& b) { if (b < a) a = b; }
template <class T> inline void chmax(T &a, const T& b) { if (b > a) a = b; }
/* clang-format on */
template <std::uint_fast64_t Modulus> class modint {
using u64 = std::uint_fast64_t;
public:
u64 a;
constexpr modint(const u64 x = 0) noexcept : a(x % Modulus) {}
constexpr u64 &value() noexcept { return a; }
constexpr const u64 &value() const noexcept { return a; }
constexpr modint operator+(const modint rhs) const noexcept {
return modint(*this) += rhs;
}
constexpr modint operator-(const modint rhs) const noexcept {
return modint(*this) -= rhs;
}
constexpr modint operator*(const modint rhs) const noexcept {
return modint(*this) *= rhs;
}
constexpr modint operator/(const modint rhs) const noexcept {
return modint(*this) /= rhs;
}
constexpr modint &operator+=(const modint rhs) noexcept {
a += rhs.a;
if (a >= Modulus) {
a -= Modulus;
}
return *this;
}
constexpr modint &operator-=(const modint rhs) noexcept {
if (a < rhs.a) {
a += Modulus;
}
a -= rhs.a;
return *this;
}
constexpr modint &operator*=(const modint rhs) noexcept {
a = a * rhs.a % Modulus;
return *this;
}
constexpr modint &operator/=(const modint rhs) noexcept {
return *this *= ~rhs;
}
constexpr modint power(u64 exp) const noexcept {
modint v = 1, x = *this;
while (exp) {
if (exp & 1) {
v *= x;
}
x *= x;
exp >>= 1;
}
return v;
}
constexpr modint operator~() const noexcept { return power(Modulus - 2); }
};
using mint = modint<1000000007>;
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;
}
};
vector<mint> fact, factInv;
void initFact(int N) {
fact.resize(N + 1);
factInv.resize(N + 1);
fact[0] = 1;
for (int i = 1; i <= N; i++)
fact[i] = fact[i - 1] * i;
factInv[N] = ~fact[N];
for (int i = N - 1; i >= 0; i--)
factInv[i] = factInv[i + 1] * (i + 1);
}
mint choose(int n, int k) {
if (n < 0 || k < 0 || k > n) {
return 0;
} else {
return fact[n] * factInv[k] * factInv[n - k];
}
}
int main() {
#ifdef DEBUG
ifstream ifs("in.txt");
cin.rdbuf(ifs.rdbuf());
#endif
int N;
while (cin >> N) {
initFact((int)1e5 + 10);
using P = pair<int, mint>;
auto f1 = [&](const P &a, const P &b) -> P {
mint x = a.snd;
mint y = b.snd;
return {a.fst + b.fst, a.snd * b.snd * choose(a.fst + b.fst, a.fst)};
};
auto f2 = [&](const P &a, int d) -> P { return {a.fst + 1, a.snd}; };
ReRooting<int, P> g(N, f1, f2, {0, mint(1)});
for (int i = 0; i < N - 1; i++) {
int a, b;
cin >> a >> b;
--a;
--b;
g.add_edge(a, b, 0);
}
for (auto &x : g.solve()) {
cout << x.snd.value() << endl;
}
}
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <vector>
using namespace std;
using ll = long long;
#define fst first
#define snd second
/* clang-format off */
template <class T, size_t D> struct _vec { using type = vector<typename _vec<T, D - 1>::type>; };
template <class T> struct _vec<T, 0> { using type = T; };
template <class T, size_t D> using vec = typename _vec<T, D>::type;
template <class T> vector<T> make_v(size_t size, const T& init) { return vector<T>(size, init); }
template <class... Ts> auto make_v(size_t size, Ts... rest) { return vector<decltype(make_v(rest...))>(size, make_v(rest...)); }
template <class T> inline void chmin(T &a, const T& b) { if (b < a) a = b; }
template <class T> inline void chmax(T &a, const T& b) { if (b > a) a = b; }
/* clang-format on */
template <std::uint_fast64_t Modulus> class modint {
using u64 = std::uint_fast64_t;
public:
u64 a;
constexpr modint(const u64 x = 0) noexcept : a(x % Modulus) {}
constexpr u64 &value() noexcept { return a; }
constexpr const u64 &value() const noexcept { return a; }
constexpr modint operator+(const modint rhs) const noexcept {
return modint(*this) += rhs;
}
constexpr modint operator-(const modint rhs) const noexcept {
return modint(*this) -= rhs;
}
constexpr modint operator*(const modint rhs) const noexcept {
return modint(*this) *= rhs;
}
constexpr modint operator/(const modint rhs) const noexcept {
return modint(*this) /= rhs;
}
constexpr modint &operator+=(const modint rhs) noexcept {
a += rhs.a;
if (a >= Modulus) {
a -= Modulus;
}
return *this;
}
constexpr modint &operator-=(const modint rhs) noexcept {
if (a < rhs.a) {
a += Modulus;
}
a -= rhs.a;
return *this;
}
constexpr modint &operator*=(const modint rhs) noexcept {
a = a * rhs.a % Modulus;
return *this;
}
constexpr modint &operator/=(const modint rhs) noexcept {
return *this *= ~rhs;
}
constexpr modint power(u64 exp) const noexcept {
modint v = 1, x = *this;
while (exp) {
if (exp & 1) {
v *= x;
}
x *= x;
exp >>= 1;
}
return v;
}
constexpr modint operator~() const noexcept { return power(Modulus - 2); }
};
using mint = modint<1000000007>;
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;
}
};
vector<mint> fact, factInv;
void initFact(int N) {
fact.resize(N + 1);
factInv.resize(N + 1);
fact[0] = 1;
for (int i = 1; i <= N; i++)
fact[i] = fact[i - 1] * i;
factInv[N] = ~fact[N];
for (int i = N - 1; i >= 0; i--)
factInv[i] = factInv[i + 1] * (i + 1);
}
mint choose(int n, int k) {
if (n < 0 || k < 0 || k > n) {
return 0;
} else {
return fact[n] * factInv[k] * factInv[n - k];
}
}
int main() {
#ifdef DEBUG
ifstream ifs("in.txt");
cin.rdbuf(ifs.rdbuf());
#endif
int N;
while (cin >> N) {
initFact((int)2 * 1e5 + 10);
using P = pair<int, mint>;
auto f1 = [&](const P &a, const P &b) -> P {
mint x = a.snd;
mint y = b.snd;
return {a.fst + b.fst, a.snd * b.snd * choose(a.fst + b.fst, a.fst)};
};
auto f2 = [&](const P &a, int d) -> P { return {a.fst + 1, a.snd}; };
ReRooting<int, P> g(N, f1, f2, {0, mint(1)});
for (int i = 0; i < N - 1; i++) {
int a, b;
cin >> a >> b;
--a;
--b;
g.add_edge(a, b, 0);
}
for (auto &x : g.solve()) {
cout << x.snd.value() << endl;
}
}
return 0;
}
| replace | 182 | 183 | 182 | 183 | 0 | |
p02728 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pr;
typedef vector<ll> vc;
#define rep(i, a, b) for (ll i = a; i <= b; i++)
#define repr(i, a, b) for (ll i = a; i >= b; i--)
#define reps(i, v) for (ll i = 0; i < v.size(); i++)
vc g[200005];
ll n, d[200005] = {0}, par[200005] = {0}, bk[200005] = {0};
ll ans[200005] = {0}, dp1[200005] = {0}, dp2[200005] = {0};
bool used[200005] = {0};
const long long mod = 1e9 + 7;
const long long c_max = 1000003;
long long fac[c_max], finv[c_max], inv[c_max];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (long long i = 2; i < c_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(long long comn, long long comk) {
if (comn < comk)
return 0;
if (comn < 0 || comk < 0)
return 0;
if (comn >= c_max) {
long long cret = finv[comk];
for (long long i = 0; i < comk; i++)
cret = (cret * (comn - i)) % mod;
return cret;
}
return fac[comn] * (finv[comk] * finv[comn - comk] % mod) % mod;
}
long long powmod(long long px, long long py, long long pmod) {
if (py == 0)
return 1;
if (py % 2 == 0)
return powmod((px * px) % pmod, py / 2, pmod);
else
return (px * powmod(px, py - 1, pmod)) % pmod;
}
// Extended_GCD
long long extgcd(long long a, long long b, long long &x, long long &y) {
long long gcd_ = a;
if (b != 0) {
gcd_ = extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return gcd_;
}
// Inverse
long long iv(long long a, long long b) {
long long x, y;
extgcd(a, b, x, y);
if (x >= 0)
return x % b;
else
return (b - (-x) % b) % b;
}
void dfs1(ll s) {
used[s] = true;
reps(i, g[s]) {
if (!used[g[s][i]]) {
par[g[s][i]] = s;
dfs1(g[s][i]);
}
}
bk[s] = 1;
reps(j, g[s]) {
if (par[s] == g[s][j])
continue;
bk[s] += bk[g[s][j]];
}
if (g[s].size() == 1 && s != 1) {
d[s] = 1;
} else {
vc d1m;
ll summ = 0;
d[s] = 1;
reps(j, g[s]) {
if (par[s] == g[s][j])
continue;
d[s] = d[s] * d[g[s][j]] % mod;
d1m.push_back(bk[g[s][j]]);
summ += bk[g[s][j]];
}
reps(j, d1m) {
d[s] = d[s] * COM(summ, d1m[j]) % mod;
summ -= d1m[j];
}
}
}
void dfs2(ll s) {
used[s] = true;
if (s != 1) {
vc d1m;
ll summ = 0;
dp1[s] = n - bk[s];
dp2[s] = dp2[par[s]];
// dp2[s]=dp2[par[s]]*d[par[s]]%mod;
// dp2[s]=dp2[s]*iv(d[s],mod)%mod;
// dp2[s]=dp2[s]*COM(n-1-bk[s],dp1[par[s]]);
d1m.push_back(dp1[par[s]]);
summ = dp1[par[s]];
reps(j, g[par[s]]) {
if (g[par[s]][j] == s)
continue;
if (g[par[s]][j] == par[par[s]])
continue;
dp2[s] = dp2[s] * d[g[par[s]][j]] % mod;
d1m.push_back(bk[g[par[s]][j]]);
summ += bk[g[par[s]][j]];
}
reps(j, d1m) {
dp2[s] = dp2[s] * COM(summ, d1m[j]) % mod;
summ -= d1m[j];
}
ans[s] = dp2[s] * d[s] % mod;
ans[s] = ans[s] * COM(n - 1, dp1[s]) % mod;
}
reps(i, g[s]) {
if (!used[g[s][i]]) {
dfs2(g[s][i]);
}
}
}
int main() {
// your code goes here
COMinit();
cin >> n;
rep(i, 1, n - 1) {
ll aa, bb;
cin >> aa >> bb;
g[aa].push_back(bb);
g[bb].push_back(aa);
}
d[0] = 1;
dfs1(1);
ans[1] = d[1];
// rep(i,1,n) cout << d[i] << endl;
rep(i, 1, n) used[i] = false;
dp1[1] = 0;
dp2[1] = 1;
dfs2(1);
rep(i, 1, n) cout << ans[i] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pr;
typedef vector<ll> vc;
#define rep(i, a, b) for (ll i = a; i <= b; i++)
#define repr(i, a, b) for (ll i = a; i >= b; i--)
#define reps(i, v) for (ll i = 0; i < v.size(); i++)
vc g[200005];
ll n, d[200005] = {0}, par[200005] = {0}, bk[200005] = {0};
ll ans[200005] = {0}, dp1[200005] = {0}, dp2[200005] = {0};
bool used[200005] = {0};
const long long mod = 1e9 + 7;
const long long c_max = 1000003;
long long fac[c_max], finv[c_max], inv[c_max];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (long long i = 2; i < c_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(long long comn, long long comk) {
if (comn < comk)
return 0;
if (comn < 0 || comk < 0)
return 0;
if (comn >= c_max) {
long long cret = finv[comk];
for (long long i = 0; i < comk; i++)
cret = (cret * (comn - i)) % mod;
return cret;
}
return fac[comn] * (finv[comk] * finv[comn - comk] % mod) % mod;
}
long long powmod(long long px, long long py, long long pmod) {
if (py == 0)
return 1;
if (py % 2 == 0)
return powmod((px * px) % pmod, py / 2, pmod);
else
return (px * powmod(px, py - 1, pmod)) % pmod;
}
// Extended_GCD
long long extgcd(long long a, long long b, long long &x, long long &y) {
long long gcd_ = a;
if (b != 0) {
gcd_ = extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return gcd_;
}
// Inverse
long long iv(long long a, long long b) {
long long x, y;
extgcd(a, b, x, y);
if (x >= 0)
return x % b;
else
return (b - (-x) % b) % b;
}
void dfs1(ll s) {
used[s] = true;
reps(i, g[s]) {
if (!used[g[s][i]]) {
par[g[s][i]] = s;
dfs1(g[s][i]);
}
}
bk[s] = 1;
reps(j, g[s]) {
if (par[s] == g[s][j])
continue;
bk[s] += bk[g[s][j]];
}
if (g[s].size() == 1 && s != 1) {
d[s] = 1;
} else {
vc d1m;
ll summ = 0;
d[s] = 1;
reps(j, g[s]) {
if (par[s] == g[s][j])
continue;
d[s] = d[s] * d[g[s][j]] % mod;
d1m.push_back(bk[g[s][j]]);
summ += bk[g[s][j]];
}
reps(j, d1m) {
d[s] = d[s] * COM(summ, d1m[j]) % mod;
summ -= d1m[j];
}
}
}
void dfs2(ll s) {
used[s] = true;
if (s != 1) {
vc d1m;
ll summ = 0;
dp1[s] = n - bk[s];
// dp2[s]=dp2[par[s]];
dp2[s] = dp2[par[s]] * d[par[s]] % mod;
dp2[s] = dp2[s] * iv(d[s], mod) % mod;
dp2[s] = dp2[s] * iv(COM(bk[par[s]] - 1, bk[s]), mod) % mod;
dp2[s] = dp2[s] * COM(n - 1 - bk[s], dp1[par[s]]) % mod;
ans[s] = dp2[s] * d[s] % mod;
ans[s] = ans[s] * COM(n - 1, dp1[s]) % mod;
}
reps(i, g[s]) {
if (!used[g[s][i]]) {
dfs2(g[s][i]);
}
}
}
int main() {
// your code goes here
COMinit();
cin >> n;
rep(i, 1, n - 1) {
ll aa, bb;
cin >> aa >> bb;
g[aa].push_back(bb);
g[bb].push_back(aa);
}
d[0] = 1;
dfs1(1);
ans[1] = d[1];
// rep(i,1,n) cout << d[i] << endl;
rep(i, 1, n) used[i] = false;
dp1[1] = 0;
dp2[1] = 1;
dfs2(1);
rep(i, 1, n) cout << ans[i] << endl;
return 0;
} | replace | 108 | 127 | 108 | 114 | TLE | |
p02728 | C++ | Runtime Error | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = a; i < b; ++i)
#define FR(a, b) for (int i = a; i >= b; --i)
#define _upgrade \
cin.tie(0); \
ios_base::sync_with_stdio(0)
#define pb push_back
#define mp make_pair
#define all(x) x.begin(), x.end()
#define INF 1e9
using namespace std;
typedef long long ll;
typedef double db;
typedef unsigned long long ull;
typedef pair<int, int> iPair;
const int MAX = 2e5 + 1;
const int M = 1e9 + 7;
ll n, sub[MAX], dp[MAX], f[MAX], res[MAX];
vector<int> tree[MAX];
ll mod_exp(ll a, ll b) {
if (b == 0)
return 1;
if (b == 1)
return a;
if (b & 1)
return ((a * mod_exp((a * a) % M, b / 2)) % M) % M;
return mod_exp((a * a) % M, b / 2) % M;
}
ll inv(ll a) { return mod_exp(a, M - 2); }
ll mul(ll a, ll b) { return (a % M * b % M) % M; }
void DFS(int v, int pr) {
sub[v] = 1;
for (int i : tree[v])
if (i != pr) {
DFS(i, v);
sub[v] += sub[i];
}
dp[v] = f[sub[v] - 1];
for (int i : tree[v])
if (i != pr)
dp[v] = ((dp[v] * dp[i]) % M * inv(f[sub[i]]) % M) % M;
}
void solve(int v, int pr) {
res[v] = dp[v];
for (int i : tree[v])
if (i != pr) {
// make i root instead of v
ll temp1 = dp[v], temp2 = dp[i];
// cout<<"V: "<<dp[v]<<"\n";
dp[v] =
(dp[v] * f[sub[i]]) % M; //* (f[sub[v] - sub[i] -1] //*
//inv(dp[i]))%M)%M; //* inv(f[sub[v]-1]))%M;
dp[v] = mul(dp[v], f[sub[v] - sub[i] - 1]);
dp[v] = mul(dp[v], inv(dp[i]));
dp[v] = mul(dp[v], inv(f[sub[v] - 1]));
// cout<<dp[v]<<"\n";
dp[i] *= inv(f[sub[i] - 1]);
dp[i] %= M;
sub[v] -= sub[i];
sub[i] += sub[v];
dp[i] *= f[sub[i] - 1];
dp[i] = ((dp[i] % M * dp[v]) % M * inv(f[sub[v]])) % M;
solve(i, v);
// revert changes
dp[v] = temp1;
sub[v] += sub[i];
}
}
int main() {
_upgrade;
cin >> n;
f[0] = 1;
FOR(i, 1, n + 1)
f[i] = (f[i - 1] * i) % M;
FOR(i, 0, n - 1) {
int a, b;
cin >> a >> b;
tree[a].pb(b);
tree[b].pb(a);
}
DFS(1, -1);
solve(1, -1);
FOR(i, 1, n + 1)
cout << res[i] << "\n";
}
| #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = a; i < b; ++i)
#define FR(a, b) for (int i = a; i >= b; --i)
#define _upgrade \
cin.tie(0); \
ios_base::sync_with_stdio(0)
#define pb push_back
#define mp make_pair
#define all(x) x.begin(), x.end()
#define INF 1e9
using namespace std;
typedef long long ll;
typedef double db;
typedef unsigned long long ull;
typedef pair<int, int> iPair;
const int MAX = 2e5 + 1;
const int M = 1e9 + 7;
ll n, sub[MAX], dp[MAX], f[MAX], res[MAX];
vector<int> tree[MAX];
ll mod_exp(ll a, ll b) {
if (b == 0)
return 1;
if (b == 1)
return a;
if (b & 1)
return ((a * mod_exp((a * a) % M, b / 2)) % M) % M;
return mod_exp((a * a) % M, b / 2) % M;
}
ll inv(ll a) { return mod_exp(a, M - 2); }
ll mul(ll a, ll b) { return (a % M * b % M) % M; }
void DFS(int v, int pr) {
sub[v] = 1;
for (int i : tree[v])
if (i != pr) {
DFS(i, v);
sub[v] += sub[i];
}
dp[v] = f[sub[v] - 1];
for (int i : tree[v])
if (i != pr)
dp[v] = ((dp[v] * dp[i]) % M * inv(f[sub[i]]) % M) % M;
}
void solve(int v, int pr) {
res[v] = dp[v];
for (int i : tree[v])
if (i != pr) {
// make i root instead of v
ll temp1 = dp[v], temp2 = dp[i];
// cout<<"V: "<<dp[v]<<"\n";
dp[v] =
(dp[v] * f[sub[i]]) % M; //* (f[sub[v] - sub[i] -1] //*
//inv(dp[i]))%M)%M; //* inv(f[sub[v]-1]))%M;
dp[v] = mul(dp[v], f[sub[v] - sub[i] - 1]);
dp[v] = mul(dp[v], inv(dp[i]));
dp[v] = mul(dp[v], inv(f[sub[v] - 1]));
// cout<<dp[v]<<"\n";
dp[i] *= inv(f[sub[i] - 1]);
dp[i] %= M;
sub[v] -= sub[i];
sub[i] += sub[v];
dp[i] *= f[sub[i] - 1];
dp[i] = ((dp[i] % M * dp[v]) % M * inv(f[sub[v]])) % M;
solve(i, v);
// revert changes
dp[v] = temp1, dp[i] = temp2;
sub[i] -= sub[v];
sub[v] += sub[i];
}
}
int main() {
_upgrade;
cin >> n;
f[0] = 1;
FOR(i, 1, n + 1)
f[i] = (f[i - 1] * i) % M;
FOR(i, 0, n - 1) {
int a, b;
cin >> a >> b;
tree[a].pb(b);
tree[b].pb(a);
}
DFS(1, -1);
solve(1, -1);
FOR(i, 1, n + 1)
cout << res[i] << "\n";
}
| replace | 72 | 73 | 72 | 74 | 0 | |
p02728 | C++ | Runtime Error | // #include <bits/stdc++.h>
// #define _ ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
// #define int long long
// #define sz(i) (int)(i.size())
// #define F first
// #define S second
// #define L long double
// #define P pair<int, int>
// const int inf = 0x3f3f3f3f3f3f3f3LL;
// const int mod = (int)1e9 + 7;
// using namespace std;
// #if LOCAL
// #include "../../tr.h"
// #else
// #define tr(...)
// #define endl '\n'
// #endif
// template<class T> void smin(T& a, T val) {if (a > val) a =
// val;}template<class T> void smax(T& a, T val) {if (a < val) a = val;} const
// int N = 55;
// int n;
// vector<int> v[N];
// int lvl[N];
// //if this is graph makes sure to loop for all the unvisited vertices, i.e,
// the graph may be unconnected void dfs(int s, int p, int lvl){
// ::lvl[lvl]++;
// for(auto i: v[s]){
// if(i != p){
// dfs(i, s, lvl);
// }
// }
// }
// int32_t main(){_
// cin>>n;
// for (int i = 0; i+1 < n; ++i)
// {
// int x, y;
// cin >> x >> y;
// v[x].push_back(y);
// swap(x, y);
// v[x].push_back(y);
// }
// for (int i = 1; i <= n; ++i)
// {
// memset(lvl, 0, sizeof lvl);
// dfs(i, -1, 0);
// int ans = lvl[0];
// for (int j = 1; j <= n; ++j)
// {
// if(j > 1)
// lvl[j] += lvl[j-1];
// tr(i, lvl[j]);
// if(lvl[j] == 0)
// continue;
// ans *= lvl[j];
// }
// cout<<ans<<endl;
// }
// return 0;
// }
#include <iostream>
#include <vector>
using namespace std;
// #1 Additional explanations regardint the number of topological
// sortings of a tree. The clasic formula using combinations with repetitions
// may be straight forward or more easy to understand, but it may be hard to
// apply it with ease. On the other hand, looking closely at those combinations
// it's easy to see that a lot of the reduce and the final answer looks like
// N! / (subtree_size[1] * subtree_size[2] * .. * subtree_size[n])
typedef long long int64;
const int kMaxN = 1e5, kMod = 1e9 + 7;
int Pow(int a, int p) {
int res = 1;
while (p) {
if (p & 1) {
res = (1LL * res * a) % kMod;
}
a = (1LL * a * a) % kMod;
p /= 2;
}
return res;
}
int inv_number[kMaxN + 1];
int fact[kMaxN + 1];
// computes X! % kMod and 1 / X % kMod in O(kMaxN)
void Initialise() {
fact[0] = fact[1] = 1;
for (int i = 2; i <= kMaxN; i += 1) {
fact[i] = (1LL * i * fact[i - 1]) % kMod;
}
int inv_fact = Pow(fact[kMaxN], kMod - 2);
for (int i = kMaxN; i; i -= 1) {
inv_number[i] = 1LL * inv_fact * fact[i - 1] % kMod;
inv_fact = 1LL * inv_fact * (i) % kMod;
}
inv_number[0] = 1;
}
vector<int> neighbour[kMaxN];
bool visited[kMaxN];
int subtree_size[kMaxN];
// roots the tree in node and computes the subtree_size for itself and all it's
// children (unvisited nodes)
void ComputeSubtree(int node) {
visited[node] = true;
for (auto itr : neighbour[node]) {
if (visited[itr]) {
continue;
}
ComputeSubtree(itr);
subtree_size[node] += subtree_size[itr];
}
subtree_size[node] += 1;
// nice hack. If you only do a DF on a tree you can do this so you don't
// have to make the visited array equal to false afterwards.
visited[node] = false;
}
// global answer and n
int64 answer = 0;
int n;
// The answer for node is "sum"
// add it to the global result and change it to match the wanted sum for each
// child and solve for the recursively
vector<int> v;
void Solve(int node, int sum) {
v[node] = sum;
visited[node] = true;
for (auto itr : neighbour[node]) {
if (visited[itr]) {
continue;
}
// if you have trouble understanding this formula read (#1) on the top of
// the source. if we move the "root" from node to itr, subtree_size[itr]
// changes from subtree_size[itr] to n and subtree_size[node] (root) changes
// from n to .. (n - subtree_size[itr]) we first must get rid of the
// previous / subtree_size[itr] and just add the new / (n -
// subtree_size[itr])
Solve(itr, 1LL * sum * subtree_size[itr] % kMod *
inv_number[(n - subtree_size[itr])] % kMod);
}
visited[node] = false;
}
int main() {
Initialise();
cin >> n;
v.resize(n);
for (int i = 1; i < n; i += 1) {
int a, b;
cin >> a >> b;
// I will make the best indexing out there.
// Like you never saw.
a -= 1;
b -= 1;
neighbour[a].push_back(b);
neighbour[b].push_back(a);
}
const int root = 0;
ComputeSubtree(root);
// computing the answer for the root. (node 0, for example, it doesn't matter
// at all)
int root_answer = fact[n];
for (int i = 0; i < n; i += 1) {
root_answer = 1LL * root_answer * inv_number[subtree_size[i]] % kMod;
}
Solve(root, root_answer);
for (int i = 0; i < n; ++i) {
cout << v[i] << endl;
}
return 0;
}
| // #include <bits/stdc++.h>
// #define _ ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
// #define int long long
// #define sz(i) (int)(i.size())
// #define F first
// #define S second
// #define L long double
// #define P pair<int, int>
// const int inf = 0x3f3f3f3f3f3f3f3LL;
// const int mod = (int)1e9 + 7;
// using namespace std;
// #if LOCAL
// #include "../../tr.h"
// #else
// #define tr(...)
// #define endl '\n'
// #endif
// template<class T> void smin(T& a, T val) {if (a > val) a =
// val;}template<class T> void smax(T& a, T val) {if (a < val) a = val;} const
// int N = 55;
// int n;
// vector<int> v[N];
// int lvl[N];
// //if this is graph makes sure to loop for all the unvisited vertices, i.e,
// the graph may be unconnected void dfs(int s, int p, int lvl){
// ::lvl[lvl]++;
// for(auto i: v[s]){
// if(i != p){
// dfs(i, s, lvl);
// }
// }
// }
// int32_t main(){_
// cin>>n;
// for (int i = 0; i+1 < n; ++i)
// {
// int x, y;
// cin >> x >> y;
// v[x].push_back(y);
// swap(x, y);
// v[x].push_back(y);
// }
// for (int i = 1; i <= n; ++i)
// {
// memset(lvl, 0, sizeof lvl);
// dfs(i, -1, 0);
// int ans = lvl[0];
// for (int j = 1; j <= n; ++j)
// {
// if(j > 1)
// lvl[j] += lvl[j-1];
// tr(i, lvl[j]);
// if(lvl[j] == 0)
// continue;
// ans *= lvl[j];
// }
// cout<<ans<<endl;
// }
// return 0;
// }
#include <iostream>
#include <vector>
using namespace std;
// #1 Additional explanations regardint the number of topological
// sortings of a tree. The clasic formula using combinations with repetitions
// may be straight forward or more easy to understand, but it may be hard to
// apply it with ease. On the other hand, looking closely at those combinations
// it's easy to see that a lot of the reduce and the final answer looks like
// N! / (subtree_size[1] * subtree_size[2] * .. * subtree_size[n])
typedef long long int64;
const int kMaxN = 2e5 + 10, kMod = 1e9 + 7;
int Pow(int a, int p) {
int res = 1;
while (p) {
if (p & 1) {
res = (1LL * res * a) % kMod;
}
a = (1LL * a * a) % kMod;
p /= 2;
}
return res;
}
int inv_number[kMaxN + 1];
int fact[kMaxN + 1];
// computes X! % kMod and 1 / X % kMod in O(kMaxN)
void Initialise() {
fact[0] = fact[1] = 1;
for (int i = 2; i <= kMaxN; i += 1) {
fact[i] = (1LL * i * fact[i - 1]) % kMod;
}
int inv_fact = Pow(fact[kMaxN], kMod - 2);
for (int i = kMaxN; i; i -= 1) {
inv_number[i] = 1LL * inv_fact * fact[i - 1] % kMod;
inv_fact = 1LL * inv_fact * (i) % kMod;
}
inv_number[0] = 1;
}
vector<int> neighbour[kMaxN];
bool visited[kMaxN];
int subtree_size[kMaxN];
// roots the tree in node and computes the subtree_size for itself and all it's
// children (unvisited nodes)
void ComputeSubtree(int node) {
visited[node] = true;
for (auto itr : neighbour[node]) {
if (visited[itr]) {
continue;
}
ComputeSubtree(itr);
subtree_size[node] += subtree_size[itr];
}
subtree_size[node] += 1;
// nice hack. If you only do a DF on a tree you can do this so you don't
// have to make the visited array equal to false afterwards.
visited[node] = false;
}
// global answer and n
int64 answer = 0;
int n;
// The answer for node is "sum"
// add it to the global result and change it to match the wanted sum for each
// child and solve for the recursively
vector<int> v;
void Solve(int node, int sum) {
v[node] = sum;
visited[node] = true;
for (auto itr : neighbour[node]) {
if (visited[itr]) {
continue;
}
// if you have trouble understanding this formula read (#1) on the top of
// the source. if we move the "root" from node to itr, subtree_size[itr]
// changes from subtree_size[itr] to n and subtree_size[node] (root) changes
// from n to .. (n - subtree_size[itr]) we first must get rid of the
// previous / subtree_size[itr] and just add the new / (n -
// subtree_size[itr])
Solve(itr, 1LL * sum * subtree_size[itr] % kMod *
inv_number[(n - subtree_size[itr])] % kMod);
}
visited[node] = false;
}
int main() {
Initialise();
cin >> n;
v.resize(n);
for (int i = 1; i < n; i += 1) {
int a, b;
cin >> a >> b;
// I will make the best indexing out there.
// Like you never saw.
a -= 1;
b -= 1;
neighbour[a].push_back(b);
neighbour[b].push_back(a);
}
const int root = 0;
ComputeSubtree(root);
// computing the answer for the root. (node 0, for example, it doesn't matter
// at all)
int root_answer = fact[n];
for (int i = 0; i < n; i += 1) {
root_answer = 1LL * root_answer * inv_number[subtree_size[i]] % kMod;
}
Solve(root, root_answer);
for (int i = 0; i < n; ++i) {
cout << v[i] << endl;
}
return 0;
}
| replace | 82 | 83 | 82 | 83 | 0 | |
p02728 | C++ | Runtime Error | #include <iostream>
#include <vector>
long long pow(long long n, long long p, long long k) { // n^k(mod p)
if (!k)
return 1;
long long a = pow(n, p, k >> 1);
a = a * a % p;
if (k & 1)
a = a * n % p;
return a;
}
void euclid(long long &a, long long &b, long long p) { // a>=b A*b+B*(a-a/b*b)=1
if (a == 1) {
a = 1;
} else {
long long A = b, B = a % b;
euclid(A, B, p);
b = (A - (p + a / b) % p * B % p + p) % p;
a = B;
}
}
long long rev(long long n, long long p) { // nの逆元 n*x-p*y=1
// long long q = p;
// euclid(p, n, p);
// return n % q;
return pow(n, p, p - 2);
}
long long bino(long long n, long long m, long long p) { // nCm(mod p)
long long ans = 1, div = 1;
for (int i = 0; i < m; i++) {
ans = (n - i) * ans % p;
div = div * (i + 1) % p;
}
return ans * rev(div, p) % p;
}
struct modint {
long long num;
long long p;
modint() {
num = 0;
p = 1000000007;
}
modint(int x) {
p = 1000000007;
num = (long long)x % p;
}
modint(long long x) {
p = 1000000007;
num = x % p;
}
modint operator+(const modint &other) {
modint ret;
ret.p = p;
ret.num = (num + other.num) % p;
return ret;
}
modint operator+(const long long &other) {
modint ret;
ret.p = p;
ret.num = (num + (other % p)) % p;
return ret;
}
modint operator-(const modint &other) {
modint ret;
ret.p = p;
ret.num = (num - other.num + p) % p;
return ret;
}
modint operator-(const long long &other) {
modint ret;
ret.p = p;
ret.num = (num - (other % p) + p) % p;
return ret;
}
modint operator*(const modint &other) {
modint ret;
ret.p = p;
ret.num = (num * other.num) % p;
return ret;
}
modint operator*(const long long &other) {
modint ret;
ret.p = p;
ret.num = (num * (other % p)) % p;
return ret;
}
modint operator/(const modint &other) {
modint ret;
ret.p = p;
ret.num = (num * rev(other.num, p)) % p;
return ret;
}
modint operator/(const long long &other) {
modint ret;
ret.p = p;
ret.num = (num * rev(other % p, p)) % p;
return ret;
}
void operator+=(const long long &other) { num = (num + other) % p; }
void operator+=(const modint &other) { num = (num + other.num) % p; }
void operator-=(const long long &other) { num = (num - other + p) % p; }
void operator-=(const modint &other) { num = (num - other.num + p) % p; }
void operator*=(const long long &other) { num = (num * other) % p; }
void operator*=(const modint &other) { num = (num * other.num) % p; }
};
std::ostream &operator<<(std::ostream &os, const modint &x) {
std::cout << x.num;
return os;
}
using namespace std;
struct combination {
vector<modint> li;
vector<modint> rev;
combination(int size = 202000) {
li = vector<modint>(size);
rev = vector<modint>(size);
li[0] = 1;
for (int i = 1; i < size; i++)
li[i] = li[i - 1] * i;
rev.back() = modint(1) / li.back();
for (int i = size - 1; i > 0; i--)
rev[i - 1] = rev[i] * i;
}
modint nCk(int n, int k) {
if (k <= 0 || n <= k)
return 1;
return li[n] * rev[k] * rev[n - k];
}
} comb(20);
struct DP {
modint c;
int t;
DP() {
c = modint(1);
t = 0;
}
void operator+=(const DP &other) {
t += other.t;
c *= comb.nCk(t, other.t) * other.c;
}
DP operator+(const DP &other) {
DP ret;
ret.t = other.t + t;
ret.c = c * comb.nCk(ret.t, other.t) * other.c;
return ret;
}
DP operator-(const DP &other) {
DP ret(*this);
ret.c = ret.c / (comb.nCk(t, other.t) * other.c);
ret.t -= other.t;
return ret;
}
DP addroot() {
DP ret(*this);
ret.t++;
return ret;
}
};
void dfs1(int child, vector<vector<int>> &da, vector<DP> &ans, int pare = -1) {
for (int i = 0; i < da[child].size(); i++) {
if (da[child][i] == pare)
continue;
dfs1(da[child][i], da, ans, child);
ans[child] += ans[da[child][i]].addroot();
}
}
void dfs2(int child, vector<vector<int>> &da, vector<DP> &ans,
const DP &dp = DP(), int pare = -1) {
if (pare != -1)
ans[child] += dp;
int size = da[child].size();
vector<DP> dpL(size + 1), dpR(size + 1);
for (int i = 0; i < size; i++) {
dpL[i + 1] = dpL[i];
if (da[child][i] == pare)
dpL[i + 1] += dp;
else
dpL[i + 1] += ans[da[child][i]].addroot();
}
for (int i = size; i > 0; i--) {
dpR[i - 1] = dpR[i];
if (da[child][i - 1] == pare)
dpR[i - 1] += dp;
else
dpR[i - 1] += ans[da[child][i - 1]].addroot();
}
for (int i = 0; i < size; i++) {
int next = da[child][i];
if (next == pare)
continue;
// printf("%d %d\n",child, next);
dfs2(next, da, ans, (dpL[i] + dpR[i + 1]).addroot(), child);
}
}
void rooting(vector<vector<int>> &da, vector<DP> &ans) {
dfs1(0, da, ans);
dfs2(0, da, ans);
}
int main() {
int n;
cin >> n;
vector<vector<int>> da(n, vector<int>(0));
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
da[a].push_back(b);
da[b].push_back(a);
}
vector<DP> ans(n);
rooting(da, ans);
for (int i = 0; i < n; i++)
cout << ans[i].c << endl;
} | #include <iostream>
#include <vector>
long long pow(long long n, long long p, long long k) { // n^k(mod p)
if (!k)
return 1;
long long a = pow(n, p, k >> 1);
a = a * a % p;
if (k & 1)
a = a * n % p;
return a;
}
void euclid(long long &a, long long &b, long long p) { // a>=b A*b+B*(a-a/b*b)=1
if (a == 1) {
a = 1;
} else {
long long A = b, B = a % b;
euclid(A, B, p);
b = (A - (p + a / b) % p * B % p + p) % p;
a = B;
}
}
long long rev(long long n, long long p) { // nの逆元 n*x-p*y=1
// long long q = p;
// euclid(p, n, p);
// return n % q;
return pow(n, p, p - 2);
}
long long bino(long long n, long long m, long long p) { // nCm(mod p)
long long ans = 1, div = 1;
for (int i = 0; i < m; i++) {
ans = (n - i) * ans % p;
div = div * (i + 1) % p;
}
return ans * rev(div, p) % p;
}
struct modint {
long long num;
long long p;
modint() {
num = 0;
p = 1000000007;
}
modint(int x) {
p = 1000000007;
num = (long long)x % p;
}
modint(long long x) {
p = 1000000007;
num = x % p;
}
modint operator+(const modint &other) {
modint ret;
ret.p = p;
ret.num = (num + other.num) % p;
return ret;
}
modint operator+(const long long &other) {
modint ret;
ret.p = p;
ret.num = (num + (other % p)) % p;
return ret;
}
modint operator-(const modint &other) {
modint ret;
ret.p = p;
ret.num = (num - other.num + p) % p;
return ret;
}
modint operator-(const long long &other) {
modint ret;
ret.p = p;
ret.num = (num - (other % p) + p) % p;
return ret;
}
modint operator*(const modint &other) {
modint ret;
ret.p = p;
ret.num = (num * other.num) % p;
return ret;
}
modint operator*(const long long &other) {
modint ret;
ret.p = p;
ret.num = (num * (other % p)) % p;
return ret;
}
modint operator/(const modint &other) {
modint ret;
ret.p = p;
ret.num = (num * rev(other.num, p)) % p;
return ret;
}
modint operator/(const long long &other) {
modint ret;
ret.p = p;
ret.num = (num * rev(other % p, p)) % p;
return ret;
}
void operator+=(const long long &other) { num = (num + other) % p; }
void operator+=(const modint &other) { num = (num + other.num) % p; }
void operator-=(const long long &other) { num = (num - other + p) % p; }
void operator-=(const modint &other) { num = (num - other.num + p) % p; }
void operator*=(const long long &other) { num = (num * other) % p; }
void operator*=(const modint &other) { num = (num * other.num) % p; }
};
std::ostream &operator<<(std::ostream &os, const modint &x) {
std::cout << x.num;
return os;
}
using namespace std;
struct combination {
vector<modint> li;
vector<modint> rev;
combination(int size = 202000) {
li = vector<modint>(size);
rev = vector<modint>(size);
li[0] = 1;
for (int i = 1; i < size; i++)
li[i] = li[i - 1] * i;
rev.back() = modint(1) / li.back();
for (int i = size - 1; i > 0; i--)
rev[i - 1] = rev[i] * i;
}
modint nCk(int n, int k) {
if (k <= 0 || n <= k)
return 1;
return li[n] * rev[k] * rev[n - k];
}
} comb(202000);
struct DP {
modint c;
int t;
DP() {
c = modint(1);
t = 0;
}
void operator+=(const DP &other) {
t += other.t;
c *= comb.nCk(t, other.t) * other.c;
}
DP operator+(const DP &other) {
DP ret;
ret.t = other.t + t;
ret.c = c * comb.nCk(ret.t, other.t) * other.c;
return ret;
}
DP operator-(const DP &other) {
DP ret(*this);
ret.c = ret.c / (comb.nCk(t, other.t) * other.c);
ret.t -= other.t;
return ret;
}
DP addroot() {
DP ret(*this);
ret.t++;
return ret;
}
};
void dfs1(int child, vector<vector<int>> &da, vector<DP> &ans, int pare = -1) {
for (int i = 0; i < da[child].size(); i++) {
if (da[child][i] == pare)
continue;
dfs1(da[child][i], da, ans, child);
ans[child] += ans[da[child][i]].addroot();
}
}
void dfs2(int child, vector<vector<int>> &da, vector<DP> &ans,
const DP &dp = DP(), int pare = -1) {
if (pare != -1)
ans[child] += dp;
int size = da[child].size();
vector<DP> dpL(size + 1), dpR(size + 1);
for (int i = 0; i < size; i++) {
dpL[i + 1] = dpL[i];
if (da[child][i] == pare)
dpL[i + 1] += dp;
else
dpL[i + 1] += ans[da[child][i]].addroot();
}
for (int i = size; i > 0; i--) {
dpR[i - 1] = dpR[i];
if (da[child][i - 1] == pare)
dpR[i - 1] += dp;
else
dpR[i - 1] += ans[da[child][i - 1]].addroot();
}
for (int i = 0; i < size; i++) {
int next = da[child][i];
if (next == pare)
continue;
// printf("%d %d\n",child, next);
dfs2(next, da, ans, (dpL[i] + dpR[i + 1]).addroot(), child);
}
}
void rooting(vector<vector<int>> &da, vector<DP> &ans) {
dfs1(0, da, ans);
dfs2(0, da, ans);
}
int main() {
int n;
cin >> n;
vector<vector<int>> da(n, vector<int>(0));
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
da[a].push_back(b);
da[b].push_back(a);
}
vector<DP> ans(n);
rooting(da, ans);
for (int i = 0; i < n; i++)
cout << ans[i].c << endl;
}
| replace | 131 | 132 | 131 | 132 | 0 | |
p02728 | C++ | Time Limit Exceeded | /*
This code has been written by MinakoKojima, feel free to ask me question.
Blog: http://www.shuizilong.com/house Template Date: 2015.10.12 Note: ...
*/
#pragma comment(linker, "/STACK:36777216")
// #pragma GCC optimize ("O2")
#define LOCAL
#include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
// #include <tr1/unordered_set>
// #include <tr1/unordered_map>
// #include <array>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; ++i)
#define FOR(i, a, b) for (int i = a; i < b; ++i)
#define DWN(i, b, a) for (int i = b - 1; i >= a; --i)
#define REP_1(i, n) for (int i = 1; i <= n; ++i)
#define FOR_1(i, a, b) for (int i = a; i <= b; ++i)
#define DWN_1(i, b, a) for (int i = b; i >= a; --i)
#define REP_C(i, n) for (int n____ = n, i = 0; i < n____; ++i)
#define FOR_C(i, a, b) for (int b____ = b, i = a; i < b____; ++i)
#define DWN_C(i, b, a) for (int a____ = a, i = b - 1; i >= a____; --i)
#define REP_N(i, n) for (i = 0; i < n; ++i)
#define FOR_N(i, a, b) for (i = a; i < b; ++i)
#define DWN_N(i, b, a) for (i = b - 1; i >= a; --i)
#define REP_1_C(i, n) for (int n____ = n, i = 1; i <= n____; ++i)
#define FOR_1_C(i, a, b) for (int b____ = b, i = a; i <= b____; ++i)
#define DWN_1_C(i, b, a) for (int a____ = a, i = b; i >= a____; --i)
#define REP_1_N(i, n) for (i = 1; i <= n; ++i)
#define FOR_1_N(i, a, b) for (i = a; i <= b; ++i)
#define DWN_1_N(i, b, a) for (i = b; i >= a; --i)
#define REP_C_N(i, n) for (int n____ = (i = 0, n); i < n____; ++i)
#define FOR_C_N(i, a, b) for (int b____ = (i = 0, b); i < b____; ++i)
#define DWN_C_N(i, b, a) for (int a____ = (i = b - 1, a); i >= a____; --i)
#define REP_1_C_N(i, n) for (int n____ = (i = 1, n); i <= n____; ++i)
#define FOR_1_C_N(i, a, b) for (int b____ = (i = a, b); i <= b____; ++i)
#define DWN_1_C_N(i, b, a) for (int a____ = (i = b, a); i >= a____; --i)
#define ECH(it, A) \
for (__typeof((A).begin()) it = (A).begin(); it != (A).end(); ++it)
#define rECH(it, A) \
for (__typeof((A).rbegin()) it = (A).rbegin(); it != (A).rend(); ++it)
#define REP_S(i, str) for (char *i = str; *i; ++i)
#define REP_L(i, hd, suc) for (int i = hd; i; i = suc[i])
#define REP_G(i, u) REP_L(i, hd[u], suc)
#define REP_SS(x, s) for (int x = s; x; x = (x - 1) & s)
#define DO(n) for (int ____n = n; ____n-- > 0;)
#define REP_2(i, j, n, m) REP(i, n) REP(j, m)
#define REP_2_1(i, j, n, m) REP_1(i, n) REP_1(j, m)
#define REP_3(i, j, k, n, m, l) REP(i, n) REP(j, m) REP(k, l)
#define REP_3_1(i, j, k, n, m, l) REP_1(i, n) REP_1(j, m) REP_1(k, l)
#define REP_4(i, j, k, ii, n, m, l, nn) \
REP(i, n) REP(j, m) REP(k, l) REP(ii, nn)
#define REP_4_1(i, j, k, ii, n, m, l, nn) \
REP_1(i, n) REP_1(j, m) REP_1(k, l) REP_1(ii, nn)
#define ALL(A) A.begin(), A.end()
#define LLA(A) A.rbegin(), A.rend()
#define CPY(A, B) memcpy(A, B, sizeof(A))
#define INS(A, P, B) A.insert(A.begin() + P, B)
#define ERS(A, P) A.erase(A.begin() + P)
#define LBD(A, x) (lower_bound(ALL(A), x) - A.begin())
#define UBD(A, x) (upper_bound(ALL(A), x) - A.begin())
#define CTN(T, x) (T.find(x) != T.end())
#define SZ(A) int((A).size())
#define PB push_back
#define MP(A, B) make_pair(A, B)
#define PTT pair<T, T>
#define Ts *this
#define rTs return Ts
#define fi first
#define se second
#define re real()
#define im imag()
#define Rush for (int ____T = RD(); ____T--;)
#define Display(A, n, m) \
{ \
REP(i, n) { \
REP(j, m - 1) cout << A[i][j] << " "; \
cout << A[i][m - 1] << endl; \
} \
}
#define Display_1(A, n, m) \
{ \
REP_1(i, n) { \
REP_1(j, m - 1) cout << A[i][j] << " "; \
cout << A[i][m] << endl; \
} \
}
typedef long long LL;
// typedef long double DB;
typedef double DB;
typedef unsigned uint;
typedef unsigned long long uLL;
typedef vector<int> VI;
typedef vector<char> VC;
typedef vector<string> VS;
typedef vector<LL> VL;
typedef vector<DB> VF;
typedef set<int> SI;
typedef set<string> SS;
typedef map<int, int> MII;
typedef map<string, int> MSI;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef vector<PII> VII;
typedef vector<VI> VVI;
typedef vector<VII> VVII;
template <class T> inline T &RD(T &);
template <class T> inline void OT(const T &);
// inline int RD(){int x; return RD(x);}
inline LL RD() {
LL x;
return RD(x);
}
inline DB &RF(DB &);
inline DB RF() {
DB x;
return RF(x);
}
inline char *RS(char *s);
inline char &RC(char &c);
inline char RC();
inline char &RC(char &c) {
scanf(" %c", &c);
return c;
}
inline char RC() {
char c;
return RC(c);
}
// inline char& RC(char &c){c = getchar(); return c;}
// inline char RC(){return getchar();}
template <class T> inline T &RDD(T &);
inline LL RDD() {
LL x;
return RDD(x);
}
template <class T0, class T1> inline T0 &RD(T0 &x0, T1 &x1) {
RD(x0), RD(x1);
return x0;
}
template <class T0, class T1, class T2> inline T0 &RD(T0 &x0, T1 &x1, T2 &x2) {
RD(x0), RD(x1), RD(x2);
return x0;
}
template <class T0, class T1, class T2, class T3>
inline T0 &RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3) {
RD(x0), RD(x1), RD(x2), RD(x3);
return x0;
}
template <class T0, class T1, class T2, class T3, class T4>
inline T0 &RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4) {
RD(x0), RD(x1), RD(x2), RD(x3), RD(x4);
return x0;
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline T0 &RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5) {
RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5);
return x0;
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline T0 &RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5, T6 &x6) {
RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5), RD(x6);
return x0;
}
template <class T0, class T1> inline void OT(const T0 &x0, const T1 &x1) {
OT(x0), OT(x1);
}
template <class T0, class T1, class T2>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2) {
OT(x0), OT(x1), OT(x2);
}
template <class T0, class T1, class T2, class T3>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3) {
OT(x0), OT(x1), OT(x2), OT(x3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3,
const T4 &x4) {
OT(x0), OT(x1), OT(x2), OT(x3), OT(x4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3,
const T4 &x4, const T5 &x5) {
OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3,
const T4 &x4, const T5 &x5, const T6 &x6) {
OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5), OT(x6);
}
inline char &RC(char &a, char &b) {
RC(a), RC(b);
return a;
}
inline char &RC(char &a, char &b, char &c) {
RC(a), RC(b), RC(c);
return a;
}
inline char &RC(char &a, char &b, char &c, char &d) {
RC(a), RC(b), RC(c), RC(d);
return a;
}
inline char &RC(char &a, char &b, char &c, char &d, char &e) {
RC(a), RC(b), RC(c), RC(d), RC(e);
return a;
}
inline char &RC(char &a, char &b, char &c, char &d, char &e, char &f) {
RC(a), RC(b), RC(c), RC(d), RC(e), RC(f);
return a;
}
inline char &RC(char &a, char &b, char &c, char &d, char &e, char &f, char &g) {
RC(a), RC(b), RC(c), RC(d), RC(e), RC(f), RC(g);
return a;
}
inline DB &RF(DB &a, DB &b) {
RF(a), RF(b);
return a;
}
inline DB &RF(DB &a, DB &b, DB &c) {
RF(a), RF(b), RF(c);
return a;
}
inline DB &RF(DB &a, DB &b, DB &c, DB &d) {
RF(a), RF(b), RF(c), RF(d);
return a;
}
inline DB &RF(DB &a, DB &b, DB &c, DB &d, DB &e) {
RF(a), RF(b), RF(c), RF(d), RF(e);
return a;
}
inline DB &RF(DB &a, DB &b, DB &c, DB &d, DB &e, DB &f) {
RF(a), RF(b), RF(c), RF(d), RF(e), RF(f);
return a;
}
inline DB &RF(DB &a, DB &b, DB &c, DB &d, DB &e, DB &f, DB &g) {
RF(a), RF(b), RF(c), RF(d), RF(e), RF(f), RF(g);
return a;
}
inline void RS(char *s1, char *s2) { RS(s1), RS(s2); }
inline void RS(char *s1, char *s2, char *s3) { RS(s1), RS(s2), RS(s3); }
template <class T0, class T1> inline T0 &RDD(T0 &a, T1 &b) {
RDD(a), RDD(b);
return a;
}
template <class T0, class T1, class T2> inline T1 &RDD(T0 &a, T1 &b, T2 &c) {
RDD(a), RDD(b), RDD(c);
return a;
}
template <class T> inline void RST(T &A) { memset(A, 0, sizeof(A)); }
template <class T> inline void FLC(T &A, int x) { memset(A, x, sizeof(A)); }
template <class T> inline void CLR(T &A) { A.clear(); }
template <class T0, class T1> inline void RST(T0 &A0, T1 &A1) {
RST(A0), RST(A1);
}
template <class T0, class T1, class T2>
inline void RST(T0 &A0, T1 &A1, T2 &A2) {
RST(A0), RST(A1), RST(A2);
}
template <class T0, class T1, class T2, class T3>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3) {
RST(A0), RST(A1), RST(A2), RST(A3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) {
RST(A0), RST(A1), RST(A2), RST(A3), RST(A4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) {
RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) {
RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5), RST(A6);
}
template <class T0, class T1> inline void FLC(T0 &A0, T1 &A1, int x) {
FLC(A0, x), FLC(A1, x);
}
template <class T0, class T1, class T2>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x);
}
template <class T0, class T1, class T2, class T3>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x), FLC(A5, x);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x), FLC(A5, x),
FLC(A6, x);
}
template <class T> inline void CLR(priority_queue<T> &Q) {
while (!Q.empty())
Q.pop();
}
template <class T> inline void CLR(stack<T> &S) {
while (!S.empty())
S.pop();
}
template <class T> inline void CLR(queue<T> &Q) {
while (!Q.empty())
Q.pop();
}
template <class T0, class T1> inline void CLR(T0 &A0, T1 &A1) {
CLR(A0), CLR(A1);
}
template <class T0, class T1, class T2>
inline void CLR(T0 &A0, T1 &A1, T2 &A2) {
CLR(A0), CLR(A1), CLR(A2);
}
template <class T0, class T1, class T2, class T3>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5), CLR(A6);
}
template <class T> inline void CLR(T &A, int n) { REP(i, n) CLR(A[i]); }
template <class T> inline bool EPT(T &a) { return a.empty(); }
template <class T> inline T &SRT(T &A) {
sort(ALL(A));
return A;
}
template <class T, class C> inline T &SRT(T &A, C cmp) {
sort(ALL(A), cmp);
return A;
}
template <class T> inline T &RVS(T &A) {
reverse(ALL(A));
return A;
}
template <class T> inline T &UNQQ(T &A) {
A.resize(unique(ALL(A)) - A.begin());
return A;
}
template <class T> inline T &UNQ(T &A) {
SRT(A);
return UNQQ(A);
}
template <class T, class C> inline T &UNQ(T &A, C cmp) {
SRT(A, cmp);
return UNQQ(A);
}
//}
/** Constant List .. **/ //{
const int MOD = int(1e9) + 7;
const int INF = 0x3f3f3f3f;
const LL INFF = 0x3f3f3f3f3f3f3f3fLL;
const DB EPS = 1e-9;
const DB OO = 1e20;
const DB PI = acos(-1.0); // M_PI;
const int dx[] = {-1, 1, 0, 0};
const int dy[] = {0, 0, 1, -1};
//}
/** Add On .. **/ //{
// <<= '0. Nichi Joo ., //{
template <class T> inline bool checkMin(T &a, const T b) {
return b < a ? a = b, 1 : 0;
}
template <class T> inline bool checkMax(T &a, const T b) {
return a < b ? a = b, 1 : 0;
}
template <class T, class C> inline bool checkUpd(T &a, const T b, C c) {
return c(b, a) ? a = b, 1 : 0;
}
template <class T> inline T min(T a, T b, T c) { return min(min(a, b), c); }
template <class T> inline T max(T a, T b, T c) { return max(max(a, b), c); }
template <class T> inline T min(T a, T b, T c, T d) {
return min(min(a, b), min(c, d));
}
template <class T> inline T max(T a, T b, T c, T d) {
return max(max(a, b), max(c, d));
}
template <class T> inline T min(T a, T b, T c, T d, T e) {
return min(min(min(a, b), min(c, d)), e);
}
template <class T> inline T max(T a, T b, T c, T d, T e) {
return max(max(max(a, b), max(c, d)), e);
}
template <class T> inline T sqr(T a) { return a * a; }
template <class T> inline T cub(T a) { return a * a * a; }
template <class T> inline T ceil(T x, T y) { return (x - 1) / y + 1; }
template <class T> T abs(T x) { return x > 0 ? x : -x; }
inline int sgn(DB x) { return x < -EPS ? -1 : x > EPS; }
inline int sgn(DB x, DB y) { return sgn(x - y); }
inline DB cos(DB a, DB b, DB c) {
return (sqr(a) + sqr(b) - sqr(c)) / (2 * a * b);
}
inline DB cot(DB x) { return 1. / tan(x); };
inline DB sec(DB x) { return 1. / cos(x); };
inline DB csc(DB x) { return 1. / sin(x); };
//}
// <<= '1. Bitwise Operation ., //{
namespace BO {
inline bool _1(int x, int i) { return bool(x & 1 << i); }
inline bool _1(LL x, int i) { return bool(x & 1LL << i); }
inline LL _1(int i) { return 1LL << i; }
inline LL _U(int i) { return _1(i) - 1; };
inline int reverse_bits(int x) {
x = ((x >> 1) & 0x55555555) | ((x << 1) & 0xaaaaaaaa);
x = ((x >> 2) & 0x33333333) | ((x << 2) & 0xcccccccc);
x = ((x >> 4) & 0x0f0f0f0f) | ((x << 4) & 0xf0f0f0f0);
x = ((x >> 8) & 0x00ff00ff) | ((x << 8) & 0xff00ff00);
x = ((x >> 16) & 0x0000ffff) | ((x << 16) & 0xffff0000);
return x;
}
inline LL reverse_bits(LL x) {
x = ((x >> 1) & 0x5555555555555555LL) | ((x << 1) & 0xaaaaaaaaaaaaaaaaLL);
x = ((x >> 2) & 0x3333333333333333LL) | ((x << 2) & 0xccccccccccccccccLL);
x = ((x >> 4) & 0x0f0f0f0f0f0f0f0fLL) | ((x << 4) & 0xf0f0f0f0f0f0f0f0LL);
x = ((x >> 8) & 0x00ff00ff00ff00ffLL) | ((x << 8) & 0xff00ff00ff00ff00LL);
x = ((x >> 16) & 0x0000ffff0000ffffLL) | ((x << 16) & 0xffff0000ffff0000LL);
x = ((x >> 32) & 0x00000000ffffffffLL) | ((x << 32) & 0xffffffff00000000LL);
return x;
}
template <class T> inline bool odd(T x) { return x & 1; }
template <class T> inline bool even(T x) { return !odd(x); }
template <class T> inline T low_bit(T x) { return x & -x; }
template <class T> inline T high_bit(T x) {
T p = low_bit(x);
while (p != x)
x -= p, p = low_bit(x);
return p;
}
template <class T> inline T cover_bit(T x) {
T p = 1;
while (p < x)
p <<= 1;
return p;
}
template <class T> inline int cover_idx(T x) {
int p = 0;
while (_1(p) < x)
++p;
return p;
}
inline int clz(int x) { return __builtin_clz(x); }
inline int clz(LL x) { return __builtin_clzll(x); }
inline int ctz(int x) { return __builtin_ctz(x); }
inline int ctz(LL x) { return __builtin_ctzll(x); }
inline int lg2(int x) { return !x ? -1 : 31 - clz(x); }
inline int lg2(LL x) { return !x ? -1 : 63 - clz(x); }
inline int low_idx(int x) { return !x ? -1 : ctz(x); }
inline int low_idx(LL x) { return !x ? -1 : ctz(x); }
inline int high_idx(int x) { return lg2(x); }
inline int high_idx(LL x) { return lg2(x); }
inline int parity(int x) { return __builtin_parity(x); }
inline int parity(LL x) { return __builtin_parityll(x); }
inline int count_bits(int x) { return __builtin_popcount(x); }
inline int count_bits(LL x) { return __builtin_popcountll(x); }
} // namespace BO
using namespace BO; //}
// <<= '2. Number Theory .,//{
namespace NT {
#define gcd __gcd
inline LL lcm(LL a, LL b) { return a * b / gcd(a, b); }
inline void INC(int &a, int b) {
a += b;
if (a >= MOD)
a -= MOD;
}
inline int sum(int a, int b) {
a += b;
if (a >= MOD)
a -= MOD;
return a;
}
/* 模数两倍刚好超 int 时。
inline int sum(uint a, int b){a += b; a %= MOD;if (a < 0) a += MOD; return a;}
inline void INC(int &a, int b){a = sum(a, b);}
*/
inline void DEC(int &a, int b) {
a -= b;
if (a < 0)
a += MOD;
}
inline int dff(int a, int b) {
a -= b;
if (a < 0)
a += MOD;
return a;
}
inline void MUL(int &a, int b) { a = (LL)a * b % MOD; }
// inline int pdt(int a, int b){return (LL)a * b % MOD;}
inline int pdt(int x, int y) {
int ret;
__asm__ __volatile__("\tmull %%ebx\n\tdivl %%ecx\n"
: "=d"(ret)
: "a"(x), "b"(y), "c"(MOD));
return ret;
}
inline int gcd(int m, int n, int &x, int &y) {
x = 1, y = 0;
int xx = 0, yy = 1, q;
while (1) {
q = m / n, m %= n;
if (!m) {
x = xx, y = yy;
return n;
}
DEC(x, pdt(q, xx)), DEC(y, pdt(q, yy));
q = n / m, n %= m;
if (!n)
return m;
DEC(xx, pdt(q, x)), DEC(yy, pdt(q, y));
}
}
inline int sum(int a, int b, int c) { return sum(a, sum(b, c)); }
inline int sum(int a, int b, int c, int d) { return sum(sum(a, b), sum(c, d)); }
inline int pdt(int a, int b, int c) { return pdt(a, pdt(b, c)); }
inline int pdt(int a, int b, int c, int d) { return pdt(pdt(a, b), pdt(c, d)); }
inline int pow(int a, LL b) {
int c(1);
while (b) {
if (b & 1)
MUL(c, a);
MUL(a, a), b >>= 1;
}
return c;
}
template <class T> inline T pow(T a, LL b) {
T c(1);
while (b) {
if (b & 1)
c *= a;
a *= a, b >>= 1;
}
return c;
}
template <class T> inline T pow(T a, int b) { return pow(a, (LL)b); }
inline int _I(int b) {
int a = MOD, x1 = 0, x2 = 1, q;
while (1) {
q = a / b, a %= b;
if (!a)
return x2;
DEC(x1, pdt(q, x2));
q = b / a, b %= a;
if (!b)
return x1;
DEC(x2, pdt(q, x1));
}
}
inline void DIV(int &a, int b) { MUL(a, _I(b)); }
inline int qtt(int a, int b) { return pdt(a, _I(b)); }
struct Int {
int val;
operator int() const { return val; }
Int(int _val = 0) : val(_val) {
val %= MOD;
if (val < 0)
val += MOD;
}
Int(LL _val) : val(_val) {
_val %= MOD;
if (_val < 0)
_val += MOD;
val = _val;
}
Int &operator+=(const int &rhs) {
INC(val, rhs);
rTs;
}
Int operator+(const int &rhs) const { return sum(val, rhs); }
Int &operator-=(const int &rhs) {
DEC(val, rhs);
rTs;
}
Int operator-(const int &rhs) const { return dff(val, rhs); }
Int &operator*=(const int &rhs) {
MUL(val, rhs);
rTs;
}
Int operator*(const int &rhs) const { return pdt(val, rhs); }
Int &operator/=(const int &rhs) {
DIV(val, rhs);
rTs;
}
Int operator/(const int &rhs) const { return qtt(val, rhs); }
Int operator-() const { return MOD - *this; }
};
} // namespace NT
using namespace NT; //}
//}
/** I/O Accelerator Interface .. **/ //{
#define g (c = getchar())
#define d isdigit(g)
#define p x = x * 10 + c - '0'
#define n x = x * 10 + '0' - c
#define pp l /= 10, p
#define nn l /= 10, n
template <class T> inline T &RD(T &x) {
char c;
while (!d)
;
x = c - '0';
while (d)
p;
return x;
}
template <class T> inline T &RDD(T &x) {
char c;
while (g, c != '-' && !isdigit(c))
;
if (c == '-') {
x = '0' - g;
while (d)
n;
} else {
x = c - '0';
while (d)
p;
}
return x;
}
inline DB &RF(DB &x) {
// scanf("%lf", &x);
char c;
while (g, c != '-' && c != '.' && !isdigit(c))
;
if (c == '-')
if (g == '.') {
x = 0;
DB l = 1;
while (d)
nn;
x *= l;
} else {
x = '0' - c;
while (d)
n;
if (c == '.') {
DB l = 1;
while (d)
nn;
x *= l;
}
}
else if (c == '.') {
x = 0;
DB l = 1;
while (d)
pp;
x *= l;
} else {
x = c - '0';
while (d)
p;
if (c == '.') {
DB l = 1;
while (d)
pp;
x *= l;
}
}
return x;
}
#undef nn
#undef pp
#undef n
#undef p
#undef d
#undef g
inline char *RS(char *s) {
// gets(s);
scanf("%s", s);
return s;
}
LL last_ans;
int Case;
template <class T> inline void OT(const T &x) {
// printf("Case #%d: ", ++Case);
// printf("%lld\n", x);
// printf("%I64d\n", x);
// printf("%.9f\n", x);
// printf("%d\n", x);
cout << x << endl;
// last_ans = x;
}
//}/*
//..................................................................................................................................
//*/
const int N = int(2e5) + 9;
Int Fact[N];
VI adj[N];
int sz[N];
Int f[N];
int n;
Int Binom(int n, int m) { return Fact[n] / (Fact[m] * Fact[n - m]); }
void dfs0(int u = 1, int p = -1) {
f[u] = 1;
Int szv = 1;
for (auto v : adj[u])
if (v != p) {
dfs0(v, u);
sz[u] += sz[v];
f[u] *= f[v];
szv *= Fact[sz[v]];
}
f[u] *= Fact[sz[u]] / szv;
sz[u] += 1;
}
// a
// u a
// v a
void dfs1(int u = 1, int p = -1) {
for (auto v : adj[u])
if (v != p) {
f[v] *=
(f[u] / f[v] / Fact[(n - 1)] * Fact[sz[v]] * Fact[(n - sz[v] - 1)]);
f[v] *= Fact[(n - 1)] / Fact[(sz[v] - 1)];
f[v] /= Fact[n - sz[v]];
// cout << " " << sz[u]-sz[v] << " " << f[v] << endl;
// f[v] *= (f[u] / f[v]) / Fact[sz[u]-sz[v]];
dfs1(v, u); // sz[u] += sz[v];
// f[u] *= f[v]; szv *= Fact[sz[v]];
}
// f[u] *= Fact[sz[u]] / szv;
// sz[u] += 1;
}
int main() {
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
// freopen("/Users/minakokojima/Documents/GitHub/ACM-Training/Workspace/out.txt",
// "w", stdout);
#endif
Fact[0] = 1;
FOR(i, 1, N) Fact[i] = Fact[i - 1] * i;
RD(n);
DO(n - 1) {
int a, b;
RD(a, b);
adj[a].PB(b);
adj[b].PB(a);
}
dfs0();
dfs1();
REP_1(i, n) { cout << f[i] << endl; }
}
| /*
This code has been written by MinakoKojima, feel free to ask me question.
Blog: http://www.shuizilong.com/house Template Date: 2015.10.12 Note: ...
*/
#pragma comment(linker, "/STACK:36777216")
// #pragma GCC optimize ("O2")
#define LOCAL
#include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
// #include <tr1/unordered_set>
// #include <tr1/unordered_map>
// #include <array>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; ++i)
#define FOR(i, a, b) for (int i = a; i < b; ++i)
#define DWN(i, b, a) for (int i = b - 1; i >= a; --i)
#define REP_1(i, n) for (int i = 1; i <= n; ++i)
#define FOR_1(i, a, b) for (int i = a; i <= b; ++i)
#define DWN_1(i, b, a) for (int i = b; i >= a; --i)
#define REP_C(i, n) for (int n____ = n, i = 0; i < n____; ++i)
#define FOR_C(i, a, b) for (int b____ = b, i = a; i < b____; ++i)
#define DWN_C(i, b, a) for (int a____ = a, i = b - 1; i >= a____; --i)
#define REP_N(i, n) for (i = 0; i < n; ++i)
#define FOR_N(i, a, b) for (i = a; i < b; ++i)
#define DWN_N(i, b, a) for (i = b - 1; i >= a; --i)
#define REP_1_C(i, n) for (int n____ = n, i = 1; i <= n____; ++i)
#define FOR_1_C(i, a, b) for (int b____ = b, i = a; i <= b____; ++i)
#define DWN_1_C(i, b, a) for (int a____ = a, i = b; i >= a____; --i)
#define REP_1_N(i, n) for (i = 1; i <= n; ++i)
#define FOR_1_N(i, a, b) for (i = a; i <= b; ++i)
#define DWN_1_N(i, b, a) for (i = b; i >= a; --i)
#define REP_C_N(i, n) for (int n____ = (i = 0, n); i < n____; ++i)
#define FOR_C_N(i, a, b) for (int b____ = (i = 0, b); i < b____; ++i)
#define DWN_C_N(i, b, a) for (int a____ = (i = b - 1, a); i >= a____; --i)
#define REP_1_C_N(i, n) for (int n____ = (i = 1, n); i <= n____; ++i)
#define FOR_1_C_N(i, a, b) for (int b____ = (i = a, b); i <= b____; ++i)
#define DWN_1_C_N(i, b, a) for (int a____ = (i = b, a); i >= a____; --i)
#define ECH(it, A) \
for (__typeof((A).begin()) it = (A).begin(); it != (A).end(); ++it)
#define rECH(it, A) \
for (__typeof((A).rbegin()) it = (A).rbegin(); it != (A).rend(); ++it)
#define REP_S(i, str) for (char *i = str; *i; ++i)
#define REP_L(i, hd, suc) for (int i = hd; i; i = suc[i])
#define REP_G(i, u) REP_L(i, hd[u], suc)
#define REP_SS(x, s) for (int x = s; x; x = (x - 1) & s)
#define DO(n) for (int ____n = n; ____n-- > 0;)
#define REP_2(i, j, n, m) REP(i, n) REP(j, m)
#define REP_2_1(i, j, n, m) REP_1(i, n) REP_1(j, m)
#define REP_3(i, j, k, n, m, l) REP(i, n) REP(j, m) REP(k, l)
#define REP_3_1(i, j, k, n, m, l) REP_1(i, n) REP_1(j, m) REP_1(k, l)
#define REP_4(i, j, k, ii, n, m, l, nn) \
REP(i, n) REP(j, m) REP(k, l) REP(ii, nn)
#define REP_4_1(i, j, k, ii, n, m, l, nn) \
REP_1(i, n) REP_1(j, m) REP_1(k, l) REP_1(ii, nn)
#define ALL(A) A.begin(), A.end()
#define LLA(A) A.rbegin(), A.rend()
#define CPY(A, B) memcpy(A, B, sizeof(A))
#define INS(A, P, B) A.insert(A.begin() + P, B)
#define ERS(A, P) A.erase(A.begin() + P)
#define LBD(A, x) (lower_bound(ALL(A), x) - A.begin())
#define UBD(A, x) (upper_bound(ALL(A), x) - A.begin())
#define CTN(T, x) (T.find(x) != T.end())
#define SZ(A) int((A).size())
#define PB push_back
#define MP(A, B) make_pair(A, B)
#define PTT pair<T, T>
#define Ts *this
#define rTs return Ts
#define fi first
#define se second
#define re real()
#define im imag()
#define Rush for (int ____T = RD(); ____T--;)
#define Display(A, n, m) \
{ \
REP(i, n) { \
REP(j, m - 1) cout << A[i][j] << " "; \
cout << A[i][m - 1] << endl; \
} \
}
#define Display_1(A, n, m) \
{ \
REP_1(i, n) { \
REP_1(j, m - 1) cout << A[i][j] << " "; \
cout << A[i][m] << endl; \
} \
}
typedef long long LL;
// typedef long double DB;
typedef double DB;
typedef unsigned uint;
typedef unsigned long long uLL;
typedef vector<int> VI;
typedef vector<char> VC;
typedef vector<string> VS;
typedef vector<LL> VL;
typedef vector<DB> VF;
typedef set<int> SI;
typedef set<string> SS;
typedef map<int, int> MII;
typedef map<string, int> MSI;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef vector<PII> VII;
typedef vector<VI> VVI;
typedef vector<VII> VVII;
template <class T> inline T &RD(T &);
template <class T> inline void OT(const T &);
// inline int RD(){int x; return RD(x);}
inline LL RD() {
LL x;
return RD(x);
}
inline DB &RF(DB &);
inline DB RF() {
DB x;
return RF(x);
}
inline char *RS(char *s);
inline char &RC(char &c);
inline char RC();
inline char &RC(char &c) {
scanf(" %c", &c);
return c;
}
inline char RC() {
char c;
return RC(c);
}
// inline char& RC(char &c){c = getchar(); return c;}
// inline char RC(){return getchar();}
template <class T> inline T &RDD(T &);
inline LL RDD() {
LL x;
return RDD(x);
}
template <class T0, class T1> inline T0 &RD(T0 &x0, T1 &x1) {
RD(x0), RD(x1);
return x0;
}
template <class T0, class T1, class T2> inline T0 &RD(T0 &x0, T1 &x1, T2 &x2) {
RD(x0), RD(x1), RD(x2);
return x0;
}
template <class T0, class T1, class T2, class T3>
inline T0 &RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3) {
RD(x0), RD(x1), RD(x2), RD(x3);
return x0;
}
template <class T0, class T1, class T2, class T3, class T4>
inline T0 &RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4) {
RD(x0), RD(x1), RD(x2), RD(x3), RD(x4);
return x0;
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline T0 &RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5) {
RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5);
return x0;
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline T0 &RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5, T6 &x6) {
RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5), RD(x6);
return x0;
}
template <class T0, class T1> inline void OT(const T0 &x0, const T1 &x1) {
OT(x0), OT(x1);
}
template <class T0, class T1, class T2>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2) {
OT(x0), OT(x1), OT(x2);
}
template <class T0, class T1, class T2, class T3>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3) {
OT(x0), OT(x1), OT(x2), OT(x3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3,
const T4 &x4) {
OT(x0), OT(x1), OT(x2), OT(x3), OT(x4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3,
const T4 &x4, const T5 &x5) {
OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void OT(const T0 &x0, const T1 &x1, const T2 &x2, const T3 &x3,
const T4 &x4, const T5 &x5, const T6 &x6) {
OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5), OT(x6);
}
inline char &RC(char &a, char &b) {
RC(a), RC(b);
return a;
}
inline char &RC(char &a, char &b, char &c) {
RC(a), RC(b), RC(c);
return a;
}
inline char &RC(char &a, char &b, char &c, char &d) {
RC(a), RC(b), RC(c), RC(d);
return a;
}
inline char &RC(char &a, char &b, char &c, char &d, char &e) {
RC(a), RC(b), RC(c), RC(d), RC(e);
return a;
}
inline char &RC(char &a, char &b, char &c, char &d, char &e, char &f) {
RC(a), RC(b), RC(c), RC(d), RC(e), RC(f);
return a;
}
inline char &RC(char &a, char &b, char &c, char &d, char &e, char &f, char &g) {
RC(a), RC(b), RC(c), RC(d), RC(e), RC(f), RC(g);
return a;
}
inline DB &RF(DB &a, DB &b) {
RF(a), RF(b);
return a;
}
inline DB &RF(DB &a, DB &b, DB &c) {
RF(a), RF(b), RF(c);
return a;
}
inline DB &RF(DB &a, DB &b, DB &c, DB &d) {
RF(a), RF(b), RF(c), RF(d);
return a;
}
inline DB &RF(DB &a, DB &b, DB &c, DB &d, DB &e) {
RF(a), RF(b), RF(c), RF(d), RF(e);
return a;
}
inline DB &RF(DB &a, DB &b, DB &c, DB &d, DB &e, DB &f) {
RF(a), RF(b), RF(c), RF(d), RF(e), RF(f);
return a;
}
inline DB &RF(DB &a, DB &b, DB &c, DB &d, DB &e, DB &f, DB &g) {
RF(a), RF(b), RF(c), RF(d), RF(e), RF(f), RF(g);
return a;
}
inline void RS(char *s1, char *s2) { RS(s1), RS(s2); }
inline void RS(char *s1, char *s2, char *s3) { RS(s1), RS(s2), RS(s3); }
template <class T0, class T1> inline T0 &RDD(T0 &a, T1 &b) {
RDD(a), RDD(b);
return a;
}
template <class T0, class T1, class T2> inline T1 &RDD(T0 &a, T1 &b, T2 &c) {
RDD(a), RDD(b), RDD(c);
return a;
}
template <class T> inline void RST(T &A) { memset(A, 0, sizeof(A)); }
template <class T> inline void FLC(T &A, int x) { memset(A, x, sizeof(A)); }
template <class T> inline void CLR(T &A) { A.clear(); }
template <class T0, class T1> inline void RST(T0 &A0, T1 &A1) {
RST(A0), RST(A1);
}
template <class T0, class T1, class T2>
inline void RST(T0 &A0, T1 &A1, T2 &A2) {
RST(A0), RST(A1), RST(A2);
}
template <class T0, class T1, class T2, class T3>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3) {
RST(A0), RST(A1), RST(A2), RST(A3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) {
RST(A0), RST(A1), RST(A2), RST(A3), RST(A4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) {
RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) {
RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5), RST(A6);
}
template <class T0, class T1> inline void FLC(T0 &A0, T1 &A1, int x) {
FLC(A0, x), FLC(A1, x);
}
template <class T0, class T1, class T2>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x);
}
template <class T0, class T1, class T2, class T3>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x), FLC(A5, x);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6, int x) {
FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x), FLC(A5, x),
FLC(A6, x);
}
template <class T> inline void CLR(priority_queue<T> &Q) {
while (!Q.empty())
Q.pop();
}
template <class T> inline void CLR(stack<T> &S) {
while (!S.empty())
S.pop();
}
template <class T> inline void CLR(queue<T> &Q) {
while (!Q.empty())
Q.pop();
}
template <class T0, class T1> inline void CLR(T0 &A0, T1 &A1) {
CLR(A0), CLR(A1);
}
template <class T0, class T1, class T2>
inline void CLR(T0 &A0, T1 &A1, T2 &A2) {
CLR(A0), CLR(A1), CLR(A2);
}
template <class T0, class T1, class T2, class T3>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3);
}
template <class T0, class T1, class T2, class T3, class T4>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4);
}
template <class T0, class T1, class T2, class T3, class T4, class T5>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5);
}
template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) {
CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5), CLR(A6);
}
template <class T> inline void CLR(T &A, int n) { REP(i, n) CLR(A[i]); }
template <class T> inline bool EPT(T &a) { return a.empty(); }
template <class T> inline T &SRT(T &A) {
sort(ALL(A));
return A;
}
template <class T, class C> inline T &SRT(T &A, C cmp) {
sort(ALL(A), cmp);
return A;
}
template <class T> inline T &RVS(T &A) {
reverse(ALL(A));
return A;
}
template <class T> inline T &UNQQ(T &A) {
A.resize(unique(ALL(A)) - A.begin());
return A;
}
template <class T> inline T &UNQ(T &A) {
SRT(A);
return UNQQ(A);
}
template <class T, class C> inline T &UNQ(T &A, C cmp) {
SRT(A, cmp);
return UNQQ(A);
}
//}
/** Constant List .. **/ //{
const int MOD = int(1e9) + 7;
const int INF = 0x3f3f3f3f;
const LL INFF = 0x3f3f3f3f3f3f3f3fLL;
const DB EPS = 1e-9;
const DB OO = 1e20;
const DB PI = acos(-1.0); // M_PI;
const int dx[] = {-1, 1, 0, 0};
const int dy[] = {0, 0, 1, -1};
//}
/** Add On .. **/ //{
// <<= '0. Nichi Joo ., //{
template <class T> inline bool checkMin(T &a, const T b) {
return b < a ? a = b, 1 : 0;
}
template <class T> inline bool checkMax(T &a, const T b) {
return a < b ? a = b, 1 : 0;
}
template <class T, class C> inline bool checkUpd(T &a, const T b, C c) {
return c(b, a) ? a = b, 1 : 0;
}
template <class T> inline T min(T a, T b, T c) { return min(min(a, b), c); }
template <class T> inline T max(T a, T b, T c) { return max(max(a, b), c); }
template <class T> inline T min(T a, T b, T c, T d) {
return min(min(a, b), min(c, d));
}
template <class T> inline T max(T a, T b, T c, T d) {
return max(max(a, b), max(c, d));
}
template <class T> inline T min(T a, T b, T c, T d, T e) {
return min(min(min(a, b), min(c, d)), e);
}
template <class T> inline T max(T a, T b, T c, T d, T e) {
return max(max(max(a, b), max(c, d)), e);
}
template <class T> inline T sqr(T a) { return a * a; }
template <class T> inline T cub(T a) { return a * a * a; }
template <class T> inline T ceil(T x, T y) { return (x - 1) / y + 1; }
template <class T> T abs(T x) { return x > 0 ? x : -x; }
inline int sgn(DB x) { return x < -EPS ? -1 : x > EPS; }
inline int sgn(DB x, DB y) { return sgn(x - y); }
inline DB cos(DB a, DB b, DB c) {
return (sqr(a) + sqr(b) - sqr(c)) / (2 * a * b);
}
inline DB cot(DB x) { return 1. / tan(x); };
inline DB sec(DB x) { return 1. / cos(x); };
inline DB csc(DB x) { return 1. / sin(x); };
//}
// <<= '1. Bitwise Operation ., //{
namespace BO {
inline bool _1(int x, int i) { return bool(x & 1 << i); }
inline bool _1(LL x, int i) { return bool(x & 1LL << i); }
inline LL _1(int i) { return 1LL << i; }
inline LL _U(int i) { return _1(i) - 1; };
inline int reverse_bits(int x) {
x = ((x >> 1) & 0x55555555) | ((x << 1) & 0xaaaaaaaa);
x = ((x >> 2) & 0x33333333) | ((x << 2) & 0xcccccccc);
x = ((x >> 4) & 0x0f0f0f0f) | ((x << 4) & 0xf0f0f0f0);
x = ((x >> 8) & 0x00ff00ff) | ((x << 8) & 0xff00ff00);
x = ((x >> 16) & 0x0000ffff) | ((x << 16) & 0xffff0000);
return x;
}
inline LL reverse_bits(LL x) {
x = ((x >> 1) & 0x5555555555555555LL) | ((x << 1) & 0xaaaaaaaaaaaaaaaaLL);
x = ((x >> 2) & 0x3333333333333333LL) | ((x << 2) & 0xccccccccccccccccLL);
x = ((x >> 4) & 0x0f0f0f0f0f0f0f0fLL) | ((x << 4) & 0xf0f0f0f0f0f0f0f0LL);
x = ((x >> 8) & 0x00ff00ff00ff00ffLL) | ((x << 8) & 0xff00ff00ff00ff00LL);
x = ((x >> 16) & 0x0000ffff0000ffffLL) | ((x << 16) & 0xffff0000ffff0000LL);
x = ((x >> 32) & 0x00000000ffffffffLL) | ((x << 32) & 0xffffffff00000000LL);
return x;
}
template <class T> inline bool odd(T x) { return x & 1; }
template <class T> inline bool even(T x) { return !odd(x); }
template <class T> inline T low_bit(T x) { return x & -x; }
template <class T> inline T high_bit(T x) {
T p = low_bit(x);
while (p != x)
x -= p, p = low_bit(x);
return p;
}
template <class T> inline T cover_bit(T x) {
T p = 1;
while (p < x)
p <<= 1;
return p;
}
template <class T> inline int cover_idx(T x) {
int p = 0;
while (_1(p) < x)
++p;
return p;
}
inline int clz(int x) { return __builtin_clz(x); }
inline int clz(LL x) { return __builtin_clzll(x); }
inline int ctz(int x) { return __builtin_ctz(x); }
inline int ctz(LL x) { return __builtin_ctzll(x); }
inline int lg2(int x) { return !x ? -1 : 31 - clz(x); }
inline int lg2(LL x) { return !x ? -1 : 63 - clz(x); }
inline int low_idx(int x) { return !x ? -1 : ctz(x); }
inline int low_idx(LL x) { return !x ? -1 : ctz(x); }
inline int high_idx(int x) { return lg2(x); }
inline int high_idx(LL x) { return lg2(x); }
inline int parity(int x) { return __builtin_parity(x); }
inline int parity(LL x) { return __builtin_parityll(x); }
inline int count_bits(int x) { return __builtin_popcount(x); }
inline int count_bits(LL x) { return __builtin_popcountll(x); }
} // namespace BO
using namespace BO; //}
// <<= '2. Number Theory .,//{
namespace NT {
#define gcd __gcd
inline LL lcm(LL a, LL b) { return a * b / gcd(a, b); }
inline void INC(int &a, int b) {
a += b;
if (a >= MOD)
a -= MOD;
}
inline int sum(int a, int b) {
a += b;
if (a >= MOD)
a -= MOD;
return a;
}
/* 模数两倍刚好超 int 时。
inline int sum(uint a, int b){a += b; a %= MOD;if (a < 0) a += MOD; return a;}
inline void INC(int &a, int b){a = sum(a, b);}
*/
inline void DEC(int &a, int b) {
a -= b;
if (a < 0)
a += MOD;
}
inline int dff(int a, int b) {
a -= b;
if (a < 0)
a += MOD;
return a;
}
inline void MUL(int &a, int b) { a = (LL)a * b % MOD; }
// inline int pdt(int a, int b){return (LL)a * b % MOD;}
inline int pdt(int x, int y) {
int ret;
__asm__ __volatile__("\tmull %%ebx\n\tdivl %%ecx\n"
: "=d"(ret)
: "a"(x), "b"(y), "c"(MOD));
return ret;
}
inline int gcd(int m, int n, int &x, int &y) {
x = 1, y = 0;
int xx = 0, yy = 1, q;
while (1) {
q = m / n, m %= n;
if (!m) {
x = xx, y = yy;
return n;
}
DEC(x, pdt(q, xx)), DEC(y, pdt(q, yy));
q = n / m, n %= m;
if (!n)
return m;
DEC(xx, pdt(q, x)), DEC(yy, pdt(q, y));
}
}
inline int sum(int a, int b, int c) { return sum(a, sum(b, c)); }
inline int sum(int a, int b, int c, int d) { return sum(sum(a, b), sum(c, d)); }
inline int pdt(int a, int b, int c) { return pdt(a, pdt(b, c)); }
inline int pdt(int a, int b, int c, int d) { return pdt(pdt(a, b), pdt(c, d)); }
inline int pow(int a, LL b) {
int c(1);
while (b) {
if (b & 1)
MUL(c, a);
MUL(a, a), b >>= 1;
}
return c;
}
template <class T> inline T pow(T a, LL b) {
T c(1);
while (b) {
if (b & 1)
c *= a;
a *= a, b >>= 1;
}
return c;
}
template <class T> inline T pow(T a, int b) { return pow(a, (LL)b); }
inline int _I(int b) {
int a = MOD, x1 = 0, x2 = 1, q;
while (1) {
q = a / b, a %= b;
if (!a)
return x2;
DEC(x1, pdt(q, x2));
q = b / a, b %= a;
if (!b)
return x1;
DEC(x2, pdt(q, x1));
}
}
inline void DIV(int &a, int b) { MUL(a, _I(b)); }
inline int qtt(int a, int b) { return pdt(a, _I(b)); }
struct Int {
int val;
operator int() const { return val; }
Int(int _val = 0) : val(_val) {
val %= MOD;
if (val < 0)
val += MOD;
}
Int(LL _val) : val(_val) {
_val %= MOD;
if (_val < 0)
_val += MOD;
val = _val;
}
Int &operator+=(const int &rhs) {
INC(val, rhs);
rTs;
}
Int operator+(const int &rhs) const { return sum(val, rhs); }
Int &operator-=(const int &rhs) {
DEC(val, rhs);
rTs;
}
Int operator-(const int &rhs) const { return dff(val, rhs); }
Int &operator*=(const int &rhs) {
MUL(val, rhs);
rTs;
}
Int operator*(const int &rhs) const { return pdt(val, rhs); }
Int &operator/=(const int &rhs) {
DIV(val, rhs);
rTs;
}
Int operator/(const int &rhs) const { return qtt(val, rhs); }
Int operator-() const { return MOD - *this; }
};
} // namespace NT
using namespace NT; //}
//}
/** I/O Accelerator Interface .. **/ //{
#define g (c = getchar())
#define d isdigit(g)
#define p x = x * 10 + c - '0'
#define n x = x * 10 + '0' - c
#define pp l /= 10, p
#define nn l /= 10, n
template <class T> inline T &RD(T &x) {
char c;
while (!d)
;
x = c - '0';
while (d)
p;
return x;
}
template <class T> inline T &RDD(T &x) {
char c;
while (g, c != '-' && !isdigit(c))
;
if (c == '-') {
x = '0' - g;
while (d)
n;
} else {
x = c - '0';
while (d)
p;
}
return x;
}
inline DB &RF(DB &x) {
// scanf("%lf", &x);
char c;
while (g, c != '-' && c != '.' && !isdigit(c))
;
if (c == '-')
if (g == '.') {
x = 0;
DB l = 1;
while (d)
nn;
x *= l;
} else {
x = '0' - c;
while (d)
n;
if (c == '.') {
DB l = 1;
while (d)
nn;
x *= l;
}
}
else if (c == '.') {
x = 0;
DB l = 1;
while (d)
pp;
x *= l;
} else {
x = c - '0';
while (d)
p;
if (c == '.') {
DB l = 1;
while (d)
pp;
x *= l;
}
}
return x;
}
#undef nn
#undef pp
#undef n
#undef p
#undef d
#undef g
inline char *RS(char *s) {
// gets(s);
scanf("%s", s);
return s;
}
LL last_ans;
int Case;
template <class T> inline void OT(const T &x) {
// printf("Case #%d: ", ++Case);
// printf("%lld\n", x);
// printf("%I64d\n", x);
// printf("%.9f\n", x);
// printf("%d\n", x);
cout << x << endl;
// last_ans = x;
}
//}/*
//..................................................................................................................................
//*/
const int N = int(2e5) + 9;
Int Fact[N];
VI adj[N];
int sz[N];
Int f[N];
int n;
Int Binom(int n, int m) { return Fact[n] / (Fact[m] * Fact[n - m]); }
void dfs0(int u = 1, int p = -1) {
f[u] = 1;
Int szv = 1;
for (auto v : adj[u])
if (v != p) {
dfs0(v, u);
sz[u] += sz[v];
f[u] *= f[v];
szv *= Fact[sz[v]];
}
f[u] *= Fact[sz[u]] / szv;
sz[u] += 1;
}
// a
// u a
// v a
void dfs1(int u = 1, int p = -1) {
for (auto v : adj[u])
if (v != p) {
f[v] *=
(f[u] / f[v] / Fact[(n - 1)] * Fact[sz[v]] * Fact[(n - sz[v] - 1)]);
f[v] *= Fact[(n - 1)] / Fact[(sz[v] - 1)];
f[v] /= Fact[n - sz[v]];
// cout << " " << sz[u]-sz[v] << " " << f[v] << endl;
// f[v] *= (f[u] / f[v]) / Fact[sz[u]-sz[v]];
dfs1(v, u); // sz[u] += sz[v];
// f[u] *= f[v]; szv *= Fact[sz[v]];
}
// f[u] *= Fact[sz[u]] / szv;
// sz[u] += 1;
}
int main() {
Fact[0] = 1;
FOR(i, 1, N) Fact[i] = Fact[i - 1] * i;
RD(n);
DO(n - 1) {
int a, b;
RD(a, b);
adj[a].PB(b);
adj[b].PB(a);
}
dfs0();
dfs1();
REP_1(i, n) { cout << f[i] << endl; }
}
| delete | 822 | 828 | 822 | 822 | TLE | |
p02728 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define ull unsigned long long
#define endl '\n'
#define ll long long
const int N = 1e5 + 5;
ll mod = 1e9 + 7;
vector<ll> node[N];
ll sz[N], dp[N], fact[N], ans[N], n;
ll inv(ll u, ll p) {
if (p == 0)
return 1;
if (p == 1)
return u;
ll t = inv(u, p / 2) % mod;
if (p & 1)
return t * t % mod * u % mod;
return t * t % mod;
}
void dfs(ll u, ll p) {
sz[u] = 1;
for (auto j : node[u]) {
if (j != p) {
dfs(j, u);
sz[u] += sz[j];
}
}
}
ll tot = 1;
void reroot(ll u, ll v) {
tot = tot * inv(sz[u], mod - 2) % mod * inv(sz[v], mod - 2) % mod;
sz[u] = n - sz[v];
sz[v] = n;
tot = tot * sz[u] % mod * sz[v] % mod;
}
void dfs1(ll u, ll p) {
ans[u] = fact[n] * inv(tot, mod - 2) % mod;
for (auto j : node[u]) {
if (j != p) {
reroot(u, j);
dfs1(j, u);
reroot(j, u);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
if (fopen(".INP", "r")) {
freopen(".INP", "r", stdin);
freopen(".OUT", "w", stdout);
}
cin >> n;
fact[0] = 1;
for (int i = 1; i <= n; i++)
fact[i] = fact[i - 1] * i % mod;
for (int i = 1; i < n; i++) {
ll u, v;
cin >> u >> v;
node[u].push_back(v);
node[v].push_back(u);
}
dfs(1, 0);
for (int i = 1; i <= n; i++) {
tot = (tot * sz[i]) % mod;
}
dfs1(1, 0);
for (int i = 1; i <= n; i++) {
cout << ans[i] << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
#define ull unsigned long long
#define endl '\n'
#define ll long long
const int N = 2e5 + 5;
ll mod = 1e9 + 7;
vector<ll> node[N];
ll sz[N], dp[N], fact[N], ans[N], n;
ll inv(ll u, ll p) {
if (p == 0)
return 1;
if (p == 1)
return u;
ll t = inv(u, p / 2) % mod;
if (p & 1)
return t * t % mod * u % mod;
return t * t % mod;
}
void dfs(ll u, ll p) {
sz[u] = 1;
for (auto j : node[u]) {
if (j != p) {
dfs(j, u);
sz[u] += sz[j];
}
}
}
ll tot = 1;
void reroot(ll u, ll v) {
tot = tot * inv(sz[u], mod - 2) % mod * inv(sz[v], mod - 2) % mod;
sz[u] = n - sz[v];
sz[v] = n;
tot = tot * sz[u] % mod * sz[v] % mod;
}
void dfs1(ll u, ll p) {
ans[u] = fact[n] * inv(tot, mod - 2) % mod;
for (auto j : node[u]) {
if (j != p) {
reroot(u, j);
dfs1(j, u);
reroot(j, u);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
if (fopen(".INP", "r")) {
freopen(".INP", "r", stdin);
freopen(".OUT", "w", stdout);
}
cin >> n;
fact[0] = 1;
for (int i = 1; i <= n; i++)
fact[i] = fact[i - 1] * i % mod;
for (int i = 1; i < n; i++) {
ll u, v;
cin >> u >> v;
node[u].push_back(v);
node[v].push_back(u);
}
dfs(1, 0);
for (int i = 1; i <= n; i++) {
tot = (tot * sz[i]) % mod;
}
dfs1(1, 0);
for (int i = 1; i <= n; i++) {
cout << ans[i] << endl;
}
}
| replace | 6 | 7 | 6 | 7 | 0 | |
p02728 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef long double ld;
#define lp(var, start, end) for (ll var = start; var < end; ++var)
#define rlp(var, start, end) for (ll var = start; var >= end; var--)
#define pb push_back
#define mp make_pair
#define pf push_front
#define ff first
#define ss second
#define vll vector<ll>
#define vld vector<ld>
#define pll pair<ll, ll>
#define pld pair<ld, ld>
#define vpll vector<pll>
#define vpld vector<pld>
#define all(X) X.begin(), X.end()
#define endl "\n"
#define sz(x) ((ll)((x).size()))
const ll N = 1e5 + 5, inf = 1e18, mod = 1e9 + 7;
ll expo(ll a, ll b, ll mod) {
ll ans = 1;
while (b != 0) {
if ((b & 1) == 1)
ans = (ans * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ans % mod;
}
vll G[N];
ll fac[N], sub[N], dp[N], invfac[N], ans[N];
ll dfs(ll a, ll p) {
dp[a] = 1;
lp(i, 0, sz(G[a])) {
ll x = G[a][i];
if (x != p) {
dfs(x, a);
sub[a] += sub[x];
dp[a] *= invfac[sub[x]];
dp[a] %= mod;
dp[a] *= dp[x];
dp[a] %= mod;
}
}
dp[a] *= fac[sub[a]];
dp[a] %= mod;
sub[a] += 1;
// if(dp[a]==0)dp[a]=1;
// cout<<a<<" "<<dp[a]<<" "<<sub[a]<<endl;
}
ll n;
ll dfs2(ll a, ll p, ll val) {
// cout<<val<<" "<<a<<endl;
ans[a] = val;
ans[a] *= fac[n - 1];
ans[a] %= mod;
ans[a] *= invfac[n - sub[a]];
ans[a] %= mod;
lp(i, 0, sz(G[a])) {
ll x = G[a][i];
if (x != p) {
ans[a] *= dp[x];
ans[a] %= mod;
ans[a] *= invfac[sub[x]];
ans[a] %= mod;
}
}
lp(i, 0, sz(G[a])) {
ll x = G[a][i];
if (x != p) {
ll val = ans[a];
val *= invfac[n - 1];
val %= mod;
val *= fac[n - 1 - sub[x]];
val %= mod;
val *= expo(dp[x], mod - 2, mod);
val %= mod;
val *= fac[sub[x]];
val %= mod;
// cout<<a<<" "<<x<<" "<<val<<" "<<ans[a]<<endl;
dfs2(x, a, val);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
fac[0] = 1;
invfac[0] = 1;
lp(i, 1, N) {
fac[i] = (fac[i - 1] * i) % mod;
invfac[i] = expo(fac[i], mod - 2, mod);
}
// ll n;
cin >> n;
lp(i, 0, n - 1) {
ll a, b;
cin >> a >> b;
G[a].pb(b);
G[b].pb(a);
}
dfs(1, 0);
dfs2(1, 0, 1);
lp(i, 1, n + 1) { cout << ans[i] << endl; }
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef long double ld;
#define lp(var, start, end) for (ll var = start; var < end; ++var)
#define rlp(var, start, end) for (ll var = start; var >= end; var--)
#define pb push_back
#define mp make_pair
#define pf push_front
#define ff first
#define ss second
#define vll vector<ll>
#define vld vector<ld>
#define pll pair<ll, ll>
#define pld pair<ld, ld>
#define vpll vector<pll>
#define vpld vector<pld>
#define all(X) X.begin(), X.end()
#define endl "\n"
#define sz(x) ((ll)((x).size()))
const ll N = 2e5 + 5, inf = 1e18, mod = 1e9 + 7;
ll expo(ll a, ll b, ll mod) {
ll ans = 1;
while (b != 0) {
if ((b & 1) == 1)
ans = (ans * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ans % mod;
}
vll G[N];
ll fac[N], sub[N], dp[N], invfac[N], ans[N];
ll dfs(ll a, ll p) {
dp[a] = 1;
lp(i, 0, sz(G[a])) {
ll x = G[a][i];
if (x != p) {
dfs(x, a);
sub[a] += sub[x];
dp[a] *= invfac[sub[x]];
dp[a] %= mod;
dp[a] *= dp[x];
dp[a] %= mod;
}
}
dp[a] *= fac[sub[a]];
dp[a] %= mod;
sub[a] += 1;
// if(dp[a]==0)dp[a]=1;
// cout<<a<<" "<<dp[a]<<" "<<sub[a]<<endl;
}
ll n;
ll dfs2(ll a, ll p, ll val) {
// cout<<val<<" "<<a<<endl;
ans[a] = val;
ans[a] *= fac[n - 1];
ans[a] %= mod;
ans[a] *= invfac[n - sub[a]];
ans[a] %= mod;
lp(i, 0, sz(G[a])) {
ll x = G[a][i];
if (x != p) {
ans[a] *= dp[x];
ans[a] %= mod;
ans[a] *= invfac[sub[x]];
ans[a] %= mod;
}
}
lp(i, 0, sz(G[a])) {
ll x = G[a][i];
if (x != p) {
ll val = ans[a];
val *= invfac[n - 1];
val %= mod;
val *= fac[n - 1 - sub[x]];
val %= mod;
val *= expo(dp[x], mod - 2, mod);
val %= mod;
val *= fac[sub[x]];
val %= mod;
// cout<<a<<" "<<x<<" "<<val<<" "<<ans[a]<<endl;
dfs2(x, a, val);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
fac[0] = 1;
invfac[0] = 1;
lp(i, 1, N) {
fac[i] = (fac[i - 1] * i) % mod;
invfac[i] = expo(fac[i], mod - 2, mod);
}
// ll n;
cin >> n;
lp(i, 0, n - 1) {
ll a, b;
cin >> a >> b;
G[a].pb(b);
G[b].pb(a);
}
dfs(1, 0);
dfs2(1, 0, 1);
lp(i, 1, n + 1) { cout << ans[i] << endl; }
return 0;
} | replace | 21 | 22 | 21 | 22 | 0 | |
p02728 | C++ | Runtime Error | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <utility>
#include <vector>
#define fir first
#define sec second
#define sz(s) (s).size()
#define pb push_back
#define get(n) scanf("%d", &n);
#define gets(s) \
string s; \
cin >> (s);
#define prfi(n) printf("%d", &n);
#define prfd(n) printf("%lf", &n);
#define All(s) (s).begin(), (s).end()
#define rep(i, j) for (int(i) = 0; (i) < (j); (i)++)
#define For(i, j, k) for (int(i) = (j); (i) < (k); (i)++)
#define drep(i, j) for (int(i) = (j); (i) >= 0; (i)--)
#define Ford(i, j, k) for (int(i) = (j); i >= (k); i--)
#define vfor(c, v) for (auto(c) : (v))
#define lpi(n) for (int i = 0; i < (n); i++)
#define lpj(n) for (int j = 0; j < (n); j++)
#define lpz(n) for (int z = 0; z < (n); z++)
#define mem(a, b) memset(a, b, sizeof(a));
#define dump(x) std::cout << #x << " = " << (x) << std::endl;
#define debug(x) \
cout << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
using ll = long long;
using ld = long double;
using pii = std::pair<int, int>;
using pll = std::pair<ll, ll>;
using vi = std::vector<int>;
using vvi = std::vector<vi>;
using vll = std::vector<ll>;
using vvll = std::vector<vll>;
using vd = std::vector<double>;
using vvd = std::vector<vd>;
using qi = std::queue<int>;
using vpii = std::vector<std::pair<int, int>>;
using vpll = std::vector<pll>;
using namespace std;
const int Mod = (1e9) + 7;
const int INF = 1e9 + 19;
const ll INFL = 1e18 + 19;
const int dx[] = {-1, 0, 0, 1};
const int dy[] = {0, -1, 1, 0};
const int dx2[] = {-1, -1, -1, 0, 0, 0, 1, 1, 1};
const int dy2[] = {1, 0, -1, 1, 0, -1, 1, 0, -1};
//_____________________________________Templates_________________________________________//
template <class T1, class T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <class T1, class T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
template <class T> inline void swap(T &a, T &b) {
T c = a;
a = b;
b = c;
}
template <class T> inline void pri(T a) { cout << a << endl; }
template <class Z> using vec = vector<Z>;
// mainly use for dynamic prog
template <class T1, class T2> void update(T1 &a, T2 b) {
a += b;
if (a > Mod)
a %= Mod;
}
inline void IN(void) { return; }
template <typename First, typename... Rest>
void IN(First &first, Rest &...rest) {
cin >> first;
IN(rest...);
return;
}
inline void OUT(void) {
cout << "\n";
return;
}
template <typename First, typename... Rest>
void OUT(First first, Rest... rest) {
cout << first << " ";
OUT(rest...);
return;
}
bool pairsort(pll pl, pll pr) {
if (pl.first == pr.first)
return pl.second > pr.second;
return pl.first < pr.first;
}
int cntbit(ll a, int n, int j) {
int res = 0;
For(i, j, n) {
if (a >> i & 1) {
res++;
}
}
return res;
}
vector<int> make_bit(int a) {
vector<int> res;
lpi(32) if (a & (1 << i)) res.pb(i);
return res;
}
bool stdbit(int a, int b) { return a & (1 << b); }
int GCD(int a, int b) {
if (b > a)
return GCD(b, a);
if (a % b == 0)
return b;
else
return GCD(b, a % b);
}
int LCM(int a, int b) { return a * b / GCD(a, b); }
int roundup(int a, int b) {
if (a % b == 0)
return a / b;
else
return (a + b) / b;
}
int rounddown(int a, int b) {
if (a % b == 0)
return a / b;
else {
return (a - b) / b;
}
}
ll GetDiviserCount(ll N) // 約数の個数
{
ll res = 1;
For(i, 2, sqrt(N) + 1) {
ll cnt = 0;
while (N % i == 0) {
cnt++;
N /= i;
}
res *= (cnt + 1);
if (N == 1)
break;
}
if (N != 1)
res *= 2;
return res;
}
vll GetDivisor(ll N) // 約数列挙
{
vll res;
for (ll i = 1; i * i <= N; i++) {
if (N % i == 0) {
res.pb(i);
if (i * i != N)
res.pb(N / i);
}
}
sort(All(res));
return res;
}
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;
}
friend ostream &operator<<(ostream &os, const mint &a);
};
ostream &operator<<(ostream &os, const mint &a) {
os << a.x;
return os;
}
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < Mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
//_____________________ following sorce code_________________________//
const int max_n = 3 * (1e5) + 1;
const int max_m = 83 * (1e5) + 1;
int n, m, k;
ll N;
int h, w;
string S;
int a, b, c;
vi v;
vector<mint> dp;
vector<mint> ans;
vvi G;
vi t;
combination comb(20101);
void dfs1(int v, int u = -1) // vは現在の頂点、uはどこからきたか
{
mint res(1);
if (G[v].size() == 0) {
dp[v] = 1;
return;
}
for (auto c : G[v]) {
if (c == u)
continue;
dfs1(c, v);
res *= dp[c];
t[v] += t[c];
}
// combination comb(n+1);
N = t[v] - 1;
for (auto c : G[v]) {
if (c == u)
continue;
res *= comb(N, t[c]);
N -= t[c];
}
dp[v] = res;
// cout << "dp[" << v << "] = " << dp[v] << endl;
// cout << "t[" << v << "]= " << t[v] << endl;
return;
}
void dfs2(int v, int u = -1) {
if (v == 0) {
for (auto c : G[v]) {
dfs2(c, 0);
}
return;
}
mint resu(1);
// dump(ans[u]);
// dump(dp[v]);
// dump(conb(n-1,t[v]));
// cout << "t[" << u << "] = " << t[u] << endl;
// cout << "t[" << v << "] = " << t[v] << endl;
mint p(n - t[v]);
resu = ans[u] * t[v];
// dump(resu);
resu /= p;
ans[v] = resu;
/*
dump(v);
dump(ans[u]);
dump(t[v]);
dump(p);
dump(resu);
OUT();
*/
for (auto c : G[v]) {
if (c == u)
continue;
dfs2(c, v);
}
// cout << "t[" << v << "]= " << t[v] << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
IN(n);
t = vi(n, 1);
dp = vector<mint>(n + 1);
G = vvi(n);
lpi(n - 1) {
IN(a, b);
a--;
b--;
G[a].pb(b);
G[b].pb(a);
}
dfs1(0);
ans = vector<mint>(n);
ans[0] = dp[0];
// dump(dp[0]);
dfs2(0);
for (auto c : ans) {
cout << c << endl;
}
// for(auto c : ans){cout << c << endl;}
// cout << fixed << setprecision(15) << ans << endl;
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <utility>
#include <vector>
#define fir first
#define sec second
#define sz(s) (s).size()
#define pb push_back
#define get(n) scanf("%d", &n);
#define gets(s) \
string s; \
cin >> (s);
#define prfi(n) printf("%d", &n);
#define prfd(n) printf("%lf", &n);
#define All(s) (s).begin(), (s).end()
#define rep(i, j) for (int(i) = 0; (i) < (j); (i)++)
#define For(i, j, k) for (int(i) = (j); (i) < (k); (i)++)
#define drep(i, j) for (int(i) = (j); (i) >= 0; (i)--)
#define Ford(i, j, k) for (int(i) = (j); i >= (k); i--)
#define vfor(c, v) for (auto(c) : (v))
#define lpi(n) for (int i = 0; i < (n); i++)
#define lpj(n) for (int j = 0; j < (n); j++)
#define lpz(n) for (int z = 0; z < (n); z++)
#define mem(a, b) memset(a, b, sizeof(a));
#define dump(x) std::cout << #x << " = " << (x) << std::endl;
#define debug(x) \
cout << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
using ll = long long;
using ld = long double;
using pii = std::pair<int, int>;
using pll = std::pair<ll, ll>;
using vi = std::vector<int>;
using vvi = std::vector<vi>;
using vll = std::vector<ll>;
using vvll = std::vector<vll>;
using vd = std::vector<double>;
using vvd = std::vector<vd>;
using qi = std::queue<int>;
using vpii = std::vector<std::pair<int, int>>;
using vpll = std::vector<pll>;
using namespace std;
const int Mod = (1e9) + 7;
const int INF = 1e9 + 19;
const ll INFL = 1e18 + 19;
const int dx[] = {-1, 0, 0, 1};
const int dy[] = {0, -1, 1, 0};
const int dx2[] = {-1, -1, -1, 0, 0, 0, 1, 1, 1};
const int dy2[] = {1, 0, -1, 1, 0, -1, 1, 0, -1};
//_____________________________________Templates_________________________________________//
template <class T1, class T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <class T1, class T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
template <class T> inline void swap(T &a, T &b) {
T c = a;
a = b;
b = c;
}
template <class T> inline void pri(T a) { cout << a << endl; }
template <class Z> using vec = vector<Z>;
// mainly use for dynamic prog
template <class T1, class T2> void update(T1 &a, T2 b) {
a += b;
if (a > Mod)
a %= Mod;
}
inline void IN(void) { return; }
template <typename First, typename... Rest>
void IN(First &first, Rest &...rest) {
cin >> first;
IN(rest...);
return;
}
inline void OUT(void) {
cout << "\n";
return;
}
template <typename First, typename... Rest>
void OUT(First first, Rest... rest) {
cout << first << " ";
OUT(rest...);
return;
}
bool pairsort(pll pl, pll pr) {
if (pl.first == pr.first)
return pl.second > pr.second;
return pl.first < pr.first;
}
int cntbit(ll a, int n, int j) {
int res = 0;
For(i, j, n) {
if (a >> i & 1) {
res++;
}
}
return res;
}
vector<int> make_bit(int a) {
vector<int> res;
lpi(32) if (a & (1 << i)) res.pb(i);
return res;
}
bool stdbit(int a, int b) { return a & (1 << b); }
int GCD(int a, int b) {
if (b > a)
return GCD(b, a);
if (a % b == 0)
return b;
else
return GCD(b, a % b);
}
int LCM(int a, int b) { return a * b / GCD(a, b); }
int roundup(int a, int b) {
if (a % b == 0)
return a / b;
else
return (a + b) / b;
}
int rounddown(int a, int b) {
if (a % b == 0)
return a / b;
else {
return (a - b) / b;
}
}
ll GetDiviserCount(ll N) // 約数の個数
{
ll res = 1;
For(i, 2, sqrt(N) + 1) {
ll cnt = 0;
while (N % i == 0) {
cnt++;
N /= i;
}
res *= (cnt + 1);
if (N == 1)
break;
}
if (N != 1)
res *= 2;
return res;
}
vll GetDivisor(ll N) // 約数列挙
{
vll res;
for (ll i = 1; i * i <= N; i++) {
if (N % i == 0) {
res.pb(i);
if (i * i != N)
res.pb(N / i);
}
}
sort(All(res));
return res;
}
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;
}
friend ostream &operator<<(ostream &os, const mint &a);
};
ostream &operator<<(ostream &os, const mint &a) {
os << a.x;
return os;
}
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < Mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
//_____________________ following sorce code_________________________//
const int max_n = 3 * (1e5) + 1;
const int max_m = 83 * (1e5) + 1;
int n, m, k;
ll N;
int h, w;
string S;
int a, b, c;
vi v;
vector<mint> dp;
vector<mint> ans;
vvi G;
vi t;
combination comb(200100);
void dfs1(int v, int u = -1) // vは現在の頂点、uはどこからきたか
{
mint res(1);
if (G[v].size() == 0) {
dp[v] = 1;
return;
}
for (auto c : G[v]) {
if (c == u)
continue;
dfs1(c, v);
res *= dp[c];
t[v] += t[c];
}
// combination comb(n+1);
N = t[v] - 1;
for (auto c : G[v]) {
if (c == u)
continue;
res *= comb(N, t[c]);
N -= t[c];
}
dp[v] = res;
// cout << "dp[" << v << "] = " << dp[v] << endl;
// cout << "t[" << v << "]= " << t[v] << endl;
return;
}
void dfs2(int v, int u = -1) {
if (v == 0) {
for (auto c : G[v]) {
dfs2(c, 0);
}
return;
}
mint resu(1);
// dump(ans[u]);
// dump(dp[v]);
// dump(conb(n-1,t[v]));
// cout << "t[" << u << "] = " << t[u] << endl;
// cout << "t[" << v << "] = " << t[v] << endl;
mint p(n - t[v]);
resu = ans[u] * t[v];
// dump(resu);
resu /= p;
ans[v] = resu;
/*
dump(v);
dump(ans[u]);
dump(t[v]);
dump(p);
dump(resu);
OUT();
*/
for (auto c : G[v]) {
if (c == u)
continue;
dfs2(c, v);
}
// cout << "t[" << v << "]= " << t[v] << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
IN(n);
t = vi(n, 1);
dp = vector<mint>(n + 1);
G = vvi(n);
lpi(n - 1) {
IN(a, b);
a--;
b--;
G[a].pb(b);
G[b].pb(a);
}
dfs1(0);
ans = vector<mint>(n);
ans[0] = dp[0];
// dump(dp[0]);
dfs2(0);
for (auto c : ans) {
cout << c << endl;
}
// for(auto c : ans){cout << c << endl;}
// cout << fixed << setprecision(15) << ans << endl;
return 0;
} | replace | 259 | 260 | 259 | 260 | 0 | |
p02728 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define rep(i, n) for (lint i = 0; i < n; i++)
#define repr(i, n) for (lint i = n - 1; i >= 0; i--)
#define repi(i, ini, n) for (lint i = ini; i < n; i++)
#define repir(i, ini, n) for (lint i = n - 1; i >= ini; i--)
#define repb(i, start, end) for (lint i = start; i <= end; i++)
#define repbr(i, start, end) for (lint i = end; i >= start; i--)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define rg(v, n) v.begin(), v.begin() + n
#define rrg(v, n) v.rbegin(), v.rbegin() + n
#define ret return 0;
namespace {
using lint = long long;
using ulint = unsigned long long;
using ld = long double;
struct xy {
lint x, y;
xy() : x(0), y(0) {}
xy(lint _x, lint _y) : x(_x), y(_y) {}
xy operator+(const xy &p) const { return xy(x + p.x, y + p.y); }
bool operator<(xy p) const {
if (y == p.y)
return x < p.x;
return y < p.y;
}
};
struct xyd {
ld x, y;
xyd() : x(0), y(0) {}
xyd(long double _x, long double _y) : x(_x), y(_y) {}
};
using vec = vector<lint>;
using vecd = vector<ld>;
using vecs = vector<string>;
using vecp = vector<xy>;
template <class T> using vect = vector<T>;
class vec2 : public vector<vector<lint>> {
public:
vec2() {}
vec2(lint n) : vector(n) {}
vec2(lint h, lint w) : vector(h, vector<lint>(w)) {}
vec2(lint h, lint w, lint v) : vector(h, vector<lint>(w, v)) {}
};
template <class T> using priq = priority_queue<T>;
template <class T> using rpriq = priority_queue<T, vector<T>, greater<T>>;
const ulint mod = 1000000007;
const double pi = 3.141592653589793238462;
const lint intmax = 9223372036854775807;
const lint inf = 1100100100100100100LL;
const ld eps = 0.0000001;
const lint alpn = 'z' - 'a' + 1;
template <class It> constexpr auto acc(It begin, It end) {
return accumulate(begin, end, typename It::value_type(0));
}
template <class T> constexpr auto msum(T arg0) { return arg0; }
template <class T, class... Types> constexpr auto msum(T arg0, Types... args) {
static_assert(sizeof...(args) > 0, "arg err");
return arg0 + msum(args...);
}
template <class It> constexpr typename It::value_type mmax(It begin, It end) {
return *max_element(begin, end);
}
template <class It> constexpr typename It::value_type mmin(It begin, It end) {
return *min_element(begin, end);
}
template <class T> constexpr auto mmax(T arg) { return arg; }
template <class T, class... Types> constexpr auto mmax(T arg0, Types... args) {
using promote_t = decltype(msum(arg0, args...));
return max(static_cast<promote_t>(arg0),
static_cast<promote_t>(mmax(args...)));
}
template <class T> constexpr auto mmin(T arg) { return arg; }
template <class T, class... Types> constexpr auto mmin(T arg0, Types... args) {
using promote_t = decltype(msum(arg0, args...));
return min(static_cast<promote_t>(arg0),
static_cast<promote_t>(mmin(args...)));
}
constexpr auto clamp(lint val, lint left, lint right) {
return mmax(mmin(val, right), left);
}
constexpr lint div2(lint p, lint q) { return (p + q - 1) / q; }
lint gcd(lint a, lint b) {
while (1) {
if (a < b)
swap(a, b);
if (!b)
break;
a %= b;
}
return a;
}
lint lcm(lint a, lint b) { return a / gcd(a, b) * b; }
lint powInt(lint a, lint b) {
if (b == 0) {
return 1;
}
if (b == 1) {
return a;
}
lint tmp = powInt(a, b / 2);
return (b % 2 == 1 ? a * tmp * tmp : tmp * tmp);
}
template <class T> T sgn(T val) {
if (val == T(0))
return T(0);
if (val < 0)
return T(-1);
if (val > 0)
return T(1);
}
template <class T> constexpr auto modK_belowN(T k, T MOD, T n) {
return (n + MOD - k - 1) / MOD;
}
template <class It, class T> bool exist(It begin, It end, const T &val) {
return find(begin, end, val) != end;
}
template <class It, class Pr> bool exist_if(It begin, It end, Pr pred) {
return find_if(begin, end, pred) != end;
}
template <class T> bool between(T val, T l, T r) {
return (val >= l) && (val <= r);
}
template <class It> auto carr(It begin, It end) {
vec c;
c.push_back(1);
auto before = *begin;
for (auto it = begin + 1; it != end; it++) {
if (before != *it) {
c.push_back(0);
before = *it;
}
c.back()++;
}
return c;
}
template <class T> struct nval {
lint n;
T val;
nval() : n(0){};
nval(lint _n, T _val) : n(_n), val(_val){};
};
template <class It> auto carr2(It begin, It end) {
using T = nval<remove_reference_t<decltype(*begin)>>;
vect<T> c;
c.push_back(T(1, *begin));
auto before = *begin;
for (auto it = begin + 1; it != end; it++) {
if (before != *it) {
c.push_back(T(0, *it));
before = *it;
}
c.back().n++;
}
return c;
}
template <class It, class... T> void sort2(It begin, It end, T... p) {
using val_t = remove_reference_t<decltype(*begin)>;
sort(begin, end, [p...](val_t a, val_t b) {
bool neq[] = {(a.*p != b.*p)...};
bool sg[] = {(a.*p < b.*p)...};
rep(i, sizeof...(p)) {
if (neq[i]) {
return sg[i];
}
}
return false;
});
}
template <size_t _K, size_t _N, class... Types, size_t... indices>
auto constexpr __ModKtuple_Impl(index_sequence<indices...>,
tuple<Types...> args) {
return make_tuple(get<indices * _N + _K>(args)...);
}
template <size_t K, size_t N, class... Types>
auto constexpr ModKtuple(Types... args) {
return __ModKtuple_Impl<K, N>(
make_index_sequence<modK_belowN(K, N, sizeof...(args))>{},
forward_as_tuple(args...));
}
template <class It, class... T, class... Tsg, size_t... indices>
void __sort3_Impl(It begin, It end, tuple<T...> p, tuple<Tsg...> sgf,
index_sequence<indices...>) {
using val_t = remove_reference_t<decltype(*begin)>;
sort(begin, end, [p, sgf](val_t a, val_t b) {
bool neq[] = {(a.*(get<indices>(p)) != b.*(get<indices>(p)))...};
bool sg[] = {((a.*(get<indices>(p)) < b.*(get<indices>(p))) !=
(get<indices>(sgf)))...};
rep(i, sizeof...(indices)) {
if (neq[i]) {
return sg[i];
}
}
return false;
});
}
template <class It, class... T> void sort3(It begin, It end, T... p) {
using val_t = remove_reference_t<decltype(*begin)>;
auto p_forward = ModKtuple<0, 2>(p...);
auto sgf_forward = ModKtuple<1, 2>(p...);
constexpr auto p_sz = tuple_size<decltype(p_forward)>::value;
constexpr auto sgf_sz = tuple_size<decltype(sgf_forward)>::value;
static_assert(p_sz == sgf_sz, "arg err");
__sort3_Impl(begin, end, p_forward, sgf_forward, make_index_sequence<p_sz>{});
}
char caesar(char s, lint key) {
if (between(s, 'A', 'Z')) {
return (s - 'A' + key) % alpn + 'A';
}
if (between(s, 'a', 'z')) {
return (s - 'a' + key) % alpn + 'a';
}
return s;
}
string caesar(string s, lint key) {
rep(i, s.length()) s[i] = caesar(s[i], key);
return s;
}
template <class It, class It2> auto spacel(It i, It2 end) {
if (i + 1 == end) {
return '\n';
} else {
return ' ';
}
}
template <class It> bool next_comb(lint n, It begin, It end) {
auto rend = make_reverse_iterator(begin);
auto rbegin = make_reverse_iterator(end);
auto rit = rbegin;
for (; rit != rend; rit++) {
if ((rit == rbegin && (*rit) + 1 != n) ||
(rit != rbegin && (*rit) + 1 != *(rit - 1))) {
goto found;
}
}
return false;
found:;
(*rit)++;
for (auto it = rit.base(); it != end; it++) {
(*it) = (*(it - 1)) + 1;
}
return true;
}
ostream &setp(ostream &ost) {
cout << setprecision(60) << fixed;
return ost;
}
#ifdef _LOCAL
auto &dbg = cout;
#else
struct dummy_cout {
template <class T> dummy_cout &operator<<(T &&op) { return *this; }
using endl_t = basic_ostream<char, char_traits<char>>;
dummy_cout &operator<<(endl_t &(*)(endl_t &)) { return *this; }
};
dummy_cout dbg;
#endif
}; // namespace
struct mint {
lint n;
mint() { n = 0; }
mint(lint a) {
if (a != -1)
n = a % mod;
else
n = a;
}
mint &operator+=(mint a) {
n += a.n;
n %= mod;
return *this;
}
mint &operator-=(mint a) {
n += mod;
n -= a.n;
n %= mod;
return *this;
}
mint &operator*=(mint a) {
n *= a.n;
n %= mod;
return *this;
}
mint &operator%=(mint a) {
n %= a.n;
return *this;
}
mint &operator++() {
n++;
n %= mod;
return *this;
}
mint &operator--() {
n += mod;
n--;
n %= mod;
return *this;
}
};
mint operator+(mint a, mint b) {
a += b;
return a;
}
mint operator-(mint a, mint b) {
a -= b;
return a;
}
mint operator*(mint a, mint b) {
a *= b;
return a;
}
vector<mint> invtbl;
vector<mint> finvtbl;
vector<mint> facttbl;
mint factMod(lint n) {
if (n == 0) {
return 1;
}
mint ans = 1;
while (n > 1) {
ans *= n;
n--;
}
return ans;
}
mint powMod(mint x, lint y) {
if (x.n <= 1) {
return x;
}
if (y == 0) {
return 1;
} else if (y == 1) {
return x;
} else if (y % 2 == 0) {
mint tmp = powMod(x, y / 2);
return tmp * tmp;
} else {
mint tmp = powMod(x, y / 2);
return tmp * tmp * x;
}
}
mint modinv(mint n) { return powMod(n, mod - 2); }
void preCalcInv(lint up) {
invtbl.resize(up + 1);
invtbl[1] = 1;
repb(a, 2, up) { invtbl[a] = invtbl[a] = mod - invtbl[mod % a] * (mod / a); }
}
mint operator/(mint a, mint b) {
if (b.n < invtbl.size()) {
a *= invtbl[b.n];
} else {
a *= modinv(b);
}
return a;
}
mint &operator/=(mint &a, mint b) {
a = a / b;
return a;
}
void preCalcFactInv(lint up) {
finvtbl.resize(up + 1);
finvtbl[0] = 1;
finvtbl[up] = modinv(factMod(up));
repbr(a, 1, up - 1) { finvtbl[a] = finvtbl[a + 1] * (a + 1); }
}
void preCalcFact(lint up) {
facttbl.resize(up + 1);
facttbl[0] = 1;
repb(a, 1, up) { facttbl[a] = facttbl[a - 1] * a; }
}
void preCalc(lint up) {
invtbl.resize(up + 1);
finvtbl.resize(up + 1);
facttbl.resize(up + 1);
invtbl[1] = 1;
facttbl[0] = facttbl[1] = 1;
finvtbl[0] = finvtbl[1] = 1;
repb(a, 2, up) {
facttbl[a] = facttbl[a - 1] * a;
invtbl[a] = invtbl[a] = mod - invtbl[mod % a] * (mod / a);
finvtbl[a] = finvtbl[a - 1] * invtbl[a];
}
}
mint factModInv(lint a) {
if (a < finvtbl.size()) {
return finvtbl[a];
} else {
return modinv(factMod(a));
}
}
mint nCrMod(lint n, lint r) {
if (n < r || n < 0 || r < 0) {
return 0;
}
r = mmin(r, n - r);
mint a = 1;
if (n < finvtbl.size() && n < facttbl.size()) {
a *= facttbl[n];
a *= finvtbl[r];
a *= finvtbl[n - r];
return a;
} else {
repb(i, n - r + 1, n) { a *= i; }
a *= factModInv(r);
return a;
}
}
mint nHrMod(lint n, lint r) { return nCrMod(n + r - 1, r); }
template <class T> struct ReRoot {
vec2 tr;
vect<T> dp;
using un_t = T(T a, T b);
using postc_t = T(T a);
un_t *un;
postc_t *post;
const T e;
ReRoot(lint n, T _e)
: tr(n), e(_e), dp(n, e), un(nullptr), post([](T a) { return a; }) {}
void add_e(lint a, lint b) { tr[a].push_back(b); }
T f(lint v, lint rt) {
T res = e;
lint cn = tr[v].size();
rep(i, cn) {
if (tr[v][i] == rt)
continue;
res = un(res, post(f(tr[v][i], v)));
}
dp[v] = res;
return res;
}
void g(lint v, lint rt, T rtDP) {
lint cn = tr[v].size();
vect<T> dpS(cn);
vect<T> dpSr(cn);
dpS[0] = e;
rep(i, cn - 1) {
if (tr[v][i] == rt) {
dpS[i + 1] = un(dpS[i], post(rtDP));
} else {
dpS[i + 1] = un(dpS[i], post(dp[tr[v][i]]));
}
}
dpSr[cn - 1] = e;
repr(i, cn - 1) {
if (tr[v][i + 1] == rt) {
dpSr[i] = un(dpSr[i + 1], post(rtDP));
} else {
dpSr[i] = un(dpSr[i + 1], post(dp[tr[v][i + 1]]));
}
}
rep(i, tr[v].size()) {
if (tr[v][i] == rt)
continue;
auto r = un(dpS[i], dpSr[i]);
dp[tr[v][i]] = un(dp[tr[v][i]], post(r));
g(tr[v][i], v, r);
}
}
void solve() {
f(0, -1);
g(0, -1, e);
}
const T &operator[](lint i) const { return post(dp[i]); }
};
struct E {
lint nn;
mint ptn;
};
int main() {
lint n;
cin >> n;
preCalc(n + 10);
ReRoot<E> t(n, {0, 1});
rep(i, n - 1) {
lint a, b;
cin >> a >> b;
a--;
b--;
t.add_e(a, b);
t.add_e(b, a);
}
t.un = [](E a, E b) {
a.nn += b.nn;
a.ptn *= b.ptn;
a.ptn *= nCrMod(a.nn, b.nn);
return a;
};
t.post = [](E a) {
a.nn++;
return a;
};
t.solve();
rep(i, n) { cout << t[i].ptn.n << endl; }
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define rep(i, n) for (lint i = 0; i < n; i++)
#define repr(i, n) for (lint i = n - 1; i >= 0; i--)
#define repi(i, ini, n) for (lint i = ini; i < n; i++)
#define repir(i, ini, n) for (lint i = n - 1; i >= ini; i--)
#define repb(i, start, end) for (lint i = start; i <= end; i++)
#define repbr(i, start, end) for (lint i = end; i >= start; i--)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define rg(v, n) v.begin(), v.begin() + n
#define rrg(v, n) v.rbegin(), v.rbegin() + n
#define ret return 0;
namespace {
using lint = long long;
using ulint = unsigned long long;
using ld = long double;
struct xy {
lint x, y;
xy() : x(0), y(0) {}
xy(lint _x, lint _y) : x(_x), y(_y) {}
xy operator+(const xy &p) const { return xy(x + p.x, y + p.y); }
bool operator<(xy p) const {
if (y == p.y)
return x < p.x;
return y < p.y;
}
};
struct xyd {
ld x, y;
xyd() : x(0), y(0) {}
xyd(long double _x, long double _y) : x(_x), y(_y) {}
};
using vec = vector<lint>;
using vecd = vector<ld>;
using vecs = vector<string>;
using vecp = vector<xy>;
template <class T> using vect = vector<T>;
class vec2 : public vector<vector<lint>> {
public:
vec2() {}
vec2(lint n) : vector(n) {}
vec2(lint h, lint w) : vector(h, vector<lint>(w)) {}
vec2(lint h, lint w, lint v) : vector(h, vector<lint>(w, v)) {}
};
template <class T> using priq = priority_queue<T>;
template <class T> using rpriq = priority_queue<T, vector<T>, greater<T>>;
const ulint mod = 1000000007;
const double pi = 3.141592653589793238462;
const lint intmax = 9223372036854775807;
const lint inf = 1100100100100100100LL;
const ld eps = 0.0000001;
const lint alpn = 'z' - 'a' + 1;
template <class It> constexpr auto acc(It begin, It end) {
return accumulate(begin, end, typename It::value_type(0));
}
template <class T> constexpr auto msum(T arg0) { return arg0; }
template <class T, class... Types> constexpr auto msum(T arg0, Types... args) {
static_assert(sizeof...(args) > 0, "arg err");
return arg0 + msum(args...);
}
template <class It> constexpr typename It::value_type mmax(It begin, It end) {
return *max_element(begin, end);
}
template <class It> constexpr typename It::value_type mmin(It begin, It end) {
return *min_element(begin, end);
}
template <class T> constexpr auto mmax(T arg) { return arg; }
template <class T, class... Types> constexpr auto mmax(T arg0, Types... args) {
using promote_t = decltype(msum(arg0, args...));
return max(static_cast<promote_t>(arg0),
static_cast<promote_t>(mmax(args...)));
}
template <class T> constexpr auto mmin(T arg) { return arg; }
template <class T, class... Types> constexpr auto mmin(T arg0, Types... args) {
using promote_t = decltype(msum(arg0, args...));
return min(static_cast<promote_t>(arg0),
static_cast<promote_t>(mmin(args...)));
}
constexpr auto clamp(lint val, lint left, lint right) {
return mmax(mmin(val, right), left);
}
constexpr lint div2(lint p, lint q) { return (p + q - 1) / q; }
lint gcd(lint a, lint b) {
while (1) {
if (a < b)
swap(a, b);
if (!b)
break;
a %= b;
}
return a;
}
lint lcm(lint a, lint b) { return a / gcd(a, b) * b; }
lint powInt(lint a, lint b) {
if (b == 0) {
return 1;
}
if (b == 1) {
return a;
}
lint tmp = powInt(a, b / 2);
return (b % 2 == 1 ? a * tmp * tmp : tmp * tmp);
}
template <class T> T sgn(T val) {
if (val == T(0))
return T(0);
if (val < 0)
return T(-1);
if (val > 0)
return T(1);
}
template <class T> constexpr auto modK_belowN(T k, T MOD, T n) {
return (n + MOD - k - 1) / MOD;
}
template <class It, class T> bool exist(It begin, It end, const T &val) {
return find(begin, end, val) != end;
}
template <class It, class Pr> bool exist_if(It begin, It end, Pr pred) {
return find_if(begin, end, pred) != end;
}
template <class T> bool between(T val, T l, T r) {
return (val >= l) && (val <= r);
}
template <class It> auto carr(It begin, It end) {
vec c;
c.push_back(1);
auto before = *begin;
for (auto it = begin + 1; it != end; it++) {
if (before != *it) {
c.push_back(0);
before = *it;
}
c.back()++;
}
return c;
}
template <class T> struct nval {
lint n;
T val;
nval() : n(0){};
nval(lint _n, T _val) : n(_n), val(_val){};
};
template <class It> auto carr2(It begin, It end) {
using T = nval<remove_reference_t<decltype(*begin)>>;
vect<T> c;
c.push_back(T(1, *begin));
auto before = *begin;
for (auto it = begin + 1; it != end; it++) {
if (before != *it) {
c.push_back(T(0, *it));
before = *it;
}
c.back().n++;
}
return c;
}
template <class It, class... T> void sort2(It begin, It end, T... p) {
using val_t = remove_reference_t<decltype(*begin)>;
sort(begin, end, [p...](val_t a, val_t b) {
bool neq[] = {(a.*p != b.*p)...};
bool sg[] = {(a.*p < b.*p)...};
rep(i, sizeof...(p)) {
if (neq[i]) {
return sg[i];
}
}
return false;
});
}
template <size_t _K, size_t _N, class... Types, size_t... indices>
auto constexpr __ModKtuple_Impl(index_sequence<indices...>,
tuple<Types...> args) {
return make_tuple(get<indices * _N + _K>(args)...);
}
template <size_t K, size_t N, class... Types>
auto constexpr ModKtuple(Types... args) {
return __ModKtuple_Impl<K, N>(
make_index_sequence<modK_belowN(K, N, sizeof...(args))>{},
forward_as_tuple(args...));
}
template <class It, class... T, class... Tsg, size_t... indices>
void __sort3_Impl(It begin, It end, tuple<T...> p, tuple<Tsg...> sgf,
index_sequence<indices...>) {
using val_t = remove_reference_t<decltype(*begin)>;
sort(begin, end, [p, sgf](val_t a, val_t b) {
bool neq[] = {(a.*(get<indices>(p)) != b.*(get<indices>(p)))...};
bool sg[] = {((a.*(get<indices>(p)) < b.*(get<indices>(p))) !=
(get<indices>(sgf)))...};
rep(i, sizeof...(indices)) {
if (neq[i]) {
return sg[i];
}
}
return false;
});
}
template <class It, class... T> void sort3(It begin, It end, T... p) {
using val_t = remove_reference_t<decltype(*begin)>;
auto p_forward = ModKtuple<0, 2>(p...);
auto sgf_forward = ModKtuple<1, 2>(p...);
constexpr auto p_sz = tuple_size<decltype(p_forward)>::value;
constexpr auto sgf_sz = tuple_size<decltype(sgf_forward)>::value;
static_assert(p_sz == sgf_sz, "arg err");
__sort3_Impl(begin, end, p_forward, sgf_forward, make_index_sequence<p_sz>{});
}
char caesar(char s, lint key) {
if (between(s, 'A', 'Z')) {
return (s - 'A' + key) % alpn + 'A';
}
if (between(s, 'a', 'z')) {
return (s - 'a' + key) % alpn + 'a';
}
return s;
}
string caesar(string s, lint key) {
rep(i, s.length()) s[i] = caesar(s[i], key);
return s;
}
template <class It, class It2> auto spacel(It i, It2 end) {
if (i + 1 == end) {
return '\n';
} else {
return ' ';
}
}
template <class It> bool next_comb(lint n, It begin, It end) {
auto rend = make_reverse_iterator(begin);
auto rbegin = make_reverse_iterator(end);
auto rit = rbegin;
for (; rit != rend; rit++) {
if ((rit == rbegin && (*rit) + 1 != n) ||
(rit != rbegin && (*rit) + 1 != *(rit - 1))) {
goto found;
}
}
return false;
found:;
(*rit)++;
for (auto it = rit.base(); it != end; it++) {
(*it) = (*(it - 1)) + 1;
}
return true;
}
ostream &setp(ostream &ost) {
cout << setprecision(60) << fixed;
return ost;
}
#ifdef _LOCAL
auto &dbg = cout;
#else
struct dummy_cout {
template <class T> dummy_cout &operator<<(T &&op) { return *this; }
using endl_t = basic_ostream<char, char_traits<char>>;
dummy_cout &operator<<(endl_t &(*)(endl_t &)) { return *this; }
};
dummy_cout dbg;
#endif
}; // namespace
struct mint {
lint n;
mint() { n = 0; }
mint(lint a) {
if (a != -1)
n = a % mod;
else
n = a;
}
mint &operator+=(mint a) {
n += a.n;
n %= mod;
return *this;
}
mint &operator-=(mint a) {
n += mod;
n -= a.n;
n %= mod;
return *this;
}
mint &operator*=(mint a) {
n *= a.n;
n %= mod;
return *this;
}
mint &operator%=(mint a) {
n %= a.n;
return *this;
}
mint &operator++() {
n++;
n %= mod;
return *this;
}
mint &operator--() {
n += mod;
n--;
n %= mod;
return *this;
}
};
mint operator+(mint a, mint b) {
a += b;
return a;
}
mint operator-(mint a, mint b) {
a -= b;
return a;
}
mint operator*(mint a, mint b) {
a *= b;
return a;
}
vector<mint> invtbl;
vector<mint> finvtbl;
vector<mint> facttbl;
mint factMod(lint n) {
if (n == 0) {
return 1;
}
mint ans = 1;
while (n > 1) {
ans *= n;
n--;
}
return ans;
}
mint powMod(mint x, lint y) {
if (x.n <= 1) {
return x;
}
if (y == 0) {
return 1;
} else if (y == 1) {
return x;
} else if (y % 2 == 0) {
mint tmp = powMod(x, y / 2);
return tmp * tmp;
} else {
mint tmp = powMod(x, y / 2);
return tmp * tmp * x;
}
}
mint modinv(mint n) { return powMod(n, mod - 2); }
void preCalcInv(lint up) {
invtbl.resize(up + 1);
invtbl[1] = 1;
repb(a, 2, up) { invtbl[a] = invtbl[a] = mod - invtbl[mod % a] * (mod / a); }
}
mint operator/(mint a, mint b) {
if (b.n < invtbl.size()) {
a *= invtbl[b.n];
} else {
a *= modinv(b);
}
return a;
}
mint &operator/=(mint &a, mint b) {
a = a / b;
return a;
}
void preCalcFactInv(lint up) {
finvtbl.resize(up + 1);
finvtbl[0] = 1;
finvtbl[up] = modinv(factMod(up));
repbr(a, 1, up - 1) { finvtbl[a] = finvtbl[a + 1] * (a + 1); }
}
void preCalcFact(lint up) {
facttbl.resize(up + 1);
facttbl[0] = 1;
repb(a, 1, up) { facttbl[a] = facttbl[a - 1] * a; }
}
void preCalc(lint up) {
invtbl.resize(up + 1);
finvtbl.resize(up + 1);
facttbl.resize(up + 1);
invtbl[1] = 1;
facttbl[0] = facttbl[1] = 1;
finvtbl[0] = finvtbl[1] = 1;
repb(a, 2, up) {
facttbl[a] = facttbl[a - 1] * a;
invtbl[a] = invtbl[a] = mod - invtbl[mod % a] * (mod / a);
finvtbl[a] = finvtbl[a - 1] * invtbl[a];
}
}
mint factModInv(lint a) {
if (a < finvtbl.size()) {
return finvtbl[a];
} else {
return modinv(factMod(a));
}
}
mint nCrMod(lint n, lint r) {
if (n < r || n < 0 || r < 0) {
return 0;
}
r = mmin(r, n - r);
mint a = 1;
if (n < finvtbl.size() && n < facttbl.size()) {
a *= facttbl[n];
a *= finvtbl[r];
a *= finvtbl[n - r];
return a;
} else {
repb(i, n - r + 1, n) { a *= i; }
a *= factModInv(r);
return a;
}
}
mint nHrMod(lint n, lint r) { return nCrMod(n + r - 1, r); }
template <class T> struct ReRoot {
vec2 tr;
vect<T> dp;
using un_t = T(T a, T b);
using postc_t = T(T a);
un_t *un;
postc_t *post;
const T e;
ReRoot(lint n, T _e)
: tr(n), e(_e), dp(n, e), un(nullptr), post([](T a) { return a; }) {}
void add_e(lint a, lint b) { tr[a].push_back(b); }
T f(lint v, lint rt) {
T res = e;
lint cn = tr[v].size();
rep(i, cn) {
if (tr[v][i] == rt)
continue;
res = un(res, post(f(tr[v][i], v)));
}
dp[v] = res;
return res;
}
void g(lint v, lint rt, T rtDP) {
lint cn = tr[v].size();
vect<T> dpS(cn);
vect<T> dpSr(cn);
dpS[0] = e;
rep(i, cn - 1) {
if (tr[v][i] == rt) {
dpS[i + 1] = un(dpS[i], post(rtDP));
} else {
dpS[i + 1] = un(dpS[i], post(dp[tr[v][i]]));
}
}
dpSr[cn - 1] = e;
repr(i, cn - 1) {
if (tr[v][i + 1] == rt) {
dpSr[i] = un(dpSr[i + 1], post(rtDP));
} else {
dpSr[i] = un(dpSr[i + 1], post(dp[tr[v][i + 1]]));
}
}
rep(i, tr[v].size()) {
if (tr[v][i] == rt)
continue;
auto r = un(dpS[i], dpSr[i]);
dp[tr[v][i]] = un(dp[tr[v][i]], post(r));
g(tr[v][i], v, r);
}
}
void solve() {
f(0, -1);
g(0, -1, e);
}
T operator[](lint i) const { return post(dp[i]); }
};
struct E {
lint nn;
mint ptn;
};
int main() {
lint n;
cin >> n;
preCalc(n + 10);
ReRoot<E> t(n, {0, 1});
rep(i, n - 1) {
lint a, b;
cin >> a >> b;
a--;
b--;
t.add_e(a, b);
t.add_e(b, a);
}
t.un = [](E a, E b) {
a.nn += b.nn;
a.ptn *= b.ptn;
a.ptn *= nCrMod(a.nn, b.nn);
return a;
};
t.post = [](E a) {
a.nn++;
return a;
};
t.solve();
rep(i, n) { cout << t[i].ptn.n << endl; }
return 0;
}
| replace | 566 | 567 | 566 | 567 | -11 | |
p02728 | C++ | Runtime Error | #pragma GCC optimize("O3")
#pragma GCC target("avx")
// #include<bits/stdc++.h>
#include <cstdio>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define Would
#define you
#define please
const int mod = 1e9 + 7;
const int IMAX = 200010;
constexpr ll modpow(ll A, ll B) {
ll kotae = 1;
while (B > 0) {
if (B & 1)
kotae = kotae * A % mod;
A = A * A % mod;
B >>= 1;
}
return kotae;
}
class unko {
public:
int fac[IMAX + 1], ifac[IMAX + 1], inv[IMAX + 1];
constexpr unko() : fac(), ifac(), inv() {
fac[0] = 1;
rep1(i, IMAX) fac[i] = ll(fac[i - 1]) * i % mod;
ifac[IMAX] = modpow(fac[IMAX], mod - 2);
for (int i = IMAX; i > 0; i--)
ifac[i - 1] = ll(ifac[i]) * i % mod;
inv[0] = 1;
rep1(i, IMAX) inv[i] = ll(ifac[i]) * fac[i - 1] % mod;
}
int comb(int A, int B) {
return ll(fac[A]) * ifac[B] % mod * ifac[A - B] % mod;
}
} f;
const int MAX = 120000;
class shuturyoku_unko {
public:
char C[MAX * 6 + 10];
int K[MAX + 10];
constexpr shuturyoku_unko() : C(), K() {
auto di = C + 1;
C[0] = '0';
K[0] = 0;
K[1] = 1;
rep1(i, MAX) {
int X = i;
int keta = 0;
char c[10] = {};
while (X) {
*(c + keta) = '0' + X % 10;
X /= 10;
keta++;
}
for (int j = keta - 1; j >= 0; j--)
*di++ = (*(c + j));
K[i + 1] = K[i] + keta;
}
}
} g;
int N;
const int VN = 200000;
int to[VN * 2 + 2], ne[VN * 2 + 2], he[VN + 1];
int n[VN + 1];
void dfs(int v) {
n[v]++;
int mae = 0;
for (int i = he[v]; i; i = ne[i]) {
int t = to[i];
if (n[t]) {
if (mae)
ne[mae] = ne[i];
else
he[v] = ne[i];
} else {
dfs(t);
n[v] += n[t];
}
mae = i;
}
}
void dfs2(int v) {
for (int i = he[v]; i; i = ne[i]) {
int t = to[i];
n[t] = ll(n[v]) * n[t] % mod * f.inv[N - n[t]] % mod;
dfs2(t);
}
}
const int CM = 2200000;
char cn[CM], *ci = cn;
const ll ma0 = 1157442765409226768;
const ll ma1 = 1085102592571150095;
const ll ma2 = 71777214294589695;
const ll ma3 = 281470681808895;
const ll ma4 = 4294967295;
inline int getint() {
ll tmp = *(ll *)ci;
int dig = 68 - __builtin_ctzll((tmp & ma0) ^ ma0);
tmp = tmp << dig & ma1;
tmp = tmp * 10 + (tmp >> 8) & ma2;
tmp = tmp * 100 + (tmp >> 16) & ma3;
tmp = tmp * 10000 + (tmp >> 32) & ma4;
ci += (64 - dig >> 3) + 1;
return tmp;
}
char *di = cn;
inline void putint(int X) {
int ue = X / 100000;
if (ue) {
for (int i = g.K[ue]; i < g.K[ue + 1]; i++)
*di++ = g.C[i];
int sita = X - ue * 100000ll;
rep(i, 5 - g.K[sita + 1] + g.K[sita]) *di++ = '0';
for (int i = g.K[sita]; i < g.K[sita + 1]; i++)
*di++ = g.C[i];
} else
for (int i = g.K[X]; i < g.K[X + 1]; i++)
*di++ = g.C[i];
*di++ = '\n';
}
int main() {
// cin.tie(0);
// ios::sync_with_stdio(false);
fread(cn, 1, CM, stdin);
N = getint();
int k = 2;
rep1(i, N - 1) {
int a = getint(), b = getint();
to[k] = b;
ne[k] = he[a];
he[a] = k++;
to[k] = a;
ne[k] = he[b];
he[b] = k++;
}
dfs(1);
ll tmp = 1;
rep1(i, N) tmp = (tmp * n[i]) % mod;
n[1] = modpow(tmp, mod - 2) * f.fac[N] % mod;
for (int i = he[1]; i; i = ne[i]) {
int t = to[i];
n[t] = ll(n[1]) * n[t] % mod * f.inv[N - n[t]] % mod;
dfs2(t);
}
rep1(i, N) putint(n[i]);
fwrite(cn, 1, di - cn, stdout);
Would you please return 0;
} | #pragma GCC optimize("O3")
#pragma GCC target("avx")
// #include<bits/stdc++.h>
#include <cstdio>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define Would
#define you
#define please
const int mod = 1e9 + 7;
const int IMAX = 200010;
constexpr ll modpow(ll A, ll B) {
ll kotae = 1;
while (B > 0) {
if (B & 1)
kotae = kotae * A % mod;
A = A * A % mod;
B >>= 1;
}
return kotae;
}
class unko {
public:
int fac[IMAX + 1], ifac[IMAX + 1], inv[IMAX + 1];
constexpr unko() : fac(), ifac(), inv() {
fac[0] = 1;
rep1(i, IMAX) fac[i] = ll(fac[i - 1]) * i % mod;
ifac[IMAX] = modpow(fac[IMAX], mod - 2);
for (int i = IMAX; i > 0; i--)
ifac[i - 1] = ll(ifac[i]) * i % mod;
inv[0] = 1;
rep1(i, IMAX) inv[i] = ll(ifac[i]) * fac[i - 1] % mod;
}
int comb(int A, int B) {
return ll(fac[A]) * ifac[B] % mod * ifac[A - B] % mod;
}
} f;
const int MAX = 120000;
class shuturyoku_unko {
public:
char C[MAX * 6 + 10];
int K[MAX + 10];
constexpr shuturyoku_unko() : C(), K() {
auto di = C + 1;
C[0] = '0';
K[0] = 0;
K[1] = 1;
rep1(i, MAX) {
int X = i;
int keta = 0;
char c[10] = {};
while (X) {
*(c + keta) = '0' + X % 10;
X /= 10;
keta++;
}
for (int j = keta - 1; j >= 0; j--)
*di++ = (*(c + j));
K[i + 1] = K[i] + keta;
}
}
} g;
int N;
const int VN = 200000;
int to[VN * 2 + 2], ne[VN * 2 + 2], he[VN + 1];
int n[VN + 1];
void dfs(int v) {
n[v]++;
int mae = 0;
for (int i = he[v]; i; i = ne[i]) {
int t = to[i];
if (n[t]) {
if (mae)
ne[mae] = ne[i];
else
he[v] = ne[i];
} else {
dfs(t);
n[v] += n[t];
}
mae = i;
}
}
void dfs2(int v) {
for (int i = he[v]; i; i = ne[i]) {
int t = to[i];
n[t] = ll(n[v]) * n[t] % mod * f.inv[N - n[t]] % mod;
dfs2(t);
}
}
const int CM = 2800000;
char cn[CM], *ci = cn;
const ll ma0 = 1157442765409226768;
const ll ma1 = 1085102592571150095;
const ll ma2 = 71777214294589695;
const ll ma3 = 281470681808895;
const ll ma4 = 4294967295;
inline int getint() {
ll tmp = *(ll *)ci;
int dig = 68 - __builtin_ctzll((tmp & ma0) ^ ma0);
tmp = tmp << dig & ma1;
tmp = tmp * 10 + (tmp >> 8) & ma2;
tmp = tmp * 100 + (tmp >> 16) & ma3;
tmp = tmp * 10000 + (tmp >> 32) & ma4;
ci += (64 - dig >> 3) + 1;
return tmp;
}
char *di = cn;
inline void putint(int X) {
int ue = X / 100000;
if (ue) {
for (int i = g.K[ue]; i < g.K[ue + 1]; i++)
*di++ = g.C[i];
int sita = X - ue * 100000ll;
rep(i, 5 - g.K[sita + 1] + g.K[sita]) *di++ = '0';
for (int i = g.K[sita]; i < g.K[sita + 1]; i++)
*di++ = g.C[i];
} else
for (int i = g.K[X]; i < g.K[X + 1]; i++)
*di++ = g.C[i];
*di++ = '\n';
}
int main() {
// cin.tie(0);
// ios::sync_with_stdio(false);
fread(cn, 1, CM, stdin);
N = getint();
int k = 2;
rep1(i, N - 1) {
int a = getint(), b = getint();
to[k] = b;
ne[k] = he[a];
he[a] = k++;
to[k] = a;
ne[k] = he[b];
he[b] = k++;
}
dfs(1);
ll tmp = 1;
rep1(i, N) tmp = (tmp * n[i]) % mod;
n[1] = modpow(tmp, mod - 2) * f.fac[N] % mod;
for (int i = he[1]; i; i = ne[i]) {
int t = to[i];
n[t] = ll(n[1]) * n[t] % mod * f.inv[N - n[t]] % mod;
dfs2(t);
}
rep1(i, N) putint(n[i]);
fwrite(cn, 1, di - cn, stdout);
Would you please return 0;
} | replace | 103 | 104 | 103 | 104 | 0 | |
p02728 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
// エイリアス
using ll = long signed long;
using ull = long unsigned long;
using ld = long double;
using P = pair<int, int>;
using llP = pair<ll, ll>;
using DoP = pair<double, double>;
// 汎用マクロ
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define rep(i, n) for (int i = 0; i < n; ++i)
#define FOREACH(i, q) for (auto &i : q)
#define UNIQUE(v) \
do { \
sort((v).begin(), (v).end()); \
(v).erase(unique((v).begin(), (v).end()), (v).end()); \
} while (false)
#define SZ(x) ((int)(x).size())
template <class T> inline bool chmin(T &a, const T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, const T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline void line_out(const vector<T> vec) {
int n = SZ(vec);
rep(i, n) {
cout << vec[i];
if (i < n - 1)
cout << " ";
}
cout << endl;
}
const int di[] = {0, 1, 0, -1, 1, 1, -1, -1};
const int dj[] = {1, 0, -1, 0, 1, -1, 1, -1};
const int INF = 1 << 28;
const ll INF64 = 1ll << 60;
const int mod = 1000000007;
// const int mod = 998244353;
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++() {
if ((x += 1) >= mod)
x -= mod;
return *this;
}
mint &operator--() {
if ((x += mod - 1) >= mod)
x -= mod;
return *this;
}
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;
}
};
vector<vector<int>> g;
vector<mint> fact(200010);
vector<map<int, pair<mint, int>>> tree;
pair<mint, int> dfs(int now, int par = 0) {
if (tree[now].find(par) != tree[now].end()) {
return tree[now][par];
}
mint res = 1;
int sum = 0;
for (auto next : g[now]) {
if (next == par)
continue;
auto p = dfs(next, now);
sum += p.second;
res *= p.first;
res /= fact[p.second];
}
res *= fact[sum];
return tree[now][par] = make_pair(res, sum + 1);
}
int main() {
int n;
cin >> n;
g.resize(n + 1);
tree.resize(n + 1);
rep(i, n - 1) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
fact[0] = fact[1] = 1;
for (int i = 2; i <= 200000; ++i)
fact[i] = fact[i - 1] * i;
for (int k = 1; k <= n; ++k)
cout << dfs(k).first.x << endl;
} | #include <bits/stdc++.h>
using namespace std;
// エイリアス
using ll = long signed long;
using ull = long unsigned long;
using ld = long double;
using P = pair<int, int>;
using llP = pair<ll, ll>;
using DoP = pair<double, double>;
// 汎用マクロ
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define rep(i, n) for (int i = 0; i < n; ++i)
#define FOREACH(i, q) for (auto &i : q)
#define UNIQUE(v) \
do { \
sort((v).begin(), (v).end()); \
(v).erase(unique((v).begin(), (v).end()), (v).end()); \
} while (false)
#define SZ(x) ((int)(x).size())
template <class T> inline bool chmin(T &a, const T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, const T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline void line_out(const vector<T> vec) {
int n = SZ(vec);
rep(i, n) {
cout << vec[i];
if (i < n - 1)
cout << " ";
}
cout << endl;
}
const int di[] = {0, 1, 0, -1, 1, 1, -1, -1};
const int dj[] = {1, 0, -1, 0, 1, -1, 1, -1};
const int INF = 1 << 28;
const ll INF64 = 1ll << 60;
const int mod = 1000000007;
// const int mod = 998244353;
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++() {
if ((x += 1) >= mod)
x -= mod;
return *this;
}
mint &operator--() {
if ((x += mod - 1) >= mod)
x -= mod;
return *this;
}
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;
}
};
vector<vector<int>> g;
vector<mint> fact(200010);
vector<map<int, pair<mint, int>>> tree;
pair<mint, int> dfs(int now, int par = 0) {
if (tree[now].find(par) != tree[now].end()) {
return tree[now][par];
}
mint res = 1;
int sum = 0;
for (auto next : g[now]) {
if (next == par)
continue;
auto p = dfs(next, now);
sum += p.second;
res *= p.first;
res /= fact[p.second];
}
res *= fact[sum];
return tree[now][par] = make_pair(res, sum + 1);
}
int main() {
int n;
cin >> n;
g.resize(n + 1);
tree.resize(n + 1);
rep(i, n - 1) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
fact[0] = fact[1] = 1;
for (int i = 2; i <= 200000; ++i)
fact[i] = fact[i - 1] * i;
for (int i = 1; i <= n; ++i) {
if (g[i].size() == n - 1) {
for (int j = 1; j <= n; ++j) {
if (j == i)
cout << fact[n - 1].x << endl;
else
cout << fact[n - 2].x << endl;
}
return 0;
}
}
for (int k = 1; k <= n; ++k)
cout << dfs(k).first.x << endl;
} | insert | 149 | 149 | 149 | 160 | TLE | |
p02728 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define MOD 1000000007
// #define MOD 998244353
class mint {
public:
int i;
mint() : i(0) {}
template <class T> mint(T x) {
i = int(x % MOD);
if (i < 0)
i += MOD;
}
mint operator+(mint x) { return i + x.i; }
mint operator-(mint x) { return i - x.i; }
mint operator*(mint x) { return (long long)i * x.i; }
mint operator/(mint x) { return (long long)i * x.pow(MOD - 2).i; }
mint inv() { return pow(MOD - 2); }
template <class T> mint pow(T p) {
long long r = 1;
long long t = i;
for (; p > 0; p >>= 1) {
if (p & 1)
r = r * t % MOD;
t = t * t % MOD;
}
return r;
}
template <class T1, class T2> static mint pow(T1 a, T2 b) {
long long r = 1;
long long t = (long long)(a % MOD);
for (; b > 0; b >>= 1) {
if (b & 1)
r = r * t % MOD;
t = t * t % MOD;
}
return r;
}
mint &operator+=(mint x) {
i = (i + x.i) % MOD;
return *this;
}
mint &operator-=(mint x) {
i = i - x.i;
if (i < 0)
i += MOD;
return *this;
}
mint &operator*=(mint x) {
i = (int)((long long)i * x.i % MOD);
return *this;
}
mint &operator/=(mint x) {
i = (long long)i * x.pow(MOD - 2).i % MOD;
return *this;
}
};
std::ostream &operator<<(std::ostream &os, const mint &m) { return os << m.i; }
mint mperm(int i, int j) {
mint res = 1;
for (; j > 0; j--) {
res *= i;
i--;
}
return res;
}
mint mcomb(int i, int j) {
int k = i - j;
if (k < j)
j = k;
return mperm(i, j) / mperm(j, j);
}
// T has to implement 'operator+' and 'add_parent' method
template <class T> class rtdp {
class Node {
public:
int k; // k_th node
rtdp &nodes; // owner object holding all nodes
const std::vector<int> &children; // children indices
const int csize;
std::vector<T> dp; // stores dps of children
std::vector<T> lmerged;
std::vector<T> rmerged;
Node(rtdp &ns, int i)
: k(i), nodes(ns), children(ns.v[i]), csize(children.size()), dp(csize),
lmerged(csize + 1), rmerged(csize + 1) {}
T fc(int parent = -1) {
const int csize = children.size();
T m;
for (int i = 0; i < csize; i++) {
int ci = children[i];
if (ci == parent)
continue;
dp[i] = nodes.ns[ci].fc(k);
m = m + dp[i];
}
return m.add_parent(k);
}
void fp(int parent = -1) {
const int csize = children.size();
// assume that dp is already filled in
// left merge
for (int i = 0; i < csize; i++) {
lmerged[i + 1] = lmerged[i] + dp[i];
}
// right merge
for (int i = csize; i > 0; i--) {
rmerged[i - 1] = rmerged[i] + dp[i - 1];
}
for (int i = 0; i < csize; i++) {
int ci = children[i];
if (ci == parent)
continue;
Node &cnode = nodes.ns[ci];
for (int j = 0; j < cnode.csize; j++) {
if (cnode.children[j] == k) {
cnode.dp[j] = (lmerged[i] + rmerged[i + 1]).add_parent(k);
break;
}
}
cnode.fp(k);
}
return;
}
};
std::vector<std::vector<int>> &v;
int size;
std::vector<Node> ns;
std::vector<T> root_dp;
public:
rtdp(std::vector<std::vector<int>> &v) : v(v), size(v.size()), root_dp(size) {
for (int i = 0; i < size; i++) {
ns.push_back(Node(*this, i));
}
}
void exec_dp(int root = 0) {
fill_in_children(root);
fill_in_parent(root);
}
void fill_in_children(int root) { ns[root].fc(); }
void fill_in_parent(int root) { ns[root].fp(); }
T get_root_dp(int i) {
Node &r = ns[i];
return r.lmerged[r.csize].add_parent(i);
}
};
struct DP {
int tsize;
mint count;
DP(int s = 0, mint c = 1) : tsize(s), count(c) {}
DP operator+(DP d) {
int tot_tsize = tsize + d.tsize;
mint tot_count = count * d.count * mcomb(tot_tsize, d.tsize);
return DP(tot_tsize, tot_count);
}
DP add_parent(int k) { return DP(tsize + 1, count); }
};
int main() {
int n;
std::cin >> n;
std::vector<std::vector<int>> v(n);
for (int i = 0; i < n - 1; i++) {
int a, b;
std::cin >> a >> b;
a--;
b--;
v[a].push_back(b);
v[b].push_back(a);
}
rtdp<DP> r(v);
r.exec_dp();
for (int i = 0; i < n; i++) {
std::cout << r.get_root_dp(i).count << std::endl;
}
}
| #include <bits/stdc++.h>
#define MOD 1000000007
// #define MOD 998244353
class mint {
public:
int i;
mint() : i(0) {}
template <class T> mint(T x) {
i = int(x % MOD);
if (i < 0)
i += MOD;
}
mint operator+(mint x) { return i + x.i; }
mint operator-(mint x) { return i - x.i; }
mint operator*(mint x) { return (long long)i * x.i; }
mint operator/(mint x) { return (long long)i * x.pow(MOD - 2).i; }
mint inv() { return pow(MOD - 2); }
template <class T> mint pow(T p) {
long long r = 1;
long long t = i;
for (; p > 0; p >>= 1) {
if (p & 1)
r = r * t % MOD;
t = t * t % MOD;
}
return r;
}
template <class T1, class T2> static mint pow(T1 a, T2 b) {
long long r = 1;
long long t = (long long)(a % MOD);
for (; b > 0; b >>= 1) {
if (b & 1)
r = r * t % MOD;
t = t * t % MOD;
}
return r;
}
mint &operator+=(mint x) {
i = (i + x.i) % MOD;
return *this;
}
mint &operator-=(mint x) {
i = i - x.i;
if (i < 0)
i += MOD;
return *this;
}
mint &operator*=(mint x) {
i = (int)((long long)i * x.i % MOD);
return *this;
}
mint &operator/=(mint x) {
i = (long long)i * x.pow(MOD - 2).i % MOD;
return *this;
}
};
std::ostream &operator<<(std::ostream &os, const mint &m) { return os << m.i; }
struct combination {
std::vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < MOD);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
} mcomb(200002);
// T has to implement 'operator+' and 'add_parent' method
template <class T> class rtdp {
class Node {
public:
int k; // k_th node
rtdp &nodes; // owner object holding all nodes
const std::vector<int> &children; // children indices
const int csize;
std::vector<T> dp; // stores dps of children
std::vector<T> lmerged;
std::vector<T> rmerged;
Node(rtdp &ns, int i)
: k(i), nodes(ns), children(ns.v[i]), csize(children.size()), dp(csize),
lmerged(csize + 1), rmerged(csize + 1) {}
T fc(int parent = -1) {
const int csize = children.size();
T m;
for (int i = 0; i < csize; i++) {
int ci = children[i];
if (ci == parent)
continue;
dp[i] = nodes.ns[ci].fc(k);
m = m + dp[i];
}
return m.add_parent(k);
}
void fp(int parent = -1) {
const int csize = children.size();
// assume that dp is already filled in
// left merge
for (int i = 0; i < csize; i++) {
lmerged[i + 1] = lmerged[i] + dp[i];
}
// right merge
for (int i = csize; i > 0; i--) {
rmerged[i - 1] = rmerged[i] + dp[i - 1];
}
for (int i = 0; i < csize; i++) {
int ci = children[i];
if (ci == parent)
continue;
Node &cnode = nodes.ns[ci];
for (int j = 0; j < cnode.csize; j++) {
if (cnode.children[j] == k) {
cnode.dp[j] = (lmerged[i] + rmerged[i + 1]).add_parent(k);
break;
}
}
cnode.fp(k);
}
return;
}
};
std::vector<std::vector<int>> &v;
int size;
std::vector<Node> ns;
std::vector<T> root_dp;
public:
rtdp(std::vector<std::vector<int>> &v) : v(v), size(v.size()), root_dp(size) {
for (int i = 0; i < size; i++) {
ns.push_back(Node(*this, i));
}
}
void exec_dp(int root = 0) {
fill_in_children(root);
fill_in_parent(root);
}
void fill_in_children(int root) { ns[root].fc(); }
void fill_in_parent(int root) { ns[root].fp(); }
T get_root_dp(int i) {
Node &r = ns[i];
return r.lmerged[r.csize].add_parent(i);
}
};
struct DP {
int tsize;
mint count;
DP(int s = 0, mint c = 1) : tsize(s), count(c) {}
DP operator+(DP d) {
int tot_tsize = tsize + d.tsize;
mint tot_count = count * d.count * mcomb(tot_tsize, d.tsize);
return DP(tot_tsize, tot_count);
}
DP add_parent(int k) { return DP(tsize + 1, count); }
};
int main() {
int n;
std::cin >> n;
std::vector<std::vector<int>> v(n);
for (int i = 0; i < n - 1; i++) {
int a, b;
std::cin >> a >> b;
a--;
b--;
v[a].push_back(b);
v[b].push_back(a);
}
rtdp<DP> r(v);
r.exec_dp();
for (int i = 0; i < n; i++) {
std::cout << r.get_root_dp(i).count << std::endl;
}
}
| replace | 73 | 88 | 73 | 90 | TLE | |
p02728 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define rep(i, x, y) for (ll i = (x); i < (y); i++)
#define rrep(i, x, y) for (ll i = (ll)(y)-1; i >= (x); i--)
#define all(x) (x).begin(), (x).end()
#ifdef LOCAL
#define dump(x) cerr << #x << " = " << (x) << endl
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl
#define dassert(...) assert(__VA_ARGS__)
#else
#define dump(x)
#define debug(x)
#define dassert(...)
#endif
// #define int long long
typedef long long ll;
const ll MOD = 1e9 + 7;
const long double EPS = 1e-8;
long long modPow(long long a, long long x, long long p) {
long long res = 1;
while (x > 0) {
if (x % 2 != 0) {
res = (res * a) % p;
}
a = (a * a) % p;
x /= 2;
}
return res;
}
long long modInverse(long long a, long long p) {
// calculates the modular multiplicative of a mod m.
//(assuming p is prime).
return modPow(a, p - 2, p);
}
long long modFactorial(long long a, long long p) {
long long fact = 1;
for (long long i = 2; i <= a; i++) {
fact *= i;
fact %= p;
}
return fact;
}
struct combination {
void preprocess(long long max_n, long long p) {
if (_is_preprocessed)
return;
factorials_ = vector<ll>(max_n + 1, 1);
inverse_factorials_ = vector<ll>(max_n + 1, 1);
for (long long i = 1; i < max_n + 1; i++) {
factorials_[i] = factorials_[i - 1] * i;
factorials_[i] %= p;
}
inverse_factorials_[max_n] = modPow(factorials_[max_n], p - 2, p);
for (long long i = max_n - 1; i >= 1; i--) {
inverse_factorials_[i] = inverse_factorials_[i + 1] * (i + 1);
inverse_factorials_[i] %= MOD;
}
_is_preprocessed = true;
}
long long combination_with_preprocessing(long long n, long long k,
long long p) {
if (!_is_preprocessed)
assert(false);
long long result = factorials_[n];
result *= inverse_factorials_[k];
result %= p;
result *= inverse_factorials_[n - k];
result %= p;
return result;
}
static long long combination_without_preprocessing(long long n, long long k,
long long p) {
// calculates C(n,k) mod p (assuming p is prime).
long long numerator = 1; // n * (n-1) * ... * (n-k+1)
for (int i = 0; i < k; i++) {
numerator = (numerator * (n - i)) % p;
}
long long denominator = 1; // k!
for (int i = 1; i <= k; i++) {
denominator = (denominator * i) % p;
}
// numerator / denominator mod p.
return (numerator * modInverse(denominator, p)) % p;
}
private:
vector<ll> factorials_, inverse_factorials_;
bool _is_preprocessed = false;
};
pair<ll, ll> dfs(int root, int current, vector<vector<int>> &edges,
vector<unordered_map<int, pair<ll, ll>>> &dp,
vector<pair<ll, ll>> &vdp) {
static combination comb;
comb.preprocess(edges.size() + 1, MOD);
if (root != -1 && dp[root].find(current) != dp[root].end()) {
return dp[root][current];
} else if (vdp[current].first != 0) {
ll numVertex = vdp[current].first, numCase = vdp[current].second;
auto diff = dfs(current, root, edges, dp, vdp);
numCase *= modInverse(
comb.combination_with_preprocessing(numVertex, diff.first, MOD), MOD);
numCase %= MOD;
numCase *= modInverse(diff.second, MOD);
numCase %= MOD;
return dp[root][current] = {numVertex - diff.first + 1, numCase};
}
vector<pair<ll, ll>> values;
for (const auto &next : edges[current]) {
if (next == root)
continue;
if (dp[current].find(next) != dp[current].end()) {
values.emplace_back(dp[current][next]);
} else {
values.emplace_back(dfs(current, next, edges, dp, vdp));
}
}
ll numCase = 1, numVertex = 0;
for (const auto &value : values)
numVertex += value.first;
ll nv = numVertex;
for (const auto &value : values) {
numCase *= value.second;
numCase %= MOD;
numCase *= comb.combination_with_preprocessing(nv, value.first, MOD);
numCase %= MOD;
nv -= value.first;
}
if (root != -1) {
return dp[root][current] = {numVertex + 1, numCase};
} else {
return vdp[current] = {numVertex, numCase};
}
}
void solve(long long N, std::vector<long long> a, std::vector<long long> b) {
vector<unordered_map<int, pair<ll, ll>>> dp(
N + 1); // dp[from][to] = {vertex cnt, case cnt};
vector<pair<ll, ll>> vdp(N + 1); // dp[vertex index] = {vertex cnt, case cnt};
vector<vector<int>> edges(N + 1);
rep(i, 0, N - 1) {
edges[a[i]].emplace_back(b[i]);
edges[b[i]].emplace_back(a[i]);
}
rep(i, 1, N + 1) {
if (edges[i].size() != 1)
continue;
dp[edges[i][0]][i] = {1, 1};
}
rep(k, 1, N + 1) { cout << dfs(-1, k, edges, dp, vdp).second << endl; }
}
signed main() {
// ios_base::sync_with_stdio(false);
// cin.tie(NULL);
long long N;
scanf("%lld", &N);
std::vector<long long> a(N - 1);
std::vector<long long> b(N - 1);
for (int i = 0; i < N - 1; i++) {
scanf("%lld", &a[i]);
scanf("%lld", &b[i]);
}
solve(N, std::move(a), std::move(b));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, x, y) for (ll i = (x); i < (y); i++)
#define rrep(i, x, y) for (ll i = (ll)(y)-1; i >= (x); i--)
#define all(x) (x).begin(), (x).end()
#ifdef LOCAL
#define dump(x) cerr << #x << " = " << (x) << endl
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl
#define dassert(...) assert(__VA_ARGS__)
#else
#define dump(x)
#define debug(x)
#define dassert(...)
#endif
// #define int long long
typedef long long ll;
const ll MOD = 1e9 + 7;
const long double EPS = 1e-8;
long long modPow(long long a, long long x, long long p) {
long long res = 1;
while (x > 0) {
if (x % 2 != 0) {
res = (res * a) % p;
}
a = (a * a) % p;
x /= 2;
}
return res;
}
long long modInverse(long long a, long long p) {
// calculates the modular multiplicative of a mod m.
//(assuming p is prime).
return modPow(a, p - 2, p);
}
long long modFactorial(long long a, long long p) {
long long fact = 1;
for (long long i = 2; i <= a; i++) {
fact *= i;
fact %= p;
}
return fact;
}
struct combination {
void preprocess(long long max_n, long long p) {
if (_is_preprocessed)
return;
factorials_ = vector<ll>(max_n + 1, 1);
inverse_factorials_ = vector<ll>(max_n + 1, 1);
for (long long i = 1; i < max_n + 1; i++) {
factorials_[i] = factorials_[i - 1] * i;
factorials_[i] %= p;
}
inverse_factorials_[max_n] = modPow(factorials_[max_n], p - 2, p);
for (long long i = max_n - 1; i >= 1; i--) {
inverse_factorials_[i] = inverse_factorials_[i + 1] * (i + 1);
inverse_factorials_[i] %= MOD;
}
_is_preprocessed = true;
}
long long combination_with_preprocessing(long long n, long long k,
long long p) {
if (!_is_preprocessed)
assert(false);
long long result = factorials_[n];
result *= inverse_factorials_[k];
result %= p;
result *= inverse_factorials_[n - k];
result %= p;
return result;
}
static long long combination_without_preprocessing(long long n, long long k,
long long p) {
// calculates C(n,k) mod p (assuming p is prime).
long long numerator = 1; // n * (n-1) * ... * (n-k+1)
for (int i = 0; i < k; i++) {
numerator = (numerator * (n - i)) % p;
}
long long denominator = 1; // k!
for (int i = 1; i <= k; i++) {
denominator = (denominator * i) % p;
}
// numerator / denominator mod p.
return (numerator * modInverse(denominator, p)) % p;
}
private:
vector<ll> factorials_, inverse_factorials_;
bool _is_preprocessed = false;
};
pair<ll, ll> dfs(int root, int current, vector<vector<int>> &edges,
vector<unordered_map<int, pair<ll, ll>>> &dp,
vector<pair<ll, ll>> &vdp) {
static combination comb;
comb.preprocess(edges.size() + 1, MOD);
if (root != -1 && dp[root].find(current) != dp[root].end()) {
return dp[root][current];
} else if (vdp[current].first != 0) {
ll numVertex = vdp[current].first, numCase = vdp[current].second;
auto diff = dfs(current, root, edges, dp, vdp);
numCase *= modInverse(
comb.combination_with_preprocessing(numVertex, diff.first, MOD), MOD);
numCase %= MOD;
numCase *= modInverse(diff.second, MOD);
numCase %= MOD;
return dp[root][current] = {numVertex - diff.first + 1, numCase};
}
vector<pair<ll, ll>> values;
for (const auto &next : edges[current]) {
if (next == root)
continue;
if (dp[current].find(next) != dp[current].end()) {
values.emplace_back(dp[current][next]);
} else {
values.emplace_back(dfs(current, next, edges, dp, vdp));
}
}
ll numCase = 1, numVertex = 0;
for (const auto &value : values)
numVertex += value.first;
ll nv = numVertex;
for (const auto &value : values) {
numCase *= value.second;
numCase %= MOD;
numCase *= comb.combination_with_preprocessing(nv, value.first, MOD);
numCase %= MOD;
nv -= value.first;
}
if (root != -1) {
return dp[root][current] = {numVertex + 1, numCase};
} else {
return vdp[current] = {numVertex, numCase};
}
}
void solve(long long N, std::vector<long long> a, std::vector<long long> b) {
vector<unordered_map<int, pair<ll, ll>>> dp(
N + 1); // dp[from][to] = {vertex cnt, case cnt};
vector<pair<ll, ll>> vdp(N + 1); // dp[vertex index] = {vertex cnt, case cnt};
vector<vector<int>> edges(N + 1);
rep(i, 0, N - 1) {
edges[a[i]].emplace_back(b[i]);
edges[b[i]].emplace_back(a[i]);
}
rep(i, 1, N + 1) {
if (edges[i].size() != 1)
continue;
dp[edges[i][0]][i] = {1, 1};
}
vector<int> dfsOrder(N);
rep(i, 0, N) dfsOrder[i] = i + 1;
sort(all(dfsOrder), [&](const int a, const int b) {
return edges[a].size() > edges[b].size();
});
rep(i, 0, N) { dfs(-1, dfsOrder[i], edges, dp, vdp); }
rep(k, 1, N + 1) { cout << vdp[k].second << endl; }
}
signed main() {
// ios_base::sync_with_stdio(false);
// cin.tie(NULL);
long long N;
scanf("%lld", &N);
std::vector<long long> a(N - 1);
std::vector<long long> b(N - 1);
for (int i = 0; i < N - 1; i++) {
scanf("%lld", &a[i]);
scanf("%lld", &b[i]);
}
solve(N, std::move(a), std::move(b));
return 0;
}
| replace | 165 | 166 | 165 | 172 | TLE | |
p02728 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 5, mod = 1e9 + 7;
int fpow(int base, int v) {
int tot = 1;
for (; v; v >>= 1, base = 1LL * base * base % mod)
if (v & 1)
tot = 1LL * tot * base % mod;
return tot;
}
vector<int> G[N];
int n, dp[N], sz[N], fac[N], ifac[N], ans[N];
void dfs(int u, int v) {
dp[u] = 1, sz[u] = 1;
for (int i = 0; i < (signed)G[u].size(); ++i)
if (G[u][i] != v) {
dfs(G[u][i], u);
sz[u] += sz[G[u][i]];
dp[u] = 1LL * dp[u] * dp[G[u][i]] % mod * ifac[sz[G[u][i]]] % mod;
}
dp[u] = 1LL * dp[u] * fac[sz[u] - 1] % mod;
}
void dfs2(int u, int v) {
if (u != 1)
ans[u] = 1LL * dp[u] * ifac[sz[u] - 1] % mod * fac[n - 1] % mod * v % mod *
ifac[n - sz[u]] % mod;
int tmp =
1LL * dp[u] * ifac[sz[u] - 1] % mod * v % mod * ifac[n - sz[u]] % mod;
for (int i = 0; i < (signed)G[u].size(); ++i)
if (sz[G[u][i]] < sz[u]) {
dfs2(G[u][i], 1LL * tmp * fac[n - sz[G[u][i]] - 1] % mod *
fpow(dp[G[u][i]], mod - 2) % mod * fac[sz[G[u][i]]] %
mod);
}
}
int main() {
scanf("%d", &n);
fac[0] = 1;
for (int i = 1; i <= n; ++i)
fac[i] = 1LL * fac[i - 1] * i % mod;
ifac[n] = fpow(fac[n], mod - 2);
for (int i = n - 1; i >= 0; --i)
ifac[i] = 1LL * ifac[i + 1] * (i + 1) % mod;
for (int i = 1; i < n; ++i) {
int a, b;
scanf("%d%d", &a, &b);
G[a].push_back(b), G[b].push_back(a);
}
dfs(1, 0);
ans[1] = dp[1];
dfs2(1, 1);
for (int i = 1; i <= n; ++i)
printf("%d\n", ans[i]);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 5, mod = 1e9 + 7;
int fpow(int base, int v) {
int tot = 1;
for (; v; v >>= 1, base = 1LL * base * base % mod)
if (v & 1)
tot = 1LL * tot * base % mod;
return tot;
}
vector<int> G[N];
int n, dp[N], sz[N], fac[N], ifac[N], ans[N];
void dfs(int u, int v) {
dp[u] = 1, sz[u] = 1;
for (int i = 0; i < (signed)G[u].size(); ++i)
if (G[u][i] != v) {
dfs(G[u][i], u);
sz[u] += sz[G[u][i]];
dp[u] = 1LL * dp[u] * dp[G[u][i]] % mod * ifac[sz[G[u][i]]] % mod;
}
dp[u] = 1LL * dp[u] * fac[sz[u] - 1] % mod;
}
void dfs2(int u, int v) {
if (u != 1)
ans[u] = 1LL * dp[u] * ifac[sz[u] - 1] % mod * fac[n - 1] % mod * v % mod *
ifac[n - sz[u]] % mod;
int tmp =
1LL * dp[u] * ifac[sz[u] - 1] % mod * v % mod * ifac[n - sz[u]] % mod;
for (int i = 0; i < (signed)G[u].size(); ++i)
if (sz[G[u][i]] < sz[u]) {
dfs2(G[u][i], 1LL * tmp * fac[n - sz[G[u][i]] - 1] % mod *
fpow(dp[G[u][i]], mod - 2) % mod * fac[sz[G[u][i]]] %
mod);
}
}
int main() {
scanf("%d", &n);
fac[0] = 1;
for (int i = 1; i <= n; ++i)
fac[i] = 1LL * fac[i - 1] * i % mod;
ifac[n] = fpow(fac[n], mod - 2);
for (int i = n - 1; i >= 0; --i)
ifac[i] = 1LL * ifac[i + 1] * (i + 1) % mod;
for (int i = 1; i < n; ++i) {
int a, b;
scanf("%d%d", &a, &b);
G[a].push_back(b), G[b].push_back(a);
}
dfs(1, 0);
ans[1] = dp[1];
dfs2(1, 1);
for (int i = 1; i <= n; ++i)
printf("%d\n", ans[i]);
return 0;
} | replace | 3 | 4 | 3 | 4 | 0 | |
p02728 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, a, ...) \
for (int i = (a) * (strlen(#__VA_ARGS__) != 0); \
i < (int)(strlen(#__VA_ARGS__) ? __VA_ARGS__ : (a)); ++i)
#define per(i, a, ...) \
for (int i = (strlen(#__VA_ARGS__) ? __VA_ARGS__ : (a)) - 1; \
i >= (int)(strlen(#__VA_ARGS__) ? (a) : 0); --i)
#define foreach(i, n) for (auto &i : (n))
#define pii pair<int, int>
#define pll pair<long long, long long>
#define all(x) (x).begin(), (x).end()
#define bit(x) (1ll << (x))
using ll = long long;
const ll MOD = (ll)1e9 + 7;
// const ll MOD = 998244353;
const int INF = (ll)1e9 + 7;
const ll INFLL = (ll)1e18;
using namespace std;
template <class t> using vvector = vector<vector<t>>;
template <class t> using vvvector = vector<vector<vector<t>>>;
template <class t>
using priority_queuer = priority_queue<t, vector<t>, greater<t>>;
template <class t, class u> bool chmax(t &a, u b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class t, class u> bool chmin(t &a, u b) {
if (a > b) {
a = b;
return true;
}
return false;
}
#ifdef DEBUG
#define debug(x) \
cout << "LINE " << __LINE__ << ": " << #x << " = " << x << endl;
#else
#define debug(x) (void)0
#endif
ll modpow(ll x, ll b) {
ll res = 1;
while (b) {
if (b & 1)
res = res * x % MOD;
x = x * x % MOD;
b >>= 1;
}
return res;
}
ll modinv(ll x) { return modpow(x, MOD - 2); }
bool was_output = false;
template <class t> void output(t a) {
if (was_output)
cout << " ";
cout << a;
was_output = true;
}
void outendl() {
was_output = false;
cout << endl;
}
ll in() {
ll res;
scanf("%lld", &res);
return res;
}
template <class t> istream &operator>>(istream &is, vector<t> &x) {
for (auto &i : x)
is >> i;
return is;
}
template <class t, class u> istream &operator>>(istream &is, pair<t, u> &x) {
is >> x.first >> x.second;
return is;
}
template <class t> void in(t &x) { cin >> x; }
template <class t> void out(t x) { cout << x; }
template <long long mod> class modint {
public:
long long x;
modint(long long a) {
x = a % mod;
if (x < 0)
x += mod;
}
modint() { x = 0; }
modint pow(long long a) {
modint res(1), b(x);
while (a) {
if (a & 1)
res *= b;
b *= b;
a >>= 1;
}
return res;
}
modint inv() { return pow(mod - 2); }
modint &operator+=(modint a) {
x = (x + a.x) % mod;
return *this;
}
modint &operator-=(modint a) {
x = x - a.x;
if (x < 0)
x += mod;
return *this;
}
modint &operator*=(modint a) {
x = x * a.x % mod;
return *this;
}
modint &operator/=(modint a) {
x = x * a.inv().x % mod;
return *this;
}
modint operator+(modint a) { return modint(x) += a; }
modint operator-(modint a) { return modint(x) -= a; }
modint operator*(modint a) { return modint(x) *= a; }
modint operator/(modint a) { return modint(x) /= a; }
modint operator-() { return modint(x); }
bool operator==(const modint a) { return x == a.x; }
bool operator<(const modint a) { return x < a.x; }
bool operator>(const modint a) { return x > a.x; }
};
template <long long mod>
ostream &operator<<(ostream &os, const modint<mod> &a) {
os << a.x;
return os;
}
using mint = modint<MOD>;
int n;
vvector<pii> edges;
mint factorial(int x) {
static vector<mint> dp;
if (dp.empty()) {
dp.resize(2e5 + 10);
dp[0] = 1;
dp[1] = 1;
rep(i, dp.size() - 1) { dp[i + 1] = dp[i] * (i + 1); }
}
if (x <= 1)
return 1;
return dp[x];
}
mint factorial_inv(int x) {
static vector<mint> dp;
if (dp.empty()) {
dp.resize(2e5 + 10);
dp[2e5 + 5] = factorial(2e5 + 5).inv();
per(i, 2e5 + 5) { dp[i] = dp[i + 1] * (i + 1); }
}
if (x <= 1)
return 1;
return dp[x];
}
using P = pair<int, mint>;
P func(int place, int last) {
static vvector<P> dp(2e5 + 10);
static vvector<bool> used(2e5 + 10);
if (dp[place].empty()) {
dp[place].resize(edges[place].size());
used[place].resize(edges[place].size(), false);
}
if (last >= 0)
if (used[place][last])
return dp[place][last];
P res(0, 1);
rep(i, edges[place].size()) {
if (i == last)
continue;
P m = func(edges[place][i].first, edges[place][i].second);
res.first += m.first;
res.second *= m.second;
res.second *= factorial_inv(m.first);
}
res.second *= factorial(res.first);
++res.first;
if (last >= 0) {
used[place][last] = true;
dp[place][last] = res;
}
return res;
}
void setup() {
n = in();
edges.resize(n);
rep(i, n - 1) {
int a = in() - 1;
int b = in() - 1;
edges[a].emplace_back(b, edges[b].size());
edges[b].emplace_back(a, edges[a].size() - 1);
}
}
int main() {
setup();
vector<mint> anses(n);
vector<pii> line;
rep(i, n) { line.emplace_back(edges[i].size(), i); }
sort(all(line), [](pii a, pii b) { return a.first > b.first; });
foreach (i, line) {
anses[i.second] = func(i.second, -1).second;
}
rep(i, n) { cout << anses[i] << endl; }
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, a, ...) \
for (int i = (a) * (strlen(#__VA_ARGS__) != 0); \
i < (int)(strlen(#__VA_ARGS__) ? __VA_ARGS__ : (a)); ++i)
#define per(i, a, ...) \
for (int i = (strlen(#__VA_ARGS__) ? __VA_ARGS__ : (a)) - 1; \
i >= (int)(strlen(#__VA_ARGS__) ? (a) : 0); --i)
#define foreach(i, n) for (auto &i : (n))
#define pii pair<int, int>
#define pll pair<long long, long long>
#define all(x) (x).begin(), (x).end()
#define bit(x) (1ll << (x))
using ll = long long;
const ll MOD = (ll)1e9 + 7;
// const ll MOD = 998244353;
const int INF = (ll)1e9 + 7;
const ll INFLL = (ll)1e18;
using namespace std;
template <class t> using vvector = vector<vector<t>>;
template <class t> using vvvector = vector<vector<vector<t>>>;
template <class t>
using priority_queuer = priority_queue<t, vector<t>, greater<t>>;
template <class t, class u> bool chmax(t &a, u b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class t, class u> bool chmin(t &a, u b) {
if (a > b) {
a = b;
return true;
}
return false;
}
#ifdef DEBUG
#define debug(x) \
cout << "LINE " << __LINE__ << ": " << #x << " = " << x << endl;
#else
#define debug(x) (void)0
#endif
ll modpow(ll x, ll b) {
ll res = 1;
while (b) {
if (b & 1)
res = res * x % MOD;
x = x * x % MOD;
b >>= 1;
}
return res;
}
ll modinv(ll x) { return modpow(x, MOD - 2); }
bool was_output = false;
template <class t> void output(t a) {
if (was_output)
cout << " ";
cout << a;
was_output = true;
}
void outendl() {
was_output = false;
cout << endl;
}
ll in() {
ll res;
scanf("%lld", &res);
return res;
}
template <class t> istream &operator>>(istream &is, vector<t> &x) {
for (auto &i : x)
is >> i;
return is;
}
template <class t, class u> istream &operator>>(istream &is, pair<t, u> &x) {
is >> x.first >> x.second;
return is;
}
template <class t> void in(t &x) { cin >> x; }
template <class t> void out(t x) { cout << x; }
template <long long mod> class modint {
public:
long long x;
modint(long long a) {
x = a % mod;
if (x < 0)
x += mod;
}
modint() { x = 0; }
modint pow(long long a) {
modint res(1), b(x);
while (a) {
if (a & 1)
res *= b;
b *= b;
a >>= 1;
}
return res;
}
modint inv() { return pow(mod - 2); }
modint &operator+=(modint a) {
x = (x + a.x) % mod;
return *this;
}
modint &operator-=(modint a) {
x = x - a.x;
if (x < 0)
x += mod;
return *this;
}
modint &operator*=(modint a) {
x = x * a.x % mod;
return *this;
}
modint &operator/=(modint a) {
x = x * a.inv().x % mod;
return *this;
}
modint operator+(modint a) { return modint(x) += a; }
modint operator-(modint a) { return modint(x) -= a; }
modint operator*(modint a) { return modint(x) *= a; }
modint operator/(modint a) { return modint(x) /= a; }
modint operator-() { return modint(x); }
bool operator==(const modint a) { return x == a.x; }
bool operator<(const modint a) { return x < a.x; }
bool operator>(const modint a) { return x > a.x; }
};
template <long long mod>
ostream &operator<<(ostream &os, const modint<mod> &a) {
os << a.x;
return os;
}
using mint = modint<MOD>;
int n;
vvector<pii> edges;
mint factorial(int x) {
static vector<mint> dp;
if (dp.empty()) {
dp.resize(2e5 + 10);
dp[0] = 1;
dp[1] = 1;
rep(i, dp.size() - 1) { dp[i + 1] = dp[i] * (i + 1); }
}
if (x <= 1)
return 1;
return dp[x];
}
mint factorial_inv(int x) {
static vector<mint> dp;
if (dp.empty()) {
dp.resize(2e5 + 10);
dp[2e5 + 5] = factorial(2e5 + 5).inv();
per(i, 2e5 + 5) { dp[i] = dp[i + 1] * (i + 1); }
}
if (x <= 1)
return 1;
return dp[x];
}
using P = pair<int, mint>;
P func(int place, int last) {
static vvector<P> dp(2e5 + 10);
static vvector<bool> used(2e5 + 10);
if (dp[place].empty()) {
dp[place].resize(edges[place].size());
used[place].resize(edges[place].size(), false);
}
if (last >= 0)
if (used[place][last])
return dp[place][last];
P res(0, 1);
rep(i, edges[place].size()) {
if (i == last)
continue;
P m = func(edges[place][i].first, edges[place][i].second);
res.first += m.first;
res.second *= m.second;
res.second *= factorial_inv(m.first);
}
res.second *= factorial(res.first);
++res.first;
if (last >= 0) {
used[place][last] = true;
dp[place][last] = res;
} else {
rep(i, edges[place].size()) {
P m = func(edges[place][i].first, edges[place][i].second);
P co = res;
--co.first;
co.second *= factorial_inv(co.first);
co.second *= factorial(m.first);
co.second /= m.second;
co.first -= m.first;
co.second *= factorial(co.first);
++co.first;
used[place][i] = true;
dp[place][i] = co;
}
}
return res;
}
void setup() {
n = in();
edges.resize(n);
rep(i, n - 1) {
int a = in() - 1;
int b = in() - 1;
edges[a].emplace_back(b, edges[b].size());
edges[b].emplace_back(a, edges[a].size() - 1);
}
}
int main() {
setup();
vector<mint> anses(n);
vector<pii> line;
rep(i, n) { line.emplace_back(edges[i].size(), i); }
sort(all(line), [](pii a, pii b) { return a.first > b.first; });
foreach (i, line) {
anses[i.second] = func(i.second, -1).second;
}
rep(i, n) { cout << anses[i] << endl; }
return 0;
}
| insert | 204 | 204 | 204 | 218 | TLE | |
p02728 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
/*
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
*/
typedef long long ll;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef pair<long long, long long> pll;
typedef vector<pll> vpll;
typedef long double ld;
typedef vector<ld> vld;
typedef vector<bool> vb;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define reps(i, n) for (ll i = 1; i <= (n); i++)
#define rrep(i, n) for (ll i = (n)-1; i >= 0; i--)
#define rreps(i, n) for (ll i = (n); i >= 1; i--)
#define all(v) (v).begin(), (v).end()
template <class T> void chmin(T &a, T b) { a = min(a, b); }
template <class T> void chmax(T &a, T b) { a = max(a, b); }
constexpr int INF = 1 << 30;
constexpr ll INFL = 1LL << 60;
constexpr ll MOD = 1000000007;
constexpr ld EPS = 1e-12;
ld PI = acos(-1.0);
struct mint {
ll x;
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;
}
};
const int cmax = 100010;
mint fac[cmax], finv[cmax], inv[cmax];
void com_init() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < cmax; i++) {
fac[i] = fac[i - 1] * i;
inv[i] = -inv[MOD % i] * (MOD / i);
finv[i] = finv[i - 1] * inv[i];
}
}
mint com(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
mint ret = fac[n] * finv[k] * finv[n - k];
return ret;
}
struct DP {
mint dp;
ll cnt;
DP(mint dp = 1, ll cnt = 0) : dp(dp), cnt(cnt){};
DP operator+(const DP &a) {
DP ret(*this);
ret.dp *= com(ret.cnt + a.cnt, ret.cnt);
ret.dp *= a.dp;
ret.cnt += a.cnt;
return ret;
}
DP operator-(const DP &a) {
DP ret(*this);
ret.cnt -= a.cnt;
ret.dp /= com(ret.cnt + a.cnt, ret.cnt);
ret.dp /= a.dp;
return ret;
}
DP add_root() {
DP ret(*this);
ret.cnt++;
return ret;
}
};
vvll g;
vector<DP> dp;
void dfs(ll v, ll p = -1) {
for (auto u : g[v]) {
if (u == p)
continue;
dfs(u, v);
dp[v] = dp[v] + dp[u].add_root();
}
}
void dfs2(ll v, ll p = -1) {
for (auto u : g[v]) {
if (u == p)
continue;
DP d = dp[v] - dp[u].add_root();
dp[u] = dp[u] + d.add_root();
dfs2(u, v);
}
}
void solve() {
ll n;
cin >> n;
g = vvll(n);
for (ll i = 0; i < n - 1; i++) {
ll a, b;
cin >> a >> b;
a--, b--;
g[a].push_back(b);
g[b].push_back(a);
}
dp = vector<DP>(n);
com_init();
dfs(0);
dfs2(0);
for (ll i = 0; i < n; i++)
cout << dp[i].dp.x << endl;
return;
}
int main() {
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
cout << fixed << setprecision(15);
solve();
} | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
/*
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
*/
typedef long long ll;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef pair<long long, long long> pll;
typedef vector<pll> vpll;
typedef long double ld;
typedef vector<ld> vld;
typedef vector<bool> vb;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define reps(i, n) for (ll i = 1; i <= (n); i++)
#define rrep(i, n) for (ll i = (n)-1; i >= 0; i--)
#define rreps(i, n) for (ll i = (n); i >= 1; i--)
#define all(v) (v).begin(), (v).end()
template <class T> void chmin(T &a, T b) { a = min(a, b); }
template <class T> void chmax(T &a, T b) { a = max(a, b); }
constexpr int INF = 1 << 30;
constexpr ll INFL = 1LL << 60;
constexpr ll MOD = 1000000007;
constexpr ld EPS = 1e-12;
ld PI = acos(-1.0);
struct mint {
ll x;
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;
}
};
const int cmax = 200010;
mint fac[cmax], finv[cmax], inv[cmax];
void com_init() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < cmax; i++) {
fac[i] = fac[i - 1] * i;
inv[i] = -inv[MOD % i] * (MOD / i);
finv[i] = finv[i - 1] * inv[i];
}
}
mint com(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
mint ret = fac[n] * finv[k] * finv[n - k];
return ret;
}
struct DP {
mint dp;
ll cnt;
DP(mint dp = 1, ll cnt = 0) : dp(dp), cnt(cnt){};
DP operator+(const DP &a) {
DP ret(*this);
ret.dp *= com(ret.cnt + a.cnt, ret.cnt);
ret.dp *= a.dp;
ret.cnt += a.cnt;
return ret;
}
DP operator-(const DP &a) {
DP ret(*this);
ret.cnt -= a.cnt;
ret.dp /= com(ret.cnt + a.cnt, ret.cnt);
ret.dp /= a.dp;
return ret;
}
DP add_root() {
DP ret(*this);
ret.cnt++;
return ret;
}
};
vvll g;
vector<DP> dp;
void dfs(ll v, ll p = -1) {
for (auto u : g[v]) {
if (u == p)
continue;
dfs(u, v);
dp[v] = dp[v] + dp[u].add_root();
}
}
void dfs2(ll v, ll p = -1) {
for (auto u : g[v]) {
if (u == p)
continue;
DP d = dp[v] - dp[u].add_root();
dp[u] = dp[u] + d.add_root();
dfs2(u, v);
}
}
void solve() {
ll n;
cin >> n;
g = vvll(n);
for (ll i = 0; i < n - 1; i++) {
ll a, b;
cin >> a >> b;
a--, b--;
g[a].push_back(b);
g[b].push_back(a);
}
dp = vector<DP>(n);
com_init();
dfs(0);
dfs2(0);
for (ll i = 0; i < n; i++)
cout << dp[i].dp.x << endl;
return;
}
int main() {
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
cout << fixed << setprecision(15);
solve();
} | replace | 103 | 104 | 103 | 104 | 0 | |
p02728 | C++ | Runtime Error | // Optimise
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
// #define MULTI_TEST
#ifdef LOCAL
#include "/home/shahraaz/bin/debug.h"
#else
#define db(...)
#define pc(...)
#endif
#define f first
#define s second
#define pb push_back
#define all(v) v.begin(), v.end()
auto TimeStart = chrono::steady_clock::now();
auto seed = TimeStart.time_since_epoch().count();
std::mt19937 rng(seed);
using ll = long long;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template <typename T> using Random = std::uniform_int_distribution<T>;
const int NAX = 2e5 + 5, MOD = 1000000007;
const int _n = 1e5 + 10;
vector<int> Fact(_n), Inv(_n);
const int kmod = 1000000007;
int mul(int a, int b, int mod = kmod) { return (long long)a * b % mod; }
int add(int a, int b, int mod = kmod) {
a += b;
if (a >= mod)
a -= mod;
return a;
}
int sub(int a, int b, int mod = kmod) {
a -= b;
if (a < 0)
a += mod;
return a;
}
int power(int base, int index, int mod = kmod) {
if (index == 0)
return 1;
int temp = power(base, index / 2, mod);
temp = mul(temp, temp, mod);
if (index & 1)
temp = mul(temp, base, mod);
return temp;
}
int mod_inv(int x, int mod = kmod) { return power(x, kmod - 2); }
void pre() {
Fact[0] = 1;
for (int i = 1; i < _n; ++i)
Fact[i] = mul(Fact[i - 1], i);
Inv[_n - 1] = mod_inv(Fact[_n - 1]);
for (int i = _n - 2; i >= 0; --i)
Inv[i] = mul(Inv[i + 1], (1 + i));
}
int ncr(int n, int r) {
if (n < 0 || r < 0 || n - r < 0)
return 0;
return mul(Fact[n], mul(Inv[r], Inv[n - r]));
}
vector<int> adj[NAX];
int sz[NAX];
int subTreeWaysDen[NAX];
int res[NAX], answer[NAX];
int num;
class Solution {
private:
void dfsInit(int node, int par) {
sz[node] = 1;
subTreeWaysDen[node] = 1;
for (auto &child : adj[node])
if (child != par) {
dfsInit(child, node);
sz[node] += sz[child];
subTreeWaysDen[node] = mul(subTreeWaysDen[node], sz[child]);
}
}
void dfsCalc0(int node, int par) {
if (sz[node] == 1) {
res[node] = 1;
// db(node, par, res[node], sz[node]);
// db("end");
return;
}
res[node] = Fact[sz[node] - 1];
for (auto &child : adj[node])
if (child != par) {
dfsCalc0(child, node);
res[node] = mul(res[node], res[child]);
res[node] = mul(res[node], Inv[sz[child]]);
// db(node, child, res[node], res[child]);
}
// db(node, par, res[node], sz[node]);
// db("end");
}
void dfsFinal(int node, int par) {
// sz[node] = n;
db(node, par, sz[node]);
res[node] = Fact[sz[node] - 1];
for (auto &child : adj[node]) {
res[node] = mul(res[node], res[child]);
res[node] = mul(res[node], Inv[sz[child]]);
db(node, child, res[node], res[child], sz[child]);
}
ll currWays = res[node];
int szOld = sz[node];
res[node] = mul(res[node], Inv[szOld]);
answer[node] = currWays;
for (auto &child : adj[node])
if (child != par) {
res[node] = currWays;
res[node] = mul(res[node], Inv[sz[node] - 1]);
sz[node] = n - sz[child];
res[node] = mul(res[node], Fact[sz[node] - 1]);
res[node] = mul(res[node], Fact[sz[child]]);
res[node] = mul(res[node], mod_inv(res[child]));
int oldCsz = sz[child];
sz[child] = n;
dfsFinal(child, node);
sz[node] = szOld;
sz[child] = oldCsz;
}
}
public:
int n;
Solution() { pre(); }
~Solution() {}
void solveCase() {
cin >> n;
for (size_t i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
adj[u].pb(v);
adj[v].pb(u);
}
dfsInit(1, 1);
num = Fact[n - 1];
dfsCalc0(1, 1);
dfsFinal(1, 1);
for (size_t i = 0; i < n; i++)
cout << answer[i + 1] << '\n';
}
};
int32_t main() {
#ifndef LOCAL
ios_base::sync_with_stdio(0);
cin.tie(0);
#endif
int t = 1;
#ifdef MULTI_TEST
cin >> t;
#endif
Solution mySolver;
for (int i = 1; i <= t; ++i) {
mySolver.solveCase();
#ifdef TIME
cerr << "Case #" << i << ": Time "
<< chrono::duration<double>(chrono::steady_clock::now() - TimeStart)
.count()
<< " s.\n";
TimeStart = chrono::steady_clock::now();
#endif
}
return 0;
} | // Optimise
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
// #define MULTI_TEST
#ifdef LOCAL
#include "/home/shahraaz/bin/debug.h"
#else
#define db(...)
#define pc(...)
#endif
#define f first
#define s second
#define pb push_back
#define all(v) v.begin(), v.end()
auto TimeStart = chrono::steady_clock::now();
auto seed = TimeStart.time_since_epoch().count();
std::mt19937 rng(seed);
using ll = long long;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template <typename T> using Random = std::uniform_int_distribution<T>;
const int NAX = 2e5 + 5, MOD = 1000000007;
const int _n = 2e5 + 10;
vector<int> Fact(_n), Inv(_n);
const int kmod = 1000000007;
int mul(int a, int b, int mod = kmod) { return (long long)a * b % mod; }
int add(int a, int b, int mod = kmod) {
a += b;
if (a >= mod)
a -= mod;
return a;
}
int sub(int a, int b, int mod = kmod) {
a -= b;
if (a < 0)
a += mod;
return a;
}
int power(int base, int index, int mod = kmod) {
if (index == 0)
return 1;
int temp = power(base, index / 2, mod);
temp = mul(temp, temp, mod);
if (index & 1)
temp = mul(temp, base, mod);
return temp;
}
int mod_inv(int x, int mod = kmod) { return power(x, kmod - 2); }
void pre() {
Fact[0] = 1;
for (int i = 1; i < _n; ++i)
Fact[i] = mul(Fact[i - 1], i);
Inv[_n - 1] = mod_inv(Fact[_n - 1]);
for (int i = _n - 2; i >= 0; --i)
Inv[i] = mul(Inv[i + 1], (1 + i));
}
int ncr(int n, int r) {
if (n < 0 || r < 0 || n - r < 0)
return 0;
return mul(Fact[n], mul(Inv[r], Inv[n - r]));
}
vector<int> adj[NAX];
int sz[NAX];
int subTreeWaysDen[NAX];
int res[NAX], answer[NAX];
int num;
class Solution {
private:
void dfsInit(int node, int par) {
sz[node] = 1;
subTreeWaysDen[node] = 1;
for (auto &child : adj[node])
if (child != par) {
dfsInit(child, node);
sz[node] += sz[child];
subTreeWaysDen[node] = mul(subTreeWaysDen[node], sz[child]);
}
}
void dfsCalc0(int node, int par) {
if (sz[node] == 1) {
res[node] = 1;
// db(node, par, res[node], sz[node]);
// db("end");
return;
}
res[node] = Fact[sz[node] - 1];
for (auto &child : adj[node])
if (child != par) {
dfsCalc0(child, node);
res[node] = mul(res[node], res[child]);
res[node] = mul(res[node], Inv[sz[child]]);
// db(node, child, res[node], res[child]);
}
// db(node, par, res[node], sz[node]);
// db("end");
}
void dfsFinal(int node, int par) {
// sz[node] = n;
db(node, par, sz[node]);
res[node] = Fact[sz[node] - 1];
for (auto &child : adj[node]) {
res[node] = mul(res[node], res[child]);
res[node] = mul(res[node], Inv[sz[child]]);
db(node, child, res[node], res[child], sz[child]);
}
ll currWays = res[node];
int szOld = sz[node];
res[node] = mul(res[node], Inv[szOld]);
answer[node] = currWays;
for (auto &child : adj[node])
if (child != par) {
res[node] = currWays;
res[node] = mul(res[node], Inv[sz[node] - 1]);
sz[node] = n - sz[child];
res[node] = mul(res[node], Fact[sz[node] - 1]);
res[node] = mul(res[node], Fact[sz[child]]);
res[node] = mul(res[node], mod_inv(res[child]));
int oldCsz = sz[child];
sz[child] = n;
dfsFinal(child, node);
sz[node] = szOld;
sz[child] = oldCsz;
}
}
public:
int n;
Solution() { pre(); }
~Solution() {}
void solveCase() {
cin >> n;
for (size_t i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
adj[u].pb(v);
adj[v].pb(u);
}
dfsInit(1, 1);
num = Fact[n - 1];
dfsCalc0(1, 1);
dfsFinal(1, 1);
for (size_t i = 0; i < n; i++)
cout << answer[i + 1] << '\n';
}
};
int32_t main() {
#ifndef LOCAL
ios_base::sync_with_stdio(0);
cin.tie(0);
#endif
int t = 1;
#ifdef MULTI_TEST
cin >> t;
#endif
Solution mySolver;
for (int i = 1; i <= t; ++i) {
mySolver.solveCase();
#ifdef TIME
cerr << "Case #" << i << ": Time "
<< chrono::duration<double>(chrono::steady_clock::now() - TimeStart)
.count()
<< " s.\n";
TimeStart = chrono::steady_clock::now();
#endif
}
return 0;
} | replace | 30 | 31 | 30 | 31 | 0 | |
p02728 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <vector>
#define ll long long int
#define mp make_pair
#define pb push_back
#define vi vector<int>
using namespace std;
vector<vector<int>> edge(200007);
vector<pair<ll, int>> dp(200007, mp(-1, 0));
vector<ll> ans(200007);
vector<int> euler(400007);
vector<bool> vis(200007, 0);
const ll p = 1e9 + 7;
ll modpower(ll base, ll power, ll mod = p) {
ll ans = 1;
base %= p;
while (power) {
if (power & 1) {
ans *= base;
ans %= p;
}
base *= base;
base %= p;
power >>= 1;
}
return ans;
}
ll fact[200007];
ll invfact[200007];
void computefactorial() {
fact[0] = 1;
for (int i = 1; i < 200007; i++) {
fact[i] = i * fact[i - 1];
fact[i] %= p;
}
invfact[200006] = modpower(fact[200006], p - 2);
for (int i = 200005; i >= 0; i--) {
invfact[i] = (i + 1) * invfact[i + 1];
invfact[i] %= p;
}
}
void eulerTree(int u, int &indx) {
vis[u] = 1;
euler[indx++] = u;
for (auto it : edge[u]) {
if (!vis[it]) {
eulerTree(it, indx);
euler[indx++] = u;
}
}
}
void solve(int u, int v) {
if (dp[u].first != -1) {
return;
}
if (u != v && edge[u].size() == 1) {
dp[u] = mp(1, 1);
return;
}
ll ans = 1;
int size = 0;
for (int i = 0; i < edge[u].size(); i++) {
if (edge[u][i] == v) {
continue;
}
solve(edge[u][i], u);
ans *= dp[edge[u][i]].first;
ans %= p;
ans *= invfact[dp[edge[u][i]].second];
ans %= p;
size += dp[edge[u][i]].second;
}
ans *= fact[size];
ans %= p;
dp[u] = mp(ans, size + 1);
return;
}
ll solve() {
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
edge[--u].pb(--v);
edge[v].pb(u);
}
solve(0, 0);
ans[0] = dp[0].first;
int idx = 0;
eulerTree(0, idx);
for (int i = 1; i < idx; i++) {
dp[euler[i - 1]].first *= invfact[dp[euler[i - 1]].second - 1];
dp[euler[i - 1]].first %= p;
dp[euler[i - 1]].second -= dp[euler[i]].second;
dp[euler[i - 1]].first *= fact[dp[euler[i - 1]].second - 1];
dp[euler[i - 1]].first %= p;
dp[euler[i - 1]].first *= modpower(dp[euler[i]].first, p - 2);
dp[euler[i - 1]].first %= p;
dp[euler[i - 1]].first *= fact[dp[euler[i]].second];
dp[euler[i - 1]].first %= p;
dp[euler[i]] = mp(-1, 0);
solve(euler[i], euler[i]);
ans[euler[i]] = dp[euler[i]].first;
}
for (int i = 0; i < n; i++) {
cout << ans[i] << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
computefactorial();
solve();
} | #include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <vector>
#define ll long long int
#define mp make_pair
#define pb push_back
#define vi vector<int>
using namespace std;
vector<vector<int>> edge(200007);
vector<pair<ll, int>> dp(200007, mp(-1, 0));
vector<ll> ans(200007);
vector<int> euler(400007);
vector<bool> vis(200007, 0);
const ll p = 1e9 + 7;
ll modpower(ll base, ll power, ll mod = p) {
ll ans = 1;
base %= p;
while (power) {
if (power & 1) {
ans *= base;
ans %= p;
}
base *= base;
base %= p;
power >>= 1;
}
return ans;
}
ll fact[200007];
ll invfact[200007];
void computefactorial() {
fact[0] = 1;
for (int i = 1; i < 200007; i++) {
fact[i] = i * fact[i - 1];
fact[i] %= p;
}
invfact[200006] = modpower(fact[200006], p - 2);
for (int i = 200005; i >= 0; i--) {
invfact[i] = (i + 1) * invfact[i + 1];
invfact[i] %= p;
}
}
void eulerTree(int u, int &indx) {
vis[u] = 1;
euler[indx++] = u;
for (auto it : edge[u]) {
if (!vis[it]) {
eulerTree(it, indx);
euler[indx++] = u;
}
}
}
void solve(int u, int v) {
if (dp[u].first != -1) {
return;
}
if (u != v && edge[u].size() == 1) {
dp[u] = mp(1, 1);
return;
}
ll ans = 1;
int size = 0;
for (int i = 0; i < edge[u].size(); i++) {
if (edge[u][i] == v) {
continue;
}
solve(edge[u][i], u);
ans *= dp[edge[u][i]].first;
ans %= p;
ans *= invfact[dp[edge[u][i]].second];
ans %= p;
size += dp[edge[u][i]].second;
}
ans *= fact[size];
ans %= p;
dp[u] = mp(ans, size + 1);
return;
}
ll solve() {
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
edge[--u].pb(--v);
edge[v].pb(u);
}
solve(0, 0);
ans[0] = dp[0].first;
int idx = 0;
eulerTree(0, idx);
for (int i = 1; i < idx; i++) {
dp[euler[i - 1]].first *= invfact[dp[euler[i - 1]].second - 1];
dp[euler[i - 1]].first %= p;
dp[euler[i - 1]].second -= dp[euler[i]].second;
dp[euler[i - 1]].first *= fact[dp[euler[i - 1]].second - 1];
dp[euler[i - 1]].first %= p;
dp[euler[i - 1]].first *= modpower(dp[euler[i]].first, p - 2);
dp[euler[i - 1]].first %= p;
dp[euler[i - 1]].first *= fact[dp[euler[i]].second];
dp[euler[i - 1]].first %= p;
dp[euler[i]].first *= invfact[dp[euler[i]].second - 1];
dp[euler[i]].second += dp[euler[i - 1]].second;
dp[euler[i]].first %= p;
dp[euler[i]].first *= fact[dp[euler[i]].second - 1];
dp[euler[i]].first %= p;
dp[euler[i]].first *= invfact[dp[euler[i - 1]].second];
dp[euler[i]].first %= p;
dp[euler[i]].first *= dp[euler[i - 1]].first;
dp[euler[i]].first %= p;
ans[euler[i]] = dp[euler[i]].first;
}
for (int i = 0; i < n; i++) {
cout << ans[i] << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
computefactorial();
solve();
} | replace | 102 | 104 | 102 | 111 | TLE | |
p02728 | C++ | Runtime Error | #include <bits/stdc++.h>
int main() {
using namespace std;
constexpr unsigned long MOD = 1000000007;
const auto &modinv = [](unsigned long a,
unsigned long b = 1) -> unsigned long {
unsigned long r{b % MOD}, n{MOD - 2};
while (n) {
if (n & 1)
(r *= a) %= MOD;
(a *= a) %= MOD;
n >>= 1;
}
return r;
};
unsigned long N;
cin >> N;
vector<unsigned long> fac(N + 1, 1), invfac(N + 1, 1);
for (unsigned long i{1}; i <= N; ++i)
fac[i] = fac[i - 1] * i % MOD;
invfac.back() = modinv(fac.back());
for (unsigned long i{N}; i--;)
invfac[i] = invfac[i + 1] * (i + 1) % MOD;
vector<vector<unsigned long>> edge(N);
vector<unsigned long> jisu(N);
for (unsigned long i{1}, a, b; i < N; ++i) {
cin >> a >> b;
edge[--a].push_back(--b);
edge[b].push_back(a);
++jisu[a];
++jisu[b];
}
assert(N < 10 || *max_element(jisu.begin(), jisu.end()) > 2);
vector<unsigned long> ord(N);
iota(ord.begin(), ord.end(), 0UL);
sort(ord.begin(), ord.end(),
[&jisu](auto i, auto j) { return jisu[i] > jisu[j]; });
map<pair<unsigned long, unsigned long>, pair<unsigned long, unsigned long>>
memo;
const auto &tree_dp =
[&modinv, &fac, &invfac, &edge,
&memo](auto f, unsigned long now,
unsigned long prev) -> pair<unsigned long, unsigned long> {
if (memo.count({now, prev}))
return memo[{now, prev}];
if (memo.count({now, now})) {
auto t = memo[{now, now}], s = memo[{prev, now}];
unsigned long cnt{t.first}, ans{t.second};
(ans *= modinv(s.second, invfac[cnt - 1] * fac[cnt - s.first - 1] % MOD *
fac[s.first])) %= MOD;
cnt -= s.first;
return memo[{now, prev}] = {cnt, ans};
}
unsigned long cnt{0}, ans{1};
for (const auto &i : edge[now])
if (i != prev) {
auto t = f(f, i, now);
cnt += t.first;
(ans *= invfac[t.first] * t.second % MOD) %= MOD;
}
(ans *= fac[cnt]) %= MOD;
return memo[{now, prev}] = {cnt + 1, ans};
};
vector<unsigned long> ans(N);
for (const auto &i : ord)
ans[i] = tree_dp(tree_dp, i, i).second;
copy(ans.begin(), ans.end(), ostream_iterator<unsigned long>(cout, "\n"));
return 0;
}
| #include <bits/stdc++.h>
int main() {
using namespace std;
constexpr unsigned long MOD = 1000000007;
const auto &modinv = [](unsigned long a,
unsigned long b = 1) -> unsigned long {
unsigned long r{b % MOD}, n{MOD - 2};
while (n) {
if (n & 1)
(r *= a) %= MOD;
(a *= a) %= MOD;
n >>= 1;
}
return r;
};
unsigned long N;
cin >> N;
vector<unsigned long> fac(N + 1, 1), invfac(N + 1, 1);
for (unsigned long i{1}; i <= N; ++i)
fac[i] = fac[i - 1] * i % MOD;
invfac.back() = modinv(fac.back());
for (unsigned long i{N}; i--;)
invfac[i] = invfac[i + 1] * (i + 1) % MOD;
vector<vector<unsigned long>> edge(N);
vector<unsigned long> jisu(N);
for (unsigned long i{1}, a, b; i < N; ++i) {
cin >> a >> b;
edge[--a].push_back(--b);
edge[b].push_back(a);
++jisu[a];
++jisu[b];
}
assert(N < 50000 || *max_element(jisu.begin(), jisu.end()) > 2);
vector<unsigned long> ord(N);
iota(ord.begin(), ord.end(), 0UL);
sort(ord.begin(), ord.end(),
[&jisu](auto i, auto j) { return jisu[i] > jisu[j]; });
map<pair<unsigned long, unsigned long>, pair<unsigned long, unsigned long>>
memo;
const auto &tree_dp =
[&modinv, &fac, &invfac, &edge,
&memo](auto f, unsigned long now,
unsigned long prev) -> pair<unsigned long, unsigned long> {
if (memo.count({now, prev}))
return memo[{now, prev}];
if (memo.count({now, now})) {
auto t = memo[{now, now}], s = memo[{prev, now}];
unsigned long cnt{t.first}, ans{t.second};
(ans *= modinv(s.second, invfac[cnt - 1] * fac[cnt - s.first - 1] % MOD *
fac[s.first])) %= MOD;
cnt -= s.first;
return memo[{now, prev}] = {cnt, ans};
}
unsigned long cnt{0}, ans{1};
for (const auto &i : edge[now])
if (i != prev) {
auto t = f(f, i, now);
cnt += t.first;
(ans *= invfac[t.first] * t.second % MOD) %= MOD;
}
(ans *= fac[cnt]) %= MOD;
return memo[{now, prev}] = {cnt + 1, ans};
};
vector<unsigned long> ans(N);
for (const auto &i : ord)
ans[i] = tree_dp(tree_dp, i, i).second;
copy(ans.begin(), ans.end(), ostream_iterator<unsigned long>(cout, "\n"));
return 0;
}
| replace | 33 | 34 | 33 | 34 | 0 | |
p02728 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using VI = vector<int>;
using VL = vector<ll>;
using VVI = vector<vector<int>>;
using VVL = vector<vector<ll>>;
using PII = std::pair<int, int>;
using PLL = std::pair<ll, ll>;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
#define rep3(i, s, n, d) for (int i = (s); i < (int)(n); i += (d))
#define allpt(v) (v).begin(), (v).end()
#define allpt_c(v) (v).cbegin(), (v).cend()
#define allpt_r(v) (v).rbegin(), (v).rend()
const int mod = 1e9 + 7;
const string wsp = " ";
const string tb = "\t";
const string rt = "\n";
template <typename T> void show1dvec(const vector<T> &v) {
if (v.size() == 0)
return;
int n = v.size() - 1;
rep(i, n) cout << v[i] << wsp;
cout << v[n];
return;
}
template <typename T> void show2dvec(const vector<vector<T>> &v) {
int n = v.size();
rep(i, n) show1dvec(v[i]);
}
template <typename T, typename S> void show1dpair(const vector<pair<T, S>> &v) {
int n = v.size();
rep(i, n) cout << v[i].first << wsp << v[i].second << rt;
return;
}
template <typename T, typename S>
void pairzip(const vector<pair<T, S>> &v, vector<T> &t, vector<T> &s) {
int n = v.size();
rep(i, n) {
t.push_back(v[i].first);
s.push_back(v[i].second);
}
return;
}
template <typename T> void maxvec(vector<T> &v) {
T s = v[0];
int n = v.size();
rep(i, n - 1) {
if (s > v[i + 1]) {
v[i + 1] = s;
}
s = v[i + 1];
}
}
template <typename T, typename S> bool myfind(T t, S s) {
return find(t.cbegin(), t.cend(), s) != t.cend();
}
bool check(int y, int x, int h, int w) {
return 0 <= y && y < h && 0 <= x && x < w;
}
VI cumsum(VI &v) {
int s = 0;
VI ret = {0};
rep(i, v.size()) {
s += v[i];
ret.push_back(s);
}
return ret;
}
void shuffle(VI &v, int t) {
int temp = v[t - 1];
rep(i, t - 1) v[t - 1 - i] = v[t - 2 - i];
v[0] = temp;
}
struct node {
VI children;
ll ans = 1;
ll ans_from_subtree = 1;
ll ans_from_surtree = 1;
int parent = -1;
int subtree_size = 1;
int surtree_size = 1;
};
void printsubtree(node n) {
cout << "parent = " << n.parent << rt;
cout << "children = ";
show1dvec(n.children);
cout << rt;
cout << "subtree_size = " << n.subtree_size << rt;
cout << "surtree_size = " << n.surtree_size << rt;
cout << "ans_from_subtree = " << n.ans_from_subtree << rt;
cout << "ans_from_surtree = " << n.ans_from_surtree << rt;
cout << "ans = " << n.ans << rt;
cout << rt;
}
ll pow_mod(int p, int q, int mod) {
ll ret = 1, r = p;
while (q) {
if (q % 2)
ret *= r, ret %= mod;
r = (r * r) % mod, q /= 2;
}
return ret % mod;
}
ll const nmax = 100001;
VL frac_table(nmax, 1);
VL frac_inv_table(nmax, 1);
void dfs(const int &x, const VVI &connect, vector<node> &nodes) {
for (auto z : connect[x]) {
if (z != nodes[x].parent) {
nodes[z].parent = x;
nodes[x].children.push_back(z);
dfs(z, connect, nodes);
}
}
}
void dfs2(const int &x, const int &n, const VVI &connect, vector<node> &nodes) {
for (auto &z : nodes[x].children) {
dfs2(z, n, connect, nodes);
nodes[x].subtree_size += nodes[z].subtree_size;
nodes[x].ans_from_subtree *= frac_inv_table[nodes[z].subtree_size];
nodes[x].ans_from_subtree %= mod;
nodes[x].ans_from_subtree *= nodes[z].ans_from_subtree;
nodes[x].ans_from_subtree %= mod;
}
nodes[x].surtree_size = n - nodes[x].subtree_size;
nodes[x].ans_from_subtree *= frac_table[nodes[x].subtree_size - 1];
nodes[x].ans_from_subtree %= mod;
}
void dfs3(const int &x, const int &n, VVI &connect, vector<node> &nodes) {
nodes[x].ans = nodes[x].ans_from_subtree;
if (nodes[x].parent != -1) {
nodes[x].ans *= frac_table[n - 1];
nodes[x].ans %= mod;
nodes[x].ans *= frac_inv_table[nodes[x].surtree_size];
nodes[x].ans %= mod;
nodes[x].ans *= frac_inv_table[nodes[x].subtree_size - 1];
nodes[x].ans %= mod;
nodes[x].ans *= nodes[x].ans_from_surtree;
nodes[x].ans %= mod;
}
for (auto z : nodes[x].children) {
nodes[z].ans_from_surtree *= nodes[x].ans;
nodes[z].ans_from_surtree *= frac_inv_table[n - 1];
nodes[z].ans_from_surtree %= mod;
nodes[z].ans_from_surtree *= frac_table[nodes[z].subtree_size];
nodes[z].ans_from_surtree %= mod;
nodes[z].ans_from_surtree *= frac_table[n - 1 - nodes[z].subtree_size];
nodes[z].ans_from_surtree %= mod;
nodes[z].ans_from_surtree *=
pow_mod(nodes[z].ans_from_subtree, mod - 2, mod);
nodes[z].ans_from_surtree %= mod;
dfs3(z, n, connect, nodes);
}
}
int main() {
#ifdef DEBUG
cout << "DEBUG MODE" << endl;
ifstream in("input.txt"); // for debug
cin.rdbuf(in.rdbuf()); // for debug
#endif
int s = 1, t = 1;
rep2(i, 1, nmax) {
frac_table[i] = (frac_table[i - 1] * i) % mod;
frac_inv_table[i] =
(frac_inv_table[i - 1] * pow_mod(i, mod - 2, mod)) % mod;
}
int n, a, b;
cin >> n;
VVI connect(n);
vector<node> nodes(n);
rep(i, n - 1) {
cin >> a >> b;
a--, b--;
connect[a].push_back(b);
connect[b].push_back(a);
}
dfs(0, connect, nodes);
dfs2(0, n, connect, nodes);
dfs3(0, n, connect, nodes);
// for_each(allpt(nodes), printsubtree);
for_each(allpt(nodes), [](const node &z) { cout << z.ans << rt; });
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using VI = vector<int>;
using VL = vector<ll>;
using VVI = vector<vector<int>>;
using VVL = vector<vector<ll>>;
using PII = std::pair<int, int>;
using PLL = std::pair<ll, ll>;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
#define rep3(i, s, n, d) for (int i = (s); i < (int)(n); i += (d))
#define allpt(v) (v).begin(), (v).end()
#define allpt_c(v) (v).cbegin(), (v).cend()
#define allpt_r(v) (v).rbegin(), (v).rend()
const int mod = 1e9 + 7;
const string wsp = " ";
const string tb = "\t";
const string rt = "\n";
template <typename T> void show1dvec(const vector<T> &v) {
if (v.size() == 0)
return;
int n = v.size() - 1;
rep(i, n) cout << v[i] << wsp;
cout << v[n];
return;
}
template <typename T> void show2dvec(const vector<vector<T>> &v) {
int n = v.size();
rep(i, n) show1dvec(v[i]);
}
template <typename T, typename S> void show1dpair(const vector<pair<T, S>> &v) {
int n = v.size();
rep(i, n) cout << v[i].first << wsp << v[i].second << rt;
return;
}
template <typename T, typename S>
void pairzip(const vector<pair<T, S>> &v, vector<T> &t, vector<T> &s) {
int n = v.size();
rep(i, n) {
t.push_back(v[i].first);
s.push_back(v[i].second);
}
return;
}
template <typename T> void maxvec(vector<T> &v) {
T s = v[0];
int n = v.size();
rep(i, n - 1) {
if (s > v[i + 1]) {
v[i + 1] = s;
}
s = v[i + 1];
}
}
template <typename T, typename S> bool myfind(T t, S s) {
return find(t.cbegin(), t.cend(), s) != t.cend();
}
bool check(int y, int x, int h, int w) {
return 0 <= y && y < h && 0 <= x && x < w;
}
VI cumsum(VI &v) {
int s = 0;
VI ret = {0};
rep(i, v.size()) {
s += v[i];
ret.push_back(s);
}
return ret;
}
void shuffle(VI &v, int t) {
int temp = v[t - 1];
rep(i, t - 1) v[t - 1 - i] = v[t - 2 - i];
v[0] = temp;
}
struct node {
VI children;
ll ans = 1;
ll ans_from_subtree = 1;
ll ans_from_surtree = 1;
int parent = -1;
int subtree_size = 1;
int surtree_size = 1;
};
void printsubtree(node n) {
cout << "parent = " << n.parent << rt;
cout << "children = ";
show1dvec(n.children);
cout << rt;
cout << "subtree_size = " << n.subtree_size << rt;
cout << "surtree_size = " << n.surtree_size << rt;
cout << "ans_from_subtree = " << n.ans_from_subtree << rt;
cout << "ans_from_surtree = " << n.ans_from_surtree << rt;
cout << "ans = " << n.ans << rt;
cout << rt;
}
ll pow_mod(int p, int q, int mod) {
ll ret = 1, r = p;
while (q) {
if (q % 2)
ret *= r, ret %= mod;
r = (r * r) % mod, q /= 2;
}
return ret % mod;
}
ll const nmax = 200001;
VL frac_table(nmax, 1);
VL frac_inv_table(nmax, 1);
void dfs(const int &x, const VVI &connect, vector<node> &nodes) {
for (auto z : connect[x]) {
if (z != nodes[x].parent) {
nodes[z].parent = x;
nodes[x].children.push_back(z);
dfs(z, connect, nodes);
}
}
}
void dfs2(const int &x, const int &n, const VVI &connect, vector<node> &nodes) {
for (auto &z : nodes[x].children) {
dfs2(z, n, connect, nodes);
nodes[x].subtree_size += nodes[z].subtree_size;
nodes[x].ans_from_subtree *= frac_inv_table[nodes[z].subtree_size];
nodes[x].ans_from_subtree %= mod;
nodes[x].ans_from_subtree *= nodes[z].ans_from_subtree;
nodes[x].ans_from_subtree %= mod;
}
nodes[x].surtree_size = n - nodes[x].subtree_size;
nodes[x].ans_from_subtree *= frac_table[nodes[x].subtree_size - 1];
nodes[x].ans_from_subtree %= mod;
}
void dfs3(const int &x, const int &n, VVI &connect, vector<node> &nodes) {
nodes[x].ans = nodes[x].ans_from_subtree;
if (nodes[x].parent != -1) {
nodes[x].ans *= frac_table[n - 1];
nodes[x].ans %= mod;
nodes[x].ans *= frac_inv_table[nodes[x].surtree_size];
nodes[x].ans %= mod;
nodes[x].ans *= frac_inv_table[nodes[x].subtree_size - 1];
nodes[x].ans %= mod;
nodes[x].ans *= nodes[x].ans_from_surtree;
nodes[x].ans %= mod;
}
for (auto z : nodes[x].children) {
nodes[z].ans_from_surtree *= nodes[x].ans;
nodes[z].ans_from_surtree *= frac_inv_table[n - 1];
nodes[z].ans_from_surtree %= mod;
nodes[z].ans_from_surtree *= frac_table[nodes[z].subtree_size];
nodes[z].ans_from_surtree %= mod;
nodes[z].ans_from_surtree *= frac_table[n - 1 - nodes[z].subtree_size];
nodes[z].ans_from_surtree %= mod;
nodes[z].ans_from_surtree *=
pow_mod(nodes[z].ans_from_subtree, mod - 2, mod);
nodes[z].ans_from_surtree %= mod;
dfs3(z, n, connect, nodes);
}
}
int main() {
#ifdef DEBUG
cout << "DEBUG MODE" << endl;
ifstream in("input.txt"); // for debug
cin.rdbuf(in.rdbuf()); // for debug
#endif
int s = 1, t = 1;
rep2(i, 1, nmax) {
frac_table[i] = (frac_table[i - 1] * i) % mod;
frac_inv_table[i] =
(frac_inv_table[i - 1] * pow_mod(i, mod - 2, mod)) % mod;
}
int n, a, b;
cin >> n;
VVI connect(n);
vector<node> nodes(n);
rep(i, n - 1) {
cin >> a >> b;
a--, b--;
connect[a].push_back(b);
connect[b].push_back(a);
}
dfs(0, connect, nodes);
dfs2(0, n, connect, nodes);
dfs3(0, n, connect, nodes);
// for_each(allpt(nodes), printsubtree);
for_each(allpt(nodes), [](const node &z) { cout << z.ans << rt; });
return 0;
}
| replace | 124 | 125 | 124 | 125 | 0 | |
p02728 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define REP(i, m, n) for (int i = (m); i < (int)(n); i++)
#define RREP(i, m, n) for (int i = (int)(n - 1); i >= m; i--)
#define rep(i, n) REP(i, 0, n)
#define rrep(i, n) RREP(i, 0, n)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define fi first
#define se second
#define debug(...) \
{ \
cerr << "[L" << __LINE__ << "] "; \
_debug(__VA_ARGS__); \
}
template <typename T> string join(const vector<T> &v, string del = ", ") {
stringstream s;
for (auto x : v)
s << del << x;
return s.str().substr(del.size());
}
template <typename T> ostream &operator<<(ostream &o, const vector<T> &v) {
if (v.size())
o << "[" << join(v) << "]";
return o;
}
template <typename T>
ostream &operator<<(ostream &o, const vector<vector<T>> &vv) {
int l = vv.size();
if (l) {
o << endl;
rep(i, l) o << (i == 0 ? "[ " : ",\n ") << vv[i]
<< (i == l - 1 ? " ]" : "");
}
return o;
}
inline void _debug() { cerr << endl; }
template <class First, class... Rest>
void _debug(const First &first, const Rest &...rest) {
cerr << first << " ";
_debug(rest...);
}
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
const double PI = (1 * acos(0.0));
const double EPS = 1e-9;
const ll INF = 0x3f3f3f3f;
const ll INFL = 0x3f3f3f3f3f3f3f3fLL;
const ll mod = 1e9 + 7;
inline void finput(string filename) { freopen(filename.c_str(), "r", stdin); }
struct mint {
long long x;
mint(long long x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint &a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint &a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint &a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint &a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint &a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint &a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint &a) { return (*this) *= a.inv(); }
mint operator/(const mint &a) const {
mint res(*this);
return res /= a;
}
friend ostream &operator<<(ostream &os, const mint &m) {
os << m.x;
return os;
}
};
struct Factorial {
vector<mint> fact;
vector<mint> factinv;
Factorial() {}
Factorial(int n) {
fact = vector<mint>(n + 1);
factinv = vector<mint>(n + 1);
fact[0] = 1;
REP(i, 1, n + 1) fact[i] = fact[i - 1] * i;
factinv[n] = fact[n].inv();
RREP(i, 1, n + 1) factinv[i - 1] = factinv[i] * i;
}
mint C(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * factinv[n - k] * factinv[k];
}
mint P(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * factinv[n - k];
}
mint H(int n, int k) {
if (n == 0 && k == 0)
return 1;
return C(n + k - 1, k);
}
};
int n;
Factorial f;
vi g[100010];
vector<mint> dp;
vi c;
void dfs1(int v, int p = -1) {
int total = 0;
c[0] = 1;
for (auto u : g[v]) {
if (u == p)
continue;
dfs1(u, v);
dp[v] *= f.factinv[c[u]] * dp[u];
total += c[u];
}
dp[v] *= f.fact[total];
c[v] = total + 1;
}
void dfs2(int v, int p = -1) {
if (p != -1) {
dp[v] = dp[p] * c[v] * mint(n - c[v]).inv();
}
for (auto u : g[v]) {
if (u == p)
continue;
dfs2(u, v);
}
}
int main() {
ios_base::sync_with_stdio(0);
// finput("./input");
cin >> n;
rep(i, n - 1) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
f = Factorial(n);
dp = vector<mint>(n, 1);
c = vi(n, 0);
dfs1(0);
dfs2(0);
rep(i, n) cout << dp[i] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, m, n) for (int i = (m); i < (int)(n); i++)
#define RREP(i, m, n) for (int i = (int)(n - 1); i >= m; i--)
#define rep(i, n) REP(i, 0, n)
#define rrep(i, n) RREP(i, 0, n)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define fi first
#define se second
#define debug(...) \
{ \
cerr << "[L" << __LINE__ << "] "; \
_debug(__VA_ARGS__); \
}
template <typename T> string join(const vector<T> &v, string del = ", ") {
stringstream s;
for (auto x : v)
s << del << x;
return s.str().substr(del.size());
}
template <typename T> ostream &operator<<(ostream &o, const vector<T> &v) {
if (v.size())
o << "[" << join(v) << "]";
return o;
}
template <typename T>
ostream &operator<<(ostream &o, const vector<vector<T>> &vv) {
int l = vv.size();
if (l) {
o << endl;
rep(i, l) o << (i == 0 ? "[ " : ",\n ") << vv[i]
<< (i == l - 1 ? " ]" : "");
}
return o;
}
inline void _debug() { cerr << endl; }
template <class First, class... Rest>
void _debug(const First &first, const Rest &...rest) {
cerr << first << " ";
_debug(rest...);
}
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
const double PI = (1 * acos(0.0));
const double EPS = 1e-9;
const ll INF = 0x3f3f3f3f;
const ll INFL = 0x3f3f3f3f3f3f3f3fLL;
const ll mod = 1e9 + 7;
inline void finput(string filename) { freopen(filename.c_str(), "r", stdin); }
struct mint {
long long x;
mint(long long x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint &a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint &a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint &a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint &a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint &a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint &a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint &a) { return (*this) *= a.inv(); }
mint operator/(const mint &a) const {
mint res(*this);
return res /= a;
}
friend ostream &operator<<(ostream &os, const mint &m) {
os << m.x;
return os;
}
};
struct Factorial {
vector<mint> fact;
vector<mint> factinv;
Factorial() {}
Factorial(int n) {
fact = vector<mint>(n + 1);
factinv = vector<mint>(n + 1);
fact[0] = 1;
REP(i, 1, n + 1) fact[i] = fact[i - 1] * i;
factinv[n] = fact[n].inv();
RREP(i, 1, n + 1) factinv[i - 1] = factinv[i] * i;
}
mint C(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * factinv[n - k] * factinv[k];
}
mint P(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * factinv[n - k];
}
mint H(int n, int k) {
if (n == 0 && k == 0)
return 1;
return C(n + k - 1, k);
}
};
int n;
Factorial f;
vi g[200010];
vector<mint> dp;
vi c;
void dfs1(int v, int p = -1) {
int total = 0;
c[0] = 1;
for (auto u : g[v]) {
if (u == p)
continue;
dfs1(u, v);
dp[v] *= f.factinv[c[u]] * dp[u];
total += c[u];
}
dp[v] *= f.fact[total];
c[v] = total + 1;
}
void dfs2(int v, int p = -1) {
if (p != -1) {
dp[v] = dp[p] * c[v] * mint(n - c[v]).inv();
}
for (auto u : g[v]) {
if (u == p)
continue;
dfs2(u, v);
}
}
int main() {
ios_base::sync_with_stdio(0);
// finput("./input");
cin >> n;
rep(i, n - 1) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
f = Factorial(n);
dp = vector<mint>(n, 1);
c = vi(n, 0);
dfs1(0);
dfs2(0);
rep(i, n) cout << dp[i] << endl;
return 0;
} | replace | 141 | 142 | 141 | 142 | 0 | |
p02728 | C++ | Runtime Error | // agrawal117
// chahatagrawal117
#include <bits/stdc++.h>
#define endl '\n'
#define mod 1000000007
typedef long long int ll;
using namespace std;
#define MAX 100005
vector<ll> v[MAX];
ll in[MAX];
ll out[MAX];
ll dp[MAX];
ll n;
void dfs(int node, int par) {
dp[node] = 1;
in[node] = 1LL;
for (auto i : v[node]) {
if (i ^ par) {
dfs(i, node);
dp[node] += dp[i];
dp[node] %= mod;
in[node] = (in[node] * in[i]) % mod;
}
}
dp[node] %= mod;
in[node] = (in[node] * dp[node]) % mod;
}
ll power(ll a, ll b) {
a %= mod;
ll res = 1LL;
while (b > 0) {
if (b & 1LL)
res = (res * a) % mod;
b >>= 1;
a = (a * a) % mod;
}
return res % mod;
}
ll inv(ll a) { return power(a, mod - 2) % mod; }
void bfs(int node, int par) {
ll mult = 1LL;
for (auto i : v[node]) {
if (i ^ par)
mult = (mult * in[i]) % mod;
}
for (auto i : v[node]) {
if (i ^ par) {
ll sub = n - dp[i];
out[i] = (((sub * out[node]) % mod) * mult) % mod;
out[i] = (out[i] * inv(in[i])) % mod;
bfs(i, node);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n - 1; i++) {
ll a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
dfs(1, 1);
out[1] = 1LL;
bfs(1, 1);
ll ans = 0;
ll fact = 1;
for (int i = 1; i <= n; i++)
fact = (fact * i) % mod;
for (int i = 1; i <= n; i++) {
ll val = in[i];
val = (val * inv(dp[i])) % mod;
val = (val * n) % mod;
val = (val * out[i]) % mod;
ll f = inv(val);
f = (fact * f) % mod;
cout << f << endl;
ans = (ans + f) % mod;
}
// cout<<an`s<<endl;
}
| // agrawal117
// chahatagrawal117
#include <bits/stdc++.h>
#define endl '\n'
#define mod 1000000007
typedef long long int ll;
using namespace std;
#define MAX 300005
vector<ll> v[MAX];
ll in[MAX];
ll out[MAX];
ll dp[MAX];
ll n;
void dfs(int node, int par) {
dp[node] = 1;
in[node] = 1LL;
for (auto i : v[node]) {
if (i ^ par) {
dfs(i, node);
dp[node] += dp[i];
dp[node] %= mod;
in[node] = (in[node] * in[i]) % mod;
}
}
dp[node] %= mod;
in[node] = (in[node] * dp[node]) % mod;
}
ll power(ll a, ll b) {
a %= mod;
ll res = 1LL;
while (b > 0) {
if (b & 1LL)
res = (res * a) % mod;
b >>= 1;
a = (a * a) % mod;
}
return res % mod;
}
ll inv(ll a) { return power(a, mod - 2) % mod; }
void bfs(int node, int par) {
ll mult = 1LL;
for (auto i : v[node]) {
if (i ^ par)
mult = (mult * in[i]) % mod;
}
for (auto i : v[node]) {
if (i ^ par) {
ll sub = n - dp[i];
out[i] = (((sub * out[node]) % mod) * mult) % mod;
out[i] = (out[i] * inv(in[i])) % mod;
bfs(i, node);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n - 1; i++) {
ll a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
dfs(1, 1);
out[1] = 1LL;
bfs(1, 1);
ll ans = 0;
ll fact = 1;
for (int i = 1; i <= n; i++)
fact = (fact * i) % mod;
for (int i = 1; i <= n; i++) {
ll val = in[i];
val = (val * inv(dp[i])) % mod;
val = (val * n) % mod;
val = (val * out[i]) % mod;
ll f = inv(val);
f = (fact * f) % mod;
cout << f << endl;
ans = (ans + f) % mod;
}
// cout<<an`s<<endl;
}
| replace | 7 | 8 | 7 | 8 | 0 | |
p02728 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define lld long long int
#define ld long double
#define mod 1000000007
#define all(v) v.begin(), v.end()
#define rep(i, a, b) for (lld i = a; i <= b; i++)
#define repr(i, a, b) for (lld i = a; i >= b; i--)
#define ar array
#define pb push_back
#define mp make_pair
#define ios \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
using namespace std;
lld n, m;
lld arr[300000];
lld siz[300000];
lld fact[300000];
lld par[300000];
lld fac(lld num) {
if (num == 0)
return 1;
if (fact[num] != -1)
return fact[num];
fact[num] = (num * fac(num - 1)) % mod;
return fact[num];
}
lld fastpower(lld x, unsigned lld y, lld p) {
lld res = 1;
x = x % p;
while (y > 0) {
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
string st;
ar<lld, 2> dp[300000];
vector<lld> adj[300000];
void dfs_siz(lld node, lld pr) {
siz[node] = 1;
par[node] = pr;
for (auto it : adj[node])
if (it != pr) {
dfs_siz(it, node);
siz[node] += siz[it];
}
}
lld dfs_dp1(lld node, lld pr) {
if (dp[node][0] != -1)
return dp[node][0];
dp[node][0] = fac(siz[node] - 1);
for (auto it : adj[node])
if (it != pr)
dp[node][0] = (((dp[node][0] * dfs_dp1(it, node)) % mod) *
fastpower(fac(siz[it]), mod - 2, mod)) %
mod;
return dp[node][0];
}
lld dfs_dp2(lld node, lld pr) {
if (dp[node][1] != -1)
return dp[node][1];
if (pr == -1) {
dp[node][1] = 1;
return dp[node][1];
}
dp[node][1] = fac(n - siz[node] - 1);
for (auto it : adj[pr])
if (it != par[pr] && it != node)
dp[node][1] = (((dp[node][1] * dfs_dp1(it, node)) % mod) *
fastpower(fac(siz[it]), mod - 2, mod)) %
mod;
dp[node][1] = (((dp[node][1] * dfs_dp2(pr, par[pr])) % mod) *
fastpower(fac(n - siz[pr]), mod - 2, mod)) %
mod;
return dp[node][1];
}
int main() {
ios;
lld TESTS, q, a, s, b, r, k, c, p, h, w, d, x, y, z, xs, ys, t;
TESTS = 1;
// ans=0;
// cin>>TESTS;
memset(dp, -1, sizeof(dp));
memset(fact, -1, sizeof(fact));
while (TESTS--) {
cin >> n;
rep(i, 0, n - 2) {
cin >> a >> b;
a--;
b--;
adj[a].pb(b);
adj[b].pb(a);
}
dfs_siz(0, -1);
rep(i, 0, n - 1) cout
<< (((((fac(n - 1) *
fastpower((fac(siz[i] - 1) * fac(n - siz[i])) % mod, mod - 2,
mod)) %
mod) *
dfs_dp1(i, par[i])) %
mod) *
dfs_dp2(i, par[i])) %
mod
<< "\n";
}
return 0;
}
| #include <bits/stdc++.h>
#define lld long long int
#define ld long double
#define mod 1000000007
#define all(v) v.begin(), v.end()
#define rep(i, a, b) for (lld i = a; i <= b; i++)
#define repr(i, a, b) for (lld i = a; i >= b; i--)
#define ar array
#define pb push_back
#define mp make_pair
#define ios \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
using namespace std;
lld n, m;
lld arr[300000];
lld siz[300000];
lld fact[300000];
lld par[300000];
lld fac(lld num) {
if (num == 0)
return 1;
if (fact[num] != -1)
return fact[num];
fact[num] = (num * fac(num - 1)) % mod;
return fact[num];
}
lld fastpower(lld x, unsigned lld y, lld p) {
lld res = 1;
x = x % p;
while (y > 0) {
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
string st;
ar<lld, 2> dp[300000];
vector<lld> adj[300000];
void dfs_siz(lld node, lld pr) {
siz[node] = 1;
par[node] = pr;
for (auto it : adj[node])
if (it != pr) {
dfs_siz(it, node);
siz[node] += siz[it];
}
}
lld dfs_dp1(lld node, lld pr) {
if (dp[node][0] != -1)
return dp[node][0];
dp[node][0] = fac(siz[node] - 1);
for (auto it : adj[node])
if (it != pr)
dp[node][0] = (((dp[node][0] * dfs_dp1(it, node)) % mod) *
fastpower(fac(siz[it]), mod - 2, mod)) %
mod;
return dp[node][0];
}
lld dfs_dp2(lld node, lld pr) {
if (dp[node][1] != -1)
return dp[node][1];
if (pr == -1) {
dp[node][1] = 1;
return dp[node][1];
}
dp[node][1] = (fac(n - siz[node] - 1) * dfs_dp1(pr, par[pr])) % mod;
// for(auto it:adj[pr]) if (it!=par[pr]&&it!=node)
// dp[node][1]=(((dp[node][1]*dfs_dp1(it,node))%mod)*fastpower(fac(siz[it]),mod-2,mod))%mod;
dp[node][1] =
(((((dp[node][1] * fastpower(dfs_dp1(node, pr), mod - 2, mod)) % mod) *
fac(siz[node])) %
mod) *
fastpower(fac(siz[pr] - 1), mod - 2, mod)) %
mod;
dp[node][1] = (((dp[node][1] * dfs_dp2(pr, par[pr])) % mod) *
fastpower(fac(n - siz[pr]), mod - 2, mod)) %
mod;
return dp[node][1];
}
int main() {
ios;
lld TESTS, q, a, s, b, r, k, c, p, h, w, d, x, y, z, xs, ys, t;
TESTS = 1;
// ans=0;
// cin>>TESTS;
memset(dp, -1, sizeof(dp));
memset(fact, -1, sizeof(fact));
while (TESTS--) {
cin >> n;
rep(i, 0, n - 2) {
cin >> a >> b;
a--;
b--;
adj[a].pb(b);
adj[b].pb(a);
}
dfs_siz(0, -1);
rep(i, 0, n - 1) cout
<< (((((fac(n - 1) *
fastpower((fac(siz[i] - 1) * fac(n - siz[i])) % mod, mod - 2,
mod)) %
mod) *
dfs_dp1(i, par[i])) %
mod) *
dfs_dp2(i, par[i])) %
mod
<< "\n";
}
return 0;
}
| replace | 69 | 75 | 69 | 78 | TLE | |
p02728 | C++ | Runtime Error | // #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define ll long long
#define ld long double
#define P pair<ll, ll>
#define FOR(i, n, m) for (ll i = n; i < (ll)m; i++)
#define FORr(i, m, n) for (ll i = n; i >= (ll)m; i--)
#define FORm(i, m) for (auto i = m.begin(); i != m.end(); i++)
#define sortAl(v) sort(v.begin(), v.end())
#define sortAlr(v) \
sort(v.begin(), v.end()); \
reverse(v.begin(), v.end())
#define cout(n) cout << fixed << setprecision(n)
#define dout(n) cout << #n << " = " << n << endl;
long long MOD = 1e9 + 7;
std::vector<long long> func(2e5 + 2);
void build_func() {
func[0] = 1;
func[1] = 1;
for (int i = 2; i <= 2e5 + 2; i++)
func[i] = func[i - 1] * i % MOD;
}
template <typename T> T ext_gcd(T a, T b, T &x, T &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
T q = a / b;
T g = ext_gcd(b, a - q * b, x, y);
T z = x - q * y;
x = y;
y = z;
return g;
}
// aは割る言、mがmod
template <typename T> T invmod(T a, T m) {
T x, y;
ext_gcd(a, m, x, y);
x %= m;
if (x < 0)
x += m;
return x;
}
struct edge {
int to, cost;
};
struct treedp {
static const int S = 200030;
vector<vector<edge>> g; // 元の木
edge dt[S]; // 有向木
// 頂点の情報
// int value[S];
map<pair<int, int>, ll> value;
map<pair<int, int>, int> c_num; // 子供の数
int depth[S]; // 深さ
int deg[S]; // 次数
bool used[S];
bool zero[S]; // 初期化子
int size;
vector<int> round;
void init() {
for (int &d : deg)
d = 0;
g.resize(S);
}
// 最初に親と子を判らせる
// 頂点からの距離
void dfs(int idx, int par) {
value[{idx, par}] = 1;
value[{idx, 0}] = 1;
value[{par, idx}] = 1;
round.push_back(idx);
for (edge &e : g[idx]) {
pair<int, int> p_node = {idx, par};
pair<int, int> c_node = {e.to, idx};
deg[e.to]++;
if (e.to == par)
continue;
dt[e.to] = {idx, e.cost};
dfs(e.to, idx);
depth[idx] = max(depth[idx], depth[e.to] + e.cost);
value[p_node] = value[p_node] * value[c_node] % MOD *
func[(c_num[p_node] + c_num[c_node] + 1)] % MOD *
invmod(func[c_num[p_node]], MOD) % MOD *
invmod(func[c_num[c_node] + 1], MOD) % MOD;
c_num[p_node] += c_num[c_node] + 1;
}
}
void set() {
size = c_num.size();
for (bool &u : used)
u = false;
map<pair<int, int>, int> tmp = c_num;
for (auto i = tmp.begin(); i != tmp.end(); i++) {
int from = i->first.first;
int to = i->first.second;
int num = i->second;
c_num[{to, from}] = size - num - 2;
}
}
void solve() {
deque<int> q;
q.push_back(round[0]);
used[q.front()] = true;
size--;
while (!q.empty()) {
int from = q.back();
q.pop_back();
pair<int, int> p_node = {from, 0};
// ans計算
value[p_node] = func[size] % MOD;
for (edge &e : g[from]) {
pair<int, int> c_node = {e.to, from};
value[p_node] = value[p_node] * value[c_node] % MOD *
invmod(func[c_num[p_node]], MOD) % MOD *
invmod(func[c_num[c_node] + 1], MOD) % MOD;
}
// value計算
for (edge &e : g[from])
if (!used[e.to]) {
used[e.to] = true;
int to = e.to;
q.push_back(to);
value[{from, to}] =
value[p_node] % MOD * invmod(value[{to, from}], MOD) % MOD *
func[size - c_num[{to, from}] - 1] % MOD *
func[c_num[{to, from}] + 1] % MOD * invmod(func[size], MOD) % MOD;
}
}
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
build_func();
int n;
cin >> n;
treedp tr;
tr.init();
FOR(i, 0, n - 1) {
int a, b, c;
cin >> a >> b >> c;
a++;
b++;
tr.g[a].push_back((edge){b, 1});
tr.g[b].push_back((edge){a, 1});
}
tr.dfs(2, -1);
tr.set();
tr.solve();
FOR(i, 1, n + 1) { cout << tr.value[{i, 0}] << endl; }
}
| // #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define ll long long
#define ld long double
#define P pair<ll, ll>
#define FOR(i, n, m) for (ll i = n; i < (ll)m; i++)
#define FORr(i, m, n) for (ll i = n; i >= (ll)m; i--)
#define FORm(i, m) for (auto i = m.begin(); i != m.end(); i++)
#define sortAl(v) sort(v.begin(), v.end())
#define sortAlr(v) \
sort(v.begin(), v.end()); \
reverse(v.begin(), v.end())
#define cout(n) cout << fixed << setprecision(n)
#define dout(n) cout << #n << " = " << n << endl;
long long MOD = 1e9 + 7;
std::vector<long long> func(2e5 + 2);
void build_func() {
func[0] = 1;
func[1] = 1;
for (int i = 2; i <= 2e5 + 2; i++)
func[i] = func[i - 1] * i % MOD;
}
template <typename T> T ext_gcd(T a, T b, T &x, T &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
T q = a / b;
T g = ext_gcd(b, a - q * b, x, y);
T z = x - q * y;
x = y;
y = z;
return g;
}
// aは割る言、mがmod
template <typename T> T invmod(T a, T m) {
T x, y;
ext_gcd(a, m, x, y);
x %= m;
if (x < 0)
x += m;
return x;
}
struct edge {
int to, cost;
};
struct treedp {
static const int S = 200030;
vector<vector<edge>> g; // 元の木
edge dt[S]; // 有向木
// 頂点の情報
// int value[S];
map<pair<int, int>, ll> value;
map<pair<int, int>, int> c_num; // 子供の数
int depth[S]; // 深さ
int deg[S]; // 次数
bool used[S];
bool zero[S]; // 初期化子
int size;
vector<int> round;
void init() {
for (int &d : deg)
d = 0;
g.resize(S);
}
// 最初に親と子を判らせる
// 頂点からの距離
void dfs(int idx, int par) {
value[{idx, par}] = 1;
value[{idx, 0}] = 1;
value[{par, idx}] = 1;
round.push_back(idx);
for (edge &e : g[idx]) {
pair<int, int> p_node = {idx, par};
pair<int, int> c_node = {e.to, idx};
deg[e.to]++;
if (e.to == par)
continue;
dt[e.to] = {idx, e.cost};
dfs(e.to, idx);
depth[idx] = max(depth[idx], depth[e.to] + e.cost);
value[p_node] = value[p_node] * value[c_node] % MOD *
func[(c_num[p_node] + c_num[c_node] + 1)] % MOD *
invmod(func[c_num[p_node]], MOD) % MOD *
invmod(func[c_num[c_node] + 1], MOD) % MOD;
c_num[p_node] += c_num[c_node] + 1;
}
}
void set() {
size = c_num.size();
for (bool &u : used)
u = false;
map<pair<int, int>, int> tmp = c_num;
for (auto i = tmp.begin(); i != tmp.end(); i++) {
int from = i->first.first;
int to = i->first.second;
int num = i->second;
c_num[{to, from}] = size - num - 2;
}
}
void solve() {
deque<int> q;
q.push_back(round[0]);
used[q.front()] = true;
size--;
while (!q.empty()) {
int from = q.back();
q.pop_back();
pair<int, int> p_node = {from, 0};
// ans計算
value[p_node] = func[size] % MOD;
for (edge &e : g[from]) {
pair<int, int> c_node = {e.to, from};
value[p_node] = value[p_node] * value[c_node] % MOD *
invmod(func[c_num[p_node]], MOD) % MOD *
invmod(func[c_num[c_node] + 1], MOD) % MOD;
}
// value計算
for (edge &e : g[from])
if (!used[e.to]) {
used[e.to] = true;
int to = e.to;
q.push_back(to);
value[{from, to}] =
value[p_node] % MOD * invmod(value[{to, from}], MOD) % MOD *
func[size - c_num[{to, from}] - 1] % MOD *
func[c_num[{to, from}] + 1] % MOD * invmod(func[size], MOD) % MOD;
}
}
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
build_func();
int n;
cin >> n;
treedp tr;
tr.init();
FOR(i, 0, n - 1) {
int a, b;
cin >> a >> b;
tr.g[a].push_back((edge){b, 1});
tr.g[b].push_back((edge){a, 1});
}
tr.dfs(2, -1);
tr.set();
tr.solve();
FOR(i, 1, n + 1) { cout << tr.value[{i, 0}] << endl; }
}
| replace | 155 | 159 | 155 | 157 | 0 | |
p02728 | C++ | Runtime Error | #include <iostream>
#include <vector>
const int maxn = 1e5 + 10;
const int mod = 1e9 + 7;
typedef long long ll;
using namespace std;
int n;
ll quick(ll a, ll b, ll m) {
ll ans = 1;
while (b > 0) {
if (b & 1)
ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
ll jiecheng[maxn];
void ini_zuhelogn() {
jiecheng[0] = 1;
for (int i = 1; i < maxn; i++) {
jiecheng[i] = jiecheng[i - 1] * i % mod;
}
}
ll zuhe_logn(int m, int n) {
if (jiecheng[0] != 1)
ini_zuhelogn();
ll ans = ((jiecheng[m] * quick(jiecheng[n], mod - 2, mod)) % mod) *
quick(jiecheng[m - n], mod - 2, mod) % mod;
return ans;
}
ll ans[maxn], ans_up[maxn], sizet[maxn];
vector<int> G[maxn];
void dfs1(int x, int f) {
ll anst = 1, sum = 0;
for (int i = 0; i < G[x].size(); i++) {
int v = G[x][i];
if (v != f) {
dfs1(v, x);
// cout<<v<<" "<<ans[v]<<" "<<sum<<" "<<sizet[v]<<endl;
anst = anst * (ans[v] * zuhe_logn(sum + sizet[v], sizet[v]) % mod) % mod;
sum += sizet[v];
}
}
ans[x] = anst;
sizet[x] = sum + 1;
}
void dfs2(int x, int f) {
ll anst = ans_up[x], sum = n - sizet[x];
for (int i = 0; i < G[x].size(); i++) {
int v = G[x][i];
if (v == f)
continue;
anst = anst * (ans[v] * zuhe_logn(sum + sizet[v], sizet[v]) % mod) % mod;
sum += sizet[v];
}
ans[x] = anst;
for (int i = 0; i < G[x].size(); i++) {
int v = G[x][i];
if (v == f)
continue;
ans_up[v] =
ans[x] *
quick((ans[v] * zuhe_logn(n - 1, sizet[v]) % mod), mod - 2, mod) % mod;
// cout<<v<<" "<<ans[x]<<" "<<ans[v]<<" "<<ans_up[v]<<endl;
dfs2(v, x);
}
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
dfs1(1, 1);
ans_up[1] = 1;
dfs2(1, 1);
for (int i = 0; i < n; i++)
cout << ans[i + 1] << endl;
}
| #include <iostream>
#include <vector>
const int maxn = 2e5 + 10;
const int mod = 1e9 + 7;
typedef long long ll;
using namespace std;
int n;
ll quick(ll a, ll b, ll m) {
ll ans = 1;
while (b > 0) {
if (b & 1)
ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
ll jiecheng[maxn];
void ini_zuhelogn() {
jiecheng[0] = 1;
for (int i = 1; i < maxn; i++) {
jiecheng[i] = jiecheng[i - 1] * i % mod;
}
}
ll zuhe_logn(int m, int n) {
if (jiecheng[0] != 1)
ini_zuhelogn();
ll ans = ((jiecheng[m] * quick(jiecheng[n], mod - 2, mod)) % mod) *
quick(jiecheng[m - n], mod - 2, mod) % mod;
return ans;
}
ll ans[maxn], ans_up[maxn], sizet[maxn];
vector<int> G[maxn];
void dfs1(int x, int f) {
ll anst = 1, sum = 0;
for (int i = 0; i < G[x].size(); i++) {
int v = G[x][i];
if (v != f) {
dfs1(v, x);
// cout<<v<<" "<<ans[v]<<" "<<sum<<" "<<sizet[v]<<endl;
anst = anst * (ans[v] * zuhe_logn(sum + sizet[v], sizet[v]) % mod) % mod;
sum += sizet[v];
}
}
ans[x] = anst;
sizet[x] = sum + 1;
}
void dfs2(int x, int f) {
ll anst = ans_up[x], sum = n - sizet[x];
for (int i = 0; i < G[x].size(); i++) {
int v = G[x][i];
if (v == f)
continue;
anst = anst * (ans[v] * zuhe_logn(sum + sizet[v], sizet[v]) % mod) % mod;
sum += sizet[v];
}
ans[x] = anst;
for (int i = 0; i < G[x].size(); i++) {
int v = G[x][i];
if (v == f)
continue;
ans_up[v] =
ans[x] *
quick((ans[v] * zuhe_logn(n - 1, sizet[v]) % mod), mod - 2, mod) % mod;
// cout<<v<<" "<<ans[x]<<" "<<ans[v]<<" "<<ans_up[v]<<endl;
dfs2(v, x);
}
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
dfs1(1, 1);
ans_up[1] = 1;
dfs2(1, 1);
for (int i = 0; i < n; i++)
cout << ans[i + 1] << endl;
}
| replace | 2 | 3 | 2 | 3 | 0 | |
p02728 | C++ | Time Limit Exceeded | #include <queue>
#include <stack>
#include <stdio.h>
#include <vector>
#define mod 1000000007
using namespace std;
typedef long long ll;
ll rev(ll a) {
ll now = mod - 2, ans = 1;
while (now) {
if (now & 1)
ans *= a;
now >>= 1, ans %= mod, a *= a, a %= mod;
}
return ans;
}
int main(void) {
ll i, j, k, n, a, b, now, ans;
scanf("%lld", &n);
vector<ll> vec[n];
for (i = 0; i < n - 1; ++i) {
scanf("%lld%lld", &a, &b);
vec[--a].push_back(--b);
vec[b].push_back(a);
}
ll fact[n + 1], dp1[n], dp2[n], c1[n], c2[n], p[n];
for (i = 0; i < n; ++i)
p[i] = -1, c1[i] = c2[i] = 0;
p[0] = 0;
fact[0] = 1;
for (i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i, fact[i] %= mod;
stack<ll> s;
queue<ll> q;
q.push(0);
while (q.size()) {
now = q.front(), q.pop();
s.push(now);
for (i = 0; i < vec[now].size(); ++i)
if (p[vec[now][i]] == -1)
p[vec[now][i]] = now, q.push(vec[now][i]);
}
while (s.size()) {
now = s.top(), s.pop();
dp1[now] = 1;
for (i = 0; i < vec[now].size(); ++i)
if (vec[now][i] != p[now]) {
c1[now] += c1[vec[now][i]] + 1;
dp1[now] *= rev(fact[c1[vec[now][i]] + 1]);
dp1[now] %= mod;
dp1[now] *= dp1[vec[now][i]];
dp1[now] %= mod;
}
dp1[now] *= fact[c1[now]];
dp1[now] %= mod;
}
q.push(0);
while (q.size()) {
now = q.front(), q.pop();
for (i = 0; i < vec[now].size(); ++i)
if (vec[now][i] != p[now])
q.push(vec[now][i]);
dp2[now] = 1;
if (now) {
for (i = 0; i < vec[p[now]].size(); ++i)
if (vec[p[now]][i] != now) {
if (vec[p[now]][i] != p[p[now]]) {
c2[now] += c1[vec[p[now]][i]] + 1;
dp2[now] *= rev(fact[c1[vec[p[now]][i]] + 1]);
dp2[now] %= mod;
dp2[now] *= dp1[vec[p[now]][i]];
dp2[now] %= mod;
} else {
c2[now] += c2[p[now]];
dp2[now] *= rev(fact[c2[p[now]]]);
dp2[now] %= mod;
dp2[now] *= dp2[p[now]];
dp2[now] %= mod;
}
}
dp2[now] *= fact[c2[now]];
dp2[now] %= mod;
c2[now]++;
}
}
for (i = 0; i < n; ++i) {
ans = dp1[i] * dp2[i];
ans %= mod;
ans *= fact[n - 1];
ans %= mod;
ans *= rev(fact[c1[i]]);
ans %= mod;
ans *= rev(fact[c2[i]]);
ans %= mod;
printf("%lld\n", ans);
}
return 0;
} | #include <queue>
#include <stack>
#include <stdio.h>
#include <vector>
#define mod 1000000007
using namespace std;
typedef long long ll;
ll rev(ll a) {
ll now = mod - 2, ans = 1;
while (now) {
if (now & 1)
ans *= a;
now >>= 1, ans %= mod, a *= a, a %= mod;
}
return ans;
}
int main(void) {
ll i, j, k, n, a, b, now, ans;
scanf("%lld", &n);
vector<ll> vec[n];
for (i = 0; i < n - 1; ++i) {
scanf("%lld%lld", &a, &b);
vec[--a].push_back(--b);
vec[b].push_back(a);
}
ll fact[n + 1], dp1[n], dp2[n], c1[n], c2[n], p[n];
for (i = 0; i < n; ++i)
p[i] = -1, c1[i] = c2[i] = 0;
p[0] = 0;
fact[0] = 1;
for (i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i, fact[i] %= mod;
stack<ll> s;
queue<ll> q;
q.push(0);
while (q.size()) {
now = q.front(), q.pop();
s.push(now);
for (i = 0; i < vec[now].size(); ++i)
if (p[vec[now][i]] == -1)
p[vec[now][i]] = now, q.push(vec[now][i]);
}
while (s.size()) {
now = s.top(), s.pop();
dp1[now] = 1;
for (i = 0; i < vec[now].size(); ++i)
if (vec[now][i] != p[now]) {
c1[now] += c1[vec[now][i]] + 1;
dp1[now] *= rev(fact[c1[vec[now][i]] + 1]);
dp1[now] %= mod;
dp1[now] *= dp1[vec[now][i]];
dp1[now] %= mod;
}
dp1[now] *= fact[c1[now]];
dp1[now] %= mod;
}
q.push(0);
while (q.size()) {
now = q.front(), q.pop();
for (i = 0; i < vec[now].size(); ++i)
if (vec[now][i] != p[now])
q.push(vec[now][i]);
dp2[now] = 1;
if (now) {
c2[now] = n - c1[now] - 2;
dp2[now] *= rev(fact[c2[p[now]]]);
dp2[now] %= mod;
dp2[now] *= dp2[p[now]];
dp2[now] %= mod;
dp2[now] *= dp1[p[now]];
dp2[now] %= mod;
dp2[now] *= rev(dp1[now]);
dp2[now] %= mod;
dp2[now] *= rev(fact[c1[p[now]]]);
dp2[now] %= mod;
dp2[now] *= fact[c1[now] + 1];
dp2[now] %= mod;
dp2[now] *= fact[c2[now]];
dp2[now] %= mod;
c2[now]++;
}
}
for (i = 0; i < n; ++i) {
ans = dp1[i] * dp2[i];
ans %= mod;
ans *= fact[n - 1];
ans %= mod;
ans *= rev(fact[c1[i]]);
ans %= mod;
ans *= rev(fact[c2[i]]);
ans %= mod;
printf("%lld\n", ans);
}
return 0;
} | replace | 66 | 82 | 66 | 79 | TLE | |
p02728 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
// #include <boost/multiprecision/cpp_int.hpp>
// namespace mp = boost::multiprecision;
// #include "atcoder/all"
using namespace std;
const double PI = 3.14159265358979323846;
typedef long long ll;
const double EPS = 1e-9;
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef pair<ll, ll> P;
const ll INF = 10e17;
#define cmin(x, y) x = min(x, y)
#define cmax(x, y) x = max(x, y)
#define ret() return 0;
double equal(double a, double b) { return fabs(a - b) < DBL_EPSILON; }
std::istream &operator>>(std::istream &in, set<int> &o) {
int a;
in >> a;
o.insert(a);
return in;
}
std::istream &operator>>(std::istream &in, queue<int> &o) {
ll a;
in >> a;
o.push(a);
return in;
}
bool contain(set<int> &s, int a) { return s.find(a) != s.end(); }
typedef priority_queue<ll, vector<ll>, greater<ll>> PQ_ASK;
const int mod = 1000000007;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
friend std::istream &operator>>(std::istream &in, mint &o) {
ll a;
in >> a;
o = a;
return in;
}
friend std::ostream &operator<<(std::ostream &out, const mint &o) {
out << o.x;
return out;
}
};
struct Triangle {
int parent;
vector<int> children;
};
class Tree {
vector<vector<int>> edges;
public:
Tree(int n) : edges(n) {}
void edge(int i, int j) {
edges[i].push_back(j);
edges[j].push_back(i);
}
vector<Triangle> root(int r) {
vector<Triangle> leafs;
queue<int> vs;
vs.push(r);
vector<bool> check(edges.size(), false);
check[r] = true;
while (!vs.empty()) {
int k = vs.front();
Triangle triangle;
triangle.parent = k;
for (int i : edges[k]) {
if (check[i])
continue;
check[i] = true;
triangle.children.push_back(i);
vs.push(i);
}
vs.pop();
leafs.push_back(triangle);
}
reverse(leafs.begin(), leafs.end());
return leafs;
}
};
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
} combination(1000000);
mint factor(int i) { return combination.fact[i]; }
int main() {
int n;
cin >> n;
vector<P> v(n - 1);
for (P &p : v)
cin >> p.first >> p.second, p.first--, p.second--;
Tree tree(n);
for (P p : v)
tree.edge(p.first, p.second);
rep(i, n) {
auto leafs = tree.root(i);
vector<int> child_counts(n);
for (Triangle &t : leafs) {
int parent = t.parent;
for (int child : t.children) {
child_counts[parent] += child_counts[child];
child_counts[parent]++;
}
}
vector<mint> dp(n, 1);
for (Triangle &t : leafs) {
int parent = t.parent;
mint parent_factor = factor(child_counts[parent]);
mint child_factor = 1;
mint child_comb = 1;
for (int child : t.children) {
child_factor *= factor(child_counts[child] + 1);
}
for (int child : t.children) {
child_comb *= dp[child];
}
mint now = parent_factor * child_comb / child_factor;
dp[parent] = now;
}
cout << dp[i] << endl;
}
}
| #include <bits/stdc++.h>
// #include <boost/multiprecision/cpp_int.hpp>
// namespace mp = boost::multiprecision;
// #include "atcoder/all"
using namespace std;
const double PI = 3.14159265358979323846;
typedef long long ll;
const double EPS = 1e-9;
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef pair<ll, ll> P;
const ll INF = 10e17;
#define cmin(x, y) x = min(x, y)
#define cmax(x, y) x = max(x, y)
#define ret() return 0;
double equal(double a, double b) { return fabs(a - b) < DBL_EPSILON; }
std::istream &operator>>(std::istream &in, set<int> &o) {
int a;
in >> a;
o.insert(a);
return in;
}
std::istream &operator>>(std::istream &in, queue<int> &o) {
ll a;
in >> a;
o.push(a);
return in;
}
bool contain(set<int> &s, int a) { return s.find(a) != s.end(); }
typedef priority_queue<ll, vector<ll>, greater<ll>> PQ_ASK;
const int mod = 1000000007;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
friend std::istream &operator>>(std::istream &in, mint &o) {
ll a;
in >> a;
o = a;
return in;
}
friend std::ostream &operator<<(std::ostream &out, const mint &o) {
out << o.x;
return out;
}
};
struct Triangle {
int parent;
vector<int> children;
};
class Tree {
vector<vector<int>> edges;
public:
Tree(int n) : edges(n) {}
void edge(int i, int j) {
edges[i].push_back(j);
edges[j].push_back(i);
}
vector<Triangle> root(int r) {
vector<Triangle> leafs;
queue<int> vs;
vs.push(r);
vector<bool> check(edges.size(), false);
check[r] = true;
while (!vs.empty()) {
int k = vs.front();
Triangle triangle;
triangle.parent = k;
for (int i : edges[k]) {
if (check[i])
continue;
check[i] = true;
triangle.children.push_back(i);
vs.push(i);
}
vs.pop();
leafs.push_back(triangle);
}
reverse(leafs.begin(), leafs.end());
return leafs;
}
};
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
} combination(1000000);
mint factor(int i) { return combination.fact[i]; }
int main() {
int n;
cin >> n;
vector<P> v(n - 1);
for (P &p : v)
cin >> p.first >> p.second, p.first--, p.second--;
Tree tree(n);
for (P p : v)
tree.edge(p.first, p.second);
auto leafs = tree.root(0);
vector<int> child_counts(n);
for (Triangle &t : leafs) {
int parent = t.parent;
for (int child : t.children) {
child_counts[parent] += child_counts[child];
child_counts[parent]++;
}
}
vector<mint> dp(n, 1);
vector<mint> child_factor_muls(n);
vector<mint> child_dp_muls(n);
vector<int> parents(n, -1);
for (Triangle &t : leafs) {
int parent = t.parent;
mint parent_factor = factor(child_counts[parent]);
mint child_factor_mul = 1;
mint child_dp_mul = 1;
for (int child : t.children) {
child_factor_mul *= factor(child_counts[child] + 1);
}
for (int child : t.children) {
child_dp_mul *= dp[child];
}
for (int child : t.children) {
parents[child] = t.parent;
}
child_factor_muls[parent] = child_factor_mul;
child_dp_muls[parent] = child_dp_mul;
mint now = parent_factor * child_dp_mul / child_factor_mul;
dp[parent] = now;
}
vector<mint> ans(n);
ans[0] = dp[0];
reverse(leafs.begin(), leafs.end());
auto calc_new_dp = [&](int prev_root, int new_root) -> mint {
mint prev_root_factor_muls = child_factor_muls[prev_root];
mint exclude_factor = factor(child_counts[new_root] + 1);
mint factor_mul = prev_root_factor_muls / exclude_factor;
mint dp_mul = child_dp_muls[prev_root] / dp[new_root];
mint all_factor = factor(n - 2 - child_counts[new_root]);
mint now = all_factor * dp_mul / factor_mul;
return now;
};
auto calc_new_leaf_size = [&](int prev_root, int new_root) -> int {
return n - 1 - child_counts[new_root];
};
auto move_root = [&](int new_root) {
int prev_root = parents[new_root];
if (prev_root == -1)
return;
// child_counts[new_root] = n - 1;
mint next = calc_new_dp(prev_root, new_root);
child_dp_muls[new_root] *= next;
child_factor_muls[new_root] *=
factor(calc_new_leaf_size(prev_root, new_root));
mint dp_mul = child_dp_muls[new_root];
mint factor_mul = child_factor_muls[new_root];
mint now = factor(n - 1) * dp_mul / factor_mul;
ans[new_root] = now;
dp[new_root] = now;
};
for (Triangle &t : leafs) {
move_root(t.parent);
}
for (mint a : ans)
cout << a << endl;
}
| replace | 184 | 220 | 184 | 267 | TLE |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.