text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
std::istream& operator>>(std::istream& i, pair<T, U>& p) {
i >> p.first >> p.second;
return i;
}
template <typename T>
std::istream& operator>>(std::istream& i, vector<T>& t) {
for (auto& v : t) {
i >> v;
}
return i;
}
template <typename T, typename U>
std::ostream& operator<<(std::ostream& o, const pair<T, U>& p) {
o << p.first << ' ' << p.second;
return o;
}
template <typename T>
std::ostream& operator<<(std::ostream& o, const vector<T>& t) {
if (t.empty()) o << '\n';
for (size_t i = 0; i < t.size(); ++i) {
o << t[i] << " \n"[i == t.size() - 1];
}
return o;
}
template <typename T>
using minheap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using maxheap = priority_queue<T, vector<T>, less<T>>;
template <typename T>
bool in(T a, T b, T c) {
return a <= b && b < c;
}
unsigned int logceil(int first) {
return first ? 8 * sizeof(int) - __builtin_clz(first) : 0;
}
namespace std {
template <typename T, typename U>
struct hash<pair<T, U>> {
hash<T> t;
hash<U> u;
size_t operator()(const pair<T, U>& p) const {
return t(p.first) ^ (u(p.second) << 7);
}
};
} // namespace std
template <typename T, typename F>
T bsh(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
l = m + 1;
r = m;
} else {
h = m - 1;
}
}
return r;
}
template <typename F>
double bshd(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
l = m;
} else {
h = m;
}
}
return (l + h) / 2;
}
template <typename T, typename F>
T bsl(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
h = m - 1;
r = m;
} else {
l = m + 1;
}
}
return r;
}
template <typename F>
double bsld(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
h = m;
} else {
l = m;
}
}
return (l + h) / 2;
}
template <typename T>
T gcd(T a, T b) {
if (a < b) swap(a, b);
return b ? gcd(b, a % b) : a;
}
template <typename T>
class vector2 : public vector<vector<T>> {
public:
vector2() {}
vector2(size_t a, size_t b, T t = T())
: vector<vector<T>>(a, vector<T>(b, t)) {}
};
template <typename T>
class vector3 : public vector<vector2<T>> {
public:
vector3() {}
vector3(size_t a, size_t b, size_t c, T t = T())
: vector<vector2<T>>(a, vector2<T>(b, c, t)) {}
};
template <typename T>
class vector4 : public vector<vector3<T>> {
public:
vector4() {}
vector4(size_t a, size_t b, size_t c, size_t d, T t = T())
: vector<vector3<T>>(a, vector3<T>(b, c, d, t)) {}
};
template <typename T>
class vector5 : public vector<vector4<T>> {
public:
vector5() {}
vector5(size_t a, size_t b, size_t c, size_t d, size_t e, T t = T())
: vector<vector4<T>>(a, vector4<T>(b, c, d, e, t)) {}
};
class TaskA {
public:
void solve(istream& cin, ostream& cout) {
int N;
cin >> N;
vector<int> A(N);
cin >> A;
for (int k = *max_element(A.begin(), A.end());; ++k) {
int first = 0, second = 0;
for (int& a : A) {
first += a;
second += k - a;
}
if (second > first) {
cout << k << '\n';
return;
}
}
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
TaskA solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, sum = 0, cnt = 0, ans = 0, ansl = 0;
cin >> t;
int a[t];
for (int i = 0; i < t; i++) {
cin >> a[i];
sum = sum + a[i];
cnt = max(cnt, a[i]);
}
for (int i = 0; i < t; i++) {
ans = ans + cnt - a[i];
}
if (ans > sum) {
cout << cnt;
} else {
while (true) {
cnt++;
ansl = 0;
for (int i = 0; i < t; i++) {
ansl = ansl + cnt - a[i];
}
if (ansl > sum) {
cout << cnt;
return 0;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y = 0, z = 0, j;
vector<int> v;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
v.push_back(x);
z += x;
}
sort(v.begin(), v.end());
for (int i = 0; i < n; i++) {
y += (v[n - 1] - v[i]);
}
if (y > z)
cout << v[n - 1];
else {
j = 1;
while (y <= z) {
v[n - 1]++;
y += n;
j++;
}
cout << v[n - 1];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<long long> a(n);
long long s = 0;
long long l = 0;
long long r = 1000000000000000;
for (int i = 0; i < n; i++) {
cin >> a[i];
s += a[i];
l = max(a[i], l);
}
long long is = r;
while (l <= r) {
long long mid = (l + r) / 2;
if (n * mid - s > s) {
is = min(is, mid);
r = mid - 1;
} else
l = mid + 1;
}
cout << is << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long b = 0, c, d, n, i, s = 0, k, s1 = 0, j;
cin >> n;
int a[n + 7];
for (i = 1; i <= n; i++) {
cin >> a[i];
s = s + a[i];
if (a[i] > b) {
b = a[i];
}
}
for (i = b; i <= 210; i++) {
for (j = 1; j <= n; j++) {
s1 = s1 + (i - a[j]);
}
if (s1 > s) {
cout << i;
return 0;
}
s1 = 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio(0);
int n;
cin >> n;
int sum = 0, mx = 0;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
sum += a;
mx = max(mx, a);
}
while (mx * n - sum <= sum) {
mx++;
}
cout << mx << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int* arr = new int[n];
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
sum += arr[i];
}
int max = *max_element(arr, arr + n);
int res = (2 * sum) / n;
if (res < max) {
cout << max << endl;
} else {
cout << ((2 * sum) / n) + 1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static const string YES = "YES", NO = "NO";
int main() {
int n;
cin >> n;
int sum = 0;
int MAX = -1;
int x;
for (int i = (0); i < (n); ++i) {
cin >> x;
sum += x;
MAX = max(x, MAX);
}
double avg = 1.0 * sum / n;
int result = max(MAX, 2 * sum / n + 1);
cout << result;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[105];
signed main() {
int n;
cin >> n;
int sum = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sum += a[i];
}
for (int k = 0; k <= 300; k++) {
bool ok = 1;
int tmp = 0;
for (int i = 1; i <= n; i++) {
if (a[i] > k) {
ok = 0;
break;
}
tmp += k - a[i];
}
if (tmp <= sum || ok == 0)
continue;
else {
cout << k;
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double PI = acos(-1.0);
const int N = 123;
int n, a[N];
int main(void) {
ios_base::sync_with_stdio(false);
cin >> n;
int k = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
k = max(a[i], k);
}
int va = 0, vb = 0;
for (int i = 0; i < n; i++) {
va += a[i];
vb += k - a[i];
}
while (vb <= va) {
k++;
vb += n;
}
cout << k << endl;
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n, a, sum = 0, i, max = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a);
sum = sum + a;
if (max < a) {
max = a;
}
}
while (1) {
if (n * max - sum > sum) {
printf("%d\n", max);
return 0;
}
max++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k1, max = 0;
cin >> n;
int a[n];
unsigned long long int sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum = sum + a[i];
if (a[i] > max) max = a[i];
}
k1 = ((sum * 2) / n) + 1;
if (k1 < max)
cout << max << endl;
else
cout << k1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long fastpow(int a, int b, int MOD) {
long long x = 1, y = a;
while (b > 0) {
if (b % 2 == 1) {
x = (x * y) % MOD;
}
y = (y * y) % MOD;
b /= 2;
}
return x;
}
long long InverseEuler(int n, int MOD) { return fastpow(n, MOD - 2, MOD); }
long long f[300000];
int a[99999];
int N;
bool win(int k) {
int A, B;
A = 0;
B = 0;
for (int i = 0; i < N; i++) {
A += a[i];
B += k - a[i];
if (k < a[i]) return 0;
}
if (B > A) return 1;
return 0;
}
int main() {
std::ios::sync_with_stdio(false);
cin >> N;
for (int i = 0; i < N; i++) cin >> a[i];
for (int k = 0; k <= 10000000; k++)
if (win(k)) {
cout << k << endl;
return 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool smin(T &a, const T &b) {
return a > b ? a = b : a;
}
template <typename T>
inline bool smax(T &a, const T &b) {
return a < b ? a = b : a;
}
const int N = (int)205, mod = (int)0;
int a[N];
int main() {
int n, mx = 0, sum = 0;
cin >> n;
for (int j = 0; j < n; ++j) {
cin >> a[j];
mx = max(mx, a[j]);
sum += a[j];
}
for (int k = mx; k < N; ++k) {
if (k * n - sum > sum) {
cout << k << endl;
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sum = 0, mx = 0;
cin >> n;
vector<int> v(n);
for (auto &it : v) {
cin >> it;
mx = max(mx, it);
sum += it;
}
sum *= 2;
sum += n;
sum /= n;
cout << max(sum, mx) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int tab[n];
int s = 0, x, m = -1;
for (int i = 0; i < n; i++) {
cin >> x;
s += x;
m = max(m, x);
}
int i = m, c = n * i - s;
while (c <= s) {
i++;
c = n * i - s;
}
cout << i;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[110], k, sum = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
sum += a[i];
}
sort(a, a + n);
for (k = a[n - 1];; k++) {
if (k * n > 2 * sum) break;
}
printf("%d\n", k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, v, mx = 0, all = 0, check = 0, ans;
cin >> n;
vector<int> vec;
for (int x = 0; x < n; x++) {
cin >> v;
all += v;
vec.push_back(v);
mx = max(mx, v);
}
for (int x = mx; x <= 10001; x++) {
check = 0;
for (int y = 0; y < n; y++) {
check += x - vec[y];
}
if (check > all) {
ans = x;
break;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, cnt = 0, sum;
cin >> n;
long long int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
cnt += a[i];
}
sort(a, a + n);
for (i = a[n - 1]; i <= 100000; i++) {
sum = 0;
for (long long int j = 0; j < n; j++) {
sum += (i - a[j]);
}
if (sum > cnt) {
cout << i;
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s = 0, m = 0;
cin >> n;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
if (t > m) m = t;
s += t;
}
int ans = (2 * s) / n + 1;
if (ans < m) ans = m;
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, max, l = 0, t = 0, j;
cin >> n;
int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
if (i == 0)
max = a[i];
else {
if (a[i] > max) max = a[i];
}
}
for (i = max; i < 500; i++) {
l = 0;
t = 0;
for (j = 0; j < n; j++) {
l = l + a[j];
t = t + i - a[j];
}
if (t > l) {
cout << i;
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mcd(int, int);
int maxi(int, int, int);
int bus(int, int, int, vector<int>, int &, int &);
bool app(vector<int> &, int);
int main() {
int n, num, suma = 0;
vector<int> vec;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> num;
vec.push_back(num);
suma += num;
}
suma *= 2;
sort(vec.begin(), vec.end());
int k = suma / n;
k++;
if (k < vec[n - 1]) {
cout << vec[n - 1];
} else {
cout << k;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s, i, j, r;
cin >> n;
int a[110];
s = 0;
int mx = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
s += a[i];
mx = max(mx, a[i]);
}
int cnt = 0;
for (i = mx; i <= 300; i++) {
cnt = 0;
for (j = 0; j < n; j++) {
cnt += (i - a[j]);
}
if (cnt > s) break;
}
printf("%d\n", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int n, a[200], k, mx = 0, c = 0, c2 = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
c += a[i];
mx = max(mx, a[i]);
}
for (int i = 0; i < n; i++) {
c2 += mx - a[i];
}
k = 0;
while (c2 + k * n <= c) {
k++;
}
cout << k + mx;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = acosl(-1.0);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, x, mx = -1, sum = 0;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> x;
sum += x;
mx = max(x, mx);
}
long long ans = ceil(2.0 * sum / n);
if (ans < mx) ans = mx;
if (ans * n == 2 * sum) ans++;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
sum = sum + arr[i];
}
int max = 0;
for (int i = 0; i < n; i++) {
if (arr[i] > max) max = arr[i];
}
int ans = max;
while (n * ans <= 2 * sum) {
ans++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long x, y, z;
deque<long long> q;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
cin >> x;
for (int i = 0; i < x; i++) {
cin >> y;
q.push_back(y);
}
sort(q.rbegin(), q.rend());
z = q[0];
while (true) {
long long s = 0, ss = 0;
for (int i = 0; i < x; i++) {
ss += q[i];
s += (z - q[i]);
}
if (s > ss) {
cout << z << endl;
return 0;
}
z++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int i;
int a[n];
int max = -1;
int sum = 0;
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (a[i] > max) max = a[i];
sum += a[i];
}
int l = 0;
for (i = 0; i < n; i++) {
l = l + (max - a[i]);
}
int temp = max;
while (sum >= l) {
temp++;
l += n;
}
printf("%d", temp);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, max, a[200], k, i, sume, suma;
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
max = a[0];
sume = 0;
for (i = 0; i < n; i++) {
sume += a[i];
if (a[i] > max) max = a[i];
}
k = max;
while (1) {
suma = 0;
for (i = 0; i < n; i++) suma += (k - a[i]);
if (suma > sume) break;
k++;
}
cout << k << endl;
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n, i, j, k, aSum, eSum, max;
while (scanf("%d", &n) != EOF) {
int a[n];
for (i = 0; i < n; i++) scanf("%d", &a[i]);
eSum = 0;
max = -1;
for (i = 0; i < n; i++) {
eSum += a[i];
if (max < a[i]) max = a[i];
}
k = max;
for (;; k++) {
aSum = 0;
for (j = 0; j < n; j++) {
aSum += (k - a[j]);
}
if (aSum > eSum) {
printf("%d\n", k);
break;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int x[n], sum = 0, k = -1;
for (int i = 0; i < n; i++) {
cin >> x[i];
sum += x[i];
if (x[i] > k) k = x[i];
}
int sum2 = 0, var;
for (int i = 0; i < n; i++) {
sum2 += (k - x[i]);
}
while (sum2 <= sum) {
k++;
sum2 = 0;
for (int i = 0; i < n; i++) {
sum2 += (k - x[i]);
}
}
cout << k;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
int vt[n + 7], sum = 0, mx = -INT_MAX;
for (int i = 1; i <= n; i++) {
cin >> vt[i];
sum += vt[i];
mx = max(mx, vt[i]);
}
for (int k = mx; k < 300; k++) {
int t = 0;
for (int i = 1; i <= n; i++) {
t += max(0, k - vt[i]);
}
if (t > sum) {
cout << k << endl;
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T read(T& x) {
x = 0;
int f = 0;
char ch = getchar();
while (ch < '0' || ch > '9') f |= (ch == '-'), ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x = f ? -x : x;
}
const int N = 100 + 10;
int n, ans, i, a[N];
bool check(int k) {
int aa = 0, bb = 0;
for (int i = 1; i <= n; ++i) {
aa += a[i];
bb += k - a[i];
}
return aa < bb;
}
int main() {
read(n);
for (i = 1; i <= n; ++i) read(a[i]);
ans = *max_element(a + 1, a + 1 + n);
for (;; ans++) {
if (check(ans)) return printf("%d\n", ans), 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[105], n, sum;
bool check(long long x) {
long long tmp = 0;
for (int i = 1; i <= n; i++) tmp += (x - a[i]);
if (tmp > sum) return true;
return false;
}
int main() {
long long i, j, k, m, l, r, ans;
while (scanf("%lld", &n) != EOF) {
l = 0;
sum = 0;
for (i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
sum += a[i];
l = max(l, a[i]);
}
r = l * 105;
while (l <= r) {
long long mid = (l + r) / 2;
if (check(mid)) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
printf("%lld\n", ans);
}
}
|
#include <bits/stdc++.h>
int n, sum(0), s, x, maxx = 0;
int main() {
scanf("%d", &n);
register int i, k;
for (i = 1; i <= n; ++i) {
scanf("%d", &x);
maxx = maxx < x ? x : maxx;
sum += x;
}
for (k = maxx; k < 1000; ++k) {
if (n * k - sum > sum) {
printf("%d", k);
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int modInverse(long long int n, long long int p) {
return power(n, p - 2, p);
}
struct point {
long long int x, y;
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
vector<long long int> arr(n);
for (long long int i = 0; i < n; i++) {
cin >> arr[i];
}
long long int k = *max_element(arr.begin(), arr.end());
while (true) {
long long int val1 = 0, val2 = 0;
for (long long int i = 0; i < n; i++) {
val2 += arr[i];
val1 += (k - arr[i]);
}
if (val1 > val2) {
cout << k << "\n";
return 0;
}
k++;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int res = 0;
int maxx = 0;
for (int i = 0; i < n; i++) {
int tp;
cin >> tp;
maxx = max(tp, maxx);
res += tp;
}
int i;
for (i = maxx;; i++) {
if (i * n > res * 2) break;
}
cout << i << endl;
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n, i, j, k, sum = 0;
int temp;
scanf("%d", &n);
int a[n];
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (i = 0; i < n; i++) {
sum = sum + a[i];
}
for (i = 0; i < n - 1; i++) {
for (j = i + 1; j < n; j++) {
if (a[i] < a[j]) {
temp = a[j];
a[j] = a[i];
a[i] = temp;
}
}
}
k = a[0];
for (i = 0; i <= a[0] + 2; i++) {
if (((k * n) - sum) > sum) {
printf("%d", k);
break;
}
++k;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, k, max = 0, sum = 0;
cin >> n;
int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
if (a[i] > max) {
max = a[i];
}
}
for (k = max;; k++) {
if ((n * k) - sum > sum) {
cout << k;
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int mx = 0, sum = 0;
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
int a;
cin >> a;
mx = max(mx, a);
sum += a;
}
sum *= 2;
sum += n;
sum /= n;
cout << max(sum, mx) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int arr[n];
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
sum += arr[i];
}
sort(arr, arr + n, greater<int>());
sum *= 2;
sum += n;
sum /= n;
cout << max(sum, arr[0]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M4 = 1e4 + 100, M5 = 1e5 + 100, M6 = 1e6 + 100, M7 = 1e7 + 100,
M8 = 1e8 + 100, M9 = 1e9 + 100;
int a[M4], k;
long long sum;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i], k = max(k, a[i]);
}
while (k * n <= 2 * sum) k++;
cout << k;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, n, a, maxx, i, sum;
int m[102];
cin >> n;
maxx = 0;
for (i = 0; i < n; i++) {
cin >> m[i];
maxx = max(m[i], maxx);
}
sum = 0;
for (i = 0; i < n; i++) {
sum += m[i];
}
a = 0;
a = maxx * n - sum;
if (sum < a) {
cout << maxx;
} else {
while (sum >= a) {
maxx++;
a += n;
}
cout << maxx;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long MAX2(long long a, long long int b) {
return (a) > (b) ? (a) : (b);
}
inline long long MAX3(long long a, long long b, long long c) {
return (a) > (b) ? ((a) > (c) ? (a) : (c)) : ((b) > (c) ? (b) : (c));
}
inline long long MIN2(long long a, long long b) {
return (a) < (b) ? (a) : (b);
}
inline long long MIN3(long long a, long long b, long long c) {
return (a) < (b) ? ((a) < (c) ? (a) : (c)) : ((b) < (c) ? (b) : (c));
}
using namespace std;
int main() {
{
int n, i;
cin >> n;
vector<int> a(n);
int maxi = -1000000000, sum = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
maxi = max(maxi, a[i]);
sum += a[i];
}
int k = max(maxi, (int)ceil((2.0 * sum + 1) / n));
cout << k;
}
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int i, n, arr[1000];
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
int x = 0;
for (i = 0; i < n; i++) {
x = x + arr[i];
}
int k = (x * 2) + 1;
while (1) {
if (k % n != 0) {
k = k + 1;
}
if (k % n == 0) {
break;
}
}
int res = k / n;
for (i = 0; i < n; i++) {
if (res < arr[i]) {
res = arr[i];
}
}
printf("%d", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, t, s, ma;
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> t;
s += t;
ma = max(ma, t);
}
cout << max(ma, (2 * s + n) / n);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int s = 0, a[n + 1], mx = INT_MIN;
for (int i = 0; i < n; i++) {
cin >> a[i];
s += a[i];
mx = max(mx, a[i]);
}
s *= 2;
cout << max(mx, s / n + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
int s = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
s += a[i];
}
for (int ans = 1; ans <= 1000; ans++) {
int cur = 0;
bool ok = 0;
for (int i = 0; i < n; i++) {
if (ans - a[i] < 0) {
ok = 1;
break;
}
int t = ans - a[i];
cur += t;
}
if (ok) continue;
if (cur > s) {
cout << ans << endl;
return 0;
}
}
}
|
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::string;
using std::vector;
int n;
int a[101];
int solve() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
int k = *std::max_element(a, a + n);
while (true) {
int sa = 0, sb = 0;
for (int i = 0; i < n; ++i) {
sa += a[i], sb += k - a[i];
}
if (sb > sa) {
cout << k;
return 0;
}
++k;
}
return 0;
}
int main(int argc, char* argv[]) {
::std::ios::sync_with_stdio(false);
::std::cin.tie(0);
::std::cout.tie(0);
int test_count = 1;
while (test_count--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, num, ma = 0, sum1 = 0, sum2 = 0;
vector<long long> v;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> num;
ma = max(ma, num);
v.push_back(num);
sum2 += num;
}
for (long long i = 0; i < n; i++) {
sum1 += ma - v[i];
}
while (sum1 <= sum2) {
sum1 += n;
ma++;
}
cout << ma;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k = 0, maxx = -1;
cin >> n;
int a[n + 10];
int sum = 0;
k = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
if (maxx < a[i]) {
maxx = a[i];
}
}
while (k * n - sum <= sum || maxx > k) {
k++;
}
cout << k;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int A[n];
int m = 0, sum = 0;
for (int i = 0; i < n; i++) {
cin >> A[i];
sum += A[i];
m = max(A[i], m);
}
int sum2 = 0;
for (int i = 0; i < n; i++) {
sum2 += (m - A[i]);
}
if (sum2 > sum) {
cout << m << "\n";
} else {
if (sum2 == sum) {
cout << m + 1;
return 0;
}
int k = sum - sum2;
int nu = k / n == 0 ? k / n : k / n + 1;
int sum3 = 0;
for (int i = 0; i < n; i++) {
sum3 += (nu + m - A[i]);
}
if (sum3 > sum)
cout << nu + m;
else {
cout << nu + m + 1;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[150], n;
int main() {
int ans = 0, s = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
ans = max(ans, a[i]);
s += a[i];
}
for (; ans * n - s <= s; ans++)
;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
int sm = 0, mx = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
sm += x;
mx = max(mx, x);
}
cout << max(mx, (2 * sm + n) / n);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tst = 1;
while (tst--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 110;
int n = 0;
int a[maxn];
int sum = 0, mx = 0;
;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
sum += a[i];
mx = max(mx, a[i]);
}
int k = 2 * sum / n;
if (k < mx) k = mx;
while (n * k <= 2 * sum) ++k;
printf("%d\n", k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long long s = 0, x;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i], s += a[i];
sort(a, a + n);
x = a[n - 1];
while (1) {
if ((n * x - s) > s) {
break;
}
x++;
}
cout << x;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
int k = 2 * accumulate(v.begin(), v.end(), 0);
k = k / n + 1;
cout << max(k, *max_element(v.begin(), v.end())) << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-11;
void fastIO() {
std::ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int main() {
fastIO();
int n, a;
cin >> n;
int tot = 0;
int mx = 0;
for (int i = 0; i < n; i++) {
cin >> a;
tot += a;
mx = max(mx, a);
}
double cond = (2.0 * tot) / n;
if (cond < mx) {
cout << mx << endl;
} else {
cout << ceil(cond + .00001) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
vector<int> a;
cin >> n;
a.resize(n);
int max = 0;
int s = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] > max) {
max = a[i];
}
s += a[i];
}
int k = max;
while (true) {
int sum = 0;
for (int i = 0; i < n; i++) {
sum = sum + k - a[i];
}
if (sum > s) {
cout << k;
return 0;
}
k++;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
int k = 0;
int sum = 0;
int sum2 = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (k == 0) {
k = a[i];
}
if (k > 0) {
k = max(k, a[i]);
}
sum = sum + a[i];
}
for (int i = 0; i < n; i++) {
sum2 = sum2 + (k - a[i]);
}
while (sum > sum2) {
k += 1;
sum2 = 0;
for (int i = 0; i < n; i++) {
sum2 = sum2 + (k - a[i]);
}
}
if (sum == sum2) {
k += 1;
}
cout << k << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[109];
int ans;
int s;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
s += a[i];
ans = max(ans, a[i]);
}
for (;; ans++) {
if (ans * n - s > s) {
printf("%d", ans);
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s = 0, max = 0;
int temp;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> temp;
if (temp > max) {
max = temp;
}
s += temp;
}
if (max * n - s > s) {
cout << max;
} else {
cout << (s * 2) / n + 1;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 130;
int n, maxx, a[Maxn], you, she;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
she += a[i];
maxx = max(a[i], maxx);
}
for (int i = maxx; i < 250; i++) {
you = i * n - she;
if (she < you) {
cout << i;
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline int nxt() {
int x;
scanf("%d", &x);
return x;
}
int main() {
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int n = nxt();
vector<int> a(n);
for (int i = 0; i < n; ++i) {
a[i] = nxt();
}
int s = accumulate((a).begin(), (a).end(), 0);
int k = *max_element((a).begin(), (a).end());
int t = k * n;
int need = 2 * s + 1;
if (need > t) {
k += (need - t + n - 1) / n;
}
printf("%d\n", k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
long long n, a[N];
long long sum, mx;
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
long long b;
cin >> b;
sum += b;
mx = max(mx, b);
}
sum *= 2;
sum /= n;
sum++;
cout << max(sum, mx);
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
char c = getchar();
int x = 0;
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + (c - '0'), c = getchar();
return x;
}
void MOD(int &x) {
if (x >= 998244353) x -= 998244353;
}
int m;
int l, nxt[1000010], head[1000010], to[1000010];
void add(int x, int y) {
l++;
nxt[l] = head[x];
head[x] = l;
to[l] = y;
}
int low[1000010], f[1000010], d[1000010];
void dfs(int x) {
low[x] = (1 << 30);
bool fl = 1;
for (int i = head[x]; i; i = nxt[i]) {
int c = to[i];
d[c] = d[x] + 1;
dfs(c);
if (low[c] - d[x] <= m) {
f[x] += f[c];
f[c] = 0;
}
low[x] = min(low[x], low[c]);
fl = 0;
}
if (fl) low[x] = d[x], f[x] = 1;
}
int getans(int x) {
int ans = 0;
for (int i = head[x]; i; i = nxt[i]) {
int c = to[i];
ans = max(ans, getans(c));
}
return ans + f[x];
}
int main() {
int n;
n = read();
m = read();
for (int i = 2; i <= n; i++) add(read(), i);
dfs(1);
printf("%d\n", getans(1));
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0;
bool neg = false;
char c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
if (c == '-') neg = true, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
if (neg) x = -x;
return x;
}
inline void write(long long x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
const int maxn = 1000000, inf = 1e9;
int n, k, H[maxn + 1], A[maxn + 1], P[maxn + 1];
vector<int> G[maxn + 1];
void dfs(int u) {
H[u] = inf;
for (auto &v : G[u]) {
dfs(v);
A[u] += A[v];
H[u] = min(H[u], H[v] + 1);
P[u] = max(P[u], P[v] - A[v]);
}
P[u] += A[u];
if (H[u] == inf) P[u] = A[u] = 1, H[u] = 0;
if (H[u] >= k) A[u] = 0;
}
int main() {
n = read();
;
k = read();
;
for (int _b = n, i = 2; i <= _b; ++i) {
int p;
p = read();
;
G[p].push_back(i);
}
dfs(1);
write(P[1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
x = 0;
int f = 0;
char ch = getchar();
while (!isdigit(ch)) f = ch == '-', ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
x = f ? -x : x;
}
const int N = 1e6 + 5;
vector<int> son[N];
int f[N], dep[N], down[N], n, h;
void dfs1(int x) {
for (auto y : son[x]) dep[y] = dep[x] + 1, dfs1(y);
}
void dfs2(int x) {
for (auto y : son[x]) dfs2(y), down[x] = min(down[y], down[x]);
}
void dfs3(int x) {
for (auto y : son[x]) {
dfs3(y);
if (down[y] - h <= dep[x]) f[x] += f[y], f[y] = 0;
}
}
int dfs4(int x) {
int res = 0;
for (auto y : son[x]) res = max(res, dfs4(y));
return res + f[x];
}
int main() {
read(n), read(h);
for (int i = 2, fa; i <= n; i++) read(fa), son[fa].push_back(i);
dfs1(1);
for (int i = 1; i <= n; i++)
if (son[i].empty())
down[i] = dep[i], f[i] = 1;
else
down[i] = 0x3f3f3f3f;
dfs2(1), dfs3(1);
printf("%d", dfs4(1));
return 0;
}
|
#include <bits/stdc++.h>
int min(int a, int b) { return a < b ? a : b; }
int max(int a, int b) { return a > b ? a : b; }
int oo[1 + 1000000 - 1], oj[1 + 1000000 - 1];
int link(int o, int j) {
static int _ = 1;
oo[_] = o, oj[_] = j;
return _++;
}
int ae[1000000], hh[1000000], dp[1000000], dq[1000000], n, k;
int dfs1(int i, int d) {
int o, d_;
if (ae[i] == 0) return d;
d_ = n;
for (o = ae[i]; o; o = oo[o]) {
int j = oj[o];
d_ = min(d_, dfs1(j, d + 1));
}
hh[i] = d_ - d;
return d_;
}
void dfs2(int i) {
int o;
if (ae[i] == 0) {
dp[i] = 1;
return;
}
for (o = ae[i]; o; o = oo[o]) {
int j = oj[o];
dfs2(j);
if (hh[j] < k) dp[i] += dp[j];
}
}
void dfs3(int i) {
int o, x = 0;
for (o = ae[i]; o; o = oo[o]) {
int j = oj[o];
dfs3(j);
x = max(x, dq[j] - (hh[j] < k ? dp[j] : 0));
}
dq[i] = dp[i] + x;
}
int main() {
int i;
scanf("%d%d", &n, &k);
for (i = 1; i < n; i++) {
int p;
scanf("%d", &p), p--;
ae[p] = link(ae[p], i);
}
dfs1(0, 0);
dfs2(0);
dfs3(0);
printf("%d\n", dq[0]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int maxn = 1e6 + 500;
const long long int mod = 998244353;
int dep[maxn], low[maxn], ans[maxn], dp[maxn];
int head[maxn], cnt;
int n, k;
struct C {
int next, to;
} E[maxn];
void add(int x, int y) {
E[cnt].to = y;
E[cnt].next = head[x];
head[x] = cnt++;
}
void dfs1(int u, int fa) {
low[u] = 0x7f7f7f7f;
dep[u] = dep[fa] + 1;
if (head[u] == -1) {
low[u] = dep[u];
dp[u] = 1;
} else {
for (int i = head[u]; i + 1; i = E[i].next) {
int v = E[i].to;
dfs1(v, u);
low[u] = min(low[u], low[v]);
if (low[v] - k <= dep[u]) dp[u] += dp[v];
}
}
}
int dfs(int u, int fa) {
if (head[u] == -1) return 1;
int ans = 0;
for (int i = head[u]; i + 1; i = E[i].next) {
int v = E[i].to;
int temp = dp[u];
if (low[v] - k <= dep[u]) temp -= dp[v];
ans = max(ans, temp + dfs(v, u));
}
return ans;
}
int main() {
int x;
scanf("%d%d", &n, &k);
memset(head, -1, sizeof head);
for (int i = 2; i <= n; i++) {
scanf("%d", &x);
add(x, i);
}
dfs1(1, 0);
printf("%d\n", dfs(1, 0));
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
int h[N], n, k;
vector<int> g[N];
pair<int, int> f[N];
void dfs(int p) {
if (!g[p].size()) {
f[p] = make_pair(k, 1);
h[p] = 1;
}
for (auto i : g[p]) {
dfs(i);
if (f[i].first)
f[p].first = max(f[p].first, f[i].first - 1), f[p].second += f[i].second;
}
for (auto i : g[p])
if (f[i].first)
h[p] = max(h[p], f[p].second - f[i].second + h[i]);
else
h[p] = max(h[p], f[p].second + h[i]);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n - 1; i++) {
int x;
scanf("%d", &x);
g[x].push_back(i + 1);
}
dfs(1);
printf("%d\n", max(f[1].second, h[1]));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
const int M = 22;
long long mod = 1e9 + 7;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
bool is_vowel(char c) {
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') return 1;
return 0;
}
long long extended_euclidean(long long a, long long b, long long &x,
long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long g = extended_euclidean(b, a % b, y, x);
y -= (a / b) * x;
return g;
}
long long power(long long base, long long p, long long mod) {
if (p == 1) return base;
if (!p) return 1ll;
long long ret = power(base, p / 2, mod);
ret *= ret;
ret %= mod;
if (p & 1) ret *= base;
return ret % mod;
}
float Trianglearea(int x1, int y1, int x2, int y2, int x3, int y3) {
return abs((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2.0);
}
pair<int, int> operator+(pair<int, int> a, pair<int, int> b) {
pair<int, int> ret = a;
ret.first += b.first;
ret.second += b.second;
return ret;
}
int dsu[N], head[N], sz[N], n, depth[N], cnt[N], par[N], k;
vector<int> adj[N], adj2[N];
int get(int node) {
return dsu[node] == node ? node : dsu[node] = get(dsu[node]);
}
void merge(int a, int b) {
a = get(a);
b = get(b);
if (a == b) return;
if (sz[a] < sz[b]) swap(a, b);
dsu[b] = a;
cnt[a] += cnt[b];
head[a] = depth[head[a]] < depth[head[b]] ? head[a] : head[b];
}
void dfs(int node, int p = 0) {
depth[node] = depth[p] + 1;
par[node] = p;
if (adj[node].empty()) cnt[node]++;
for (auto i : adj[node]) {
dfs(i, node);
}
}
void dfs2(int node) {
for (auto i : adj[node]) {
dfs2(i);
}
if (adj[node].empty()) {
merge(get(node), get(par[node]));
int cur = par[head[get(node)]];
while (cur && depth[cur] + k >= depth[node]) {
merge(get(node), get(cur));
cur = par[head[get(node)]];
}
}
}
int solve(int node) {
int ret = 0;
for (int i : adj2[node]) {
ret = max(solve(i), ret);
}
return ret + cnt[get(node)];
}
int main() {
scanf("%d %d", &n, &k);
for (int i = (1); i <= (n); ++i) {
head[i] = dsu[i] = i;
sz[i] = 1;
}
for (int i = (2); i <= (n); ++i) {
int p;
scanf("%d", &p);
adj[p].push_back(i);
}
dfs(1);
dfs2(1);
for (int i = (1); i <= (n); ++i) {
for (int j : adj[i]) {
if (get(i) != get(j)) adj2[get(i)].push_back(get(j));
}
}
cout << solve(get(1));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace IO {
const int buffer_size = 1e5 + 5;
char buf[buffer_size], *S, *T;
bool flag_EOF;
inline char read_char() {
if (S == T) T = (S = buf) + fread(buf, 1, buffer_size, stdin);
return S != T ? *(S++) : EOF;
}
inline int read_int() {
int flag = 1;
char c = read_char();
while (c < '0' || c > '9') {
if (c == EOF) {
flag_EOF = true;
return 0;
}
flag = (c == '-' ? -1 : 1);
c = read_char();
}
int x = 0;
while (c >= '0' && c <= '9') {
x = x * 10 + (c ^ 48);
c = read_char();
}
return x * flag;
}
char st[13];
int _top;
inline void Write(int x) {
if (!x) {
putchar('0');
return;
}
if (x < 0) {
putchar('-');
x = -x;
}
while (x) {
st[++_top] = x % 10 + '0';
x /= 10;
}
while (_top > 0) putchar(st[_top--]);
}
} // namespace IO
int n, k;
const int max_n = 1e6 + 5;
int End[max_n], Last[max_n], Next[max_n], e;
inline void add_edge(int x, int y) {
End[++e] = y;
Next[e] = Last[x];
Last[x] = e;
}
int cnt[max_n], dep[max_n], low[max_n];
void dfs(int x, int fa) {
dep[x] = dep[fa] + 1;
low[x] = 1e9;
int cnt_son = 0;
for (int i = Last[x]; i; i = Next[i]) {
int y = End[i];
if (y != fa) {
dfs(y, x);
if (low[y] <= dep[x] + k) {
cnt[x] += cnt[y], cnt[y] = 0;
low[x] = min(low[x], low[y]);
}
++cnt_son;
}
}
if (cnt_son == 0) cnt[x] = 1, low[x] = dep[x];
}
void dfs_solve(int x, int fa) {
cnt[x] += cnt[fa];
for (int i = Last[x]; i; i = Next[i]) {
int y = End[i];
if (y != fa) dfs_solve(y, x);
}
}
int main() {
n = IO::read_int(), k = IO::read_int();
for (int i = 2; i <= n; ++i) {
int fa = IO::read_int();
add_edge(fa, i);
}
dfs(1, 0);
dfs_solve(1, 0);
int ans = 0;
for (int i = 1; i <= n; ++i) ans = max(ans, cnt[i]);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
vector<int> g[maxn];
int n, k, md[maxn], d[maxn], f[maxn], dp[maxn];
void dfs(int u, int dep) {
md[u] = n;
d[u] = dep;
if (g[u].empty()) md[u] = dep;
for (int i = 0; i < g[u].size(); ++i) {
int v = g[u][i];
dfs(v, dep + 1);
md[u] = min(md[u], md[v]);
}
}
int dfs2(int u) {
int as = 0;
if (g[u].empty()) {
f[u] = 1;
dp[u] = 1;
}
for (int i = 0; i < g[u].size(); ++i) {
int v = g[u][i];
dfs2(v);
f[u] += f[v];
dp[u] += f[v];
as = max(as, dp[v] - f[v]);
}
if (md[u] - d[u] > k - 1) f[u] = 0;
dp[u] += as;
return dp[u];
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 2; i <= n; ++i) {
int p;
scanf("%d", &p);
g[p].push_back(i);
}
dfs(1, 0);
printf("%d\n", dfs2(1));
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x, f[1000005], g[1000005], len[1000005], deep[1000005];
int num, q[1000005], ne[1000005], head[1000005];
void addnum(int x, int y) {
num++;
q[num] = y;
ne[num] = head[x];
head[x] = num;
}
void dfs(int t) {
if (head[t] == 0) {
f[t] = 1;
g[t] = 1;
len[t] = deep[t];
return;
}
len[t] = n;
for (int i = head[t]; i != 0; i = ne[i]) {
deep[q[i]] = deep[t] + 1;
dfs(q[i]);
len[t] = min(len[t], len[q[i]]);
if (len[q[i]] - deep[t] <= m) {
g[t] += g[q[i]];
f[t] = max(f[t], f[q[i]] - g[q[i]]);
} else
f[t] = max(f[t], f[q[i]]);
}
f[t] += g[t];
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 2; i <= n; i++) {
scanf("%d", &x);
addnum(x, i);
}
deep[1] = 1;
dfs(1);
printf("%d", f[1]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000006;
int n, k, p[N];
vector<int> g[N];
int st[N], pt;
int cnt[N];
int prec(int u) {
st[pt++] = u;
int ans = N;
for (int v : g[u]) ans = min(ans, prec(v));
if (g[u].empty()) cnt[u] = 1, ans = max(0, pt - k - 1);
if (ans < pt - 1) cnt[st[ans]] += cnt[u], cnt[u] = 0;
pt--;
return ans;
}
int f(int u) {
int ans = 0;
for (int v : g[u]) ans = max(ans, f(v));
return ans + cnt[u];
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 2; i <= n; i++) {
scanf("%d", p + i);
g[p[i]].push_back(i);
}
prec(1);
printf("%d\n", f(1));
}
|
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 21], *p1 = buf, *p2 = buf;
template <class T>
inline bool cmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
inline bool cmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
inline int read() {
char ch;
bool flag = 0;
int res;
while (!isdigit(
ch = (p1 == p2 &&
(p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++)))
(ch == '-') && (flag = true);
for (res = ch - '0'; isdigit(
ch = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin),
p1 == p2)
? EOF
: *p1++));
res = res * 10 + ch - '0')
;
(flag) && (res = -res);
return res;
}
const int N = 1e6 + 5, inf = 0x3f3f3f3f;
int head[N], Next[N], ver[N], tot;
inline void add(int u, int v) {
ver[++tot] = v, Next[tot] = head[u], head[u] = tot;
}
int dp[N], a[N], h[N], n, k;
void dfs(int u) {
h[u] = inf;
for (int i = head[u]; i; i = Next[i]) {
int v = ver[i];
dfs(v);
cmin(h[u], h[v] + 1), a[u] += a[v], cmax(dp[u], dp[v] - a[v]);
}
dp[u] += a[u];
if (h[u] == inf) dp[u] = a[u] = 1, h[u] = 0;
if (h[u] >= k) a[u] = 0;
}
int main() {
n = read(), k = read();
for (int i = 2, fa; i <= n; ++i) fa = read(), add(fa, i);
dfs(1);
printf("%d\n", dp[1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MXN = 1e6 + 30;
long long INF = 1ll << 60;
int N, K;
int dep[MXN], fa[MXN], f[MXN][2], dis[MXN];
std::vector<int> e[MXN];
void dfs(int u, int fu) {
dep[u] = dep[fu] + 1;
dis[u] = N;
for (int v : e[u]) {
dfs(v, u);
dis[u] = min(dis[u], dis[v] + 1);
if (dis[v] + 1 <= K) {
f[u][1] += f[v][0];
}
f[u][1] = max(f[u][1], f[v][1] + f[u][0]);
if (dis[v] + 1 <= K) {
f[u][0] += f[v][0];
}
}
dis[u] %= N;
if (!dis[u]) f[u][0] = f[u][1] = 1;
}
int main() {
scanf("%d %d", &N, &K);
for (int i = 2; i <= N; ++i) {
cin >> fa[i];
e[fa[i]].push_back(i);
}
dfs(1, 0);
cout << max(f[1][1], f[1][0]) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
const int nax = 1e6 + 2;
vector<int> v[nax];
int h[nax];
pair<int, int> dp[nax];
void go(int u, int par) {
if ((int)v[u].size() == 0 and u != 1) {
dp[u] = {1, h[u] - k};
return;
}
dp[u] = {0, nax + 5};
for (auto it : v[u]) {
h[it] = h[u] + 1;
go(it, u);
if (dp[it].second <= h[u]) {
dp[u].first += dp[it].first;
dp[u].second = min(dp[u].second, dp[it].second);
}
}
}
int ans = 0;
void dfs(int u, int par, int cur) {
ans = max(ans, cur + ((int)v[u].size() == 0 and u != 1));
for (auto it : v[u]) {
int sum = dp[u].first;
if (dp[it].second <= h[u]) sum -= dp[it].first;
dfs(it, u, cur + sum);
}
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = 2; n >= i; ++i) {
int a;
cin >> a;
v[a].push_back(i);
}
go(1, -1);
dfs(1, -1, 0);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0;
char ch = getchar();
bool d = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') d = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return d ? x : -x;
}
inline unsigned long long rnd() {
return ((unsigned long long)rand() << 30 ^ rand()) << 4 | rand() % 4;
}
const int N = 1e6 + 5;
int n, m, mn[N], f[N][2], dep[N];
vector<long long> v[N];
void dfs(int u, int fa) {
mn[u] = 0x3f3f3f3f;
int sum = 0, cnt = 0;
for (auto k : v[u]) {
cnt++;
dep[k] = dep[u] + 1;
dfs(k, u);
if (mn[k] - m <= dep[u]) sum += f[k][0];
mn[u] = min(mn[u], mn[k]);
}
if (!cnt) {
mn[u] = dep[u];
f[u][0] = f[u][1] = 1;
return;
}
f[u][0] = sum;
for (auto k : v[u]) {
int t = f[k][0];
if (mn[k] - m > dep[u]) t = 0;
f[u][1] = max(f[u][1], sum - t + f[k][1]);
}
}
int main() {
n = read();
m = read();
for (int i = (int)(2); i <= (int)(n); i++) v[read()].push_back(i);
dfs(1, 0);
cout << max(f[1][0], f[1][1]);
}
|
#include <bits/stdc++.h>
using namespace std;
inline int getint() {
char c = getchar();
int x = 0;
bool p = 0;
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') p = 1, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
if (p) x = -x;
return x;
}
int n, k, tot, la[1000010], dp[1000010][2], s[1000010], st[1000010];
struct edge {
int v, ne;
} e[1000010];
inline void add(int u, int v) {
e[tot].v = v, e[tot].ne = la[u], la[u] = tot++;
}
void init() {
tot = 0;
memset(la, -1, sizeof(la));
n = getint(), k = getint();
for (int i = 2; i <= n; ++i) add(getint(), i);
}
inline void dfs(int u, int d) {
st[d] = u;
for (int i = la[u]; ~i; i = e[i].ne) {
int v = e[i].v;
dfs(v, d + 1);
s[u] += s[v];
if (s[v]) dp[u][0] += dp[v][0];
}
for (int i = la[u]; ~i; i = e[i].ne) {
int v = e[i].v;
if (s[v])
dp[u][1] = max(dp[u][1], dp[u][0] - dp[v][0] + dp[v][1]);
else
dp[u][1] = max(dp[u][1], dp[u][0] + dp[v][1]);
}
if (la[u] == -1) {
dp[u][0] = dp[u][1] = 1;
++s[u], --s[st[max(1, d - k)]];
}
}
void solve() {
dfs(1, 1);
printf("%d\n", dp[1][1]);
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int v1[1000010], l, q[1000010], comp[1000010], d[1000010], k, nr;
vector<int> v[1000010], vt[1000010], ctc[1000010];
char vaz[1000010], leaf[1000010];
const int inf = 1e9;
void dfs(int nod, int nivel) {
v1[nivel] = nod;
int poz = max(1, nivel - k);
vaz[nod] = 1;
if (!v[nod].size()) {
leaf[nod] = 1;
v[nod].push_back(v1[poz]);
vt[v1[poz]].push_back(nod);
}
for (int i = 0; i < v[nod].size(); i++)
if (!vaz[v[nod][i]]) dfs(v[nod][i], nivel + 1);
}
void dfs1(int nod) {
vaz[nod] = 1;
for (int i = 0; i < v[nod].size(); i++)
if (!vaz[v[nod][i]]) dfs1(v[nod][i]);
q[++l] = nod;
}
void dfs2(int nod) {
vaz[nod] = 0;
ctc[nr].push_back(nod);
comp[nod] = nr;
for (int i = 0; i < vt[nod].size(); i++)
if (vaz[vt[nod][i]]) dfs2(vt[nod][i]);
}
int main() {
int x, n, sol = 0;
scanf("%d%d", &n, &k);
for (int i = 2; i <= n; i++) {
scanf("%d", &x);
v[x].push_back(i);
vt[i].push_back(x);
}
dfs(1, 1);
memset(vaz, 0, sizeof(vaz));
for (int i = 1; i <= n; i++)
if (!vaz[i]) dfs1(i);
for (int i = l; i >= 1; i--)
if (vaz[q[i]]) {
nr++;
dfs2(q[i]);
}
for (int i = nr; i >= 1; i--) {
int s = 0;
for (int j = 0; j < ctc[i].size(); j++) {
int nod = ctc[i][j];
s += leaf[nod];
for (int k = 0; k < v[nod].size(); k++) {
int vec = v[nod][k];
d[i] = max(d[i], d[comp[vec]]);
}
}
d[i] += s;
sol = max(sol, d[i]);
}
printf("%d", sol);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1000000007;
const long long BIG = 1446803456761533460LL;
const int Big = 336860180;
const long long int INF = LONG_LONG_MAX;
const vector<vector<long long int> > adj4({{0, 1}, {0, -1}, {1, 0}, {-1, 0}});
const vector<vector<long long int> > adj8(
{{0, 1}, {0, -1}, {1, 0}, {-1, 0}, {-1, -1}, {1, -1}, {-1, 1}, {1, 1}});
long long int gcd(long long int a, long long int b) {
return b == 0 ? a : gcd(b, a % b);
}
bool isprime(long long int n) {
if (n == 2 || n == 3) return true;
if (n < 2 || n % 2 == 0 || n % 3 == 0) return false;
for (long long int i = 6; (i - 1) * (i - 1) <= n; i += 6) {
if (n % (i - 1) == 0 || n % (i + 1) == 0) {
return false;
}
}
return true;
}
vector<bool> sprime;
void genPrime(long long int sz) {
sprime = vector<bool>(sz, true);
sprime[0] = false;
sprime[1] = false;
for (long long int i = (2); i < (sz); ++i) {
if (sprime[i]) {
for (long long int j = i * i; j < sz; j += i) {
sprime[j] = false;
}
}
}
}
long long int powMod(long long int a, long long int b, long long int mod) {
long long int n = 1;
long long int p = a;
while (b > 0) {
if (b % 2 == 1) {
n *= p;
n %= mod;
}
p *= p;
p %= mod;
b /= 2;
}
return n;
}
long long int modularInverse(long long int a, long long int mod) {
return powMod(a, mod - 2, mod);
}
long long int binarysearch(long long int l, long long int r,
bool (*bsfunction)(long long int)) {
while (r - l > 1) {
long long int mid = (l + r) / 2;
bool val = bsfunction(mid);
if (val) {
r = mid;
} else {
l = mid;
}
}
return l;
}
stringstream sss;
const long long int maxn = 1000010;
vector<long long int> out[maxn];
vector<long long int> in[maxn];
long long int vis[maxn];
vector<long long int> p;
long long int k;
vector<long long int> stk;
long long int scc[maxn];
set<long long int> gg[maxn];
long long int islf[maxn];
long long int lf[maxn];
long long int dp[maxn];
void dfs(long long int step) {
p.push_back(step);
for (auto x : out[step]) {
dfs(x);
}
p.pop_back();
if (out[step].empty()) {
islf[step] = 1;
long long int up = max(0LL, (long long int)p.size() - k);
out[step].push_back(p[up]);
in[p[up]].push_back(step);
}
}
void dfs2(long long int step) {
for (auto x : out[step]) {
if (vis[x] == 0) {
vis[x] = 1;
dfs2(x);
}
}
stk.push_back(step);
}
void dfs3(long long int step) {
for (auto x : in[step]) {
if (vis[x] == 1) {
vis[x] = 2;
scc[x] = scc[step];
dfs3(x);
}
}
}
void solve(long long int step) {
if (dp[step] != -1) return;
dp[step] = 0;
for (auto x : gg[step]) {
solve(x);
dp[step] = max(dp[step], (dp[x]));
}
dp[step] += lf[step];
}
void MAIN() {
long long int n;
cin >> n;
cin >> k;
for (long long int i = 0; i < (n - 1); ++i) {
long long int x;
cin >> x;
out[x - 1].push_back(i + 1);
in[i + 1].push_back(x - 1);
}
vis[0] = 1;
dfs(0);
dfs2(0);
long long int t = 0;
for (long long int i = (n)-1; i >= 0; --i) {
long long int x = stk[i];
if (vis[x] == 1) {
vis[x] = 2;
scc[x] = t++;
dfs3(x);
}
}
for (long long int i = 0; i < (n); ++i) {
for (auto x : out[i]) {
gg[scc[i]].insert(scc[x]);
}
gg[scc[i]].erase(scc[i]);
lf[scc[i]] += islf[i];
}
memset(dp, -1, sizeof dp);
solve(scc[0]);
cout << (dp[scc[0]]) << endl;
}
const long long int TESTCASEN = 1;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(10);
sss << R"(
8 2
1 1 2 3 4 5 5
7 1
1 1 3 3 4 4
)";
for (long long int i = 0; i < (TESTCASEN); ++i) {
MAIN();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
vector<int> G[maxn];
int a[maxn], h[maxn], d[maxn], n, k, inf = 1e9;
void dfs(int u) {
h[u] = inf;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
dfs(v);
a[u] += a[v];
h[u] = min(h[u], h[v] + 1);
d[u] = max(d[u], d[v] - a[v]);
}
d[u] += a[u];
if (h[u] == inf) d[u] = a[u] = 1, h[u] = 0;
if (h[u] >= k) a[u] = 0;
}
int main() {
int p;
scanf("%d%d", &n, &k);
for (int i = 2; i <= n; i++) {
scanf("%d", &p);
G[p].push_back(i);
}
dfs(1);
printf("%d\n", d[1]);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > adj(1000001), v(1000001);
int k, d[1000001], a[1000001], parent[1000001];
void ParentDFS(int i) {
d[i] = 1 + d[parent[i]];
v[d[i]].push_back(i);
for (auto j : adj[i]) {
ParentDFS(j);
}
}
int AnsDFS(int i) {
int ans = 0;
for (auto j : adj[i]) {
ans = max(ans, AnsDFS(j));
}
ans += a[i];
return ans;
}
int Find(int i, int x, int &s) {
s += a[i];
a[i] = 0;
return (d[i] == x) ? i : parent[i] = Find(parent[i], x, s);
}
int main() {
int n;
scanf("%d%d", &n, &k);
for (int i = 2; i <= n; ++i) {
scanf("%d", &parent[i]);
adj[parent[i]].push_back(i);
}
ParentDFS(1);
for (int i = 2; i <= n; ++i) {
a[i] = (adj[i].size() == 0);
}
for (int x = n - 1; x > 0; --x) {
for (auto i : v[x]) {
if (adj[i].size()) {
continue;
}
int s = 0, j = Find(i, max(1, d[i] - k), s);
a[j] = s;
}
}
printf("%d\n", AnsDFS(1));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T read(register T& t) {
register T f = 1;
register char ch = getchar();
t = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -f;
ch = getchar();
}
while (ch >= '0' && ch <= '9') t = t * 10 + ch - '0', ch = getchar();
t *= f;
return t;
}
template <typename T, typename... Args>
inline void read(T& t, Args&... args) {
read(t);
read(args...);
}
const long long p = 1e9 + 7;
inline long long power(register long long x, register long long k = p - 2) {
register long long re = 1;
for (; k; k >>= 1, x = x * x % p)
if (k & 1) re = re * x % p;
return re;
}
int n, k;
vector<int> to[1000005];
int ned[1000005];
int dep[1000005];
int dfs1(int now, int fa) {
dep[now] = dep[fa] + 1;
if (to[now].size() == 0) return ned[now] = dep[now];
ned[now] = 1e9;
for (int i : to[now]) ned[now] = min(ned[now], dfs1(i, now));
return ned[now];
}
int f[1000005];
void dfs2(int now) {
if (to[now].size() == 0) return f[now] = 1, void();
for (int i : to[now]) {
dfs2(i);
if (ned[i] - dep[now] <= k) {
f[now] += f[i];
f[i] = 0;
}
}
}
int ans;
void dfs3(int now, int s) {
ans = max(ans, s);
for (int i : to[now]) dfs3(i, s + f[i]);
}
int main() {
read(n, k);
for (int i = 1, x; i < n; i++) read(x), to[x].push_back(i + 1);
dfs1(1, 0);
dfs2(1);
dfs3(1, f[1]);
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000025, INF = (int)1e9;
const int LOG_N = 20;
int root = 0;
int n, m, a, b;
int val[N];
vector<int> G[N];
int dp[2][N];
int up[N], down[N];
void get(int v) {
dp[0][v] = val[v];
for (int nxt : G[v]) {
get(nxt);
dp[0][v] += dp[0][nxt];
dp[1][v] = max(dp[1][v], dp[1][nxt]);
}
if (up[v] == -1) {
dp[1][v] = dp[1][v] + dp[0][v];
dp[0][v] = 0;
}
}
int dfs_val(int v, int p) {
if (G[v].size() == 0) {
down[v] = 0;
val[v] = 1;
} else {
down[v] = INF;
for (int nxt : G[v]) {
if (nxt != p) {
down[v] = min(down[v], dfs_val(nxt, v) + 1);
}
}
}
up[v] = (down[v] < m ? 1 : -1);
return down[v];
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i < n; i++) {
int x;
scanf("%d", &x);
x--;
G[x].push_back(i);
}
dfs_val(0, -1);
get(0);
cout << dp[0][0] + dp[1][0] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int des;
int next;
} e[1000005 << 1];
int cnt;
int head[1000005];
void ins(int u, int v) {
++cnt;
e[cnt].des = v;
e[cnt].next = head[u];
head[u] = cnt;
}
int n;
int k;
int g[1000005];
int f[1000005];
int low[1000005];
int depth[1000005];
void dfs1(int u, int ff) {
depth[u] = depth[ff] + 1;
low[u] = 0x3f3f3f3f;
if (head[u] == 0) {
low[u] = depth[u];
g[u] = 1;
f[u] = 1;
return;
}
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].des;
dfs1(v, u);
if (low[v] - depth[u] <= k) {
low[u] = min(low[u], low[v]);
g[u] += g[v];
}
}
}
void dfs2(int u) {
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].des;
dfs2(v);
if (low[v] - depth[u] <= k)
f[u] = max(f[u], g[u] - g[v] + f[v]);
else
f[u] = max(f[u], g[u] + f[v]);
}
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 2; i <= n; ++i) {
int f;
scanf("%d", &f);
ins(f, i);
}
dfs1(1, 0);
dfs2(1);
printf("%d\n", f[1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 1e6 + 1;
int dp[MX], dpRet[MX], hi[MX], dep, k;
vector<int> chd[MX];
void dfs(int u) {
hi[u] = 1e9;
int mx = 0, sum = 0;
for (auto c : chd[u]) {
++dep;
dfs(c);
--dep;
hi[u] = min(hi[u], hi[c]);
sum += dpRet[c];
mx = max(mx, dp[c] - dpRet[c]);
}
if (hi[u] == 1e9) {
hi[u] = dep;
sum = 1;
}
if (hi[u] - dep < k) {
dpRet[u] = sum;
}
dp[u] = mx + sum;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n >> k;
for (int i = 2; i <= n; ++i) {
int p;
cin >> p;
chd[p].push_back(i);
}
dfs(1);
cout << dp[1] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int grand(int x) { return uniform_int_distribution<int>(0, x - 1)(rng); }
const int maxn = 1e6 + 7;
const long long inf = 1e15;
const long long md = 1e9 + 7;
long long gcd(long long x, long long y) {
if (x < y) return gcd(y, x);
if (y == 0) return x;
return gcd(y, x % y);
}
int K;
vector<int> G[maxn];
int pars[maxn];
int ka[maxn];
int g;
vector<int> lf;
struct digraph {
vector<int> G[maxn];
vector<int> H[maxn];
int A[maxn];
int N;
int totalColors;
vector<int> T[maxn];
void init(int n) {
N = n;
totalColors = 0;
for (int i = 1; i <= n; i++) {
G[i].clear();
H[i].clear();
T[i].clear();
A[i] = -1;
}
}
void addEdge(int x, int y) {
;
G[x].push_back(y);
H[y].push_back(x);
}
void dfs(int x, bool vis[], stack<int> *second) {
vis[x] = true;
for (int y : G[x]) {
if (vis[y]) continue;
dfs(y, vis, second);
}
second->push(x);
}
void dfscc(int x, bool vis[], vector<int> *comp) {
vis[x] = true;
comp->push_back(x);
for (int y : H[x]) {
if (vis[y]) continue;
dfscc(y, vis, comp);
}
}
vector<vector<int> > scc() {
stack<int> second;
bool vis[N + 1];
fill(vis, vis + N + 2, false);
for (int i = 1; i <= N; i++) {
if (!vis[i]) {
dfs(i, vis, &second);
}
}
vector<vector<int> > sccs;
fill(vis, vis + N + 2, false);
while (!second.empty()) {
int v = second.top();
second.pop();
if (vis[v]) continue;
;
vector<int> comp;
dfscc(v, vis, &comp);
sccs.push_back(comp);
}
return sccs;
}
void topoSortComponents() {
totalColors = 0;
for (vector<int> comp : scc()) {
totalColors++;
for (int v : comp) {
A[v] = totalColors;
}
}
for (int x = 1; x <= N; x++) {
for (int y : G[x]) {
T[A[x]].push_back(A[y]);
}
}
for (int x = 1; x <= totalColors; x++) {
sort(T[x].begin(), T[x].end());
T[x].resize(unique(T[x].begin(), T[x].end()) - T[x].begin());
}
}
bool dfsr(int x, bool vis[], int y) {
if (x == y) return true;
vis[x] = true;
for (int z : G[x]) {
if (vis[z]) continue;
if (dfsr(z, vis, y)) return true;
}
return false;
}
bool reachable(int x, int y) {
bool vis[N + 1];
fill(vis, vis + N + 2, false);
return dfsr(x, vis, y);
}
int getCol(int x) { return A[x]; }
} W;
void dfs(int x, int pi, int idx) {
pars[++idx] = x;
if (idx > K) {
ka[x] = pars[idx - K];
} else {
ka[x] = pars[1];
}
if (ka[x] != x && G[x].size() == 0) {
W.addEdge(x, ka[x]);
}
for (int y : G[x]) {
dfs(y, x, idx);
W.addEdge(x, y);
}
}
vector<vector<int> > comps;
int cnt[maxn];
int fuc[maxn];
int main() {
{
ios ::sync_with_stdio(false);
cin.tie(0);
};
int n;
cin >> n >> K;
for (int i = 2; i <= n; i++) {
int p;
cin >> p;
G[p].push_back(i);
}
W.init(n);
fill(cnt, cnt + maxn, 0);
pars[1] = -1;
dfs(1, -1, 0);
comps = W.scc();
W.topoSortComponents();
fill(fuc, fuc + maxn, 0);
for (int j = 1; j <= n; j++) {
if (G[j].size() == 0 && j != 1) fuc[W.getCol(j)]++;
}
int ans = 0;
for (int j = W.totalColors; j >= 1; j--) {
cnt[j] = fuc[j];
for (int q : W.T[j]) {
if (q == j) continue;
cnt[j] = max(cnt[j], fuc[j] + cnt[q]);
}
ans = max(ans, cnt[j]);
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000005;
vector<int> g[MAX];
int p[MAX], cont[MAX], par_k[MAX], d[MAX];
int n, k;
bool cmp(int a, int b) { return d[a] < d[b]; }
void go_down(int u, int dis = 0) {
d[u] = dis;
for (auto v : g[u]) {
go_down(v, dis + 1);
}
}
int go_up(int u, int k) {
if (par_k[u] != -1) return par_k[u];
if (k == 0) return par_k[u] = u;
return par_k[u] = go_up(p[u], k - 1);
}
int dfs(int u) {
int ans = 0;
for (auto v : g[u]) {
ans = max(ans, dfs(v));
}
return cont[u] + ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
memset(par_k, -1, sizeof(par_k));
for (int i = 1; i < n; i++) {
cin >> p[i];
p[i]--;
g[p[i]].push_back(i);
}
vector<int> level(n);
iota(level.begin(), level.end(), 0);
go_down(0);
sort(level.begin(), level.end(), cmp);
for (auto u : level) {
if (g[u].size()) continue;
cont[go_up(u, k)]++;
}
cout << dfs(0) << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int n, k, par[20][N];
vector<int> g[N], g2[N], H[N], ord;
bool mark[N], l[N];
int f[N], h[N], p[N], c, s[N], la[N], ans;
void ff();
void input();
void dp();
void dfs(int);
void dfss(int);
void dfsss(int);
void c_g();
int get_par(int, int);
void dfssss(int);
int main() {
input();
c_g();
ff();
fill(mark, mark + n, false);
s[p[0]] = la[p[0]];
dfssss(p[0]);
cout << ans << endl;
}
void input() {
cin >> n >> k;
for (int i = 1; i <= n - 1; i++) {
cin >> par[0][i];
par[0][i]--, g[par[0][i]].push_back(i);
g2[i].push_back(par[0][i]);
}
}
void dfs(int x) {
mark[x] = true;
if (g[x].size() == 0)
f[x] = k, l[x] = true;
else
for (int y : g[x]) {
if (!mark[y]) {
h[y] = h[x] + 1;
dfs(y);
f[x] = max(f[x], f[y] - 1);
}
}
f[x] = min(f[x], h[x]);
}
void c_g() {
dfs(0);
dp();
for (int i = 0; i < n; i++)
if (f[i] != 0) {
int d = get_par(i, f[i]);
g[i].push_back(d);
g2[d].push_back(i);
}
}
void dp() {
for (int i = 1; i < 20; i++)
for (int j = 0; j < n; j++) par[i][j] = par[i - 1][par[i - 1][j]];
}
int get_par(int x, int b) {
for (int i = 20 - 1; i >= 0; i--)
if (b >= (1 << i)) b -= (1 << i), x = par[i][x];
return x;
}
void ff() {
fill(mark, mark + n, false);
dfss(0);
fill(mark, mark + n, false);
for (int i = n - 1; i >= 0; i--)
if (!mark[ord[i]]) dfsss(ord[i]), c++;
for (int i = 1; i < n; i++) {
if (p[i] != p[par[0][i]]) H[p[par[0][i]]].push_back(p[i]);
if (l[i]) {
la[p[i]]++;
}
}
}
void dfss(int x) {
mark[x] = true;
for (int y : g[x]) {
if (!mark[y]) dfss(y);
}
ord.push_back(x);
}
void dfsss(int x) {
mark[x] = true;
p[x] = c;
for (int y : g2[x]) {
if (!mark[y]) dfsss(y);
}
}
void dfssss(int x) {
mark[x] = true;
for (int y : H[x]) {
if (!mark[y]) {
s[y] = la[y] + s[x];
dfssss(y);
}
}
if (H[x].size() == 0) ans = max(ans, s[x]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
int n, k;
int dp[1000005], dpe[1000005];
int md[1000005];
vector<int> G[1000005];
void dfs(int v, int cd) {
if (G[v].empty()) {
md[v] = cd;
dp[v] = 1;
return;
}
md[v] = INF;
for (int i = 0; i < (int)G[v].size(); i++) {
int u = G[v][i];
dfs(u, cd + 1);
md[v] = min(md[v], md[u]);
if (md[u] <= cd + k) {
dp[v] += dp[u];
dpe[v] = max(dpe[v], dpe[u] - dp[u]);
} else
dpe[v] = max(dpe[v], dpe[u]);
}
dpe[v] += dp[v];
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 2; i <= n; i++) {
int v;
scanf("%d", &v);
G[v].push_back(i);
}
dfs(1, 0);
cout << dpe[1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int k, n, dp[1000005], lcnt[1000005], h[1000005];
vector<int> ms[1000005];
void dfs(int x) {
if (ms[x].empty()) {
dp[x] = 1;
lcnt[x] = 1;
h[x] = 0;
return;
}
int br = 0;
h[x] = n;
for (vector<int>::iterator i = ms[x].begin(); i != ms[x].end(); ++i) {
int o = *i;
dfs(o);
h[x] = min(h[x], h[o] + 1);
br += lcnt[o];
}
for (vector<int>::iterator i = ms[x].begin(); i != ms[x].end(); ++i) {
int o = *i;
dp[x] = max(dp[x], dp[o] + br - lcnt[o]);
}
if (h[x] < k) {
lcnt[x] = br;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 2; i <= n; ++i) {
int x;
cin >> x;
ms[x].push_back(i);
}
dfs(1);
cout << dp[1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
vector<int> G[N];
int dp[N][2], up[N], n, k;
void dfs(int x) {
if (G[x].size() == 0) {
dp[x][0] = dp[x][1] = 1;
up[x] = k;
}
for (int u : G[x]) {
dfs(u);
dp[x][0] += dp[u][0];
up[x] = max(up[x], up[u] - 1);
}
int tmp = dp[x][0];
if (up[x] == 0) {
dp[x][1] = dp[x][0];
dp[x][0] = 0;
}
for (int u : G[x]) {
if (up[u]) tmp -= dp[u][0];
dp[x][1] = max(dp[x][1], tmp + dp[u][1]);
if (up[u]) tmp += dp[u][0];
}
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; ++i) up[i] = 0;
for (int i = 2; i <= n; ++i) {
int x;
scanf("%d", &x);
G[x].push_back(i);
}
dfs(1);
printf("%d\n", max(dp[1][0], dp[1][1]));
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, d[1000006], dd[1000006], l[1000006];
bool leaf[1000006], f[1000006];
vector<int> c[1000006];
void DFS(int u) {
f[u] = true;
for (int i = 0; i < c[u].size(); i++) {
int v = c[u][i];
if (f[v]) continue;
l[v] = l[u] + 1;
DFS(v);
}
}
void get(int u) {
if (leaf[u]) {
d[u] = 1;
return;
}
int m = l[u];
l[u] = 1e9;
f[u] = false;
for (int i = 0; i < c[u].size(); i++) {
int v = c[u][i];
if (f[v])
get(v);
else
continue;
if (l[v] - m <= k)
d[u] += d[v], dd[u] = max(dd[u], dd[v]);
else
dd[u] = max(dd[u], d[v] + dd[v]);
l[u] = min(l[u], l[v]);
}
f[u] = true;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) leaf[i] = true;
for (int v = 2; v <= n; v++) {
int u;
scanf("%d", &u);
c[u].push_back(v);
c[v].push_back(u);
leaf[u] = false;
}
l[1] = 1;
DFS(1);
get(1);
printf("%d", d[1] + dd[1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 1e6 + 10;
int n, k;
int dp[MX], f[MX], num[MX];
vector<int> G[MX];
void dfs(int u) {
if (!G[u].size()) {
f[u] = 0;
num[u] = 1;
return;
}
int MIN = 1e9, MAX = 0;
for (auto v : G[u]) {
dfs(v);
if (f[v] < k) num[u] += num[v];
MAX = max(MAX, dp[v] - (f[v] < k ? num[v] : 0));
MIN = min(MIN, f[v] + 1);
}
f[u] = MIN;
dp[u] = num[u] + MAX;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 2, p; i <= n; i++) {
cin >> p;
G[p].push_back(i);
}
dfs(1);
cout << dp[1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, siz[1000005], dep[1000005], low[1000005], f[1000005];
bool is_leaf[1000005];
vector<int> G[1000005];
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
(x *= 10) += ch - '0';
ch = getchar();
}
return x * f;
}
void dfs1(int u, int c_fa) {
dep[u] = dep[c_fa] + 1;
low[u] = 2e9;
if (is_leaf[u]) low[u] = dep[u];
for (int v : G[u]) dfs1(v, u), low[u] = min(low[u], low[v]);
}
void dfs2(int u) {
if (is_leaf[u]) siz[u] = 1;
for (int v : G[u]) {
dfs2(v);
if (low[v] - dep[u] <= k) siz[u] += siz[v], siz[v] = 0;
}
}
void dfs3(int u) {
f[u] = siz[u];
int mx = 0;
for (int v : G[u]) dfs3(v), mx = max(mx, f[v]);
f[u] += mx;
}
int main() {
n = read(), k = read();
memset(is_leaf, true, sizeof(is_leaf));
for (int i = 2, x; i <= n; i++)
x = read(), is_leaf[x] = false, G[x].push_back(i);
dfs1(1, 0);
dfs2(1);
dfs3(1);
printf("%d\n", f[1]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long double Pi = 3.14159265359;
const long long MOD = 1000 * 1000 * 1000 + 7;
const long long N = 1e6 + 10;
const long long INF = 1e18;
const long long LOG = 20;
long long n, COM[N], k, v, u;
vector<long long> gin[N], gout[N], fn;
bitset<N> mark;
vector<long long> path;
long long deg[N];
vector<long long> G[N];
long long dp[N];
void DFS(long long v, long long p = 0) {
mark[v] = 1;
path.push_back(v);
for (auto u : gout[v]) {
if (mark[u]) continue;
DFS(u, v);
}
if (deg[v] == 1 && p != 0) {
long long node;
if (path.size() - 1 - k < 0)
node = 1;
else {
node = path[path.size() - 1 - k];
}
gout[v].push_back(node);
gin[node].push_back(v);
}
path.pop_back();
fn.push_back(v);
}
void SDF(long long v, long long C) {
mark[v] = 1;
COM[v] = C;
for (auto u : gin[v]) {
if (!mark[u]) {
SDF(u, C);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 2; i <= n; i++) {
cin >> v;
gout[v].push_back(i), gin[i].push_back(v);
deg[i]++, deg[v]++;
}
DFS(1);
for (int i = 0; i < N; i++) mark[i] = 0;
long long com = 1;
reverse(fn.begin(), fn.end());
for (auto u : fn) {
if (!mark[u]) {
SDF(u, com++);
}
}
for (int i = 1; i <= n; i++) {
for (auto u : gout[i]) {
if (COM[u] == COM[i]) continue;
G[COM[i]].push_back(COM[u]);
}
if (i != 1 && deg[i] == 1) {
dp[COM[i]]++;
}
}
for (int i = com - 1; i >= 1; i--) {
long long ans = 0;
for (auto u : G[i]) {
ans = max(ans, dp[u]);
}
dp[i] += ans;
}
cout << dp[COM[1]];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5, inf = 1e9;
int n, m, x, cnt, head[N], sz[N], low[N], dep[N], ans;
struct edge {
int to, nxt;
} e[N << 1];
void adde(int x, int y) {
e[++cnt].to = y;
e[cnt].nxt = head[x];
head[x] = cnt;
}
void dfs(int u, int par) {
low[u] = 0;
bool leaf = 1;
for (int i = head[u], v; i; i = e[i].nxt)
if (v = e[i].to, v != par) {
leaf = 0;
dep[v] = dep[u] + 1;
dfs(v, u);
if (dep[low[v]] - dep[u] <= m) sz[u] += sz[v], sz[v] = 0;
if (dep[low[v]] < dep[low[u]]) low[u] = low[v];
}
if (leaf) low[u] = u, sz[u] = 1;
}
void dfs1(int u, int par, int val) {
ans = max(ans, val);
for (int i = head[u], v; i; i = e[i].nxt)
if (v = e[i].to, v != par) dfs1(v, u, val + sz[v]);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (2); i <= (n); i++) scanf("%d", &x), adde(i, x), adde(x, i);
dep[0] = inf;
dfs(1, 0);
dfs1(1, 0, sz[1]);
printf("%d\n", ans);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.