solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
struct event {
int type;
int where;
bool operator<(const event that) const { return where < that.where; }
};
int n, k;
vector<event> lis;
long long F[200001];
long long invF[200001];
long long mod = 1000000007LL;
long long power(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) ret = (ret * a) % mod;
a = (a * a) % mod;
b /= 2;
}
return ret;
}
long long inv(long long x) { return power(x, mod - 2); }
long long C(int n, int m) {
if (m < 0 || m > n) return 0;
long long ret = F[n];
ret *= invF[m];
ret %= mod;
ret *= invF[n - m];
ret %= mod;
return ret;
}
int MAIN() {
F[0] = invF[0] = 1;
for (int i = 1; i <= 200000; i++) {
F[i] = (F[i - 1] * i) % mod;
invF[i] = inv(F[i]);
}
cin >> n >> k;
for (int i = 1; i <= n; i++) {
int L, R;
cin >> L >> R;
event t;
t.type = 1;
t.where = L;
lis.push_back(t);
t.type = -1;
t.where = R + 1;
lis.push_back(t);
}
int lastPos = -1000000001;
int current = 0;
long long ans = 0;
sort(lis.begin(), lis.end());
for (int i = 0; i < lis.size(); i++) {
long long amount = lis[i].where - lastPos;
ans += amount * C(current, k);
ans %= mod;
lastPos = lis[i].where;
current += lis[i].type;
}
cout << ans << endl;
return 0;
}
int main() {
int start = clock();
ios ::sync_with_stdio(false);
cout << fixed << setprecision(16);
int ret = MAIN();
return ret;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (auto &x : v) is >> x;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, vector<T> &v) {
for (long long i = 0; i < v.size(); i++) {
cout << v[i];
if (i != v.size() - 1) cout << endl;
};
return os;
}
template <typename T>
void Out(T x) {
cout << x << endl;
}
template <typename T1, typename T2>
void Ans(bool first, T1 y, T2 n) {
if (first)
Out(y);
else
Out(n);
}
using vec = vector<long long>;
using mat = vector<vec>;
using Pii = pair<long long, long long>;
using PiP = pair<long long, Pii>;
using PPi = pair<Pii, long long>;
using bools = vector<bool>;
using pairs = vector<Pii>;
const long long mod = 1000000007;
signed main() {
long long n;
cin >> n;
vec a(n), b(n);
vector<PPi> pa(n);
for (long long i = (0); i < (n); i++) {
cin >> a[i] >> b[i];
pa[i] = PPi(Pii(a[i], -b[i]), i);
}
sort(pa.begin(), pa.end());
long long m;
cin >> m;
vec c(m), d(m), k(m);
vector<PPi> pc(m);
for (long long i = (0); i < (m); i++) {
cin >> c[i] >> d[i] >> k[i];
pc[i] = PPi(Pii(c[i], d[i]), i);
}
sort(pc.begin(), pc.end());
map<long long, set<long long>> U;
vec ans(n);
long long l = 0;
for (long long i = (0); i < (n); i++) {
long long i0 = pa[i].second;
while (l < m && pc[l].first.first <= a[i0]) {
U[pc[l].first.second].insert(pc[l].second);
l++;
}
auto it = U.lower_bound(b[i0]);
if (it == U.end()) {
Out("NO");
return 0;
}
long long x = *((it->second).begin());
ans[i0] = x;
k[x]--;
if (k[x] == 0) {
(it->second).erase(x);
if (((long long)it->second.size()) == 0) U.erase(it);
}
}
Out("YES");
for (long long i = (0); i < (n); i++) cout << ans[i] + 1 << ' ';
cout << endl;
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
char str[105];
int main() {
int n, d;
scanf("%d%d", &n, &d);
int tmp = 0, ans = 0;
for (int it = 0; it < d; it++) {
scanf("%s", str);
bool ok = 0;
for (int i = 0; i < n; i++) {
if (str[i] == '0') ok = 1;
}
if (ok)
tmp++;
else
tmp = 0;
ans = max(ans, tmp);
}
cout << ans << endl;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 2e18;
int n, m, l, t;
long long ma[10], ta[30], tca[30];
pair<long long, long long> tt[30];
long long dist[30][1 << 8][1 << 8];
vector<int> cs;
void getDist() {
for (int i = 0; i < 1 << m; i++) {
int c = 0;
for (int j = 0; j < m; j++)
if (i >> j & 1) c++;
if (c == n) cs.push_back(i);
}
for (int d = 0; d < 30; d++)
for (int i = 0; i < 1 << m; i++)
for (int j = 0; j < 1 << m; j++) dist[d][i][j] = inf;
for (auto i : cs) {
int nx, mp = 0;
for (;; mp++) {
if (i >> mp & 1) break;
}
nx = (i ^ (1 << mp)) >> 1;
for (int j = 0; j < m - mp; j++)
if (!(nx & 1 << (j + mp))) {
int tmp = nx | 1 << (j + mp);
dist[0][i][tmp] = min(dist[0][i][tmp], ma[j]);
}
if (mp != 0) dist[0][i][i >> 1] = min(dist[0][i][1 >> i], 0ll);
}
for (int d = 1; d < 30; d++)
for (auto i : cs)
for (auto j : cs)
for (auto k : cs) {
dist[d][i][k] =
min(dist[d][i][k], dist[d - 1][i][j] + dist[d - 1][j][k]);
}
}
long long cur[1 << 8];
set<int> tr, co;
map<int, long long> vtr;
void moX(long long d, int b) {
long long tmp[1 << 8];
for (int di = 0; d >> di; di++) {
if (d >> di & 1) {
for (int i = 0; i < 1 << m; i++) tmp[i] = inf;
for (auto i : cs)
for (auto j : cs) {
long long cost = cur[i] + dist[di][i][j];
if (d == 1 && di == 0) {
for (int k = 0; k < m; k++) {
if ((j >> k & 1) && !(i >> (k + 1) & 1) &&
co.find(b + k) != co.end()) {
cost += vtr[b + k];
}
}
}
tmp[j] = min(tmp[j], cost);
}
for (int i = 0; i < 1 << m; i++) cur[i] = tmp[i];
}
}
}
void solve() {
for (int i = 0; i < 1 << m; i++) cur[i] = inf;
cur[(1 << n) - 1] = 0;
for (int i = 0; i < t; i++) {
co.insert(ta[i]);
vtr[ta[i]] = tca[i];
for (int j = max(1ll, ta[i] - m); j <= ta[i]; j++) tr.insert(j);
}
tr.insert(l - n + 1);
int cp = 1;
for (auto &np : tr) {
if (cp == np) continue;
if (np > l - n + 1) break;
moX(np - cp, np);
cp = np;
}
}
int main() {
scanf("%d%d%d%d", &n, &m, &l, &t);
for (int i = 0; i < m; i++) scanf("%lld", ma + i);
for (int i = 0; i < t; i++) scanf("%lld%lld", ta + i, tca + i);
for (int i = 0; i < t; i++) tt[i] = pair<long long, long long>(ta[i], tca[i]);
sort(tt, tt + t);
for (int i = 0; i < t; i++) ta[i] = tt[i].first, tca[i] = tt[i].second;
getDist();
solve();
printf("%lld\n", cur[(1 << n) - 1]);
return 0;
}
| 21
|
#include <bits/stdc++.h>
using namespace std;
long long int powe(long long int x, long long int y, long long int m) {
if (y == 0) return 1;
long long int p = powe(x, y / 2, m) % m;
p = (p * p) % m;
return (y % 2 == 0) ? p : (x * p) % m;
}
int gcd(int a, int b) {
if (a == 0) return b;
return (b % a, a);
}
int main() {
int d1, d2, i, n, j, a, x[3], y[3];
for (int(i) = (0); (i) <= (2); ++i) cin >> x[i] >> y[i];
set<int> s;
for (int(i) = (0); (i) <= (2); ++i) {
d1 = x[(i + 1) % 3] - x[(i + 2) % 3];
d2 = y[(i + 1) % 3] - y[(i + 2) % 3];
a = x[i] - d1 + 4000;
a *= 10000;
a += y[i] - d2 + 4000;
s.insert(a);
a = d1 + x[i] + 4000;
a *= 10000;
a += d2 + y[i] + 4000;
s.insert(a);
}
cout << s.size() << endl;
for (set<int>::iterator it = s.begin(); it != s.end(); it++) {
d1 = *it / 10000 - 4000;
d2 = (*it % 10000) - 4000;
cout << d1 << " " << d2 << endl;
}
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
const int N = 11000, M = 4e7 + 100;
int n, m, st[100][100], a[N];
char s[N], t[N], as[N], at[N];
int day[13] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
queue<int> q;
inline int read() {
int f = 1, x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
return x * f;
}
inline int calday(char s[]) {
int m = (s[6] - '0') * 10 + s[7] - '0', d = (s[9] - '0') * 10 + s[10] - '0';
for (int i = 1; i < m; i++) d += day[i];
return d * 24 * 60 * 60;
}
inline int calin(char s[]) {
int h, m, se;
h = (s[1] - '0') * 10 + s[2] - '0';
m = (s[4] - '0') * 10 + s[5] - '0';
se = (s[7] - '0') * 10 + s[8] - '0';
return h * 60 * 60 + m * 60 + se;
}
inline void endline() {
char x = getchar();
while (x != '\n') x = getchar();
}
signed main() {
n = read();
m = read();
int i = 0;
bool bl = 1;
while (scanf("%s", s + 1) != EOF) {
i++;
a[i] = calday(s);
scanf("%s", t + 1);
a[i] += calin(t);
endline();
while (!q.empty() && a[i] - q.front() >= n) q.pop();
q.push(a[i]);
if ((int)q.size() >= m) {
printf("%s ", s + 1);
for (int i = 1; i <= 8; i++) printf("%c", t[i]);
printf("\n");
return 0;
}
}
printf("-1\n");
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using dl = double;
const int N = 2e5 + 10;
ll aarray[200000 + 10];
ll magic[101][101];
vector<ll> primes;
bool prime[1000001];
int main() {
ios_base::sync_with_stdio(false);
string str;
ll i, j, n, m, k;
cin >> n;
ll sum = 0;
multiset<ll> sl;
map<ll, ll> mp;
vector<ll> v;
for (i = 1; i <= n; i++) {
cin >> aarray[i];
}
ll s1 = 0, s2 = 0, ans = 0;
ll r, l;
for (l = 1, r = n; l <= r;) {
if (s1 <= s2) {
s1 += aarray[l];
l++;
} else if (s1 > s2) {
s2 += aarray[r];
r--;
}
if (s1 == s2) {
ans = max(ans, s1);
}
}
cout << ans << endl;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
int N;
string s;
int main() {
scanf("%d\n", &N);
cin >> s;
if (N == 1) {
cout << 1 << endl;
return 0;
}
if (N == 2) {
cout << 2 << endl;
return 0;
}
int ans = 1;
for (int i = 1; i < N; i++)
if (s[i] != s[i - 1]) ans++;
if (ans == N) {
cout << N << endl;
return 0;
}
if (ans + 2 <= N) {
cout << ans + 2 << endl;
} else {
cout << N << endl;
}
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e4 + 7;
int res[maxn], t[2];
struct node {
int x, y, c, id;
double sn;
node(int x = 0, int y = 0, int c = 0, int id = 0) {
this->x = x, this->y = y, this->c = c, this->id = id;
}
inline friend bool operator<(const node &a, const node &b) {
return a.sn < b.sn;
}
inline friend node operator-(const node &a, const node &b) {
return node(a.x - b.x, a.y - b.y, a.c, a.id);
}
inline friend node operator+(const node &a, const node &b) {
return node(a.x + b.x, a.y + b.y, a.c, a.id);
}
};
inline void clear(vector<node> &now) {
vector<node> asas;
swap(now, asas);
}
void solve(vector<node> &now) {
if (!now.size()) return;
for (node &x : now)
if (x.x < now[0].x || (x.x == now[0].x && x.y < now[0].y)) swap(now[0], x);
node tmp = now[0];
for (node &x : now) x = x - tmp, x.sn = atan2(x.y, x.x);
sort(now.begin() + 1, now.end());
t[0] = t[1] = 0;
vector<node> L, R;
for (int i = 1; i < now.size(); ++i) {
node p = now[i];
++t[p.c];
if (t[now[0].c ^ 1] - t[now[0].c] == 1) {
if (!p.c)
res[p.id] = now[0].id;
else
res[now[0].id] = p.id;
for (int j = i + 1; j < now.size(); ++j) R.push_back(now[j] + tmp);
break;
}
L.push_back(p + tmp);
}
clear(now);
solve(L);
solve(R);
}
int main() {
int n, x, y, c;
cin >> n;
vector<node> cs;
for (int i = 1; i <= n; ++i) cin >> x >> y, cs.push_back(node(x, y, 0, i));
for (int i = 1; i <= n; ++i) cin >> x >> y, cs.push_back(node(x, y, 1, i));
solve(cs);
for (int i = 1; i <= n; ++i) cout << res[i] << endl;
return 0;
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
int n, color;
int cnt[105];
int dp[105][10005];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
color += !cnt[x];
cnt[x]++;
}
if (color <= 2) return cout << n, 0;
dp[0][0] = 1;
for (int i = 1; i <= 100; i++) {
for (int j = n; j >= 0; j--)
for (int k = 0; k <= 10000; k++) {
for (int d = 1; d <= cnt[i]; d++) {
int &res = dp[j + d][k + d * i];
if (j + d > n || k + d * i > 10000) break;
res += dp[j][k];
if (res >= 2) res = 2;
}
}
}
int ans = 0;
for (int i = 1; i <= 100; i++) {
for (int j = 1; j <= cnt[i]; j++) {
if (dp[j][i * j] >= 2) break;
ans = max(ans, j);
}
}
cout << ans;
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n + 1];
fill(a, a + n + 1, 0);
priority_queue<pair<int, int>> q;
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
temp;
q.push(make_pair(n, (n % 2 == 0) ? n / 2 - 1 : n / 2));
int r = 1;
while (q.top().first != 1 || (r > 1 && !temp.empty())) {
int idx, y;
if (!temp.empty()) {
y = temp.top().first;
idx = temp.top().second;
temp.pop();
} else {
idx = q.top().second;
y = q.top().first;
q.pop();
while (q.top().first == y && idx > q.top().second) {
int x = q.top().second;
q.pop();
temp.push(make_pair(y, idx));
idx = x;
}
}
a[idx] = r;
if (y % 2 == 1) {
if ((y / 2) % 2 == 1) {
q.push(make_pair(y / 2, idx - y / 4 - 1));
q.push(make_pair(y / 2, idx + y / 4 + 1));
} else {
q.push(make_pair(y / 2, idx - y / 4 - 1));
q.push(make_pair(y / 2, idx + y / 4));
}
} else {
if ((y / 2) % 2 == 1) {
if (y == 2) {
if (idx - 1 < 0 || a[idx - 1] != 0)
q.push(make_pair(1, idx + 1));
else {
q.push(make_pair(1, idx - 1));
}
} else {
q.push(make_pair(y / 2 - 1, idx - (y / 2 - 1) / 2 - 1));
q.push(make_pair(y / 2, idx + y / 4 + 1));
}
} else {
q.push(make_pair(y / 2 - 1, idx - (y / 2 - 1) / 2 - 1));
q.push(make_pair(y / 2, idx + y / 4));
}
}
r++;
}
for (int i = 0; i < n; i++) {
if (a[i] > 0)
cout << a[i] << ' ';
else {
cout << r << ' ';
r++;
}
}
cout << endl;
}
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
long long k, l, r;
cin >> k >> l >> r;
long long u = ((long long)1e18 / k + 1) * k;
l += u;
r += u;
cout << r / k - (l - 1) / k;
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long clock[3];
for (int i = 0; i < 3; i++) cin >> clock[i];
clock[0] *= 50000;
clock[1] *= 100;
long long t1, t2;
cin >> t1 >> t2;
if (t1 > t2) {
long long zhan = t1;
t1 = t2;
t2 = zhan;
}
t1 *= 50000;
t2 *= 50000;
int flag1, flag2;
flag1 = flag2 = 0;
clock[1] += clock[2];
clock[0] += clock[1];
int u = 1;
for (int i = 0; i < 3; i++) {
clock[i] *= u;
u *= 100;
if (clock[i] > t2 || clock[i] < t1) flag1 = 1;
if (clock[i] > t1 && clock[i] < t2) flag2 = 1;
}
if (flag1 == 1 && flag2 == 1)
cout << "NO" << endl;
else
cout << "YES" << endl;
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 99999;
const int INF = (1 << 30);
const double PI = acos(-1.0);
const double EPS = 1e-11;
int n, m, atk[105], def[105], c[105];
int size_atk, size_def;
int input() {
int i;
string s;
cin >> n >> m;
size_atk = size_def = 0;
for (i = 0; i < n; i++) {
cin >> s;
if (s == "ATK")
cin >> atk[size_atk++];
else
cin >> def[size_def++];
}
for (i = 0; i < m; i++) cin >> c[i];
sort(atk, atk + size_atk);
sort(def, def + size_def);
sort(c, c + m);
return 0;
}
int lager(int arr[], int size_arr, int x) {
int i;
for (i = 0; i < size_arr; i++)
if (arr[i] > x) return i;
return -1;
}
int lagerOrEqual(int arr[], int size_arr, int x) {
int i;
for (i = 0; i < size_arr; i++)
if (arr[i] >= x) return i;
return -1;
}
int killAll() {
int i;
int sum = 0;
for (i = 0; i < size_def; i++) {
int p = lager(c, m, def[i]);
if (p == -1) return 0;
c[p] = -1;
}
for (i = 0; i < size_atk; i++) {
int p = lagerOrEqual(c, m, atk[i]);
if (p == -1) return 0;
sum += (c[p] - atk[i]);
c[p] = -1;
}
for (i = 0; i < m; i++)
if (c[i] != -1) sum += c[i];
return sum;
}
int process() {
int i, k;
int res;
res = 0;
for (k = 1; k <= min(m, size_atk); k++) {
int sum = 0;
for (i = 0; i < k; i++) sum += max(0, c[m - k + i] - atk[i]);
res = max(res, sum);
}
res = max(res, killAll());
cout << res << endl;
return 0;
}
int main() {
input();
process();
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int son[500][26][26];
int memo[500][26][26];
int cambios[500][26][26];
char A[500][500];
int m, n;
void solve(int x, int y, int z) {
for (int row = 0; row < x; row++)
for (int a = 0; a < y; a++)
for (int b = 0; b < z; b++) {
int &aux = son[row][a][b];
int &res = memo[row][a][b];
if (row == 0) {
res = cambios[0][a][b];
continue;
}
int mn = 1 << 29;
for (int i = 0; i < 26; i++)
if (i != a)
for (int j = 0; j < 26; j++)
if (j != b && j != i) {
int tmp = memo[row - 1][i][j] + cambios[row][a][b];
if (mn > tmp) mn = tmp, aux = 1000 * i + j;
}
res = mn;
}
}
int main() {
cin >> m >> n;
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++) scanf(" %c", &A[m - 1 - i][j]);
for (int row = 0; row < m; row++) {
for (int a = 0 + 'a'; a < 26 + 'a'; a++)
for (int b = 0 + 'a'; b < 26 + 'a'; b++)
if (b != a) {
int s = 0;
int x[2];
x[0] = a, x[1] = b;
for (int k = 0; k < n; k++) {
if (A[row][k] != x[k & 1]) s++;
}
cambios[row][a - 'a'][b - 'a'] = s;
}
}
solve(m, 26, 26);
int mn = 1 << 29;
int a, b;
for (int i = 0; i < 26; i++)
for (int j = 0; j < 26; j++)
if (j != i) {
if (mn > memo[m - 1][i][j]) mn = memo[m - 1][i][j], a = i, b = j;
}
printf("%d\n", mn);
for (int row = m - 1; row >= 0; row--) {
for (int i = 0; i < n; i++) {
if ((i & 1) == 0)
printf("%c", char(a + 'a'));
else
printf("%c", char(b + 'a'));
}
printf("\n");
int tmp = son[row][a][b];
a = tmp / 1000;
b = tmp % 1000;
}
}
| 12
|
#include <bits/stdc++.h>
char s[20], t[20];
int main() {
int n;
scanf("%s", s);
n = strlen(s);
for (int i = 0; i <= n; i++) {
int j;
for (j = 0; j < i; j++) {
t[j] = s[j];
}
for (j = i; j < n; j++) {
t[j + 1] = s[j];
}
t[i] = t[n - i];
for (j = 0; j <= n; j++) {
if (t[j] != t[n - j]) {
break;
}
}
if (j > n) {
printf("%s\n", t);
return 0;
}
}
printf("NA\n");
return 0;
}
| 22
|
#include <bits/stdc++.h>
using namespace std;
const int N = 505;
int source, sink, n, residual[N][N], f, parent[N];
void augment(int u, int flow) {
if (u == source) {
f = flow;
} else if (parent[u] != -1) {
augment(parent[u], min(flow, residual[parent[u]][u]));
residual[parent[u]][u] -= f;
residual[u][parent[u]] += f;
}
}
bool vis[N];
vector<int> adj[N];
int solve() {
int ans = 0;
do {
for (int i = 0; i < n; ++i) {
parent[i] = -1;
vis[i] = false;
}
queue<int> q;
q.push(source);
vis[source] = true;
while (!q.empty()) {
int u = q.front();
q.pop();
if (u == sink) {
break;
}
for (int j = 0; j < (int)adj[u].size(); ++j) {
int v = adj[u][j];
if (!vis[v] && residual[u][v] > 0) {
parent[v] = u;
vis[v] = true;
q.push(v);
}
}
}
f = 0;
augment(sink, 1 << 30);
ans += f;
} while (f);
return ans;
}
bool isprime(int x) {
for (int i = 2; i * i <= x; ++i) {
if (x % i == 0) {
return false;
}
}
return true;
}
vector<int> answer[N];
void dfs(int u, int i, int lado) {
vis[u] = true;
answer[i].push_back(u);
for (int j = 0; j < (int)adj[u].size(); ++j) {
int v = adj[u][j];
if (!vis[v] && residual[u][v] == lado) {
dfs(v, i, !lado);
break;
}
}
}
void add_edge(int a, int b, int valor) {
adj[a].push_back(b);
adj[b].push_back(a);
residual[a][b] += valor;
}
int a[N], x[N], y[N];
int main() {
int m;
cin >> m;
int le = 0, ri = 0;
for (int i = 0; i < m; ++i) {
cin >> a[i];
if (a[i] % 2 == 0) {
x[le++] = i;
} else {
y[ri++] = i;
}
}
if (le != ri) {
cout << "Impossible" << endl;
return 0;
}
n = m + 2;
source = m, sink = m + 1;
for (int i = 0; i < le; i++) {
add_edge(source, x[i], 2);
add_edge(y[i], sink, 2);
for (int j = 0; j < ri; ++j) {
if (isprime(a[x[i]] + a[y[j]])) {
add_edge(x[i], y[j], 1);
}
}
}
if (solve() != 2 * le) {
cout << "Impossible" << endl;
} else {
for (int i = 0; i < n; ++i) {
vis[i] = false;
}
vis[source] = vis[sink] = true;
int sz = 0;
for (int i = 0; i < le; ++i) {
if (!vis[x[i]]) {
dfs(x[i], sz++, 0);
}
}
cout << sz << endl;
for (int i = 0; i < sz; ++i) {
cout << answer[i].size();
for (int j = 0; j < (int)answer[i].size(); ++j) {
cout << " " << answer[i][j] + 1;
}
cout << endl;
}
}
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
int cal(double v, int k) {
int cnt = 0;
while (v > 0) {
cnt += (int)v;
v /= k;
}
return cnt;
}
int bs(int l, int r, int n, int k) {
int middle = (l + r) / 2;
if (cal(middle, k) >= n) {
if (cal(middle - 1, k) < n)
return middle;
else
return bs(l, middle, n, k);
} else {
if (cal(middle + 1, k) >= n)
return middle + 1;
else
return bs(middle, r, n, k);
}
}
int main() {
int n, k;
cin >> n >> k;
cout << bs(1, n, n, k);
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000007;
const int MAXX = 100000;
int max(int a, int b) {
if (a > b) return a;
return b;
}
int min(int a, int b) {
if (a < b) return a;
return b;
}
struct point {
int x, y;
long long d2;
double tan2;
bool operator==(const point& p) const { return (x == p.x && y == p.y); }
bool operator<(const point& p) const {
if (x == p.x) return y < p.y;
return x < p.x;
}
long long dist2(const point& p) {
long long d = (p.x - x) * 1LL * (p.x - x) + (p.y - y) * 1LL * (p.y - y);
return d;
}
} a0;
vector<point> pts;
bool cmp(const point& a, const point& b) {
long long x = (a.y - a0.y) * 1LL * (b.x - a0.x);
long long y = (b.y - a0.y) * 1LL * (a.x - a0.x);
if (x == y) {
return a.d2 < b.d2;
} else {
return a.tan2 < b.tan2;
}
}
long long area(point& a, point& b, point& c) {
long long ar = a.x * 1LL * b.y - a.y * 1LL * b.x;
ar += b.x * 1LL * c.y - c.x * 1LL * b.y;
ar += c.x * 1LL * a.y - a.x * 1LL * c.y;
return ar;
}
double getR(point& a, point& b, point& c) {
double d1 = sqrt(a.dist2(b));
double d2 = sqrt(b.dist2(c));
double d3 = sqrt(c.dist2(a));
double d = (d1 * d2 * d3);
double ar = 2.0 * abs(area(a, b, c));
return d / ar;
}
int main() {
int n;
scanf("%d", &n);
pts.reserve(n * 8);
for (int i = 0; i < (n); ++i) {
int x, y, v;
scanf("%d %d %d", &x, &y, &v);
if (x - v < 0) {
pts.push_back({0, min(y + v - x, MAXX), 0, 0});
pts.push_back({0, max(y - v + x, 0), 0, 0});
} else
pts.push_back({x - v, y, 0, 0});
if (x + v > MAXX) {
pts.push_back({MAXX, min(y + x + v - MAXX, MAXX), 0, 0});
pts.push_back({MAXX, max(y - v + MAXX - x, 0), 0, 0});
} else
pts.push_back({x + v, y, 0, 0});
if (y - v < 0) {
pts.push_back({max(0, x - v + y), 0, 0, 0});
pts.push_back({min(MAXX, x + v - y), 0, 0, 0});
} else
pts.push_back({x, y - v, 0, 0});
if (y + v > MAXX) {
pts.push_back({max(0, x - v - y + MAXX), MAXX, 0, 0});
pts.push_back({min(MAXX, x + y + v - MAXX), MAXX, 0, 0});
} else
pts.push_back({x, y + v, 0, 0});
}
sort(pts.begin(), pts.end());
pts.resize(unique(pts.begin(), pts.end()) - pts.begin());
a0 = pts.front();
for (int i = 1; i < pts.size(); ++i) {
pts[i].d2 = a0.dist2(pts[i]);
pts[i].tan2 = atan2(pts[i].y - a0.y, pts[i].x - a0.x);
}
sort(pts.begin() + 1, pts.end(), cmp);
int pn = pts.size();
pts.push_back(a0);
vector<point> hull;
hull.push_back(pts[0]);
hull.push_back(pts[1]);
for (int i = 2; i <= pn; ++i) {
while (hull.size() > 1) {
int h = hull.size();
if (area(hull[h - 2], hull[h - 1], pts[i]) <= 0)
hull.pop_back();
else
break;
}
hull.push_back(pts[i]);
}
hull.pop_back();
double maxr = 0;
int idx = -1;
for (int i = 0; i < hull.size(); ++i) {
int j = (i + 1) % hull.size();
int k = (i + 2) % hull.size();
double r = getR(hull[i], hull[j], hull[k]);
if (r > maxr) {
idx = i;
maxr = r;
}
}
for (int i = 0; i < 3; ++i) {
printf("%d %d\n", hull[(i + idx) % hull.size()].x,
hull[(i + idx) % hull.size()].y);
}
return 0;
}
| 20
|
#include <bits/stdc++.h>
#define all(i) (i).begin(), (i).end()
#define debug(x) cerr << "Line(" << __LINE__ << ") -> " << #x << " is " << x << endl
using namespace std;
template<typename T1, typename T2>
ostream& operator << (ostream &i, pair<T1, T2> j) {
return i << j.first << ' ' << j.second;
}
template<typename T>
ostream& operator << (ostream &i, vector<T> j) {
i << '{' << j.size() << ':';
for (T ii : j) i << ' ' << ii;
return i << '}';
}
typedef long long ll;
typedef pair<int, int> pi;
vector<vector<pi>> g;
vector<int> cc, dep, low, stk;
vector<ll> d, v;
vector<bool> vis;
int _t;
void dfs(int i) {
vis[i] = true;
low[i] = dep[i] = _t++;
stk.push_back(i);
for (pi j : g[i]) if (cc[j.first] == -1) {
if (!vis[j.first]) dfs(j.first);
low[i] = min(low[i], low[j.first]);
}
if (low[i] == dep[i]) {
while (stk.back() != i) cc[stk.back()] = v.size(), stk.pop_back();
cc[i] = v.size(), stk.pop_back();
v.push_back(0);
}
}
void dfs2(int i, ll _d) {
vis[i] = true, d[i] = _d;
for (pi j : g[i]) if (!vis[j.first] && cc[j.first] == cc[i])
dfs2(j.first, _d + j.second);
}
ll gcd(ll i, ll j) {
return j ? gcd(j, i % j) : i;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int n, m;
cin >> n >> m;
g.resize(n), cc.assign(n, -1), dep.resize(n), low.resize(n), d.resize(n), vis.assign(n, false);
for (int i = 0; i < m; ++i) {
int x, y, z;
cin >> x >> y >> z;
--x, --y;
g[x].emplace_back(y, z);
}
for (int i = 0; i < n; ++i) if (!vis[i]) dfs(i);
vis.assign(n, false);
for (int i = 0; i < n; ++i) {
if (!vis[i]) dfs2(i, 0);
for (pi j : g[i]) if (cc[i] == cc[j.first])
v[cc[i]] = gcd(v[cc[i]], abs(d[i] + j.second - d[j.first]));
}
int q;
cin >> q;
while (q--) {
int x, y, z;
cin >> x >> y >> z;
z = gcd(z, v[cc[--x]]);
cout << (y % z ? "NO\n" : "YES\n");
}
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int ans = (s.size() + 1) * 26, t = 1;
for (int i = 1; i < s.size(); i++) {
if (s[i] == s[i - 1]) {
t++;
} else {
ans -= t;
t = 1;
}
}
ans -= t;
cout << ans;
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
int n, cnt;
struct node {
int x, y;
} a[8000009];
struct hsh {
int tot, fst[20000003], pnt[8000009], len[8000009], nxt[8000009];
void ins(int x, int y) {
int z = x % 20000003;
pnt[++tot] = x;
len[tot] = y;
nxt[tot] = fst[z];
fst[z] = tot;
}
int calc(int x) {
int i, z = x % 20000003;
for (i = fst[z]; i; i = nxt[i])
if (pnt[i] == x) return len[i];
return -1;
}
} sg;
bool cmp(node u, node v) { return u.x < v.x; }
int dp(int x) {
int tmp = sg.calc(x);
if (tmp != -1) return tmp;
int i;
bool vis[33];
memset(vis, 0, sizeof(vis));
for (i = 1; x >> i; i++) vis[dp(x >> i | x & (1 << i) - 1)] = 1;
for (i = 0; vis[i]; i++)
;
sg.ins(x, i);
return i;
}
int main() {
scanf("%d", &n);
int i, j, x;
for (i = 1; i <= n; i++) {
scanf("%d", &x);
for (j = 2; j * j <= x; j++)
if (!(x % j)) {
a[++cnt].x = j;
for (; !(x % j); x /= j) a[cnt].y++;
}
if (x > 1) {
a[++cnt].x = x;
a[cnt].y = 1;
}
}
sort(a + 1, a + cnt + 1, cmp);
int ans = 0;
for (i = j = 1; i <= cnt; i = j) {
int tmp = 0, now = 0;
for (; j <= cnt && a[i].x == a[j].x; j++) {
tmp++;
now |= 1 << a[j].y;
}
if (tmp < n) now |= 1;
ans ^= dp(now);
}
puts((ans > 0) ? "Mojtaba" : "Arpa");
return 0;
}
| 14
|
#include <bits/stdc++.h>
#pragma ide diagnostic ignored "OCUnusedGlobalDeclarationInspection"
#pragma ide diagnostic ignored "OCUnusedMacroInspection"
using namespace std;
#define itn int
#define sqr(a) ((a)*(a))
#define cub(a) ((a)*(a)*(a))
#define forn(i, n) for(int i = 0; i < (int)n; ++i)
#define rep(i, k, n) for(int i = (int)k; i < (int)n; ++i)
#define nrof(i, n) for(int i = (int)n - 1; i >= 0; --i)
#define x first
#define y second
#define mp make_pair
#define sz(a) (int)(a.size())
#define pb push_back
#define eb emplace_back
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef double dd;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int N = 1e6 + 9;
const int M = 2e3 + 9;
const int INFINT = 1e9 + 9;
const ll INFLL = 1e18 + 9;
const ll MOD = (ll) (1000000007);
int solve() {
int n;
cin >> n;
vector<pll> a(n);
forn(i, n) {
cin >> a[i].y >> a[i].x;
}
// .x - надо на скидку, .y - всего надо
sort(all(a));
// l - стараемся со скидкой, r - затариваемся
int l = 0, r = n - 1;
ll ans = 0, total = 0;
while (l < r) {
ll max_buy = total + a[r].y;
if (a[l].x <= total) { // скидка < тотал, берем по 1
// cout << "buy all sale " << l << ' ' << r << endl;
ans += a[l].y;
total += a[l].y;
a[l].y = 0;
++l;
} else if (a[l].x > max_buy) { // сколько бы ни взяли, скидки не будет
// cout << "buy all max price " << l << ' ' << r << endl;
ans += a[r].y * 2;
total += a[r].y;
a[r].y = 0;
--r;
} else {
// cout << "buy to gr and sale " << l << ' ' << r << endl;
ll diff = a[l].x - total; // надо докупить до скидки
ans += diff * 2;
total += diff;
a[r].y -= diff;
// cout << "new r " << a[r].y << endl;
ans += a[l].y; // затариваемся по скидке
total += a[l].y;
a[l].y = 0;
++l;
}
// cout << ans << endl;
}
if (a[l].x <= total) {
ans += a[l].y;
} else if (a[l].x > total + a[l].y) {
ans += a[l].y * 2;
} else {
ll diff = a[l].x - total;
ans += diff * 2;
a[l].y -= diff;
ans += a[l].y;
}
cout << ans << endl;
return 0;
}
int main() {
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int tt = 1;
// cin >> tt;
while (tt--) {
solve();
}
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
const int mod = (1e9) + 7;
const double eps = 1e-10;
const int siz = 1e5 + 5, siz2 = 18, siz3 = 5032108;
int n, k, deg[siz], del[siz];
vector<int> adj[siz], temp;
queue<int> cur;
bool vis[siz];
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
deg[u]++;
deg[v]++;
}
if (n <= 3) {
printf("No\n");
return 0;
}
for (int i = 1; i <= n; i++) {
if (adj[i].size() == 1) {
cur.push(i);
}
}
int levels = 0;
while (!cur.empty()) {
while (!cur.empty()) {
int node = cur.front();
cur.pop();
for (int a : adj[node]) {
if (deg[a] == 0) {
continue;
}
deg[a]--;
deg[node]--;
del[a]++;
if (!vis[a]) {
vis[a] = true;
temp.push_back(a);
}
}
}
for (int node : temp) {
if (deg[node] > 1 || del[node] < 3) {
printf("No\n");
return 0;
}
if (deg[node] == 1) {
cur.push(node);
}
del[node] = 0;
vis[node] = false;
}
temp.clear();
levels++;
}
printf("%s\n", levels == k ? "Yes" : "No");
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename S>
inline bool REMIN(T& a, const S& b) {
return a > b ? a = b, 1 : 0;
}
template <typename T, typename S>
inline bool REMAX(T& a, const S& b) {
return a < b ? a = b, 1 : 0;
}
int bit(long long x, int pos) { return (x >> pos) & 1; }
long long power(long long base, long long exp, long long c = 1e9 + 7) {
if (!exp) return 1;
long long r = power(base, exp >> 1, c);
r = (r * r) % c;
if (exp & 1) r = (r * base) % c;
return r;
}
long long T, N, M, K;
int a, b, c;
string s1, s2;
const long double PI = 2 * acos(0);
const long long INF = 1e9 + 4;
const long long MOD = 1000000007;
const int NMAX = 3e5 + 5;
int dp[56][2];
int got[60];
int suf[56];
int dper(int pos, int per) {
if (pos > N) return 0;
if (dp[pos][per] != -1) return dp[pos][per];
int& ret = dp[pos][per];
ret = 0;
REMAX(ret, got[pos] + suf[pos + 1] - dper(pos + 1, 1 - per));
REMAX(ret, dper(pos + 1, per));
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
memset(dp, -1, sizeof(dp));
cin >> N;
long long tot = 0;
for (int(i) = int(1); (i) <= int(N); ++(i)) {
cin >> got[i];
tot += got[i];
}
for (int(i) = int(N); (i) >= int(1); --(i)) {
suf[i] = got[i] + suf[i + 1];
}
cout << tot - dper(1, 1) << ' ' << dper(1, 1);
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
int pos[100005], a[100005], b[100005], n;
multiset<int> s;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) pos[a[i]] = i;
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
for (int i = 1; i <= n; i++) s.insert(i - pos[b[i]]);
for (int i = 0; i <= n - 1; i++) {
multiset<int>::iterator it = s.lower_bound(i);
int ans = 914990825;
if (it != s.end()) ans = min(ans, (*it) - i);
if (it != s.begin()) ans = min(ans, i - (*(--it)));
printf("%d\n", ans);
s.erase(s.find(i + 1 - pos[b[i + 1]]));
s.insert(i + n + 1 - pos[b[i + 1]]);
}
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[4][4];
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 3; j++) {
cin >> a[i][j];
}
}
if (a[1][1] == a[3][3] && a[1][2] == a[3][2] && a[1][3] == a[3][1] &&
a[2][1] == a[2][3]) {
cout << "YES";
} else {
cout << "NO";
}
}
| 0
|
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
const int Maxn=100000;
vector<int> e[Maxn+5];
vector<int> level[Maxn+5];
vector<int> cnt[Maxn+5];
int dep[Maxn+5];
int depd[755],depc[755],tot;
int mdep;
bool f[755][Maxn+5];
int ccnt[Maxn+5];
int maxn[Maxn+5];
bool cmp(vector<int> x,vector<int> y){
return x.size()<y.size();
}
void dfs(int x){
for(int i=0;i<(int)e[x].size();i++){
int to=e[x][i];
dep[to]=dep[x]+1;
mdep=max(mdep,dep[to]);
cnt[dep[to]].push_back(to);
dfs(to);
}
}
int ans[Maxn+5];
void print(int layer,int re){
if(re==0){
return;
}
for(int i=0;i<=depc[layer]&&i*depd[layer]<=re;i++){
if(f[layer-1][re-depd[layer]*i]){
print(layer-1,re-depd[layer]*i);
for(int j=0;j<i;j++){
for(int k=0;k<(int)cnt[level[depd[layer]][j]].size();k++){
ans[cnt[level[depd[layer]][j]][k]]=1;
}
}
break;
}
}
}
int main(){
int n,x;
scanf("%d%d",&n,&x);
for(int i=2;i<=n;i++){
int a;
scanf("%d",&a);
e[a].push_back(i);
}
dfs(1);
cnt[0].push_back(1);
for(int i=0;i<=mdep;i++){
level[cnt[i].size()].push_back(i);
}
for(int i=1;i<=n;i++){
if(level[i].size()){
depd[++tot]=i,depc[tot]=level[i].size();
}
}
for(int i=0;i<=tot;i++){
f[i][0]=1;
}
for(int i=1;i<=tot;i++){
for(int j=1;j<=x;j++){
maxn[j]=-1;
if(f[i-1][j]){
maxn[j%depd[i]]=j;
}
if(maxn[j%depd[i]]!=-1&&(j-maxn[j%depd[i]])<=depd[i]*depc[i]){
f[i][j]=1;
}
}
}
if(f[tot][x]){
printf("%d\n",mdep+1);
print(tot,x);
}
else{
printf("%d\n",mdep+2);
int re=x;
int now=n;
int tag=mdep;
for(int i=0;i<mdep;i++){
if(!re){
break;
}
if((int)cnt[i].size()<re){
for(int j=0;j<(int)cnt[i].size();j++){
ans[cnt[i][j]]=1;
}
re-=cnt[i].size();
}
else if((int)cnt[i].size()>now-re){
int nleaf=0;
for(int j=0;j<(int)cnt[i].size();j++){
if(e[cnt[i][j]].size()){
nleaf++;
ans[cnt[i][j]]=1;
}
}
re-=nleaf;
tag=i;
}
now-=cnt[i].size();
}
if(re){
for(int i=0;i<(int)cnt[tag].size()&&re;i++){
if(!ans[cnt[tag][i]]){
ans[cnt[tag][i]]=1;
re--;
}
}
}
}
for(int i=1;i<=n;i++){
if(ans[i]){
putchar('a');
}
else{
putchar('b');
}
}
puts("");
return 0;
}
| 23
|
#include <bits/stdc++.h>
using namespace std;
vector<bool> done;
vector<int> par, dep;
vector<vector<int> > bs, es;
void dfs(int u, int p, int d) {
done[u] = true;
dep[u] = d;
par[u] = p;
for (const auto& v : es[u]) {
if (v == p) continue;
if (done[v])
bs[u].push_back(v);
else
dfs(v, u, d + 1);
}
}
vector<int> route(int u, int v) {
if (dep[u] > dep[v]) return route(v, u);
vector<int> r;
while (true) {
r.push_back(v + 1);
if (v == u) break;
v = par[v];
}
return r;
}
void print_route(const vector<int>& r) {
printf("%zd\n", r.size());
if (r.size() == 0) {
printf("\n");
return;
}
printf("%d", r[0]);
for (size_t i = 1; i < r.size(); i++) printf(" %d", r[i]);
printf("\n");
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int V, E;
size_t K;
scanf("%d%d%zd", &V, &E, &K);
done = vector<bool>(V, false);
par = vector<int>(V);
dep = vector<int>(V);
bs = vector<vector<int> >(V);
es = vector<vector<int> >(V);
for (int e = 0; e < E; e++) {
int a, b;
scanf("%d%d", &a, &b);
es[a - 1].push_back(b - 1);
es[b - 1].push_back(a - 1);
}
dfs(0, -1, 0);
auto deg_max = max_element(dep.begin(), dep.end());
if (*deg_max >= (int)((V + K - 1) / K)) {
printf("PATH\n");
print_route(route(0, deg_max - dep.begin()));
} else {
printf("CYCLES\n");
vector<int> leaves;
for (int v = 1; v < V && leaves.size() < K; v++)
if (bs[v].size() + 1 == es[v].size()) leaves.push_back(v);
for (const auto& v : leaves) {
vector<int> good;
for (const auto& u : bs[v]) {
good.push_back(u);
sort(good.begin(), good.end());
if (good.size() > 2) good.pop_back();
}
vector<int> r;
for (const auto& u : good) {
if ((dep[v] - dep[u] + 1) % 3 == 0) continue;
r = route(u, v);
break;
}
if (r.size() == 0) {
r = route(good[0], good[1]);
r.push_back(v + 1);
}
print_route(r);
}
}
return 0;
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
int n, c[210], p[210], d[210];
bool b[210], a[210][210];
int find(int k) {
for (int i = 1; i <= n; i++)
if (c[i] == k)
if (d[i] == 0 && b[i]) return i;
return n + 1;
}
int calc(int k) {
memset(b, true, sizeof(b));
for (int i = 1; i <= n; i++) d[i] = p[i];
int ret = 0;
for (int z = 1; z <= n; z++) {
int x = find(k);
while (x > n) {
k++;
if (k == 4) k = 1;
ret++;
x = find(k);
}
b[x] = false;
ret++;
for (int i = 1; i <= n; i++)
if (a[i][x]) d[i]--;
}
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &c[i]);
memset(a, false, sizeof(a));
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
for (int j = 1; j <= p[i]; j++) {
int y;
scanf("%d", &y);
a[i][y] = true;
}
}
int ans = calc(1);
int temp;
temp = calc(2);
if (temp < ans) ans = temp;
temp = calc(3);
if (temp < ans) ans = temp;
printf("%d\n", ans);
return 0;
}
| 9
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3", "unroll-loops")
#pragma GCC target("avx2")
using namespace std;
template <class T, class U>
inline void checkmin(T &x, U y) {
if (y < x) x = y;
}
template <class T, class U>
inline void checkmax(T &x, U y) {
if (y > x) x = y;
}
template <class T, class U>
inline bool ifmax(T &x, U y) {
if (y > x) return x = y, true;
return false;
}
template <class T, class U>
inline bool ifmin(T &x, U y) {
if (y < x) return x = y, true;
return false;
}
template <class T>
inline void sort(T &a) {
sort(a.begin(), a.end());
}
template <class T>
inline void rsort(T &a) {
sort(a.rbegin(), a.rend());
}
template <class T>
inline void reverse(T &a) {
reverse(a.begin(), a.end());
}
template <class T, class U>
inline istream &operator>>(istream &str, pair<T, U> &p) {
return str >> p.first >> p.second;
}
template <class T>
inline istream &operator>>(istream &str, vector<T> &a) {
for (auto &i : a) str >> i;
return str;
}
template <class T>
inline T sorted(T a) {
sort(a);
return a;
}
void solve() {
int n;
cin >> n;
vector<int> a(n);
cin >> a;
for (auto &i : a) --i;
vector<bool> used(n);
vector<int> ans(n);
for (int i = 0; i < n; ++i)
if (!used[i]) {
vector<int> check(1, i);
int k = a[i];
while (k != i) check.push_back(k), k = a[k];
for (auto i : check) {
used[i] = true;
ans[i] = signed(check.size());
}
}
for (auto i : ans) cout << i << ' ';
cout << '\n';
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(12);
srand(94385);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300010;
queue<pair<pair<int, int>, int> > Q;
struct recc {
int a, b, c, d, e;
};
int n;
int f[N], g[N];
pair<int, int> t[N * 4];
recc a[N];
void print(int n) {
if (f[n] != 0) print(g[n]);
printf("%d ", a[n].e);
}
void build(int i, int l, int r) {
int mid = (l + r) >> 1;
if (l == r) {
t[i] = make_pair(a[l].b, l);
return;
}
build(i * 2, l, mid);
build(i * 2 + 1, mid + 1, r);
t[i] = min(t[i * 2], t[i * 2 + 1]);
}
void change(int i, int l, int r, int k) {
if (l == r) {
t[i] = make_pair(2000000000, 0);
return;
}
int mid = (l + r) >> 1;
if (k <= mid) change(i * 2, l, mid, k);
if (k > mid) change(i * 2 + 1, mid + 1, r, k);
t[i] = min(t[i * 2], t[i * 2 + 1]);
}
pair<int, int> query(int i, int l, int r, int ll, int rr) {
if (ll <= l && r <= rr) return t[i];
int mid = (l + r) >> 1;
pair<int, int> res = make_pair(2000000000, 0);
if (ll <= mid) res = min(res, query(i * 2, l, mid, ll, rr));
if (rr > mid) res = min(res, query(i * 2 + 1, mid + 1, r, ll, rr));
return res;
}
int cmp(recc a, recc b) { return a.a < b.a || (a.a == b.a && a.b < b.b); }
int find(int p) {
int l = 1, r = n;
while (l < r) {
int mid = (l + r + 1) >> 1;
if (a[mid].a <= p)
l = mid;
else
r = mid - 1;
}
return l;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d%d%d%d", &a[i].a, &a[i].b, &a[i].c, &a[i].d), a[i].e = i;
int tmpx = a[n].a, tmpy = a[n].b;
sort(a + 1, a + 1 + n, cmp);
build(1, 1, n);
for (int i = 1; i <= n; i++) f[i] = -1;
for (int i = 1; i <= n; i++)
if (a[i].a == 0 && a[i].b == 0)
Q.push(make_pair(make_pair(a[i].c, a[i].d), i)), f[i] = 0,
change(1, 1, n, i);
while (!Q.empty()) {
pair<pair<int, int>, int> tmp = Q.front();
Q.pop();
int r = find(tmp.first.first);
while (1) {
pair<int, int> now = query(1, 1, n, 1, r);
if (now.first <= tmp.first.second) {
change(1, 1, n, now.second);
Q.push(
make_pair(make_pair(a[now.second].c, a[now.second].d), now.second));
f[now.second] = f[tmp.second] + 1;
g[now.second] = tmp.second;
} else
break;
}
}
int aim = 0;
for (int i = 1; i <= n; i++)
if (a[i].e == n) aim = i;
if (f[aim] == -1) {
printf("-1\n");
return 0;
}
printf("%d\n", f[aim] + 1);
print(aim);
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (--t >= 0) {
int n, i = 0, se = 0, so = 0;
cin >> n;
int a[n];
if ((n / 2) % 2 != 0) {
cout << "NO" << endl;
continue;
}
cout << "YES" << endl;
while (i < n) {
if (i < n / 2) {
a[i] = (i + 1) * 2;
se += a[i];
} else {
a[i] = 2 * (i - n / 2) + 1;
so += a[i];
}
i++;
}
so -= a[n - 1];
a[n - 1] = se - so;
i = 0;
while (i < n) {
cout << a[i] << " ";
i++;
}
cout << endl;
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y;
};
int n;
int p[8] = {1, 0, -1, 0, 1, 1, -1, -1};
int q[8] = {0, 1, 0, -1, 1, -1, 1, -1};
bool is_check(point K, point Q) {
return Q.x == K.x || Q.y == K.y || abs(Q.x - K.x) == abs(Q.y - K.y);
}
bool vis[1005][1005];
point Q;
bool bfs(point K, point C) {
queue<point> qx;
vis[K.x][K.y] = 1;
qx.push(K);
while (!qx.empty()) {
point now = qx.front();
qx.pop();
for (int i = 0; i < 8; i++) {
point tmp = now;
tmp.x += p[i];
tmp.y += q[i];
if (tmp.x > n || tmp.x < 1 || tmp.y > n || tmp.y < 1 || vis[tmp.x][tmp.y])
continue;
if (is_check(tmp, Q)) continue;
vis[tmp.x][tmp.y] = 1;
if (C.x == tmp.x && C.y == tmp.y) return 1;
qx.push(tmp);
}
}
return 0;
}
point K, C;
int main() {
scanf("%d", &n);
scanf("%d%d", &Q.x, &Q.y);
scanf("%d%d", &K.x, &K.y);
scanf("%d%d", &C.x, &C.y);
if (bfs(K, C)) {
printf("YES\n");
} else
printf("NO\n");
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long int llINF = (long long)(1e18) + 100;
const int MAXN = 3e2 + 10;
const int MAXM = 9e4;
int ned, first[MAXN], work[MAXN], dist[MAXN], q[MAXN];
int cap[MAXM], to[MAXM], nxt[MAXM];
void init() {
memset(first, -1, sizeof first);
ned = 0;
}
void add(int u, int v, int f) {
to[ned] = v, cap[ned] = f;
nxt[ned] = first[u];
first[u] = ned++;
to[ned] = u, cap[ned] = 0;
nxt[ned] = first[v];
first[v] = ned++;
}
int dfs(int u, int f, int t) {
if (u == t) return f;
for (int &e = work[u]; e != -1; e = nxt[e]) {
int v = to[e];
if (dist[v] == dist[u] + 1 && cap[e] > 0) {
int df = dfs(v, min(f, cap[e]), t);
if (df > 0) {
cap[e] -= df;
cap[e ^ 1] += df;
return df;
}
}
}
return 0;
}
bool bfs(int s, int t) {
memset(&dist, -1, sizeof dist);
dist[s] = 0;
int st = 0, en = 0;
q[en++] = s;
while (en > st) {
int u = q[st++];
for (int e = first[u]; e != -1; e = nxt[e]) {
int v = to[e];
if (dist[v] < 0 && cap[e] > 0) {
dist[v] = dist[u] + 1;
q[en++] = v;
}
}
}
return dist[t] >= 0;
}
int dinic(int s, int t) {
int flow = 0, f;
while (bfs(s, t)) {
memcpy(work, first, sizeof work);
while (f = dfs(s, INF, t)) flow += f;
}
return flow;
}
int n, m;
int back_cap[MAXM];
int pai[MAXN], fpai[MAXN], cuts[MAXN];
int mflow[MAXN][MAXN];
void find_cut(int v) {
cuts[v] = true;
for (int e = first[v]; e != -1; e = nxt[e])
if (!cuts[to[e]] and cap[e] > 0) find_cut(to[e]);
}
int min_cut(int s, int t) {
memset(cuts, 0, sizeof cuts);
memcpy(cap, back_cap, sizeof cap);
int flow = dinic(s, t);
find_cut(s);
return flow;
}
void gomory_hu() {
memset(mflow, -1, sizeof mflow);
memcpy(back_cap, cap, sizeof cap);
fill(pai, pai + n + 1, 1);
for (int s = 2; s <= n; s++) {
int t = pai[s];
fpai[s] = min_cut(s, t);
mflow[s][t] = mflow[t][s] = fpai[s];
for (int v = s + 1; v <= n; v++)
if (cuts[v] and pai[v] == t) pai[v] = s;
for (int v = 1; v < s; v++)
if (mflow[s][v] == -1)
mflow[s][v] = mflow[v][s] = min(mflow[s][t], mflow[t][v]);
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
init();
cin >> n >> m;
int v, u, w;
for (int i = 0; i < m; i++) {
cin >> v >> u >> w;
add(u, v, w);
add(v, u, w);
}
gomory_hu();
int sum = 0;
for (int i = 1; i <= n; i++) sum += fpai[i];
vector<int> ans(2), used(n + 1, 0);
int mx = -1;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
if (mflow[i][j] > mx) {
ans[0] = i;
ans[1] = j;
mx = mflow[i][j];
}
used[ans[0]] = used[ans[1]] = 1;
while (ans.size() < n) {
mx = -1;
for (int i = 1; i <= n; i++)
if (!used[i] and mflow[ans.back()][i] > mx) {
v = i;
mx = mflow[ans.back()][i];
}
ans.push_back(v);
used[v] = 1;
}
cout << sum << endl;
for (int v : ans) cout << v << ' ';
cout << endl;
}
| 21
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 100;
int n, m;
vector<pair<int, int>> g[N];
int U[N], V[N], W[N];
int top[N];
bool can(int MAX) {
vector<int> in(n + 1);
vector<vector<int>> g(n + 1);
for (int i = 0; i < m; i++) {
if (W[i] <= MAX) {
continue;
}
g[U[i]].push_back(V[i]);
in[V[i]]++;
}
int l = 0, r = 0;
for (int i = 1; i <= n; i++) {
if (in[i] == 0) {
top[r++] = i;
}
}
while (l < r) {
int u = top[l++];
for (auto v : g[u]) {
in[v]--;
if (in[v] == 0) {
top[r++] = v;
}
}
}
return r == n;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> U[i] >> V[i] >> W[i];
}
int lo = 0, hi = 2e9;
while (lo < hi) {
int m = (lo + hi) / 2;
if (can(m)) {
hi = m;
} else {
lo = m + 1;
}
}
can(lo);
vector<int> pos(n + 1);
for (int i = 0; i < n; i++) {
pos[top[i]] = i;
}
vector<int> ch;
cout << lo << " ";
for (int i = 0; i < m; i++) {
if (W[i] <= lo) {
if (pos[U[i]] > pos[V[i]]) {
ch.push_back(i + 1);
}
}
}
cout << ch.size() << '\n';
for (auto v : ch) {
cout << v << " ";
}
cout << '\n';
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
map<int, vector<int> > m;
set<int> ss;
void dfs(int s) {
cout << s << ' ';
ss.insert(s);
for (typeof((m[s]).begin()) it = (m[s]).begin(); it != (m[s]).end(); ++it)
if (!((ss).find(*it) != (ss).end())) dfs(*it);
}
int main() {
ios_base::sync_with_stdio(false);
int n, src, dest, s;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> src >> dest;
m[src].push_back(dest);
m[dest].push_back(src);
}
for (typeof((m).begin()) it = (m).begin(); it != (m).end(); ++it)
if (int((it->second).size()) == 1) {
s = it->first;
break;
}
dfs(s);
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a >> b;
int len1 = a.length();
int len2 = b.length();
int count1 = 0;
for (int i = 0; i < len1; ++i) {
if ((i + len2) > len1) break;
string s1 = a.substr(i, len2);
if (s1 == b) {
count1++;
i = (i + len2 - 1);
}
}
cout << count1 << "\n";
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
double a, b, l;
double calc(double x) {
double y = sqrt(l * l - x * x);
return (b / x + a / y - 1) / sqrt(1 / x / x + 1 / y / y);
}
int main() {
scanf("%lf%lf%lf", &a, &b, &l);
if (a > b) swap(a, b);
if (l <= a) {
printf("%.8f\n", l);
return false;
}
if (l <= b) {
printf("%.8f\n", a);
return false;
}
double L = 0, R = l;
while (R - L > 1e-10) {
double threeHalf = (R - L) / 3;
if (calc(L + threeHalf) < calc(R - threeHalf))
R -= threeHalf;
else
L += threeHalf;
}
if (calc(L) < 1e-7)
puts("My poor head =(");
else
printf("%.8f\n", calc(L));
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int r, g, b;
cin >> r >> g >> b;
r = (r / 2) + (!(!(r % 2)));
g = (g / 2) + (!(!(g % 2)));
b = (b / 2) + (!(!(b % 2)));
cout << 30 + max((r - 1) * 3, max((g - 1) * 3 + 1, (b - 1) * 3 + 2)) << endl;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
int n, t, k;
long long a[N], b[N], c[N], sa[N], sb[N];
long long f0[N][N], g0[N][N], f[N][N], g[N][N];
int main() {
cin >> n >> t >> k;
for (int i = 1; i <= n; i++) cin >> a[i] >> b[i] >> c[i];
n++, a[n] = b[n] = k, c[n] = 1ll << 60;
for (int i = 1; i <= n; i++)
sa[i] = sa[i - 1] + a[i], sb[i] = sb[i - 1] + b[i];
memset(f0, 0x3f, sizeof f0), memset(g0, 0x3f, sizeof g0);
memset(f0[0], 0, sizeof f0[0]), memset(g0[0], 0, sizeof g0[0]);
for (int i = 1; i <= n; i++) f0[i][0] = g0[i][0] = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= t; j++) {
if (b[i] * j <= c[i]) {
f0[i][j] = min(f0[i][j], f0[i - 1][j]);
long long res = sb[i - 1] * j - f0[i - 1][j] * k;
if (res >= 0) {
long long x = res > 0 ? (res - 1) / k + 1 : 0;
if (x * k <= res + b[i] * j)
g0[i][j] = min(g0[i][j], f0[i - 1][j] + x);
}
}
for (int t = 1; t < j; t++) {
long long res = sb[i] * t - g0[i][t] * k;
if (res < 0) continue;
long long tp = res + (j - t) * b[i] - c[i];
long long x = tp > 0 ? (tp - 1) / k + 1 : 0;
if (x * k > res) continue;
f0[i][j] = min(f0[i][j], g0[i][t] + x + f0[i - 1][j - t]);
res = res - x * k + (j - t) * b[i];
tp = sb[i - 1] * (j - t) - f0[i - 1][j - t] * k;
if (tp < 0) continue;
long long y = (tp - 1) / k + 1;
if (y * k <= tp + res)
g0[i][j] = min(g0[i][j], g0[i][t] + x + f0[i - 1][j - t] + y);
}
}
memset(f, 0x3f, sizeof f), memset(g, 0x3f, sizeof g);
memset(f[0], 0, sizeof f[0]), memset(g[0], 0, sizeof g[0]);
for (int i = 1; i <= n; i++) {
f[i][0] = 0;
long long x = sa[i - 1] > 0 ? (sa[i - 1] - 1) / k + 1 : 0;
if (x * k <= sa[i]) g[i][0] = x;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= t; j++) {
if (a[i] + b[i] * j <= c[i]) {
f[i][j] = min(f[i][j], f[i - 1][j]);
long long res = sa[i - 1] + sb[i - 1] * j - f[i - 1][j] * k;
if (res >= 0) {
long long x = res > 0 ? (res - 1) / k + 1 : 0;
if (x * k <= res + a[i] + b[i] * j)
g[i][j] = min(g[i][j], f[i - 1][j] + x);
}
}
for (int t = 0; t < j; t++) {
long long res = sa[i] + sb[i] * t - g[i][t] * k;
if (res < 0) continue;
long long tp = res + (j - t) * b[i] - c[i];
long long x = tp > 0 ? (tp - 1) / k + 1 : 0;
if (x * k > res) continue;
f[i][j] = min(f[i][j], g[i][t] + x + f0[i - 1][j - t]);
res = res - x * k + (j - t) * b[i];
tp = sb[i - 1] * (j - t) - f0[i - 1][j - t] * k;
if (tp < 0) continue;
long long y = (tp - 1) / k + 1;
if (y * k <= tp + res)
g[i][j] = min(g[i][j], g[i][t] + x + f0[i - 1][j - t] + y);
}
}
cout << f[n][t];
}
| 26
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, ans = 0, mul = 1;
cin >> n;
while (n % mul == 0) {
ans++;
mul *= 3;
}
cout << n / mul + 1;
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
int i, j, a, b;
int arr[1005] = {0};
for (i = 0; i < n; i++) {
cin >> a >> b;
if (a > b) {
int t = a;
a = b;
b = t;
}
for (j = a; j <= b; j++) {
arr[j]++;
}
}
int st = -1, end = -1;
for (i = 0; i < 1005; i++) {
if (arr[i] == n && st == -1 && end == -1) {
st = i;
} else if (st != -1 && arr[i] != n) {
end = i - 1;
break;
}
}
if (st == -1 && end == -1)
cout << -1 << endl;
else if (x >= st && x <= end)
cout << 0 << endl;
else
cout << min(abs(st - x), abs(x - end)) << endl;
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int a[maxn], b[maxn];
int c[maxn];
signed main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
for (int i = 1; i <= n; i++) {
c[a[i]] = b[i];
}
for (int i = 1; i <= n; i++) {
if (i != n)
printf("%d ", c[i]);
else
printf("%d\n", c[i]);
}
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
const int maxm = 210;
int T, now;
char str[maxm], c[100], *key = c + 50;
bool flag = true;
set<char> s;
bool null(int x) { return key[x] == '\0'; }
int check(char ch, int pos) {
if (key[pos - 1] == ch)
return -1;
else if (key[pos + 1] == ch)
return 1;
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> T;
while (T--) {
cin >> str;
for (char a = 'a'; a <= 'z'; ++a) s.insert(a);
for (int i = 0, res; str[i]; ++i) {
if (null(now)) {
key[now] = str[i];
s.erase(str[i]);
continue;
}
res = check(str[i], now);
if (res != 0) {
now += res;
} else {
if (null(now - 1) && s.find(str[i]) != s.end()) {
key[now - 1] = str[i];
s.erase(str[i]);
now--;
} else if (null(now + 1) && s.find(str[i]) != s.end()) {
key[now + 1] = str[i];
s.erase(str[i]);
now++;
} else {
flag = false;
break;
}
}
}
cout << (flag ? "YES\n" : "NO\n");
if (flag) {
while (!null(now)) --now;
cout << (key + now + 1);
for (char c : s) cout << c;
cout << endl;
}
now = 0;
memset(c, 0, sizeof c);
flag = true;
}
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
if (n == 0) {
cout << 1 << '\n';
return 0;
}
if (n == 1) {
cout << 8 << '\n';
} else if (n == 2)
cout << 4 << '\n';
else if (n == 3)
cout << 2 << '\n';
else if (n == 4)
cout << 6 << '\n';
else {
n %= 4;
if (n == 1) {
cout << 8 << '\n';
} else if (n == 2)
cout << 4 << '\n';
else if (n == 3)
cout << 2 << '\n';
else if (n == 0)
cout << 6 << '\n';
}
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 500007, N = 1e6 + 7;
int main() {
long long int n, help = 1;
cin >> n;
for (int i = 1; i <= (n / 2); i++) cout << i << " " << n + 1 - i << " ";
if (n % 2) {
cout << (n + 1) / 2;
}
cout << "\n";
return 0;
}
| 4
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma G++ optimize(2)
using namespace std;
struct my_deque {
int head, tail;
int t0, t1;
pair<long long, int> dat[1010];
void dq_init() {
head = tail = 0;
t0 = t1 = 0;
memset(dat, 0x3f, sizeof(dat));
}
void dq_push(int key) {
while (tail >= head && dat[tail].first >= key) tail--;
dat[++tail] = make_pair(key, t1);
t1++;
}
int dq_top() { return dat[head].first; }
void dq_pop() {
if (dat[head].second == t0) head++;
t0++;
}
};
int n, m, a, b;
long long h[1010][1010];
long long mn[1010][1010];
long long sum[1010][1010];
bool done[1010][1010];
vector<pair<long long, pair<int, int> > > city_pos;
vector<pair<long long, pair<int, int> > > chosen;
int main() {
scanf("%d%d%d%d", &n, &m, &a, &b);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) scanf("%I64d", &h[i][j]);
}
for (int i = 0; i < n; i++) {
my_deque now;
now.dq_init();
for (int j = 0; j < b - 1; j++) now.dq_push(h[i][j]);
for (int j = 0; j < m - b + 1; j++) {
now.dq_push(h[i][j + b - 1]);
mn[i][j] = now.dq_top();
now.dq_pop();
}
}
for (int j = 0; j < m - b + 1; j++) {
my_deque now;
now.dq_init();
for (int i = 0; i < a - 1; i++) now.dq_push(mn[i][j]);
for (int i = 0; i < n - a + 1; i++) {
now.dq_push(mn[i + a - 1][j]);
mn[i][j] = now.dq_top();
now.dq_pop();
}
}
for (int i = 0; i < n; i++) {
long long nowsum = 0;
for (int j = 0; j < b - 1; j++) nowsum += h[i][j];
for (int j = 0; j < m - b + 1; j++) {
nowsum += h[i][j + b - 1];
sum[i][j] = nowsum;
nowsum -= h[i][j];
}
}
for (int j = 0; j < m - b + 1; j++) {
long long nowsum = 0;
for (int i = 0; i < a - 1; i++) nowsum += sum[i][j];
for (int i = 0; i < n - a + 1; i++) {
nowsum += sum[i + a - 1][j];
long long temp = nowsum;
nowsum -= sum[i][j];
sum[i][j] = temp;
}
}
long long sz = a * b;
for (int i = 0; i < n - a + 1; i++) {
for (int j = 0; j < m - b + 1; j++) {
city_pos.push_back(make_pair(sum[i][j] - sz * mn[i][j], make_pair(i, j)));
}
}
sort(city_pos.begin(), city_pos.end());
for (int i = 0; i < city_pos.size(); i++) {
int x = city_pos[i].second.first, y = city_pos[i].second.second;
if (!done[x][y] && !done[x][y + b - 1] && !done[x + a - 1][y] &&
!done[x + a - 1][y + b - 1]) {
chosen.push_back(make_pair(city_pos[i].first, make_pair(x, y)));
for (int nx = x; nx < x + a; nx++) {
for (int ny = y; ny < y + b; ny++) {
done[nx][ny] = 1;
}
}
}
}
printf("%d\n", chosen.size());
for (int i = 0; i < chosen.size(); i++) {
printf("%d %d %I64d\n", chosen[i].second.first + 1,
chosen[i].second.second + 1, chosen[i].first);
}
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
inline void read(int& x) {
x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
}
struct edge {
int u, v, w;
inline edge(int u = 0, int v = 0, int w = 0) : u(u), v(v), w(w) {}
inline bool operator<(const edge& x) const { return w < x.w; }
} e[1000003];
int fa[1000003], a[1000003], size[1000003];
int n;
long long ans;
inline int find(int x) {
while (x != fa[x]) x = fa[x] = fa[fa[x]];
return x;
}
inline void merge(int u, int v, int w) {
u = find(u), v = find(v);
ans += (long long)w * size[u] * size[v];
fa[u] = v;
size[v] += size[u];
}
int main() {
int u, v;
read(n);
for (register int i = 1; i <= n; ++i) read(a[i]);
for (register int i = 1; i < n; ++i) {
read(u), read(v);
e[i] = edge(u, v, min(a[u], a[v]));
fa[i] = i;
size[i] = 1;
}
fa[n] = n, size[n] = 1;
sort(e + 1, e + n);
for (register int i = n - 1; i; --i) merge(e[i].u, e[i].v, e[i].w);
ans = -ans;
for (register int i = 1; i <= n; ++i) fa[i] = i, size[i] = 1;
for (register int i = 1; i < n; ++i) e[i].w = max(a[e[i].u], a[e[i].v]);
sort(e + 1, e + n);
for (register int i = 1; i < n; ++i) merge(e[i].u, e[i].v, e[i].w);
printf("%I64d", ans);
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200002;
long long po(long long a, long long b) {
return !b ? 1
: po(a * a % 1000000007ll, b / 2) * (b & 1 ? a : 1) % 1000000007ll;
}
long long inv(long long b) { return po(b, 1000000007ll - 2); }
long long dp[maxn], d[maxn];
long long a[maxn], b[maxn];
void solve() {
int n;
cin >> n;
for (__typeof(n + 1) i = (1) - ((1) > (n + 1));
i != (n + 1) - ((1) > (n + 1)); i += 1 - 2 * ((1) > (n + 1))) {
cin >> a[i];
}
for (__typeof(n + 1) i = (1) - ((1) > (n + 1));
i != (n + 1) - ((1) > (n + 1)); i += 1 - 2 * ((1) > (n + 1))) {
cin >> b[i];
b[i] += b[i - 1];
}
for (__typeof(n + 1) i = (1) - ((1) > (n + 1));
i != (n + 1) - ((1) > (n + 1)); i += 1 - 2 * ((1) > (n + 1))) {
long long bb = b[i] - b[i - 1];
if (a[i] <= bb) {
d[i] += a[i];
} else {
int l = upper_bound(b + 1, b + n + 1, a[i] + b[i - 1]) - b - 1;
dp[i]++;
dp[l + 1]--;
d[l + 1] += a[i] - (b[l] - b[i - 1]);
}
dp[i] += dp[i - 1];
cout << dp[i] * bb + d[i] << " ";
}
}
int main() {
int n = 1;
while (n--) solve();
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
std::vector<int> v(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
int left = -1;
for (int i = 0; i < n; ++i) {
if (v[i] > k)
break;
else
left++;
}
int right = -1;
for (int i = n - 1; i > left; --i) {
if (v[i] > k)
break;
else
right++;
}
int cnt = 0;
if (left != -1) cnt += left + 1;
if (right != -1) cnt += right + 1;
cout << cnt << "\n";
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int t;
scanf("%d", &t);
return t;
}
int n;
struct wangluoliu {
int head[40010], last[800000], val[800000], v[800000], p = 1;
int dep[40010], cur[40010];
void add(int a, int b, int c) {
v[++p] = b;
last[p] = head[a];
head[a] = p;
val[p] = c;
}
int cnt, S, T;
const int inf = 0x3f3f3f3f;
bool bfs() {
memset(dep, 0x3f, sizeof(dep));
memcpy(cur, head, sizeof(head));
queue<int> q;
dep[S] = 0;
q.push(S);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = head[u]; i; i = last[i])
if (dep[v[i]] > dep[u] + 1 && val[i]) {
dep[v[i]] = dep[u] + 1;
if (v[i] == T) return 1;
q.push(v[i]);
}
}
return 0;
}
int dfs(int x, int f) {
if (x == T || !f) return f;
int used = 0;
for (int &i = cur[x], w; i; i = last[i]) {
int u = v[i];
if (!val[i] || dep[u] != dep[x] + 1) continue;
w = dfs(u, min(f, val[i]));
if (!w) continue;
val[i] -= w;
val[i ^ 1] += w;
f -= w;
used += w;
if (!f) return used;
}
return used;
}
inline int dinic() {
int res = 0;
while (bfs()) {
memcpy(cur, head, sizeof(head));
res += dfs(S, inf);
}
return res;
}
void ADD(int a, int b, int c) {
add(a, b, c);
add(b, a, 0);
}
int maxflow;
} S;
vector<pair<int, int> > ID[10010];
int id(int a, int b) { return (a - 1) * n + b; }
int s[40010], tot;
int w[210][210];
void build() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (w[i][j] != -1) {
int x_ = i - 1, y_ = j;
if (x_ >= 1 && y_ >= 1 && w[x_][y_] != -1)
S.ADD(id(x_, y_), id(i, j), 1), S.ADD(id(i, j), id(x_, y_), 1);
x_ = i, y_ = j - 1;
if (x_ >= 1 && y_ >= 1 && w[x_][y_] != -1)
S.ADD(id(x_, y_), id(i, j), 1), S.ADD(id(i, j), id(x_, y_), 1);
}
}
int Val[40010];
signed main() {
n = read();
int m = n;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
w[i][j] = read();
if (w[i][j] >= 1) s[++tot] = w[i][j];
}
sort(s + 1, s + 1 + tot), tot = unique(s + 1, s + 1 + tot) - s - 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
if (w[i][j] >= 1) {
w[i][j] = lower_bound(s + 1, s + 1 + tot, w[i][j]) - s;
ID[w[i][j]].push_back(make_pair(i, j));
}
Val[id(i, j)] = w[i][j];
}
if (tot == 1)
cout << 0;
else {
S.S = n * n + 1, S.T = n * n + 2, S.cnt = n * n + 3;
for (int i = 0; i < ID[1].size(); i++)
S.ADD(S.S, id(ID[1][i].first, ID[1][i].second), S.inf);
for (int k = 2; k <= tot; k++)
for (int i = 0; i < ID[k].size(); i++)
S.ADD(id(ID[k][i].first, ID[k][i].second), S.T, S.inf);
build();
long long ans = 0;
S.maxflow = S.dinic();
ans += 1ll * S.maxflow * (s[2] - s[1]);
for (int i = 2; i < tot; i++) {
for (int j = S.head[S.T]; j; j = S.last[j])
if (Val[S.v[j]] == i) {
S.ADD(n * m + 3, S.v[j], S.val[j]);
S.val[j] = S.val[j ^ 1] = 0;
S.S = n * m + 3, S.T = n * m + 1;
S.maxflow -= S.dinic();
S.S = n * m + 1, S.T = n * m + 2;
S.ADD(S.S, S.v[j], S.inf);
S.maxflow += S.dinic();
}
ans += 1ll * S.maxflow * (s[i + 1] - s[i]);
}
cout << ans;
}
return 0;
}
| 25
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = 2 * acos(0.0);
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T, class TT>
bool pal(T a, TT n) {
int k = 0;
for (int i = 0; i <= n / 2; i++) {
if (a[i] != a[n - i - 1]) {
k = 1;
break;
}
}
return k ? 0 : 1;
}
long long dp[222222][4];
int main() {
long long n, l, r;
cin >> n >> l >> r;
long long a = r / 3 - (l - 1) / 3,
b = (r - 1) / 3 - ((l - 1) / 3 + ((l - 1) % 3 != 0)) + 1,
c = (r - 2 < 0 ? -1 : (r - 2) / 3) -
(l - 2 < 0 ? 0 : (l - 2) / 3 + ((l - 2) % 3 != 0)) + 1;
dp[0][0] = 1;
cerr << "a"
<< " = " << a << '\n';
cerr << "b"
<< " = " << b << '\n';
cerr << "c"
<< " = " << c << '\n';
for (int i = 1; i <= n; i++) {
dp[i][0] =
((dp[i - 1][1] * c) % 1000000007 + (dp[i - 1][2] * b) % 1000000007 +
(dp[i - 1][0] * a) % 1000000007) %
1000000007;
dp[i][1] =
((dp[i - 1][1] * a) % 1000000007 + (dp[i - 1][2] * c) % 1000000007 +
(dp[i - 1][0] * b) % 1000000007) %
1000000007;
dp[i][2] =
((dp[i - 1][1] * b) % 1000000007 + (dp[i - 1][2] * a) % 1000000007 +
(dp[i - 1][0] * c) % 1000000007) %
1000000007;
}
cout << dp[n][0];
getchar();
getchar();
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
const int rx[] = {0, -1, 0, 1, -1, 1, 1, -1};
const int cy[] = {1, 0, -1, 0, 1, 1, -1, -1};
double a, d;
int n;
int chk(double x, double y) {
if ((x >= 0 && x <= a) && (y == 0))
return 1;
else if ((x == a) && (y >= 0 && y <= a))
return 2;
else if ((x >= 0 && x <= a) && (y == a))
return 3;
else if (x == 0 && (y >= 0 && y <= a))
return 4;
else if ((x > a) && (y == 0))
return 5;
else if (x == a && y > a)
return 6;
else if (y == a && x < 0)
return 7;
else if (x == 0 && y < 0)
return 8;
return 0;
}
int main() {
cin >> a >> d >> n;
while (d >= 4 * a) {
d -= (4 * a);
}
double x = 0, y = 0;
double nx, ny;
int dir;
for (int i = 0; i < n; i++) {
dir = chk(x, y);
if (dir == 1) {
nx = x + d;
ny = y;
} else if (dir == 2) {
nx = x;
ny = y + d;
} else if (dir == 3) {
nx = x - d;
ny = y;
} else {
nx = x;
ny = y - d;
}
x = nx, y = ny;
while (1) {
dir = chk(x, y);
if (dir > 0 && dir < 5) {
printf("%.10lf %.10lf\n", x, y);
break;
}
if (dir == 5) {
ny = 0 + (x - a);
nx = a;
} else if (dir == 6) {
ny = a;
nx = a - (y - a);
} else if (dir == 7) {
nx = 0;
ny = a - (0 - x);
} else {
ny = 0;
nx = 0 + (0 - y);
}
x = nx;
y = ny;
}
}
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
struct T {
int i, v;
T(int i = 0, int v = 0) : i(i), v(v) {}
};
bool operator<(T a, T b) { return a.v > b.v; }
int l, n, u[10010], w[10010], p[10010], a[2 * 100010], c[2 * 100010],
e[2 * 100010];
vector<int> m[10010];
priority_queue<T> q;
void push(int i, int v, int j) {
if (v < u[i]) {
u[i] = v;
p[i] = j;
q.push(T(i, v));
}
}
bool bfs(int b, int s) {
int i, v, j, k;
for (fill(u, u + n, 1000000000), push(b, 0, -1); !q.empty();) {
i = q.top().i;
v = q.top().v;
q.pop();
if (v == u[i])
for (j = 0; j < m[i].size(); j++)
if (a[k = m[i][j]]) push(e[k], v + c[k] + w[i] - w[e[k]], k);
}
return u[s] < 1000000000;
}
int mcmf(int b, int s) {
int i, j, f;
for (i = 0; i < n; w[i] = 1000000000, i++)
;
for (w[0] = 0, i = 0; i < n; i++)
for (j = 0; j < n; j++)
for (f = 0; f < m[j].size(); f++)
if (a[m[j][f]] > 0)
if (w[j] + c[m[j][f]] < w[e[m[j][f]]])
w[e[m[j][f]]] = w[j] + c[m[j][f]];
for (; bfs(b, s);) {
for (j = 1000000000, i = s; i != b; j = min(j, a[p[i]]), i = e[p[i] ^ 1])
;
for (i = s; i != b;
a[p[i]] -= j, a[p[i] ^ 1] += j, f += c[p[i]] * j, i = e[p[i] ^ 1])
;
for (i = 0; i < n; w[i] += (u[i] - 1000000000) & u[i], i++)
;
}
return f;
}
void add(int i, int j, int v, int p) {
e[l] = j;
a[l] = v;
c[l] = p;
m[i].push_back(l++);
e[l] = i;
a[l] = 0;
c[l] = -p;
m[j].push_back(l++);
}
map<int, int> y;
map<int, int>::iterator it;
int s[10010], f[10010], z[10010];
int main() {
int i, k, d, v;
for (scanf("%d%d", &n, &k), v = n, i = 0; i < n;
scanf("%d%d%d", &s[i], &f[i], &z[i]), f[i] += s[i], y[s[i]] = 1,
y[f[i]] = 1, i++)
;
y[-1] = 1;
y[1000000000] = 1;
for (i = 0, it = y.begin(); it != y.end(); it->second = i, i++, it++)
;
d = y.size();
for (i = 0; i < d - 1; add(i, i + 1, k, 0), i++)
;
for (i = 0; i < n;
add(y[s[i]], d + i, 1, 0), add(d + i, y[f[i]], 1, -z[i]), i++)
;
n = d + v;
mcmf(0, d - 1);
n = v;
for (i = 0; i < n;
k = a[m[d + i][1]] == 0, printf("%d%c", k, i < n - 1 ? ' ' : '\n'), i++)
;
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int A[n + 1];
for (int i = 1; i <= n; i++) {
cin >> A[i];
}
int mi = 1;
int ma = n;
int posmin, posmax, posmin1, posmax1;
for (int i = 1; i <= n; i++) {
if (mi == A[i]) {
posmin = i;
}
if (ma == A[i]) {
posmax = i;
}
}
if ((posmin == 1 || posmin == n) && (posmax == n || posmax == 1)) {
cout << n - 1 << endl;
}
if (abs(posmax - posmin) + 1 < n) {
if (posmin == 1 && posmax < n) {
cout << n - 1 << endl;
}
if (posmax == n && posmin != 1) {
cout << n - 1 << endl;
}
if (posmin != 1 && posmax != n) {
posmin1 = posmin;
posmax1 = posmax;
posmin1 = 1;
posmax1 = n;
int c = max(abs(posmax - posmin1), abs(posmax1 - posmin));
posmin1 = n;
posmax1 = 1;
c = max(c, abs(posmax - posmin1));
c = max(c, abs(posmax1 - posmin));
cout << c << endl;
}
}
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const int INFint = 2147483547;
const long long INF = 9223372036854775807ll;
const long long MOD = 1000000007ll;
const long double EPS = 1e-13;
int main() {
ios_base::sync_with_stdio(0);
int n, b;
cin >> n >> b;
vector<pair<int, int> > qrs(n);
for (int i = 0; i < n; i++) cin >> qrs[i].first >> qrs[i].second;
vector<long long> ans(n, -1);
deque<int> q;
long long timer = qrs[0].first;
int v = 0;
int cnt = 0;
for (int i = 1; i < n; i++) {
bool ok = 1;
while (1) {
if (timer + qrs[v].second <= qrs[i].first) {
timer += qrs[v].second;
ans[v] = timer;
if (0)
cerr << "upd " << v << ' ' << ans[v] << ' ' << i << ' '
<< qrs[i].first << endl;
if (!q.empty()) {
v = q.front();
ok = 1;
q.pop_front();
cnt--;
} else {
ok = 0;
break;
}
} else
break;
}
if (!ok) {
timer = qrs[i].first;
if (0) cerr << "new kek " << i << ' ' << timer << endl;
v = i;
} else {
if (cnt < b) {
if (0) cerr << "add" << ' ' << i << ' ' << timer << endl;
cnt++;
q.push_back(i);
}
}
}
if (0) cerr << q.size() << ' ' << v << endl;
while (1) {
timer += qrs[v].second;
ans[v] = timer;
if (q.empty()) break;
v = q.front();
q.pop_front();
}
for (int i = 0; i < n; i++) cout << ans[i] << ' ';
fprintf(stderr, "\nTIME = %lf\n", 1.0 * clock() / CLOCKS_PER_SEC);
;
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2003;
char a[N][N];
vector<pair<int, int> > q;
pair<int, int> tmp;
int n, m;
inline bool f(int x, int y) {
int res = 0;
if (a[x][y] != '.') return false;
if (a[x + 1][y] == '.') res++;
if (a[x - 1][y] == '.') res++;
if (a[x][y - 1] == '.') res++;
if (a[x][y + 1] == '.') res++;
if (res == 1) return true;
return false;
}
inline void check(int x, int y) {
if (f(x + 1, y)) q.push_back(make_pair(x + 1, y));
if (f(x - 1, y)) q.push_back(make_pair(x - 1, y));
if (f(x, y + 1)) q.push_back(make_pair(x, y + 1));
if (f(x, y - 1)) q.push_back(make_pair(x, y - 1));
}
inline void g(int x, int y) {
if (a[x + 1][y] == '.') {
a[x][y] = '^';
a[x + 1][y] = 'v';
check(x + 1, y);
}
if (a[x - 1][y] == '.') {
a[x][y] = 'v';
a[x - 1][y] = '^';
check(x - 1, y);
}
if (a[x][y + 1] == '.') {
a[x][y + 1] = '>';
a[x][y] = '<';
check(x, y + 1);
}
if (a[x][y - 1] == '.') {
a[x][y - 1] = '<';
a[x][y] = '>';
check(x, y - 1);
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
getchar();
for (int j = 1; j <= m; ++j) {
a[i][j] = getchar();
}
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (f(i, j)) q.push_back(make_pair(i, j));
while (!q.empty()) {
tmp = q.back();
q.pop_back();
g(tmp.first, tmp.second);
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; j++)
if (a[i][j] == '.') return cout << "Not unique", 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) printf("%c", a[i][j]);
printf("\n");
}
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
string line;
bool getLine() {
line = "";
char c;
read:
if (scanf("%c", &c) == EOF) {
return false;
}
if (c == 10 || c == 13) return true;
line += c;
goto read;
}
int main() {
vector<string> v;
int maxt = 0, cur, left, right;
char isleft = true;
while (getLine()) {
v.push_back(line);
}
for (int i = 0; i < v.size(); i++) {
maxt = max(maxt, (int)v[i].size());
}
for (int i = 0; i < maxt + 2; i++) {
printf("*");
}
cout << endl;
for (int i = 0; i < v.size(); i++) {
printf("*");
cur = maxt - v[i].size();
if (cur % 2) {
for (int j = 0; j < cur / 2; j++) {
printf(" ");
}
if (!isleft) printf(" ");
cout << v[i];
if (isleft) printf(" ");
for (int j = 0; j < cur / 2; j++) {
printf(" ");
}
isleft = !isleft;
} else {
for (int j = 0; j < cur / 2; j++) {
printf(" ");
}
cout << v[i];
for (int j = 0; j < cur / 2; j++) {
printf(" ");
}
}
printf("*");
cout << endl;
}
for (int i = 0; i < maxt + 2; i++) {
printf("*");
}
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 1e5 + 5;
const long long inf = 1e18;
char s[N];
int i, j, aux[200];
int main() {
scanf("%s", s);
int len = strlen(s);
int index = 123;
for (i = 0; i < len; i++) aux[s[i]] = i;
for (i = 122; i >= 97; i--) {
for (j = aux[index]; j < len; j++) {
if (s[j] == i) {
printf("%c", char(i));
index = i;
}
}
}
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
int mod = 1e9 + 7;
void solve() {
int n, m;
cin >> n >> m;
long long a[m + 1][n + 1], b[m + 1][n + 1];
for (int i = 1; i <= n; i++) {
a[1][i] = 1;
b[1][i] = n - i + 1;
}
for (int i = 2; i <= m; i++) {
long long sum = 0;
for (int j = 1; j <= n; j++) {
sum = (sum + a[i - 1][j]) % mod;
a[i][j] = sum % mod;
}
}
for (int i = 2; i <= m; i++) {
long long sum = 0;
for (int j = n; j >= 1; j--) {
sum = (sum + b[i - 1][j]) % mod;
b[i][j] = sum % mod;
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans = (ans + (a[m][i] * b[m][i]) % mod) % mod;
}
cout << ans << endl;
}
int main() { solve(); }
| 8
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
long long dp[2][N];
int buf[N], a[N];
int cnt;
long long min(const long long &x, const long long &y) { return x < y ? x : y; }
inline int pos(int x) { return lower_bound(buf, buf + cnt, x) - buf; }
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
buf[cnt++] = a[i];
}
sort(buf, buf + cnt);
cnt = unique(buf, buf + cnt) - buf;
for (int i = 0; i < cnt; i++) {
dp[0][i] = abs(a[0] - buf[i]);
}
int flag = 1;
for (int i = 1; i < n; i++, flag ^= 1) {
long long tmp = 1LL << 50;
for (int j = 0; j < cnt; j++) {
tmp = min(dp[flag ^ 1][j], tmp);
dp[flag][j] = tmp + abs(a[i] - buf[j]);
}
}
long long ret = 1LL << 50;
for (int i = 0; i < cnt; i++) {
ret = min(ret, dp[flag ^ 1][i]);
}
cout << ret << endl;
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
vector<int> a(2 * n + 1);
vector<int> mx(2 * n + 1);
for (int i = 1; i <= 2 * n; i++) {
scanf("%d", &a[i]);
mx[i] = max(mx[i - 1], a[i]);
}
vector<vector<vector<int> > > dp(
2 * n + 2, vector<vector<int> >(n + 1, vector<int>(2)));
dp[2 * n + 1][n][0] = dp[2 * n + 1][n][1] = 1;
for (int i = 2 * n; i > 1; i--) {
for (int up = 0; up <= n; up++) {
if (up < n) dp[i][up][0] |= dp[i + 1][up + 1][0];
if (a[i] > mx[i - 1]) dp[i][up][0] |= dp[i + 1][up][1];
dp[i][up][1] |= dp[i + 1][up][1];
if (up < n && a[i] > mx[i - 1]) dp[i][up][1] |= dp[i + 1][up + 1][0];
}
}
int ans = dp[2][1][0] | dp[2][0][1];
if (ans)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%d%d", &n, &k);
vector<long long> a(n, 0);
for (int i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
a[i] = x;
}
int kol = 0;
long long sum = 0;
for (int i = 0; i < n; ++i) {
long long d = sum - (long long)kol * (n - i - 1) * a[i];
if (d < k) {
printf("%d\n", i + 1);
} else {
sum += (long long)kol * a[i];
++kol;
}
}
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20005;
struct EDGE {
int to, next;
} e[N];
int laste[N], eid;
void add_edge(int u, int v) {
e[eid].to = v;
e[eid].next = laste[u];
laste[u] = eid++;
}
int n, m, bd, lastbd;
int used[N], lst[N], dep[N];
int dp1[N], dp2[N];
void dfs(int u, int D) {
used[u] = 1;
dep[u] = D;
dp1[u] = dp2[u] = 0;
for (int i = laste[u]; ~i; i = e[i].next) {
if (lst[u] == (i ^ 1)) continue;
int v = e[i].to;
if (!used[v]) {
lst[v] = i;
dfs(v, D ^ 1);
dp1[u] += dp1[v];
dp2[u] += dp2[v];
} else if (used[v] == 1) {
if (dep[u] == dep[v]) {
bd++;
lastbd = (i >> 1) + 1;
dp1[u]++;
} else
dp2[u]++;
} else {
if (dep[u] == dep[v])
dp1[u]--;
else
dp2[u]--;
}
}
used[u] = 2;
}
int main() {
scanf("%d%d", &n, &m);
eid = 0;
memset(laste, -1, sizeof(laste));
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
add_edge(u, v);
add_edge(v, u);
}
memset(lst, -1, sizeof(lst));
memset(used, 0, sizeof(used));
bd = 0;
for (int i = 1; i <= n; i++)
if (!used[i]) dfs(i, 0);
vector<int> ans;
if (!bd)
for (int i = 1; i <= m; i++) ans.push_back(i);
else {
if (bd == 1) ans.push_back(lastbd);
for (int i = 1; i <= n; i++)
if (lst[i] != -1 && dp1[i] == bd && !dp2[i])
ans.push_back((lst[i] >> 1) + 1);
sort(ans.begin(), ans.end());
}
printf("%d\n", (int)ans.size());
for (int i = 0, _ = ans.size(); i < _; i++) printf("%d ", ans[i]);
puts("");
return 0;
}
| 21
|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long x, y;
int id;
node() {}
node(long long _x, long long _y, int _id) {
x = _x;
y = _y;
id = _id;
}
friend node operator-(const node &a, const node &b) {
return node(a.x - b.x, a.y - b.y, 0);
}
friend long long operator*(const node &a, const node &b) {
return a.x * b.y - a.y * b.x;
}
friend bool operator<(const node &a, const node &b) {
if (a.x < b.x) return 1;
if (a.x > b.x) return 0;
return a.y < b.y;
}
} a[1555];
node base;
vector<int> g[1555];
int s[1555], n, x, y, ans[1555];
bool cmp(const node &a, const node &b) { return (a - base) * (b - base) > 0; }
void dfs(int id, int fa) {
s[id] = 1;
for (vector<int>::iterator ii = g[id].begin(); ii != g[id].end(); ii++)
if (*ii != fa) {
dfs(*ii, id);
s[id] += s[*ii];
}
}
void solve(int id, int fa, int l, int r) {
for (int i = l; i < r; i++)
if (a[i] < a[l]) swap(a[i], a[l]);
base = a[l];
sort(a + l + 1, a + r, cmp);
ans[a[l].id] = id;
l++;
for (vector<int>::iterator ii = g[id].begin(); ii != g[id].end(); ii++)
if (*ii != fa) {
solve(*ii, id, l, l + s[*ii]);
l += s[*ii];
}
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 0; i < n; i++) {
scanf("%d%d", &x, &y);
a[i] = node(x, y, i);
}
dfs(1, 0);
solve(1, 0, 0, n);
for (int i = 0; i < n; i++) !i ? printf("%d", ans[i]) : printf(" %d", ans[i]);
printf("\n");
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
vector<int> bin, v;
int find(int n) {
bin.clear();
int b = 1, num = 0;
while (n) {
bin.push_back(n % 2);
n /= 2;
}
for (int i = 7; i >= 0; i--) {
int t;
if (i < bin.size())
t = bin[i];
else
t = 0;
num += t * b;
b *= 2;
}
return num;
}
int main() {
char ch;
int a, p;
p = 0;
while (scanf("%c", &ch) != -1) {
int n = find(ch);
a = (256 - n + p) % 256;
p = n;
v.push_back(a);
}
for (int i = 0; i < v.size() - 1; i++) cout << v[i] << endl;
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e15;
struct edge {
int from, to;
long long w;
bool operator<(edge other) const { return w < other.w; }
};
edge edg[100011];
vector<pair<int, long long>> g[100011];
long long dist[100011];
int origion[100011];
int n, k, m;
int portal[100011];
int f[100011];
int visited[100011];
void init() {
int i;
for (i = 0; i < 100011; ++i) {
f[i] = i;
dist[i] = INF;
origion[i] = i;
}
}
int find(int x) {
if (x == f[x]) return x;
return f[x] = find(f[x]);
}
void unionset(int x, int y) {
x = find(x), y = find(y);
f[x] = y;
}
void dijkstra() {
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
q;
int i;
for (i = 1; i <= k; ++i) {
dist[portal[i]] = 0;
q.push(make_pair(0, portal[i]));
}
while (!q.empty()) {
auto p = q.top();
q.pop();
if (visited[p.second]) continue;
dist[p.second] = p.first;
visited[p.second] = 1;
for (auto np : g[p.second]) {
int nv = np.first;
if (!visited[nv] && dist[nv] > dist[p.second] + np.second) {
dist[nv] = dist[p.second] + np.second;
q.push(make_pair(dist[nv], nv));
origion[nv] = origion[p.second];
}
}
}
}
long long kruskal() {
int i;
long long ret = 0;
for (i = 1; i <= m; ++i) {
if (find(edg[i].from) != find(edg[i].to)) {
ret += edg[i].w;
unionset(edg[i].from, edg[i].to);
}
}
return ret;
}
int main() {
int i;
init();
scanf("%d%d", &n, &m);
for (i = 1; i <= m; ++i) {
scanf("%d%d%I64d", &edg[i].from, &edg[i].to, &edg[i].w);
g[edg[i].from].emplace_back(edg[i].to, edg[i].w);
g[edg[i].to].emplace_back(edg[i].from, edg[i].w);
}
scanf("%d", &k);
for (i = 1; i <= k; ++i) {
scanf("%d", &portal[i]);
}
dijkstra();
for (i = 1; i <= m; ++i) {
edg[i].w = dist[edg[i].from] + edg[i].w + dist[edg[i].to];
edg[i].from = origion[edg[i].from];
edg[i].to = origion[edg[i].to];
}
sort(edg + 1, edg + 1 + m);
printf("%I64d\n", kruskal() + dist[1]);
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
int a[100];
int main() {
long long n, k;
scanf("%lld%lld", &n, &k);
long long m = n, len = 0, res = 0;
int cnt = 1;
while (m) {
len++;
if (m & 1) res++;
a[cnt++] = m % 2;
m = m / 2;
}
cnt = cnt - 1;
if (k != 1)
printf("%lld\n", (long long)pow(2, cnt) - 1);
else
printf("%lld\n", n);
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
long long int a, b, c, d, t, k;
long long int bs(long long int l, long long int r, long long int val) {
if (r == l) {
if (l * (l - 1) / 2 == val) return l;
return -1;
}
if (r - l == 1) {
if (l * (l - 1) / 2 == val)
return l;
else if (r * (r - 1) / 2 == val)
return r;
else
return -1;
}
long long int mid = (l + r) / 2;
if (mid * (mid - 1) / 2 < val)
bs(mid + 1, r, val);
else if (mid * (mid - 1) / 2 == val)
return mid;
else
bs(l, mid - 1, val);
}
int main() {
scanf("%lld%lld%lld%lld", &a, &b, &c, &d);
t = bs(0ll, 1000000000ll, a);
k = bs(0ll, 1000000000ll, d);
if (t == -1 || k == -1) {
printf("Impossible\n");
return 0;
}
if (a != 0 && d != 0) {
if (t * k != b + c) {
printf("Impossible\n");
return 0;
}
}
if (a == 0 && (b || c)) t = 1;
if (d == 0 && (b || c)) k = 1;
if (!a && !b && !c && !d) t = 1;
if (!a && !d && (b || c)) {
t = 1;
k = 1;
}
if (t * k != b + c) {
printf("Impossible\n");
return 0;
}
for (long long int i = k; i >= 1; i--) {
c = b / i;
t -= c;
for (long long int j = 0; j < c; j++) printf("%d", 0);
printf("%d", 1);
b -= c * i;
}
while (t > 0) {
printf("%d", 0);
t--;
}
printf("\n");
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, k;
string x, y;
vector<pair<string, string> > v;
cin >> t;
while (t--) {
k = 0;
cin >> x >> y;
for (int i = 0; i < v.size(); i++) {
if (x == v[i].second) {
v[i].second = y;
k = 1;
break;
}
}
if (k == 0) {
v.push_back(make_pair(x, y));
}
}
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
cout << v[i].first << " " << v[i].second << endl;
}
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
deque<long long> d;
vector<pair<long long, long long> > v;
int main() {
long long n, q, m = 0;
long long a[100001];
cin >> n >> q;
for (long long i = 0; i < n; i++) {
cin >> a[i];
m = max(m, a[i]);
d.push_back(a[i]);
}
long long x = a[0];
v.push_back(make_pair(d[0], d[1]));
while (d[0] != m) {
if (d[0] > d[1]) {
long long w = d[0], e = d[1];
d.pop_front();
d.pop_front();
d.push_back(e);
d.push_front(w);
} else {
long long w = d[0], e = d[1];
d.pop_front();
d.push_back(w);
}
v.push_back(make_pair(d[0], d[1]));
}
for (int i = 0; i < q; i++) {
long long t;
cin >> t;
if (t <= v.size())
cout << v[t - 1].first << " " << v[t - 1].second << endl;
else {
cout << d[0] << " " << d[1 + (t - v.size()) % (n - 1)] << " ";
}
}
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200042, B = 30;
int tab[MAXN], gol[MAXN][32], gor[MAXN][32];
int bigl[MAXN], bigr[MAXN];
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
for (int i = (1); i <= (n); ++i) {
int x;
cin >> x;
tab[i] = x;
}
for (int i = (1); i <= (n); ++i) {
for (int j = (0); j <= (B); ++j) {
if ((1 << j) & tab[i])
gol[i][j] = i;
else
gol[i][j] = gol[i - 1][j];
}
}
for (int j = (0); j <= (B); ++j) gor[n + 1][j] = n + 1;
for (int i = n; i >= 1; i--) {
for (int j = (0); j <= (B); ++j) {
if ((1 << j) & tab[i])
gor[i][j] = i;
else
gor[i][j] = gor[i + 1][j];
}
}
stack<int> S;
for (int i = (1); i <= (n); ++i) {
while (!S.empty() && tab[S.top()] < tab[i]) S.pop();
if (S.empty())
bigl[i] = 0;
else
bigl[i] = S.top();
S.push(i);
}
while (!S.empty()) S.pop();
for (int i = n; i >= 1; i--) {
while (!S.empty() && tab[S.top()] <= tab[i]) S.pop();
if (S.empty())
bigr[i] = n + 1;
else
bigr[i] = S.top();
S.push(i);
}
long long res = 0;
for (int i = (1); i <= (n); ++i) {
int l = bigl[i] + 1, r = bigr[i] - 1;
int lb = 0, rb = n + 1;
for (int b = (0); b <= (B); ++b) {
if (((1 << b) & tab[i]) == 0) lb = max(lb, gol[i][b]);
if (((1 << b) & tab[i]) == 0) rb = min(rb, gor[i][b]);
}
if (lb >= l) res += 1LL * (lb - l + 1) * (r - i + 1);
if (rb <= r) res += 1LL * (r - rb + 1) * (i - l + 1);
if (lb >= l && rb <= r) res -= 1LL * (lb - l + 1) * (r - rb + 1);
}
cout << res << "\n";
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
char a[110][110];
int n, m, i, j, b[110], ans = 0;
bool check() {
int ii, x = j, y = j - 1;
for (ii = 1; ii <= ans; ii++)
if (a[x][b[ii]] > a[y][b[ii]]) return 1;
return a[x][i] >= a[y][i] ? 1 : 0;
}
int main() {
cin >> n >> m;
for (i = 0; i < n; i++) cin >> a[i];
if (n == 1) {
cout << 0;
return 0;
}
for (i = 0; i < m; i++) {
bool t = true;
for (j = 1; j < n; j++) {
if (!check()) {
t = false;
break;
}
}
if (t) b[++ans] = i;
}
cout << (m - ans);
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n <= 2)
cout << 1 << endl << 1 << endl;
else if (n == 3)
cout << 2 << endl << 1 << " " << 3 << endl;
else if (n == 4)
cout << 4 << endl << 3 << " " << 1 << " " << 4 << " " << 2 << endl;
else {
cout << n << endl;
for (int i = 1; i <= n; i += 2) cout << i << " ";
for (int i = 2; i <= n; i += 2) cout << i << " ";
cout << endl;
}
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 101234;
long double fac[MN] = {}, ans = 0;
long double chs(int x, int y) { return fac[y] - fac[x] - fac[y - x]; }
int main() {
for (int i = 1; i < MN; i++) fac[i] = fac[i - 1] + log(i);
int n, m, k, good;
cin >> n >> m >> k;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++)
if ((good = i * n + j * n - i * j) <= k)
ans += exp(chs(i, n) + chs(j, n) + chs(k - good, m - good) - chs(k, m));
cout << setprecision(60) << min((long double)1e99, ans);
}
| 19
|
#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
const int max_n = 50 + 5;
int L[max_n], R[max_n];
const int max_q = 100 + 5;
int t[max_q], l[max_q], r[max_q], v[max_q];
int N, S, T;
const int max_N = 100 + 10;
const int max_M = 5050 + 5;
int End[max_M << 1], Last[max_N], Next[max_M << 1], cap[max_M << 1],
cost[max_M << 1], e = 1;
inline void add_edge(int x, int y, int w, int c) {
End[++e] = y;
Next[e] = Last[x];
Last[x] = e;
cap[e] = w;
cost[e] = c;
End[++e] = x;
Next[e] = Last[y];
Last[y] = e;
cap[e] = 0;
cost[e] = -c;
}
int dis[max_N];
queue<int> q;
bool mark_inq[max_N];
int pre[max_N];
int Flow, Cost;
bool spfa() {
for (int i = 1; i <= N; ++i) dis[i] = 1e9;
dis[S] = 0;
q.push(S);
mark_inq[S] = true;
while (q.size()) {
int x = q.front();
q.pop();
mark_inq[x] = false;
for (int i = Last[x]; i; i = Next[i]) {
int y = End[i];
if (cap[i] > 0 && dis[y] > dis[x] + cost[i]) {
dis[y] = dis[x] + cost[i];
pre[y] = i;
if (!mark_inq[y]) {
q.push(y);
mark_inq[y] = true;
}
}
}
}
if (dis[T] == 1e9) return false;
int flow = 1e9;
for (int x = T; x != S; x = End[pre[x] ^ 1]) flow = min(flow, cap[pre[x]]);
Flow += flow;
Cost += dis[T] * flow;
for (int x = T; x != S; x = End[pre[x] ^ 1]) {
cap[pre[x]] -= flow;
cap[pre[x] ^ 1] += flow;
}
return true;
}
int main() {
int n, q;
cin >> n >> q;
for (int i = 1; i <= q; ++i) cin >> t[i] >> l[i] >> r[i] >> v[i];
for (int i = 1; i <= n; ++i) {
L[i] = 1, R[i] = n;
for (int j = 1; j <= q; ++j) {
if (l[j] <= i && i <= r[j]) {
if (t[j] == 1)
L[i] = max(L[i], v[j]);
else
R[i] = min(R[i], v[j]);
}
}
if (L[i] > R[i]) {
puts("-1");
return 0;
}
}
N = 2 * n + 2;
S = 2 * n + 1;
T = 2 * n + 2;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= (n << 1); j += 2) add_edge(S, i, 1, j);
for (int i = 1; i <= n; ++i)
for (int j = L[i]; j <= R[i]; ++j) add_edge(j, i + n, 1, 0);
for (int i = 1; i <= n; ++i) add_edge(i + n, T, 1, 0);
while (spfa())
;
printf("%d\n", Cost);
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
class TaskA {
public:
void solve(std::istream& in, std::ostream& out) {
ios::sync_with_stdio(false);
int n;
string home, res;
in >> n;
if (n % 2 == 0) {
res = "home";
} else {
res = "contest";
}
out << res << endl;
}
};
int main() {
TaskA solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 1
|
#include <bits/stdc++.h>
#define ll long long int
#define pb push_back
#define ff first
#define sss second
using namespace std;
int main()
{
ll t,n;
cin >> t;
set<ll>s;
for(ll i=1;i<=10000;i++)
{
s.insert(i*i*i);
}
while(t--)
{
cin >> n;
ll f=0;
for(auto x:s)
{
if(s.find(n-x)!=s.end())f=1;
}
if(f==1)cout << "YES" << endl;
else{cout << "NO" << endl;}
}
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<bool> v(n);
int cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int a, b;
cin >> a >> b;
cnt += a || b;
}
}
cout << cnt;
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T abs(T a) {
return ((a < 0) ? -a : a);
}
template <typename T>
inline T sqr(T a) {
return a * a;
}
const int N = 5009;
const int logN = 20;
const int sqrN = 450;
const int MOD = 100000;
const int INF = 1e9;
const long long INF64 = 1e18;
const long double PI = 3.1415926535897932384626433832795;
const long double eps = 1e-9;
int dx[] = {0, 0, -1, 1};
int dy[] = {-1, 1, 0, 0};
pair<int, int> a[N];
bool u[N];
vector<int> v[N];
vector<int> sum;
void add(int x) {
while ((int)(sum.size()) < (int)(v[x].size())) sum.push_back(0);
for (int i = 0; i < (int)((int)(v[x].size())); ++i) sum[i] += v[x][i];
for (int j = 0; j < (int)((int)(sum.size()) - 1); ++j) {
sum[j + 1] += sum[j] / MOD;
sum[j] %= MOD;
}
if (sum[(int)(sum.size()) - 1] >= MOD) {
int j = (int)(sum.size()) - 1;
int d = sum[j] / MOD;
sum[j] %= MOD;
sum.push_back(d);
}
}
void show() {
if ((int)(sum.size()) == 0) {
cout << 0;
return;
}
reverse(sum.begin(), sum.end());
for (int i = 0; i < (int)((int)(sum.size())); ++i)
if (i)
printf("%05d", sum[i]);
else
printf("%d", sum[i]);
}
void calc() {
v[0].push_back(1);
for (int i = 1; i < N; ++i) {
v[i] = v[i - 1];
for (int j = 0; j < (int)((int)(v[i].size())); ++j) v[i][j] *= 2;
for (int j = 0; j < (int)((int)(v[i].size()) - 1); ++j) {
v[i][j + 1] += v[i][j] / MOD;
v[i][j] %= MOD;
}
if (v[i][(int)(v[i].size()) - 1] >= MOD) {
int j = (int)(v[i].size()) - 1;
int d = v[i][j] / MOD;
v[i][j] %= MOD;
v[i].push_back(d);
}
}
}
int main() {
srand(time(NULL));
cout << setprecision(10) << fixed;
cerr << setprecision(10) << fixed;
calc();
int n;
cin >> n;
for (int i = 0; i < (int)(n); ++i) {
string t;
int x;
cin >> t >> x;
if (t == "win")
a[i] = make_pair(1, x);
else
a[i] = make_pair(0, x);
}
for (int x = 2000; x >= 0; --x) {
int pos = -1;
for (int i = 0; i < (int)(n); ++i)
if (a[i].first == 0 && a[i].second == x) pos = i;
if (pos == -1) continue;
for (int i = pos; i >= 0; --i) {
if (u[i]) break;
if (a[i].first == 1 && a[i].second == x) {
for (int j = i; j <= pos; ++j) u[j] = true;
add(x);
break;
}
}
}
show();
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename L>
inline bool smax(T &x, L y) {
return x < y ? (x = y, true) : false;
}
template <typename T, typename L>
inline bool smin(T &x, L y) {
return y < x ? (x = y, true) : false;
}
constexpr int MAXN = 256;
int n;
string s;
set<int> st;
int cnt;
int main() {
cin >> n >> s;
for (int i = 0; i < s.size(); i++) {
set<char> stt;
while (s[i] >= 'a' && s[i] <= 'z') {
stt.insert(s[i]);
i++;
}
smax(cnt, stt.size());
}
return cout << cnt << endl, false;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
void c_p_c() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const long long N = 123456;
vector<long long> graph[N + 1];
long long dist[N + 1];
void dfs(long long src, long long par, long long& maxlen, long long& snode,
set<long long>& s) {
if (s.find(src) != s.end()) {
if (dist[src] > maxlen) {
maxlen = dist[src];
snode = src;
}
if (dist[src] == maxlen && src < snode) snode = src;
}
for (long long nbr : graph[src]) {
if (nbr != par) {
dist[nbr] = dist[src] + 1;
dfs(nbr, src, maxlen, snode, s);
}
}
}
long long dfs2(long long src, long long par, set<long long>& s) {
long long ans = -1;
if (s.find(src) != s.end()) ans = 0;
for (long long nbr : graph[src]) {
if (nbr != par) {
long long subans = dfs2(nbr, src, s);
if (subans == -1)
continue;
else {
if (ans == -1) ans = 0;
ans += subans + 1;
}
}
}
return ans;
}
int32_t main() {
c_p_c();
long long n, m;
cin >> n >> m;
set<long long> s;
for (long long i = 0; i < n - 1; i++) {
long long a, b;
cin >> a >> b;
graph[a].push_back(b);
graph[b].push_back(a);
}
for (long long i = 0; i < m; i++) {
long long a;
cin >> a;
s.insert(a);
}
if (m == 1) {
cout << *(s.begin()) << endl;
cout << 0 << endl;
return 0;
}
long long maxnode = -1;
queue<long long> q;
q.push(*(s.begin()));
vector<bool> visited(n + 1, false);
visited[*(s.begin())] = true;
while (!q.empty()) {
long long src = q.front();
q.pop();
for (long long nbr : graph[src]) {
if (!visited[nbr]) {
if (s.find(nbr) != s.end()) {
maxnode = nbr;
}
visited[nbr] = true;
q.push(nbr);
}
}
}
long long snode = maxnode;
long long maxlen = 0;
dist[snode] = 0;
dfs(maxnode, -1, maxlen, snode, s);
dist[snode] = 0;
dfs(snode, -1, maxlen, snode, s);
cout << snode << endl;
cout << 2 * dfs2(snode, -1, s) - maxlen << endl;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
int ch[100005][26], sz[100005], ed[100005], top;
multiset<int>* se[100005];
void dfs(int u, int d) {
int heavy = -1, mx = 0;
for (int i = 0; i < 26; i++) {
if (ch[u][i] && sz[ch[u][i]] > mx) {
heavy = i;
mx = sz[ch[u][i]];
}
}
if (heavy == -1) {
se[u] = new multiset<int>();
} else {
dfs(ch[u][heavy], d + 1);
se[u] = se[ch[u][heavy]];
}
for (int i = 0; i < 26; i++) {
if (ch[u][i] && i != heavy) {
dfs(ch[u][i], d + 1);
int v = ch[u][i];
se[u]->insert(se[v]->begin(), se[v]->end());
}
}
se[u]->insert(d);
if (!ed[u]) {
auto it = se[u]->end();
--it;
se[u]->erase(it);
}
}
int main(int argc, char* argv[]) {
std::ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<string> a(n);
ed[0] = 1;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
int now = 0;
for (auto c : s) {
int x = c - 'a';
if (!ch[now][x]) {
ch[now][x] = ++top;
}
now = ch[now][x];
sz[now]++;
}
ed[now]++;
}
dfs(0, 0);
int ans = 0;
for (auto x : *se[0]) {
ans += x;
}
cout << ans << endl;
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const int N = 1e6 + 6;
int S;
ll br(int l, int r, vector<ll> &s) {
ll res = 0;
for (int i = l; i <= r; ++i)
for (int j = i; j <= r; ++j)
if (s[i] - s[j + 1] == S) ++res;
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n >> S;
vector<int> t(n);
for (int &i : t) cin >> i;
vector<int> a(n);
for (int &x : a) cin >> x;
for (int i = 0; i < n; ++i)
if (t[i] == 2) a[i] *= -1;
vector<ll> s(n + 1);
for (int i = n - 1; i >= 0; --i) s[i] = s[i + 1] + a[i];
map<ll, int> mid;
int cid = 0;
for (int i = 0; i <= n; ++i)
if (mid.count(s[i]) == 0) mid[s[i]] = ++cid;
vector<int> id(n + 1), id2(n + 1), id3(n + 1);
for (int i = 0; i <= n; ++i) {
id[i] = mid[s[i]];
id2[i] = mid[s[i] + S];
id3[i] = mid[s[i] - S];
}
int m;
cin >> m;
vector<ll> ans(m);
vector<pair<int, int>> q(m);
int K = sqrt(n);
cerr << "K = " << K << endl;
vector<vector<int>> g(n);
for (int i = 0; i < m; ++i) {
int l, r;
cin >> l >> r;
--l;
--r;
q[i] = {l, r};
g[l / K].push_back(i);
}
for (int k = 0; k * K < n; ++k) {
sort((g[k]).begin(), (g[k]).end(),
[&](int i, int j) { return q[i].second < q[j].second; });
vector<int> cnt(cid + 1);
ll cur = 0;
int L = k * K;
int R = L - 1;
cnt[id[R + 1]] = 1;
for (int i : g[k]) {
int l = q[i].first, r = q[i].second;
while (R < r) {
++R;
cur += cnt[id2[R + 1]];
++cnt[id[R + 1]];
}
while (l < L) {
--L;
cur += cnt[id3[L]];
++cnt[id[L]];
}
while (L < l) {
--cnt[id[L]];
cur -= cnt[id3[L]];
++L;
}
ans[i] = cur;
}
}
for (ll res : ans) cout << res << '\n';
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
bool comp(pair<long long, long long> p1, pair<long long, long long> p2) {
return (p1.second != p2.second ? p1.second > p2.second : p1.first > p2.first);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<vector<pair<long long, long long>>> G(n);
while (m--) {
long long a, b, w;
cin >> a >> b >> w;
G[--a].emplace_back(--b, w);
G[b].emplace_back(a, w);
}
priority_queue<
pair<long long, long long>, vector<pair<long long, long long>>,
function<bool(pair<long long, long long>, pair<long long, long long>)>>
pq(comp);
vector<long long> D(n, LLONG_MAX);
D[0] = 0;
vector<int> neighbor(n, -1);
pq.emplace(0, 0);
while (!pq.empty()) {
pair<long long, long long> u = pq.top();
pq.pop();
for (pair<long long, long long> v : G[u.first])
if (D[v.first] > u.second + v.second) {
neighbor[v.first] = u.first;
D[v.first] = u.second + v.second;
pq.emplace(v.first, D[v.first]);
}
}
if (D[n - 1] == LLONG_MAX) {
cout << -1;
return 0;
}
stack<int> output;
int vertex = n - 1;
while (vertex != -1) {
output.push(vertex + 1);
vertex = neighbor[vertex];
}
while (!output.empty()) {
cout << output.top() << ' ';
output.pop();
}
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
stack<char> stk;
char ch;
int fn(char ch) {
if (ch == '<' || ch == '(' || ch == '[' || ch == '{')
return 1;
else
return 0;
}
int main() {
int cnt = 0;
while (scanf("%c", &ch) == 1 && ch != '\n') {
if (stk.empty()) {
stk.push(ch);
} else if (fn(ch) == 1)
stk.push(ch);
else {
if (stk.top() == '<' && ch == '>')
stk.pop();
else if (stk.top() == '(' && ch == ')')
stk.pop();
else if (stk.top() == '{' && ch == '}')
stk.pop();
else if (stk.top() == '[' && ch == ']')
stk.pop();
else if (fn(ch) != fn(stk.top())) {
cnt++;
stk.pop();
} else {
printf("Impossible");
return 0;
}
}
}
if (stk.empty()) {
printf("%d", cnt);
} else {
printf("Impossible");
}
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000;
int a, b;
void input() { cin >> a >> b; }
void solve() {
vector<pair<int, int> > u, v;
for (int i = -N; i <= N; ++i) {
if (!i) continue;
for (int j = 1; j <= N; ++j) {
int k = i * i + j * j;
if (k == a * a) u.push_back(make_pair(i, j));
if (k == b * b) v.push_back(make_pair(i, j));
}
}
for (auto& p : u) {
for (auto& q : v) {
if (p.second == q.second) continue;
if (p.first * q.first + p.second * q.second == 0) {
cout << "YES" << endl
<< 0 << ' ' << 0 << endl
<< p.first << ' ' << p.second << endl
<< q.first << ' ' << q.second << endl;
return;
}
}
}
cout << "NO" << endl;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
input();
solve();
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
template <class T1>
inline void debug(T1 _x) {
cout << _x << '\n';
}
template <class T1, class T2>
inline void debug(T1 _x, T2 _y) {
cout << _x << ' ' << _y << '\n';
}
template <class T1, class T2, class T3>
inline void debug(T1 _x, T2 _y, T3 _z) {
cout << _x << ' ' << _y << ' ' << _z << '\n';
}
template <class T1, class T2, class T3, class T4>
inline void debug(T1 _x, T2 _y, T3 _z, T4 _zz) {
cout << _x << ' ' << _y << ' ' << _z << ' ' << _zz << '\n';
}
template <class T1>
inline void debug(T1 _array, int _size) {
cout << "[";
for (int i = 0; i < _size; ++i) {
cout << ' ' << _array[i];
}
puts(" ]");
}
inline bool CI(int &_x) { return scanf("%d", &_x) == 1; }
inline bool CI(int &_x, int &_y) { return CI(_x) && CI(_y); }
inline bool CI(int &_x, int &_y, int &_z) { return CI(_x) && CI(_y) && CI(_z); }
inline bool CI(int &_x, int &_y, int &_z, int &_zz) {
return CI(_x) && CI(_y) && CI(_z) && CI(_zz);
}
inline void wait(double seconds) {
double endtime = clock() + (seconds * CLOCKS_PER_SEC);
while (clock() < endtime) {
;
}
}
const int inf = (int)1000000;
bitset<inf> used;
int primes[inf];
int cnt;
inline bool isP(int x) {
if (x < 2) return false;
if (x == 2) return true;
if (x % 2 == 0) return false;
return used[x] == false;
}
inline void sieve() {
int sqrtN = (int)sqrt((double)inf) + 1;
used = 0;
int i, j;
for (i = 3; i <= sqrtN; i += 2) {
if (!used[i]) {
for (j = i * i; j < inf; j += i) {
used[j] = 1;
}
}
}
cnt = 0;
primes[cnt++] = 2;
for (i = 3; i < inf; i += 2) {
if (!used[i]) primes[cnt++] = i;
}
}
inline int toI(string _str) {
assert((int)(_str).length());
int var;
sscanf(_str.c_str(), "%d", &var);
return var;
}
inline string toS(int var) {
char _buff[50];
sprintf(_buff, "%d", var);
return (string)_buff;
}
inline void Proc() {
sieve();
int x;
CI(x);
for (int i = 0, j1 = cnt; i < j1; ++i) {
int var = primes[i];
string rvar = toS(var);
reverse(rvar.begin(), rvar.end());
int rr = toI(rvar);
if (isP(rr) && rr != var) {
--x;
}
if (x == 0) {
cout << var;
puts("");
return;
}
}
}
int main() {
int tt = 1;
for (int i = 1, j1 = tt + 1; i < j1; ++i) {
Proc();
}
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
char nt = ':';
cin >> a >> nt >> b;
cin >> c;
if (c >= 60) {
a += c / 60;
b += c % 60;
} else
b += c;
if (b >= 60) {
a += b / 60;
b = b % 60;
}
if (a > 23) a = a % 24;
if (a / 10 == 0 && b / 10 == 0)
cout << "0" << a << ":"
<< "0" << b;
else if (a / 10 == 0 && b / 10 != 0)
cout << "0" << a << ":" << b;
else if (a / 10 != 0 && b / 10 == 0)
cout << a << ":"
<< "0" << b;
else
cout << a << ":" << b;
return 0;
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long k;
long long d[300002];
long long df[300002];
long long c[300002];
int bef[300002];
int aft[300002];
struct SparseMin {
long long sp[20][300002];
void build() {
for (int LOG = 1; LOG < 20; LOG++)
for (int i = 0; i <= n + 1; i++) {
int mid = min(i + (1 << (LOG - 1)), n + 1);
sp[LOG][i] = min(sp[LOG - 1][i], sp[LOG - 1][mid]);
}
}
int lg2(long long x) {
int ret = 0;
while (x != 1) x /= 2, ret++;
return ret;
}
long long get(int a, int b) {
int pw = lg2(b - a + 1);
int mid = b - (1 << pw) + 1;
return min(sp[pw][a], sp[pw][mid]);
}
};
SparseMin pr;
SparseMin su;
long long goLeft(int lo, int hi) { return pr.sp[0][hi] - pr.get(lo - 1, hi); }
long long goRight(int lo, int hi) { return su.sp[0][lo] - su.get(lo, hi + 1); }
long long mxov(int lo, int mid, int hi) {
return max(0LL, goLeft(lo, mid - 1) + goRight(mid, hi));
}
long long sq(long long x) { return x * x; }
int main() {
cout << setprecision(10);
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> d[i] >> c[i], c[i] = k - c[i];
for (int i = 1; i <= n; i++) df[i] = sq(d[i] - d[i - 1]);
for (int i = 1; i <= n; i++) pr.sp[0][i] = c[i] + pr.sp[0][i - 1];
pr.build();
for (int i = n; i >= 1; i--) su.sp[0][i] = c[i] + su.sp[0][i + 1];
su.build();
vector<int> s;
s.push_back(1);
bef[1] = 1;
for (int i = 2; i <= n; i++) {
while (s.size() != 1 && df[s.back()] <= df[i]) s.pop_back();
bef[i] = s.back();
s.push_back(i);
}
s.clear();
s.push_back(n + 1);
for (int i = n; i >= 1; i--) {
while (s.size() != 1 && df[s.back()] <= df[i]) s.pop_back();
aft[i] = s.back() - 1;
s.push_back(i);
}
long long ret = 0;
for (int i = 1; i <= n; i++) ret = max(ret, c[i]);
for (int i = 2; i <= n; i++) ret = max(ret, mxov(bef[i], i, aft[i]) - df[i]);
cout << ret;
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
long long dp[(int)(1e5 + 10)][(1 << 8) + 5];
struct nod {
long long a;
long long s[10];
} mem[(int)(1e5 + 10)];
int cmp(nod x, nod y) { return x.a > y.a; }
int cnt(int n) {
int res = 0;
while (n) {
if (n & 1) res++;
n >>= 1;
}
return res;
}
int main() {
int n, p, k;
scanf("%d%d%d", &n, &p, &k);
for (int i = 0; i < n; i++) scanf("%lld", &mem[i].a);
for (int j = 0; j < n; j++)
for (int i = 0; i < p; i++) scanf("%lld", &mem[j].s[i]);
sort(mem, mem + n, cmp);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 1 << p; j++) {
dp[i][j] = dp[i - 1][j];
if (i - 1 - cnt(j) < k && i - 1 >= cnt(j)) dp[i][j] += mem[i - 1].a;
for (int t = 0; t < p; t++)
if (j >= 1 << t && j & (1 << t))
dp[i][j] = max(dp[i][j], dp[i - 1][j - (1 << t)] + mem[i - 1].s[t]);
}
}
printf("%lld", dp[n][(1 << p) - 1]);
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int solve(int l, int h) {
if (l > h) {
return 0;
}
int mid = (l + h) / 2;
if (h - l + 1 == 2) {
v.push_back(l + 1);
v.push_back(l);
v.push_back(l + 1);
return 3;
}
if (h - l + 1 == 3) {
v.push_back(l + 1);
v.push_back(l);
v.push_back(l + 2);
v.push_back(l + 1);
return 4;
}
int ans = 0;
v.push_back(mid);
ans += 1;
ans += solve(l, mid - 1);
ans += solve(mid + 1, h);
if (mid != l) {
v.push_back(mid);
ans += 1;
}
return ans;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int n;
cin >> n;
int ans = 2 * (n / 2) + ((n / 2) + (n % 2));
cout << ans << endl;
for (int i = 0; i < n; i++) {
if (i & 1) {
cout << i + 1 << " ";
}
}
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
cout << i + 1 << " ";
}
}
for (int i = 0; i < n; i++) {
if (i & 1) {
cout << i + 1 << " ";
}
}
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int dp[2][507][507];
int ct[507], prefix[507];
int main() {
int n, m;
scanf("%d%d", &n, &m);
dp[0][0][0] = 1;
for (int i = 0; i < n; i++) {
memset(dp[(i & 1) ^ 1], 0x00, sizeof(dp[(i & 1) ^ 1]));
for (int j = 0; j <= n; j++)
for (int k = 0; k <= n; k++) {
dp[(i & 1) ^ 1][j + 1][max(k, j + 1)] += dp[i & 1][j][k];
dp[(i & 1) ^ 1][j + 1][max(k, j + 1)] %= 998244353;
dp[(i & 1) ^ 1][1][max(k, 1)] += dp[i & 1][j][k];
dp[(i & 1) ^ 1][1][max(k, 1)] %= 998244353;
}
}
memset(ct, 0x00, sizeof(ct));
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++) {
ct[i] += dp[n & 1][j][i];
ct[i] %= 998244353;
}
memset(prefix, 0x00, sizeof(prefix));
for (int i = 0; i <= n; i++) prefix[i + 1] = (prefix[i] + ct[i]) % 998244353;
int ans = 0;
for (int i = 1; i <= n; i++)
ans = (ans + (ct[i] * (long long int)prefix[min(n, (m - 1) / i) + 1]) %
998244353) %
998244353;
ans = (ans * (long long int)((998244353 + 1) / 2)) % 998244353;
printf("%d\n", ans);
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
static const int INF = 500000000;
template <class T>
void debug(T a, T b) {
for (; a != b; ++a) cerr << *a << ' ';
cerr << endl;
}
int b, d;
string a, c;
int where[105], done[105];
int solve(int len) {
string tmp;
int n = a.size(), m = c.size();
for (int i = 0; i < len; ++i) tmp += a[n - 1 - i % n];
reverse((tmp).begin(), (tmp).end());
int pos = 0;
for (int i = 0; i < tmp.size(); ++i) {
if (c[pos % m] == tmp[i]) ++pos;
}
return pos / m;
}
int main() {
cin >> b >> d >> a >> c;
int n = a.size(), m = c.size();
int pos = 0, cnt = 0;
int able = 0;
while (1) {
for (int i = 0; i < m; ++i) {
int fail = 1;
for (int j = 0; j < n; ++j)
if (a[(pos + j) % n] == c[i]) {
pos += j;
fail = 0;
break;
}
++pos;
if (fail) {
puts("0");
return 0;
}
}
if (pos > a.size() * b) {
able = cnt;
break;
}
if (done[pos % n]) {
for (int j = 0; j < cnt; ++j)
if (where[j] % n == pos % n) {
int tot_len = a.size() * b;
int rest = tot_len - pos;
int block = pos - where[j], how = rest / block;
int worth = cnt - j;
int rest2 = rest % block;
able = solve(rest2) + cnt + 1 + how * worth;
goto exi;
}
}
where[cnt++] = pos;
done[pos % n] = 1;
}
exi:;
printf("%d\n", able / d);
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using ull = unsigned long long;
vector<int> a[1001001];
const ll mod = 1000000007;
int main() {
int n, m;
cin >> n >> m;
int g, h;
for (int i = 0; i < n; ++i) {
cin >> g;
for (int j = 0; j < g; ++j) {
cin >> h;
h--;
a[h].push_back(i);
}
}
sort(a, a + m);
ll ans = 1;
ll cur = 1;
for (int i = 1; i < m; i++) {
if (a[i] == a[i - 1]) {
cur++;
ans = (ans * cur) % mod;
} else {
cur = 1;
}
}
cout << ans << endl;
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
long long d[100005];
long long t[10];
long long gcd(long long a, long long b) {
while (b) {
long long r = a % b;
a = b;
b = r;
}
return a;
}
long long x1[] = {1, 4, 6, 7};
long long x2[] = {2, 4, 5, 7};
long long x3[] = {3, 5, 6, 7};
map<vector<long long>, bool> mp;
int xx[100][100];
int main() {
for (long long i = 1; i <= 100000; ++i)
for (long long j = i; j <= 100000; j += i) d[j]++;
long long n;
cin >> n;
xx[1][1] = 0;
xx[1][2] = 3;
xx[1][3] = 1;
xx[2][1] = 1;
xx[2][2] = 3;
xx[2][3] = 1;
xx[3][1] = 2;
xx[3][2] = 1;
xx[3][3] = 1;
xx[4][1] = 2;
xx[4][2] = 1;
xx[4][3] = 3;
xx[5][1] = 2;
xx[5][2] = 3;
xx[5][3] = 1;
xx[6][1] = 3;
xx[6][2] = 0;
xx[6][3] = 2;
xx[7][1] = 3;
xx[7][2] = 1;
xx[7][3] = 0;
xx[8][1] = 3;
xx[8][2] = 1;
xx[8][3] = 1;
xx[9][1] = 3;
xx[9][2] = 1;
xx[9][3] = 2;
xx[10][1] = 3;
xx[10][2] = 1;
xx[10][3] = 3;
xx[11][1] = 3;
xx[11][2] = 2;
xx[11][3] = 2;
xx[12][1] = 3;
xx[12][2] = 3;
xx[12][3] = 1;
xx[13][1] = 3;
xx[13][2] = 3;
xx[13][3] = 2;
for (long long i = 1; i <= n; ++i) {
long long a, b, c;
cin >> a >> b >> c;
long long abc = gcd(gcd(a, b), c);
long long ab = gcd(a, b);
long long bc = gcd(c, b);
long long ca = gcd(c, a);
long long da = d[a] - d[ab] - d[ca] + d[abc];
long long db = d[b] - d[ab] - d[bc] + d[abc];
long long dc = d[c] - d[bc] - d[ca] + d[abc];
t[1] = da;
t[2] = db;
t[3] = dc;
t[4] = d[ab] - d[abc];
t[5] = d[bc] - d[abc];
t[6] = d[ca] - d[abc];
t[7] = d[abc];
long long ans = 0;
for (long long x = 0; x < 4; ++x)
for (long long y = 0; y < 4; ++y)
for (long long z = 0; z < 4; ++z) {
bool ok = 1;
for (int rr = 1; rr <= 13; ++rr)
if (x == xx[rr][1] && y == xx[rr][2] && z == xx[rr][3]) ok = 0;
if (ok == 1) {
if (x1[x] == x2[y] && x1[x] != x3[z]) {
ans +=
1LL * (t[x1[x]] * (t[x1[x]] - 1) / 2 + t[x1[x]]) * t[x3[z]];
} else if (x1[x] == x3[z] && x1[x] != x2[y]) {
ans +=
1LL * (t[x1[x]] * (t[x1[x]] - 1) / 2 + t[x1[x]]) * t[x2[y]];
} else if (x2[y] == x3[z] && x1[x] != x3[z]) {
ans +=
1LL * (t[x2[y]] * (t[x2[y]] - 1) / 2 + t[x2[y]]) * t[x1[x]];
} else if (x1[x] == x2[y] && x1[x] == x2[y]) {
ans += 1LL * (t[x1[x]] * (t[x1[x]] - 1) * (t[x1[x]] - 2)) / 6;
ans += 1LL * t[x1[x]] * (t[x1[x]] - 1);
ans += t[x1[x]];
} else {
ans += 1LL * t[x1[x]] * t[x2[y]] * t[x3[z]];
}
}
}
cout << ans << '\n';
}
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
long long solve(long long n, int h, bool f) {
if (!h) return 0;
long long ret = 1;
long long total = (1ll << h) - 1, leaf = 1ll << (h - 1);
if (f) {
if (leaf < n) {
ret += total;
ret += solve(n - leaf, h - 1, f);
} else
ret += solve(n, h - 1, !f);
} else {
if (leaf < n) {
ret += solve(n - leaf, h - 1, !f);
} else {
ret += total;
ret += solve(n, h - 1, f);
}
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, h;
cin >> h >> n;
cout << solve(n, h, 1) << endl;
return 0;
}
| 9
|
#include <bits/stdc++.h>
const double PI = 3.141592653589793238460;
using namespace std;
int E[1000001], S[1000001], F[1000001];
int main() {
string st;
int mx = 0;
stack<int> stk;
cin >> st;
for (int i = 0; i < st.size(); i++) {
char ch = st[i];
if (ch == '(') {
stk.push(i);
} else {
if (stk.empty()) {
S[i] = E[i] = -1;
} else {
int idx = stk.top();
stk.pop();
S[i] = E[i] = idx;
if (idx > 0 && st[idx - 1] == ')' && S[idx - 1] >= 0) E[i] = E[idx - 1];
int l = i - E[i] + 1;
F[l]++;
mx = max(mx, l);
}
}
}
F[0] = 1;
cout << mx << " " << F[mx];
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
long long ABS(long long a) {
if (a >= 0) return a;
return -a;
}
struct num {
long long a;
long long mod;
num(long long a) { this->a = a; }
num() {}
num(long long a, long long mod) {
this->a = a % mod;
this->mod = mod;
}
num operator+(const num &o) const { return num((o.a + a) % mod, mod); }
num operator-(const num &o) const { return num((mod - o.a + a) % mod, mod); }
bool operator==(const num &o) const { return a == o.a; }
num operator*(const num &o) const { return num((a * o.a) % mod, mod); }
num operator/(const num &o) const {
num buffer = *this;
return buffer * pow(o, mod - 2);
}
num pow(const num &o, long long n) const {
num ans = num(1, mod);
num buffer = o;
while (n) {
if (!(n & 1)) {
buffer = buffer * buffer;
n >>= 1;
} else {
ans = ans * buffer;
n--;
}
}
return ans;
}
};
bool check(long long p) {
long long edge = pow(p, .5);
for (long long i = 2; i <= edge; i++)
if (!(p % i)) return false;
return true;
}
long long generate(long long range) {
while (true) {
if (check(range)) return range;
range++;
}
}
int main() {
long long p, q, n;
vector<long long> mas;
cin >> p >> q >> n;
mas.resize(n);
for (int i = 0; i < n; i++) cin >> mas[i];
reverse(mas.begin(), mas.end());
long long range = 1e+8;
for (int j = 0; j < 100; j++) {
long long mod = generate(range);
range = mod + 1;
if (q % mod == 0) continue;
num left = num(p, mod) / num(q, mod);
num right = num(0, mod);
bool ok = true;
for (int i = 0; i < mas.size(); i++) {
right = right + num(mas[i], mod);
if (i != mas.size() - 1) {
if (right.a == 0) {
ok = false;
break;
}
right = num(1, mod) / right;
}
}
if (ok)
if (!(left == right)) {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
| 9
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.