solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
char ch;
while (cin >> n >> ch) {
long long tim = 0;
long long sta;
long long cis = ((n - 1) / 4) * 2 + (n + 1) % 2;
long long loa = (n - 1) / 2;
if (loa % 2 == 0)
sta = 1;
else
sta = 3;
tim += n - sta;
tim += cis * 6;
if (ch == 'f')
tim += 1;
else if (ch == 'e')
tim += 2;
else if (ch == 'd')
tim += 3;
else if (ch == 'a')
tim += 4;
else if (ch == 'b')
tim += 5;
else if (ch == 'c')
tim += 6;
cout << tim << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void init() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
}
long long a, b, c, ans;
void solveIn2(long long p, long long q, long long r, long long turns) {}
int main() {
init();
long long cases;
cin >> cases;
for (long long testCase = 1; testCase <= cases; testCase++) {
long long n, m;
cin >> n >> m;
long long mat[n][m];
set<long long> row, col;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> mat[i][j];
if (mat[i][j]) {
row.insert(i);
col.insert(j);
}
}
}
long long ans = min(n - row.size(), m - col.size());
if (ans & 1)
cout << "Ashish" << '\n';
else
cout << "Vivek" << '\n';
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T& x) {
bool fu = 0;
char c;
for (c = getchar(); c <= 32; c = getchar())
;
if (c == '-') fu = 1, c = getchar();
for (x = 0; c > 32; c = getchar()) x = x * 10 + c - '0';
if (fu) x = -x;
};
template <class T>
inline void read(T& x, T& y) {
read(x);
read(y);
}
template <class T>
inline void read(T& x, T& y, T& z) {
read(x);
read(y);
read(z);
}
inline char getc() {
char c;
for (c = getchar(); c <= 32; c = getchar())
;
return c;
}
int n, i, j, k, mod;
long long x, y, p, q, ss, res, tt;
long long a[1000010];
long long pow(long long a, long long b, long long c) {
long long ans = 1;
for (a %= c; b; b >>= 1, a = a * a % c)
if (b & 1) ans = ans * a % c;
return ans;
}
long long fac[1111111];
long long C(long long a, long long b) {
return fac[a] * pow(fac[b], mod - 2, mod) % mod *
pow(fac[a - b], mod - 2, mod) % mod;
}
struct mat {
long long s[2][2];
} G, E, T;
mat operator+(mat a, mat b) {
mat c;
int i, j;
for (i = 0; i <= 1; i++)
for (j = 0; j <= 1; j++) c.s[i][j] = (a.s[i][j] + b.s[i][j]) % mod;
return c;
}
mat operator*(mat a, mat b) {
mat c;
int i, j, k;
for (i = 0; i <= 1; i++)
for (j = 0; j <= 1; j++) {
c.s[i][j] = 0;
for (k = 0; k <= 1; k++)
c.s[i][j] = (c.s[i][j] + 1LL * a.s[i][k] * b.s[k][j]) % mod;
}
return c;
}
mat operator^(mat a, long long x) {
mat ans = E;
for (; x; x >>= 1, a = a * a)
if (x & 1) ans = ans * a;
return ans;
}
long long A, B;
void get(long long n) {
G.s[0][0] = G.s[0][1] = G.s[1][0] = 1;
E.s[0][0] = E.s[1][1] = 1;
G = G ^ n;
A = G.s[0][0];
B = G.s[0][1];
}
long long th(long long n) {
long long t = pow(3, n, 2 * mod) + 1;
t /= 2;
return t % mod;
}
int main() {
read(n);
read(p, q);
read(mod);
for (i = 1; i <= n; i++) read(a[i]), ss += a[i];
ss %= mod;
if (n == 1) {
cout << a[1] % mod << endl;
return 0;
}
res = (ss - a[1] - a[n]) * pow(3, p, mod) + (a[1] + a[n]) * th(p);
res %= mod;
get(p);
long long a0 = a[1] % mod, b0 = (A * a[n] + B * a[n - 1]) % mod;
res = (res - a0 - b0) % mod * pow(3, q, mod) + th(q) * (a0 + b0);
res %= mod;
if (res < 0) res += mod;
cout << res << endl;
scanf("\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
long double T;
cin >> n >> T;
vector<pair<long double, long double> > tap(n);
long double sum = 0;
for (int i = 0; i < n; ++i) {
cin >> tap[i].second;
sum += tap[i].second;
}
for (int i = 0; i < n; ++i) {
cin >> tap[i].first;
}
sort(tap.begin(), tap.end());
long double left = 0, right = sum;
while ((right - left) / max(left, (long double)1.0) > 1e-8) {
long double mid = (right + left) / 2;
long double want = T * mid;
long double bigT = 0, smallT = 0, bigSum = mid, smallSum = mid;
for (int i = 0; i < n; ++i) {
if (bigSum < tap[i].second) {
bigT = bigT + bigSum * tap[i].first;
bigSum = 0;
} else {
bigT = bigT + tap[i].first * tap[i].second;
bigSum = bigSum - tap[i].second;
}
}
for (int i = n - 1; i >= 0; --i) {
if (smallSum < tap[i].second) {
smallT += smallSum * tap[i].first;
smallSum = 0;
} else {
smallSum -= tap[i].second;
smallT += tap[i].first * tap[i].second;
}
}
if (bigT <= want && smallT >= want)
left = mid;
else
right = mid;
}
cout << fixed << setprecision(9) << (left + right) / 2 << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long a[505];
int main() {
int n;
scanf("%d", &n);
long long value = 0;
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
if (n >= 3) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j) continue;
for (int k = 1; k <= n; k++) {
if (i == k || j == k) continue;
if (value < ((a[i] | a[j]) | a[k])) value = (a[i] | a[j]) | a[k];
}
}
}
printf("%lld", value);
} else {
if (n == 1)
printf("%lld\n", a[1]);
else
printf("%lld\n", a[1] | a[2]);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
set<string> st;
vector<string> ans;
int n;
string k;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> k;
if (st.count(k) == 1) {
ans.push_back("YES");
} else {
ans.push_back("NO");
}
st.insert(k);
}
for (int i = 0; i < n; i++) {
cout << ans[i] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char c = getchar();
int x = 0, f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
const int MOD = 1e9 + 7;
const double eps = 1e-5;
const int INF = 0x3f3f3f3f;
const long long INFLL = 0x7f7f7f7f;
int gcd(int a, int b) { return (a % b == 0) ? b : gcd(b, a % b); }
long long gcd(long long a, long long b) {
return (a % b == 0) ? b : gcd(b, a % b);
}
int lowbit(int x) { return x & -x; }
const int N1 = 1005;
const int N = 1e5 + 5;
vector<int> vt;
int solve(vector<int> a, int now) {
if (now == -1 || a.size() == 0) return 0;
vector<int> a0, a1;
for (int i = 0; i < a.size(); ++i) {
if (a[i] & (1 << now))
a1.push_back(a[i]);
else
a0.push_back(a[i]);
}
if (a0.size() == 0) return solve(a1, now - 1);
if (a1.size() == 0)
return solve(a0, now - 1);
else
return (min(solve(a0, now - 1), solve(a1, now - 1)) | (1 << now));
}
int main() {
int n;
scanf("%d", &n);
int x;
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
vt.push_back(x);
}
int ans = solve(vt, 30);
printf("%d", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int const N = 500000;
int x[N + 1];
pair<int, int> p[N + 1];
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq;
void solve() {
int n;
scanf("%d", &n);
for (int i = 1; i < (int)(n + 1); ++i) p[i] = make_pair(0, 0);
vector<int> z;
for (int i = 1; i < (int)(n + 1); ++i) {
scanf("%d", x + i);
if (x[i] == 0) z.push_back(i);
}
int zs = z.size(), m = zs >> 1, t = 0;
if (m == 0) {
printf("0\n");
return;
}
for (int i = 1; i < (int)(z[m - 1]); ++i)
if (x[i] == 0)
++t;
else
p[x[i]].first = t;
t = 0;
for (int i = n; i > z[zs - m]; --i)
if (x[i] == 0)
++t;
else
p[x[i]].second = t;
for (int i = z[m - 1]; i < (int)(z[zs - m]); ++i) p[x[i]] = make_pair(-1, -1);
vector<int> l;
for (int i = 1; i < (int)(n + 1); ++i)
if (p[i].first > 0) l.push_back(i);
sort(l.begin(), l.end(),
[](int a, int b) { return p[a].first > p[b].first; });
int j = 0, an = 0;
while (!pq.empty()) pq.pop();
for (int i = m - 1; i > 0; --i) {
while (j < l.size() && p[l[j]].first == i) {
pq.push(make_pair(p[l[j]].second, l[j]));
++j;
}
if (!pq.empty()) {
++an;
p[pq.top().second].second = 0;
pq.pop();
}
}
l.clear();
for (int i = 1; i < (int)(n + 1); ++i)
if (p[i].second > 0) l.push_back(i);
sort(l.begin(), l.end(),
[](int a, int b) { return p[a].second > p[b].second; });
j = 0;
int s = 0;
for (int i = m - 1; i > 0; --i) {
while (j < l.size() && p[l[j]].second == i) ++s, ++j;
if (s) --s, ++an;
}
for (int i = 1; i < (int)(n + 1); ++i)
if (p[i].first == -1) ++an;
printf("%d\n", min(an, m));
}
int main() {
int t;
scanf("%d", &t);
while (t--) solve();
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const bool debug = 0;
struct trio {
int a, b, c;
trio(int a, int b, int c) : a(a), b(b), c(c) {}
};
int main() {
if (!debug) {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(0);
}
int n;
cin >> n;
vector<int> first(n);
for (int i = 0; i < n; i++) cin >> first[i];
int h = -1;
if (first.size() % 2 == 0) {
h = first.back();
first.pop_back();
n--;
}
vector<trio> out;
for (int i = 0; i < n - 1; i += 2) {
out.push_back({i + 1, i + 2, i + 3});
first[i] = first[i + 1] = first[i + 2] =
first[i] ^ first[i + 1] ^ first[i + 2];
}
for (int i = 0; i < n - 3; i += 2) {
out.push_back({i + 1, i + 2, n});
first[i] = first[i + 1] = first[i + 2] =
first[i] ^ first[i + 1] ^ first[i + 2];
}
if (h == -1 || h == first.back()) {
cout << "YES\n";
cout << out.size() << '\n';
for (int i = 0; i < out.size(); i++)
cout << out[i].a << ' ' << out[i].b << ' ' << out[i].c << '\n';
} else
cout << "NO";
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1073741824")
using namespace std;
const int nmax = 110;
int a[nmax][nmax];
int sumr[nmax], sumc[nmax];
bool c[nmax];
bool r[nmax];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int(i) = 0; (i) < (n); ++(i))
for (int(j) = 0; (j) < (m); ++(j)) scanf("%d", &a[i][j]);
bool good = false;
for (int(i) = 0; (i) < (n); ++(i)) {
sumr[i] = 0;
for (int(j) = 0; (j) < (m); ++(j)) {
sumr[i] += a[i][j];
}
}
while (!good) {
for (int(i) = 0; (i) < (n); ++(i))
if (sumr[i] < 0) {
r[i] ^= 1;
for (int(j) = 0; (j) < (m); ++(j)) a[i][j] = -a[i][j];
}
for (int(j) = 0; (j) < (m); ++(j)) {
sumc[j] = 0;
for (int(i) = 0; (i) < (n); ++(i)) {
sumc[j] += a[i][j];
}
}
for (int(j) = 0; (j) < (m); ++(j))
if (sumc[j] < 0) {
c[j] ^= 1;
for (int(i) = 0; (i) < (n); ++(i)) a[i][j] = -a[i][j];
}
for (int(i) = 0; (i) < (n); ++(i)) {
sumr[i] = 0;
for (int(j) = 0; (j) < (m); ++(j)) {
sumr[i] += a[i][j];
}
}
good = true;
for (int(i) = 0; (i) < (n); ++(i))
if (sumr[i] < 0) good = false;
}
int aa = 0;
for (int(i) = 0; (i) < (n); ++(i))
if (r[i]) ++aa;
cout << aa;
for (int(i) = 0; (i) < (n); ++(i))
if (r[i]) cout << " " << i + 1;
cout << endl;
aa = 0;
for (int(i) = 0; (i) < (m); ++(i))
if (c[i]) ++aa;
cout << aa;
for (int(i) = 0; (i) < (m); ++(i))
if (c[i]) cout << " " << i + 1;
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, c = 0;
cin >> n;
c += n / 100;
n = n % 100;
c += n / 20;
n = n % 20;
c += n / 10;
n = n % 10;
c += n / 5;
n = n % 5;
c += n / 1;
cout << c;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1003;
const int M = (1 << 8);
int dp[N][M];
int n;
int g[N], cur[8];
vector<int> v[8];
int ok(int m) {
memset((cur), (0), sizeof(cur));
memset((dp), (-1), sizeof(dp));
dp[0][0] = 0;
for (int i = (int)0; i < (int)n; ++i) {
for (int j = (int)0; j < (int)M; ++j)
if (dp[i][j] != -1) {
for (int k = (int)0; k < (int)8; ++k)
if (!((1 << k) & j)) {
int x = m + cur[k] - 1, y, z;
if (x >= ((int)(v[k]).size())) continue;
y = v[k][x];
z = j | (1 << k);
dp[y][z] = max(dp[y][z], dp[i][j]);
if (++x >= ((int)(v[k]).size())) continue;
y = v[k][x];
dp[y][z] = max(dp[y][z], dp[i][j] + 1);
}
}
++cur[g[i]];
}
int x = -1;
for (int i = (int)0; i < (int)n; ++i) x = max(x, dp[i][M - 1]);
return x == -1 ? x : m * 8 + x;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = (int)0; i < (int)n; ++i) {
cin >> g[i];
v[--g[i]].push_back(i);
}
int l = 1, r = (n >> 3) + 1, m;
int res = 0, x;
while (l + 1 <= r) {
m = (l + r) >> 1;
if ((x = ok(m)) != -1) {
l = m + 1;
res = max(res, x);
} else
r = m;
}
if (res == 0)
for (int i = (int)0; i < (int)8; ++i)
if (!v[i].empty()) ++res;
cout << res;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int N;
vector<int> edges[500000];
int mx[500000];
map<int, int> dp[500000];
int dfs(int i, int par) {
for (int j : edges[i])
if (j != par) {
int res = dfs(j, i);
dp[i][res]++;
}
if (dp[i].size()) mx[i] = dp[i].rbegin()->first;
return mx[i] + 1;
}
void chmax(int& a, int b) { a = max(a, b); }
int ans[500010], ans2[500010];
void dfs2(int i, int par) {
int sum = 0;
for (auto it = dp[i].rbegin(); it != dp[i].rend(); it++) {
int mn = it->first, s = it->second;
if (sum + 1 >= 2) chmax(ans[2 * mn + 1], sum + 1);
if (sum + s >= 2) chmax(ans[2 * mn], sum + s);
sum += s;
}
for (int j : edges[i])
if (j != par) {
int del = mx[j] + 1;
dp[i][del]--;
if (dp[i][del] == 0) dp[i].erase(del);
for (auto& p : dp[j]) dp[i][p.first] += p.second;
int sum = 0;
for (auto it = dp[i].rbegin(); it != dp[i].rend(); it++) {
int mn = it->first, s = it->second;
sum += s;
if (sum >= 2) {
int x = 2 * mn;
chmax(ans2[x], sum);
}
}
for (auto& p : dp[j]) {
dp[i][p.first] -= p.second;
if (dp[i][p.first] == 0) dp[i].erase(p.first);
}
int u = 1;
if (dp[i].size()) u += dp[i].rbegin()->first;
dp[j][u]++;
dfs2(j, i);
dp[i][del]++;
}
}
int main() {
cin >> N;
for (int i = 0; i < N - 1; i++) {
int a, b;
scanf("%d %d", &a, &b);
edges[a - 1].push_back(b - 1);
edges[b - 1].push_back(a - 1);
}
for (int i = 0; i < N; i++) chmax(ans[1], 1 + edges[i].size());
ans[N] = 1;
dfs(0, -1);
dfs2(0, -1);
for (int i = N - 1; i > 0; i--) chmax(ans[i], ans[i + 1]);
for (int i = N / 2 * 2; i > 0; i -= 2) chmax(ans2[i], ans2[i + 2]);
for (int i = 1; i <= N; i++)
printf("%d%c", max(ans[i], ans2[i]), " \n"[i == N]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5005;
const int inf = 0x3f3f3f3f;
int m, n, d;
int f[maxn][maxn], pre[maxn][maxn], mx;
int head[maxn], nxt[maxn], to[maxn], tot, w[maxn];
int rudu[maxn];
vector<int> q;
stack<int> path;
void addedge(int v, int u, int z) {
tot++;
nxt[tot] = head[v];
w[tot] = z;
head[v] = tot;
to[tot] = u;
}
void topo() {
queue<int> p;
for (int i = 1; i <= n; i++) {
if (rudu[i] == 0) {
p.push(i);
}
}
while (!p.empty()) {
int tmp = p.front();
p.pop();
q.push_back(tmp);
for (int i = head[tmp]; i; i = nxt[i]) {
if (--rudu[to[i]] == 0) {
p.push(to[i]);
}
}
}
}
int main() {
memset(f, 0x3f, sizeof(f));
memset(pre, -1, sizeof(pre));
cin >> n >> m >> d;
for (int i = 1; i <= m; i++) {
int v, u, z;
cin >> v >> u >> z;
addedge(v, u, z);
rudu[u]++;
}
topo();
f[1][1] = 0;
for (int k = 0; k < q.size(); k++) {
int t = q[k];
for (int i = head[t]; i; i = nxt[i]) {
for (int j = 2; j <= n; j++) {
if (w[i] + f[t][j - 1] < f[to[i]][j]) {
f[to[i]][j] = w[i] + f[t][j - 1];
pre[to[i]][j] = t;
}
}
}
}
for (int i = n; i >= 1; i--) {
if (f[n][i] <= d) {
mx = i;
break;
}
}
cout << mx << endl;
int pos = n, dep = mx;
while (pos != -1) {
path.push(pos);
pos = pre[pos][dep];
dep--;
}
while (!path.empty()) {
cout << path.top() << ' ';
path.pop();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int inch = n / 3 + (n % 3 == 2 ? 1 : 0);
printf("%d %d", inch / 12, inch % 12);
exit(EXIT_SUCCESS);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%i%i", &n, &k);
int m;
m = n / 2;
bool flag = m == 0 && k >= 1;
if (k < m || flag) {
printf("-1");
} else {
if (k == m) {
for (int i = 0; i < n; i++) {
int aux = i + 1;
printf("%i ", aux);
}
} else {
int z = k - m;
z++;
printf("%i ", z);
z = z * 2;
printf("%i ", z);
for (int i = 2; i < n; i++) {
z++;
printf("%i ", z);
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long arr[300000];
int main() {
long long n, a, i, sum, ans;
while (scanf("%I64d%I64d", &n, &a) != EOF) {
sum = 0;
for (i = 0; i < n; i++) {
scanf("%I64d", &arr[i]);
sum += arr[i];
}
for (i = 0; i < n - 1; i++) {
ans = 0;
if (sum - arr[i] < a) ans += a - sum + arr[i] - 1;
if (a < arr[i] + n - 1) ans += arr[i] - a + n - 1;
printf("%I64d ", ans);
}
ans = 0;
if (sum - arr[n - 1] < a) ans += a - sum + arr[n - 1] - 1;
if (a < arr[n - 1] + n - 1) ans += arr[n - 1] - a + n - 1;
printf("%I64d\n", ans);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const long long INFL = LLONG_MAX;
const long double pi = acos(-1);
long long N, Q, size[100100], P[100100];
vector<int> adj[100100];
int A[100100];
int B[100100];
long long L[100100];
int dfs(int u, int p) {
P[u] = p;
size[u] = 1;
for (int(i) = 0, j123 = adj[u].size(); (i) < j123; (i)++) {
int v = adj[u][i];
if (v == p) continue;
dfs(v, u);
size[u] += size[v];
}
return size[u];
}
int main() {
ios_base::sync_with_stdio(0);
cout.precision(10);
cout << fixed;
cout.tie(0);
cin >> N;
for (int(i) = 1, j123 = N - 1; (i) <= j123; (i)++) {
int a, b, l;
cin >> A[i] >> B[i] >> L[i];
adj[A[i]].push_back(B[i]);
adj[B[i]].push_back(A[i]);
}
dfs(1, -1);
for (int(i) = 1, j123 = N - 1; (i) <= j123; (i)++) {
if (P[B[i]] == A[i]) swap(A[i], B[i]);
}
long double answer = 0;
for (int(i) = 1, j123 = N - 1; (i) <= j123; (i)++)
answer += 1LL * size[A[i]] * (N - size[A[i]]) * L[i];
cin >> Q;
for (int(i) = 1, j123 = Q; (i) <= j123; (i)++) {
long long r, w;
cin >> r >> w;
long long diff = L[r] - w;
L[r] = w;
answer -= 1LL * size[A[r]] * (N - size[A[r]]) * diff;
cout << 6 * answer / N / (N - 1) << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int cl[5000010], cr[5000010], ld[5000010], sl = 1;
bool yz[5000010];
void pushd(int x) {
if (cl[x] == 0) {
cl[x] = ++sl;
yz[cl[x]] = 1;
}
if (cr[x] == 0) {
cr[x] = ++sl;
yz[cr[x]] = 1;
}
yz[x] = 0;
if (ld[x] == 0) return;
ld[cl[x]] = ld[cr[x]] = ld[x];
ld[x] = 0;
}
vector<int> cf[50010], ve[5000010];
void addqj(int i, long long l, long long r, long long L, long long R, int x) {
if (R <= l || r <= L) return;
if (L <= l && r <= R) {
ld[i] = x;
cf[x].push_back(i);
return;
}
long long m = (l + r) >> 1;
pushd(i);
addqj(cl[i], l, m, L, R, x);
addqj(cr[i], m, r, L, R, x);
}
void link(int x, int y) {
if (yz[x] && yz[y]) {
if (ld[x] < ld[y])
ve[x].push_back(y);
else
ve[y].push_back(x);
return;
}
link(yz[x] ? x : cl[x], yz[y] ? y : cl[y]);
link(yz[x] ? x : cr[x], yz[y] ? y : cr[y]);
}
int find(int i, long long l, long long r, long long x) {
if (yz[i]) return i;
long long m = (l + r) >> 1;
return x < m ? find(cl[i], l, m, x) : find(cr[i], m, r, x);
}
int lx[50010], fa[5000010], ans[50010];
long long A[50010], B[50010];
int getv(int x) { return x == fa[x] ? x : fa[x] = getv(fa[x]); }
void merge(int x, int y) {
x = getv(x);
y = getv(y);
if (x != y) fa[x] = y;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
ld[1] = m + 1;
yz[1] = 1;
for (int i = 1; i <= m; i++) {
char zf[10];
scanf("%s%lld%lld", zf, &A[i], &B[i]);
lx[i] = zf[0] == 'b' ? 0 : 1;
if (lx[i] == 0) addqj(1, 0, (1ll << n), A[i], B[i] + 1, i);
}
for (int i = 1; i <= sl; i++) {
fa[i] = i;
if (!yz[i]) link(cl[i], cr[i]);
}
for (int i = 1; i <= sl; i++) {
if (ld[i] != m + 1) continue;
for (int j = 0; j < ve[i].size(); j++) merge(i, ve[i][j]);
}
for (int i = m; i >= 1; i--) {
if (lx[i])
ans[i] = (getv(find(1, 0, (1ll << n), A[i])) ==
getv(find(1, 0, (1ll << n), B[i])));
else {
for (int x = 0; x < cf[i].size(); x++) {
int u = cf[i][x];
for (int y = 0; y < ve[u].size(); y++) merge(u, ve[u][y]);
}
}
}
for (int i = 1; i <= m; i++) {
if (lx[i]) printf("%d\n", ans[i]);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
long long const M1 = 999999937;
long long const M2 = 104857601;
long long const X = 33533;
void sort(long long* a, long long* b) {
if (a + 1 >= b) return;
long long* i = a;
long long* j = b - 1;
long long x = a[(b - a) * 2 / 7];
while (i <= j) {
while (*i < x) ++i;
while (*j > x) --j;
if (i <= j) {
long long tmp = *i;
*i = *j;
*j = tmp;
++i;
--j;
}
}
sort(a, j + 1);
sort(i, b);
}
long long h[555555];
int s[555555];
int main() {
int n, m;
scanf("%d%d", &n, &m);
int i;
for (i = 0; i < n; i++) {
int c = getchar();
while (c <= 32) c = getchar();
long long h1 = 0;
long long h2 = 0;
while (c > 32) {
h1 = (h1 * X + c) % M1;
h2 = (h2 * X + c) % M2;
c = getchar();
}
h[i] = (h1 << 32) | h2;
}
sort(h, h + n);
for (i = 0; i + 1 < n; i++)
if (h[i] > h[i + 1]) {
puts("bad");
return 1;
}
for (i = 0; i < m; i++) {
int c = getchar();
while (c <= 32) c = getchar();
int len = 0;
long long h1 = 0;
long long h2 = 0;
while (c > 32) {
h1 = (h1 * X + c) % M1;
h2 = (h2 * X + c) % M2;
s[len++] = c;
c = getchar();
}
int j;
long long p1 = 1;
long long p2 = 1;
int ans = 0;
for (j = len - 1; j >= 0; j--) {
int let;
for (let = 'a'; let <= 'c'; let++) {
if (let == s[j]) continue;
long long ch1 = (h1 + p1 * (let - s[j]) + M1 * M1) % M1;
long long ch2 = (h2 + p2 * (let - s[j]) + M2 * M2) % M2;
long long ch = (ch1 << 32) | ch2;
int l = -1;
int r = n;
while (l < r - 1) {
int mid = (l + r) / 2;
if (h[mid] > ch)
r = mid;
else
l = mid;
}
if (l >= 0 && h[l] == ch) {
ans = 1;
j = -1;
break;
}
}
p1 = p1 * X % M1;
p2 = p2 * X % M2;
}
if (ans)
puts("YES");
else
puts("NO");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%d %d", &n, &k);
long long ans = 0;
for (int i = (0); i < (k); ++i) {
int m;
scanf("%d", &m);
int ant, l = 1;
scanf("%d", &ant);
bool ok = false;
if (ant == 1) ok = true;
for (int j = (0); j < (m - 1); ++j) {
int x;
scanf("%d", &x);
if (x == ant + 1) {
++l;
ant = x;
}
}
if (ok)
ans += 2 * (m - l) + 1;
else
ans += 2 * (m - 1) + 1;
}
cout << ans - 1 << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
if (n == 1) {
cout << a[0];
return 0;
}
sort(a, a + n);
long long t = (log2(n) / 2) + 1, ct = 1, ans = 0;
for (long long i = n - 1; i >= 0; i--) {
if (ct > 0) {
ans += a[i] * t;
ct--;
}
if (ct == 0) {
t--;
ct = 3 * (n - i);
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 16;
int n, m;
int d[2][N];
int get_n(int x, int n) {
int tmp = 3 << (n * 2);
tmp = x & tmp;
tmp >>= n * 2;
return tmp;
}
int set_n(int x, int n, int y) {
int tmp = 3 << (n * 2);
x = x & (~tmp);
y <<= (n * 2);
x |= y;
return x;
}
void update(int &x, int y) {
if (x == -1 || x < y) x = y;
}
int solve() {
int i, j, k;
int t = 0;
memset(d, -1, sizeof(d));
d[0][0] = 0;
int tot = 1 << (n * 2 + 2);
for (i = 0; i < m; ++i) {
for (j = 0; j < n; ++j) {
memset(d[1 - t], -1, sizeof(d[1 - t]));
for (k = 0; k < tot; ++k) {
if (d[t][k] == -1) continue;
int t0 = get_n(k, j);
int t1 = get_n(k, j + 1);
int st = set_n(k, j, 1);
st = set_n(st, j + 1, 1);
update(d[1 - t][st], d[t][k]);
if (t0 > 0) {
st = set_n(k, j - 1, 2);
st = set_n(st, j, 0);
st = set_n(st, j + 1, 0);
update(d[1 - t][st], d[t][k] + 1);
if (t0 == 1) {
st = set_n(k, j - 1, 0);
st = set_n(st, j, 2);
st = set_n(st, j + 1, 2);
update(d[1 - t][st], d[t][k] + 1);
}
}
if (t1 > 0) {
st = set_n(k, j, 0);
st = set_n(st, j + 1, 0);
update(d[1 - t][st], d[t][k] + 1);
if (t1 == 1) {
st = set_n(k, j, 2);
st = set_n(st, j + 1, 2);
update(d[1 - t][st], d[t][k] + 1);
}
}
if (t0 == 1 && t1 == 1) {
st = set_n(k, j - 1, 0);
st = set_n(st, j, 2);
st = set_n(st, j + 1, 2);
update(d[1 - t][st], d[t][k] + 2);
}
}
t = 1 - t;
}
memset(d[1 - t], -1, sizeof(d[1 - t]));
for (k = 0; k < tot; ++k) {
int st = set_n(k, n, 0);
st <<= 2;
update(d[1 - t][st], d[t][k]);
}
t = 1 - t;
}
int ans = -1;
for (k = 0; k < tot; ++k) {
update(ans, d[t][k]);
}
return ans;
}
int main() {
int i, j, k, t, nc = 0;
while (scanf("%d%d", &n, &m) != EOF) {
if (n > m) swap(n, m);
int ans = solve();
printf("%d\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[300007];
long long pref[300007];
long long fastpow(long long x, long long pw) {
long long ret = 1;
while (pw > 0) {
if ((pw % 2) == 0) {
x = (x * x) % 998244353;
pw /= 2;
} else {
ret = (ret * x) % 998244353;
--pw;
}
}
return ret;
}
void input() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; ++i) {
pref[i] = (pref[i - 1] + a[i]) % 998244353;
}
}
void solve() {
long long inv = fastpow(n, 998244353 - 2);
for (int i = 1; i <= n; ++i) {
int en = n - i;
long long ans = 0;
long long aux = 1;
while (en >= i) {
ans += (pref[en] - pref[en - i]) * (aux++);
ans %= 998244353;
en -= i;
}
ans += pref[en] * aux;
ans %= 998244353;
ans = (ans * inv) % 998244353;
cout << ans << " ";
}
cout << "\n";
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
input();
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
int ans = 0;
int for2 = b;
b *= 2;
while (n--) {
int k;
cin >> k;
if (k == 1) {
if (a)
a--;
else if (for2)
for2--, b--;
else if (b)
b--;
else
ans++;
} else {
if (for2)
for2--, b -= 2;
else
ans += 2;
}
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105;
int n, mid[MAXN];
int main(int argc, char const *argv[]) {
cin >> n;
int k = 0, sumCiel = 0, sumJiro = 0;
for (int i = 0; i < n; i++) {
int len;
cin >> len;
int temp;
for (int i = 0; i < len; i++) {
cin >> temp;
if (i < len / 2)
sumCiel += temp;
else if (len % 2 && i == len / 2)
mid[k++] = temp;
else
sumJiro += temp;
}
}
sort(mid, mid + k);
for (int i = k - 1; i >= 0; i--) {
if ((k - i) % 2)
sumCiel += mid[i];
else
sumJiro += mid[i];
}
cout << sumCiel << ' ' << sumJiro << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
set<int> AdjList[200001];
int nChild[200001];
int d[200001];
int p[200001];
int d_x;
int cur_sz = 0;
int lim;
void cal_d(int u, int par) {
for (set<int>::iterator it = AdjList[u].begin(); it != AdjList[u].end();
it++) {
int v = *it;
if (v != par) {
p[v] = u;
d[v] = d[u] + 1;
cal_d(v, u);
}
}
}
void cal_sz(int u, int par) {
cur_sz++;
nChild[u] = 1;
for (set<int>::iterator it = AdjList[u].begin(); it != AdjList[u].end();
it++) {
int v = *it;
if (v != par) {
cal_sz(v, u);
nChild[u] += nChild[v];
}
}
}
int find_c(int u, int par) {
for (set<int>::iterator it = AdjList[u].begin(); it != AdjList[u].end();
it++) {
int v = *it;
if (v != par && nChild[v] > lim) return find_c(v, u);
}
return u;
}
void decomp(int u) {
cur_sz = 0;
cal_sz(u, -1);
lim = cur_sz / 2;
int c = find_c(u, -1);
int cur_d;
cout << "d " << c << endl;
cin >> cur_d;
if (cur_d == 0) {
cout << "! " << c << endl;
exit(0);
}
if (d_x - d[c] == cur_d) {
cout << "s " << c << endl;
int nxt;
cin >> nxt;
AdjList[nxt].erase(c);
decomp(nxt);
} else {
AdjList[p[c]].erase(c);
decomp(p[c]);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n - 1; i++) {
int u, v;
cin >> u >> v;
AdjList[u].insert(v);
AdjList[v].insert(u);
}
cal_d(1, -1);
cout << "d 1" << endl;
cin >> d_x;
decomp(1);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<char> mn;
vector<int> used;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
used.resize(s.size());
mn.resize(s.size());
for (long long i = s.size() - 1; i >= 0; i--) {
if (i == s.size() - 1) {
mn[i] = s[i];
} else {
mn[i] = min(s[i], mn[i + 1]);
}
}
string ans = "", dop = "";
for (long long i = 0; i < s.size(); i++) {
;
if (dop.size() > 0 && dop[dop.size() - 1] <= mn[i]) {
ans += dop[dop.size() - 1];
dop.erase(dop.size() - 1, 1);
i--;
continue;
}
if (s[i] == mn[i]) {
ans += s[i];
} else {
dop += s[i];
}
}
if (dop.size() > 0) reverse(dop.begin(), dop.end());
cout << ans + dop;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k, mod = 998244353;
vector<int> a;
int solve(int x) {
if (x > a.back() / (k - 1)) return 0;
vector<int> dp(n + 1, 1);
dp.back() = 0;
for (int itt = 2; itt <= k; itt++) {
for (int i = n - 1; i >= 0; i--) {
dp[i] += dp[i + 1];
if (dp[i] >= mod) dp[i] -= mod;
}
vector<int> new_dp(n + 1);
int pt = n;
for (int i = n - 1; i >= 0; i--) {
while (a[i] + x <= a[pt - 1]) pt--;
new_dp[i] = dp[pt];
}
dp = new_dp;
}
int ret = 0;
for (auto &i : dp) {
ret += i;
if (ret >= mod) ret -= mod;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
a.resize(n);
for (auto &i : a) cin >> i;
sort(a.begin(), a.end());
int ans = 0;
for (int i = 1; i <= a.back(); i++) {
ans += solve(i);
if (ans >= mod) ans -= mod;
}
cout << ans << endl;
}
| 8 |
#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;
}
string s[2005];
int n, K;
int lcp[2005];
int prof[2005][2005];
struct segtree {
pair<int, int> val[10000];
int n;
void init(int n_) {
n = 1;
while (n < n_) n <<= 1;
for (int i = 0; i < n * 2; ++i) val[i] = make_pair(INF, INF);
}
void set(int k, int a) {
val[k + n - 1] = make_pair(a, k);
k += n - 1;
while (k > 0) {
k = (k - 1) / 2;
val[k] = min(val[k * 2 + 1], val[k * 2 + 2]);
}
}
pair<int, int> query(int a, int b, int i, int l, int r) {
if (a <= l && r <= b) return val[i];
if (b <= l || r <= a) return make_pair(INF, INF);
int md = (l + r) >> 1;
return min(query(a, b, i * 2 + 1, l, md), query(a, b, i * 2 + 2, md, r));
}
};
segtree seg;
int dp[105][105][105];
int rec(int s, int e, int k) {
k = min(k, e - s);
if (e - s == 1) return 0;
if (dp[s][e][k] != -1) return dp[s][e][k];
pair<int, int> mini = seg.query(s, e - 1, 0, 0, seg.n);
for (int i = 0; i < k + 1; ++i)
dp[s][e][k] = max(dp[s][e][k], rec(s, mini.second + 1, i) +
rec(mini.second + 1, e, k - i) +
i * (k - i) * mini.first);
return dp[s][e][k];
}
int main() {
scanf("%d%d", &n, &K);
for (int i = 0; i < n; ++i) cin >> s[i];
sort(s, s + n);
seg.init(n);
for (int i = 0; i < n - 1; ++i) {
int& t = lcp[i];
for (t = 0;
t < s[i].size() && t < s[i + 1].size() && s[i][t] == s[i + 1][t]; ++t)
;
seg.set(i, t);
}
for (int i = 0; i < n; ++i) prof[i][i] = 0;
for (int len = 1; len <= n - 1; ++len)
for (int i = 0; i < n - len; ++i) {
int j = i + len;
pair<int, int> mini = seg.query(i, j, 0, 0, seg.n);
prof[i][j] = prof[i][mini.second] + prof[mini.second + 1][j] +
(mini.second - i + 1) * (j - mini.second) * mini.first;
}
memset(dp, -1, sizeof(dp));
printf("%d\n", rec(0, n, K));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int found, N, M, nr, d[1609][1609], ap[1609][1609], cnt[10009];
char sir[4009];
bool a[1609][1609];
int dx[] = {-1, 1, 0, 0, -1, -1, 1, 1};
int dy[] = {0, 0, -1, 1, -1, 1, -1, 1};
queue<pair<int, int> > cc;
void fill(int i, int j) {
if (i < 1 || i > N || j < 1 || j > M || ap[i][j] == -1 || ap[i][j] > 0)
return;
ap[i][j] = nr;
for (int k = 0; k < 4; k++) fill(i + dx[k], j + dy[k]);
}
void fill2(int i, int j) {
if (ap[i][j] > 0) {
found = ap[i][j];
return;
}
if (i < 1 || i > N || j < 1 || j > M || ap[i][j] != -1 || a[i][j] == 0)
return;
ap[i][j] = -2;
for (int k = 0; k < 8; k++) fill2(i + dx[k], j + dy[k]);
}
int main() {
scanf("%d %d\n", &N, &M);
for (int i = 1; i <= N; i++) {
gets(sir);
for (int j = 1; j <= M; j++) {
a[i][j] = sir[j * 2 - 2] - '0', d[i][j] = 10000;
if (a[i][j] == 0) cc.push(make_pair(i, j)), d[i][j] = 0;
}
}
while (!cc.empty()) {
pair<int, int> curr = cc.front();
cc.pop();
for (int k = 0; k < 4; k++) {
int x = curr.first + dx[k], y = curr.second + dy[k];
if (d[x][y] > d[curr.first][curr.second] + 1) {
d[x][y] = d[curr.first][curr.second] + 1;
cc.push(make_pair(x, y));
}
}
}
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++)
if (d[i][j] > 4)
cc.push(make_pair(i, j)), d[i][j] = 0;
else
d[i][j] = 10000;
while (!cc.empty()) {
pair<int, int> curr = cc.front();
cc.pop();
for (int k = 0; k < 4; k++) {
int x = curr.first + dx[k], y = curr.second + dy[k];
if (d[x][y] > d[curr.first][curr.second] + 1) {
d[x][y] = d[curr.first][curr.second] + 1;
if (d[x][y] <= 6) cc.push(make_pair(x, y));
}
}
}
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++)
if (d[i][j] >= 10000) ap[i][j] = -1;
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++)
if (ap[i][j] == 0) nr++, fill(i, j);
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++)
if (ap[i][j] == -1 && a[i][j] == 1) {
found = 0, fill2(i, j);
cnt[found]++;
}
sort(cnt + 1, cnt + nr + 1);
printf("%d\n", nr);
for (int i = 1; i <= nr; i++) printf("%d ", cnt[i]);
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<pair<int, int>> v(n);
for (int i = 0; i < (int)n; i++) {
cin >> v[i].first >> v[i].second;
if (v[i].second > v[i].first) swap(v[i].first, v[i].second);
}
int yes = true;
int curHeight = 2000000000;
for (int i = 0; i < n && yes; i++) {
if (v[i].first <= curHeight)
curHeight = v[i].first;
else {
if (v[i].second <= curHeight)
curHeight = v[i].second;
else
yes = false;
}
}
string ans = yes ? "YES" : "NO";
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int kkk = 0, x = 1;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') c = getchar(), x = -1;
while (c >= '0' && c <= '9')
kkk = (kkk << 3) + (kkk << 1) + (c - '0'), c = getchar();
return kkk * x;
}
map<pair<int, int>, bool> Q;
int n, m, q, head[200001], tot = 1, headn[200001], totn, point[200001], cnt;
int jump[200001][18], deep[200001], tag[200001][2], root[200001], mem[200001];
int dfn[200001], low[200001], T, bridge[400001];
struct sb {
int to, nextn;
} a[400001], an[400001];
inline void ADD(int from, int to) {
a[++tot].to = to, a[tot].nextn = head[from];
head[from] = tot;
}
inline void ADDn(int from, int to) {
an[++totn].to = to, an[totn].nextn = headn[from];
headn[from] = totn;
}
inline void tarjan(int u, int from) {
dfn[u] = low[u] = ++T;
for (register int i = head[u]; i != 0; i = a[i].nextn) {
int v = a[i].to;
if (!dfn[v]) {
tarjan(v, i);
low[u] = min(low[u], low[v]);
if (low[v] > dfn[u]) bridge[i] = bridge[i ^ 1] = 1;
} else if (i != (from ^ 1))
low[u] = min(low[u], dfn[v]);
}
}
inline void fun(int u) {
point[u] = cnt;
for (register int i = head[u]; i != 0; i = a[i].nextn) {
int v = a[i].to;
if (bridge[i] || point[v]) continue;
fun(v);
}
}
inline void format(int u, int fa) {
deep[u] = deep[fa] + 1;
jump[u][0] = fa;
int LOG = log2(deep[u]);
for (register int i = 1; i <= LOG; ++i)
jump[u][i] = jump[jump[u][i - 1]][i - 1];
for (register int i = headn[u]; i != 0; i = an[i].nextn) {
int v = an[i].to;
if (v == fa) continue;
mem[v] = mem[u];
format(v, u);
}
}
inline int LCA(int x, int y) {
if (deep[x] < deep[y]) swap(x, y);
int C = deep[x] - deep[y];
int LOG = log2(C);
for (register int i = 0; i <= LOG; ++i)
if (C & (1 << i)) x = jump[x][i];
if (x == y) return x;
LOG = log2(deep[x]);
for (register int i = LOG; i >= 0; --i)
if (jump[x][i] != jump[y][i]) {
x = jump[x][i];
y = jump[y][i];
}
return jump[x][0];
}
inline int get(int u, int fa) {
for (register int i = headn[u]; i != 0; i = an[i].nextn) {
int v = an[i].to;
if (v == fa) continue;
int bck = get(v, u);
if (!bck) return 0;
tag[u][0] += tag[v][0];
tag[u][1] += tag[v][1];
}
if (tag[u][0] && tag[u][1]) return 0;
return 1;
}
int main() {
n = read(), m = read(), q = read();
for (register int i = 1; i <= m; ++i) {
int u = read(), v = read();
ADD(u, v);
ADD(v, u);
}
for (register int i = 1; i <= n; ++i)
if (!dfn[i]) tarjan(i, 0);
for (register int i = 1; i <= n; ++i)
if (!point[i]) ++cnt, fun(i);
for (register int u = 1; u <= n; ++u)
for (register int i = head[u]; i != 0; i = a[i].nextn) {
int v = a[i].to;
if (point[u] == point[v] || point[v] < point[u] ||
Q[make_pair(point[u], point[v])])
continue;
Q[make_pair(point[u], point[v])] = 1;
ADDn(point[u], point[v]);
ADDn(point[v], point[u]);
}
for (register int i = 1; i <= cnt; ++i)
if (!deep[i]) mem[i] = i, format(root[++root[0]] = i, 0);
for (register int i = 1; i <= q; ++i) {
int s = point[read()], t = point[read()];
if (s == t) continue;
if (mem[s] != mem[t]) {
puts("No");
return 0;
}
int lca = LCA(s, t);
++tag[s][0];
++tag[t][1];
--tag[lca][0];
--tag[lca][1];
}
puts(get(1, 0) ? "Yes" : "No");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, m, t;
char s[1010][1010];
int d[1010][1010];
int dx[5] = {-1, 0, 1, 0};
int dy[5] = {0, -1, 0, 1};
queue<int> q;
queue<int> q1;
int check(int i, int j, int x, int y) {
if (0 <= x && x < n && 0 <= y && y < m && s[i][j] == s[x][y]) {
return 1;
}
return 0;
}
void work() {
for (int i = 0; i < n; ++i) {
scanf("%s", s[i]);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int hassam = 0;
for (int k = 0; k < 4; ++k) {
if (check(i, j, i + dx[k], j + dy[k])) {
hassam = 1;
}
}
if (hassam) {
d[i][j] = 0;
q.push(i);
q1.push(j);
} else {
d[i][j] = -1;
}
}
}
while (!q.empty()) {
int x = q.front();
q.pop();
int y = q1.front();
q1.pop();
for (int i = 0; i < 4; ++i) {
int xx = x + dx[i];
int yy = y + dy[i];
if (0 <= xx && xx < n && 0 <= yy && yy < m && d[xx][yy] == -1) {
d[xx][yy] = d[x][y] + 1;
q.push(xx);
q1.push(yy);
}
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &t);
work();
while (t--) {
int i, j;
long long p;
scanf("%d%d%lld", &i, &j, &p);
i--;
j--;
int now = s[i][j] - '0';
if (d[i][j] == -1) {
printf("%d\n", now);
} else {
if (p < d[i][j]) {
printf("%d\n", now);
} else {
if ((p - d[i][j]) & 1) {
printf("%d\n", now ^ 1);
} else {
printf("%d\n", now);
}
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int k, i, j;
int a[5][5];
char temp;
scanf("%d", &k);
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++) {
scanf("%c", &temp);
if (temp == '.') {
a[i][j] = -1;
} else if (temp == '\n') {
j--;
} else {
temp -= '0';
a[i][j] = temp;
}
}
}
int x;
int time = 1;
int count = 0;
int fl = 0;
for (x = 0; x < 9; x++) {
count = 0;
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++) {
if (a[i][j] == time) count++;
}
}
if (count > (2 * k)) {
fl = 1;
break;
}
time++;
}
if (fl == 0)
printf("YES\n");
else
printf("NO\n");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int r, c, d1[1000005], d2[1000005];
char m[1005][1005];
bool v1[1005][1005], v2[1005][1005];
queue<int> q11;
queue<int> q12;
queue<int> q21;
queue<int> q22;
int f(int i, int j) { return ((i - 1) * c) + j; }
int main() {
int xx = -1, xy = -1;
memset(v1, false, sizeof v1);
memset(v2, false, sizeof v2);
scanf("%d %d", &r, &c);
for (int i = 1; i <= r * c; i++) d1[i] = d2[i] = 100000000;
for (int i = 1; i <= r; i++) {
for (int j = 1; j <= c; j++) {
scanf(" %c", &m[i][j]);
if (m[i][j] == 'S') {
q11.push(i);
q12.push(j);
v1[i][j] = true;
d1[f(i, j)] = 0;
} else if (m[i][j] == 'E') {
q21.push(i);
q22.push(j);
xx = i;
xy = j;
v2[i][j] = true;
d2[f(i, j)] = 0;
} else if (m[i][j] == 'T') {
v1[i][j] = v2[i][j] = true;
}
}
}
while (!q11.empty()) {
int x = q11.front();
int y = q12.front();
q11.pop();
q12.pop();
if (x - 1 >= 1 && !v1[x - 1][y]) {
q11.push(x - 1);
q12.push(y);
v1[x - 1][y] = true;
d1[f(x - 1, y)] = d1[f(x, y)] + 1;
}
if (x + 1 <= r && !v1[x + 1][y]) {
q11.push(x + 1);
q12.push(y);
v1[x + 1][y] = true;
d1[f(x + 1, y)] = d1[f(x, y)] + 1;
}
if (y - 1 >= 1 && !v1[x][y - 1]) {
q11.push(x);
q12.push(y - 1);
v1[x][y - 1] = true;
d1[f(x, y - 1)] = d1[f(x, y)] + 1;
}
if (y + 1 <= c && !v1[x][y + 1]) {
q11.push(x);
q12.push(y + 1);
v1[x][y + 1] = true;
d1[f(x, y + 1)] = d1[f(x, y)] + 1;
}
}
while (!q21.empty()) {
int x = q21.front();
int y = q22.front();
q21.pop();
q22.pop();
if (x - 1 >= 1 && !v2[x - 1][y]) {
q21.push(x - 1);
q22.push(y);
v2[x - 1][y] = true;
d2[f(x - 1, y)] = d2[f(x, y)] + 1;
}
if (x + 1 <= r && !v2[x + 1][y]) {
q21.push(x + 1);
q22.push(y);
v2[x + 1][y] = true;
d2[f(x + 1, y)] = d2[f(x, y)] + 1;
}
if (y - 1 >= 1 && !v2[x][y - 1]) {
q21.push(x);
q22.push(y - 1);
v2[x][y - 1] = true;
d2[f(x, y - 1)] = d2[f(x, y)] + 1;
}
if (y + 1 <= c && !v2[x][y + 1]) {
q21.push(x);
q22.push(y + 1);
v2[x][y + 1] = true;
d2[f(x, y + 1)] = d2[f(x, y)] + 1;
}
}
int cmpp = d1[f(xx, xy)];
int resp = 0;
for (int i = 1; i <= r; i++) {
for (int j = 1; j <= c; j++) {
if (m[i][j] >= '0' && m[i][j] <= '9' && d2[f(i, j)] <= cmpp) {
resp += (m[i][j] - '0');
}
}
}
printf("%d\n", resp);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int N, M, K, visit, ar[100010][2], rmq[100010][21], depth[100010], ata[100010];
vector<int> way[100010], yeni[100010];
int findset(int x) {
if (x != ata[x]) ata[x] = findset(ata[x]);
return ata[x];
}
void f(int node, int dad) {
ar[node][0] = ar[node][1] = ++visit;
for (int i = 0; i < (int)way[node].size(); i++) {
if (way[node][i] == dad) continue;
if (!ar[way[node][i]][0]) {
f(way[node][i], node);
if (ar[node][1] > ar[way[node][i]][1]) {
ata[node] = way[node][i];
ar[node][1] = ar[way[node][i]][1];
}
} else if (ar[node][1] > ar[way[node][i]][0]) {
ata[node] = way[node][i];
ar[node][1] = ar[way[node][i]][0];
}
}
}
void g(int node, int dad, int cnt) {
rmq[node][0] = dad;
depth[node] = cnt;
for (int i = 0; i < (int)yeni[node].size(); i++) {
if (yeni[node][i] == dad) continue;
g(yeni[node][i], node, cnt + 1);
}
}
int lca(int a, int b) {
if (a == b) return 0;
if (depth[b] > depth[a]) swap(a, b);
int x = depth[a], y = depth[b];
for (int i = 20; i >= 0; i--)
if (depth[rmq[a][i]] >= depth[b]) a = rmq[a][i];
if (a == b) return x - depth[a];
for (int i = 20; i >= 0; i--)
if (rmq[a][i] != rmq[b][i]) {
a = rmq[a][i];
b = rmq[b][i];
}
a = rmq[a][0];
return x - depth[a] + y - depth[a];
}
int main() {
scanf("%d%d", &N, &M);
for (int i = 1, a, b; i <= M; i++) {
scanf("%d%d", &a, &b);
way[a].push_back(b);
way[b].push_back(a);
}
for (int i = 1; i <= N; i++) ata[i] = i;
f(1, 0);
for (int i = 1; i <= N; i++) {
findset(i);
}
for (int i = 1; i <= N; i++)
for (int j = 0; j < (int)way[i].size(); j++) {
if (ata[i] == ata[way[i][j]]) continue;
yeni[ata[i]].push_back(ata[way[i][j]]);
}
g(1, 0, 0);
for (int j = 1; j <= 20; j++)
for (int i = 1; i <= N; i++)
rmq[ata[i]][j] = rmq[rmq[ata[i]][j - 1]][j - 1];
scanf("%d", &K);
for (int i = 1, a, b; i <= K; i++) {
scanf("%d%d", &a, &b);
cout << lca(ata[a], ata[b]) << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 605, X = 90005, M = 200005;
int n, m, p, S, T, nA, nB, cnt, du[N], le[X], ri[X], ans[X];
int tot, lnk[N], son[M], w[M], v[M], nxt[M];
int q[N], dst[N], pre[N];
bool bo[N], vis[N];
int read() {
int x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x;
}
void Ifmin(int &x, int y) {
if (y < x) x = y;
}
void add(int x, int y, int z1, int z2) {
tot++;
son[tot] = y;
w[tot] = z1;
v[tot] = z2;
nxt[tot] = lnk[x];
lnk[x] = tot;
tot++;
son[tot] = x;
w[tot] = 0;
v[tot] = -z2;
nxt[tot] = lnk[y];
lnk[y] = tot;
}
bool spfa() {
for (int i = (1); i <= (n); i++) bo[i] = vis[i] = 0, dst[i] = 1e9;
int hed = 0, tal = 1;
dst[q[1] = S] = 0;
bo[S] = vis[S] = 1;
while (hed != tal) {
int x = q[hed = (hed + 1) % N];
vis[x] = 0;
for (int j = lnk[x]; j; j = nxt[j])
if (w[j] > 0 && dst[x] + v[j] < dst[son[j]]) {
dst[son[j]] = dst[x] + v[j];
bo[son[j]] = 1;
pre[son[j]] = j;
if (!vis[son[j]]) vis[q[tal = (tal + 1) % N] = son[j]] = 1;
}
}
return bo[T];
}
void getflow() {
while (spfa()) {
int mn = 1e9;
for (int x = T; x != S; x = son[pre[x] ^ 1]) Ifmin(mn, w[pre[x]]);
for (int x = T; x != S; x = son[pre[x] ^ 1])
w[pre[x]] -= mn, w[pre[x] ^ 1] += mn;
}
}
int main() {
nA = read(), nB = read(), m = read(), p = read();
for (int i = (1); i <= (m); i++) le[i] = read(), ri[i] = read();
for (int i = (1); i <= (m); i++) du[le[i]]++, du[nA + ri[i]]++;
for (int i = (1); i <= (nA + nB); i++)
if (du[i] % p) cnt++;
printf("%d\n", cnt);
for (n = nA + nB, S = ++n, T = ++n; p; p--) {
tot = 1;
memset(lnk, 0, sizeof(lnk));
for (int i = (1); i <= (m); i++)
if (!ans[i]) add(le[i], nA + ri[i], 1, 0);
for (int i = (1); i <= (nA); i++) {
add(S, i, du[i] / p, 0);
if (du[i] % p) add(S, i, 1, 1);
}
for (int i = (nA + 1); i <= (nA + nB); i++) {
add(i, T, du[i] / p, 0);
if (du[i] % p) add(i, T, 1, 1);
}
getflow();
int _ = 0;
for (int i = (1); i <= (m); i++)
if (!ans[i]) {
_ += 2;
if (!w[_]) ans[i] = p, du[le[i]]--, du[nA + ri[i]]--;
}
}
for (int i = (1); i <= (m); i++) printf("%d ", ans[i]);
puts("");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, citys[109] = {0}, arr[109];
cin >> n >> m;
for (int f = 0; f < m; f++) {
int i = 0;
for (int f1 = 0; f1 < n; f1++) {
cin >> arr[f1];
if (arr[f1] > arr[i]) i = f1;
}
citys[i]++;
}
int ans = 0;
for (int f = 0; f < n; f++)
if (citys[ans] < citys[f]) ans = f;
cout << ans + 1 << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char a[155][155];
int ans, x, y;
int abs(int x) {
if (x < 0) return -x;
return x;
}
int main() {
cin >> n >> m;
int i, j;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) {
if (i % 2 == 0) {
for (j = 0; j < m; j++) {
if (a[i][j] == 'W') {
ans += i - x + abs(j - y);
x = i;
y = j;
}
}
} else {
for (j = m - 1; j >= 0; j--) {
if (a[i][j] == 'W') {
ans += i - x + fabs(j - y);
x = i;
y = j;
}
}
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
string s, tmp;
int n, nums;
int main() {
tmp = "";
nums = 0;
ios::sync_with_stdio(false);
cin >> s;
n = s.size();
for (int i = 0; i < n; i++) {
if (s[i] == '1')
++nums;
else
tmp += s[i];
}
string ns(nums, '1'), tmp2 = ns;
ns += tmp;
int ze = 0, curr = n;
for (int i = nums; i < n; i++) {
if (ns[i] == '2') {
curr = i;
break;
}
if (ns[i] == '0') ++ze;
}
string ans(ze, '0');
ans += tmp2;
for (int i = curr; i < n; i++) ans += ns[i];
cout << min(ans, s) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
#include<iostream>
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define endl "\n"
#define int long long
const int N = 2e5 + 5;
const int MOD = 1e9 + 7;
int xc[N];
int yc[N];
int pow(int a, int b, int m)
{
int ans = 1;
while (b)
{
if (b & 1)
ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans;
}
int n, k, sz, ans = 0;
bool vis[N];
vector<int> g[N];
vector<int> ansx[N];
vector<int> ansy[N];
void dfs(int a, int b)
{
for (int i = 0; i < g[a].size(); i++)
{
if (g[a][i] != b)
{
dfs(g[a][i], a);
ansx[a][0]+=max(ansx[g[a][i]][0]+abs(xc[a]-xc[g[a][i]]),ansy[g[a][i]][0]+abs(xc[a]-yc[g[a][i]]));
ansy[a][0]+=max(ansx[g[a][i]][0]+abs(yc[a]-xc[g[a][i]]),ansy[g[a][i]][0]+abs(yc[a]-yc[g[a][i]]));
}
}
}
int32_t main()
{
IOS;
int ts;
cin >> ts;
while (ts--)
{
cin >> n;
for(int i=1;i<=n+1;i++){
ansx[i].clear();
ansy[i].clear();
g[i].clear();
}
for (int i = 1; i <= n; i++)
{
int a, b;
cin >> a >> b;
xc[i] = a;
yc[i] = b;
}
for (int i = 1; i <= n - 1; i++)
{
int u, v;
cin >> u >> v;
g[u].push_back(v), g[v].push_back(u);
ansx[u].push_back(0);
ansx[v].push_back(0);
ansy[u].push_back(0);
ansy[v].push_back(0);
}
dfs(1,-1);
cout <<max(ansx[1][0],ansy[1][0])<<endl;
}
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int count[32] = {0};
for (int j = 0; j < 32; j++) {
for (int i = 0; i < n; i++) {
if ((1 << j) & a[i]) {
count[j]++;
}
}
}
cout << endl;
int max = 0;
int pos = -1;
for (int i = 0; i < n; i++) {
int temp = 0;
for (int j = 0; j < 32; j++) {
if (count[j] == 1 && ((1 << j) & a[i])) {
temp = temp + (1 << j);
}
}
if (temp > max) {
max = temp;
pos = i;
}
}
if (pos != -1) {
cout << a[pos] << " ";
for (int i = 0; i < n; i++)
if (i != pos) cout << a[i] << " ";
} else {
for (int i = 0; i < n; i++) cout << a[i] << " ";
}
cout << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
inline void add(int &x, int y) {
if ((x += y) >= MOD) x -= MOD;
}
inline int mult(int x, int y) { return (long long)x * y % MOD; }
const int maxn = 2001;
int d[maxn][maxn];
int C[maxn][maxn];
void countD(int nm, int km) {
memset(C, 0, sizeof(C));
for (int n = 0; n <= nm; n++) {
C[n][0] = C[n][n] = 1;
for (int k = 1; k < n; k++)
add(C[n][k], C[n - 1][k]), add(C[n][k], C[n - 1][k - 1]);
}
int fact = 1;
for (int n = 0; n <= nm; n++) {
if (n) fact = mult(fact, n);
for (int k = 0; k <= n && k <= km; k++) {
if (n - k != nm - km) continue;
int &cur = d[n][k];
cur = fact;
for (int x = 1; x <= k; x++)
add(cur, MOD - mult(C[k][x], d[n - x][k - x]));
}
}
}
int a[maxn];
int used[maxn];
bool solve() {
int n;
if (scanf("%d", &n) < 1) return 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (a[i] != -1) --a[i];
used[i] = 0;
}
int m = 0, k = 0;
for (int i = 0; i < n; i++)
if (a[i] != -1) used[a[i]] = 1;
for (int i = 0; i < n; i++)
if (!used[i]) {
int cnt = 0;
for (int x = i; x != -1; x = a[x], cnt++) used[x] = 1;
++m;
if (cnt == 1) k++;
}
countD(m, k);
printf("%d\n", d[m][k]);
return 1;
}
int main() {
while (1) {
if (!solve()) break;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:1024000000,1024000000")
int Scan() {
int res = 0, flag = 0;
char ch;
if ((ch = getchar()) == '-')
flag = 1;
else if (ch >= '0' && ch <= '9')
res = ch - '0';
while ((ch = getchar()) >= '0' && ch <= '9') res = res * 10 + (ch - '0');
return flag ? -res : res;
}
void Out(int a) {
if (a < 0) {
putchar('-');
a = -a;
}
if (a >= 10) Out(a / 10);
putchar(a % 10 + '0');
}
const int N = 100005;
int n;
double s, f, r, v;
bool check(double t) {
double S = v * t, l = 2 * acos(-1.0) * r;
double ss = S - floor(S / l) * l;
double T = S + fabs(sin(ss / 2 / r)) * 2 * r;
return T >= f - s;
}
int main() {
scanf("%d%lf%lf", &n, &r, &v);
while (n--) {
scanf("%lf%lf", &s, &f);
double l = 0, r = 1e12;
int tot = 100;
while (tot--) {
double mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
printf("%.7lf\n", l);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
double x, y;
double pi;
int main() {
scanf("%d", &n);
pi = acos(-1);
if (n <= 4) {
puts("No solution");
return 0;
}
printf("%.9lf %.9lf\n", x, y);
for (int i = 1; i <= n - 2; i++) {
double now = 2 * pi / n * i;
double nowl = 100 + 0.002 * i;
x += nowl * cos(now);
y += nowl * sin(now);
printf("%.9lf %.9lf\n", x, y);
}
double now = 2 * pi / n * (n - 1);
x -= y / tan(now);
y = 0;
printf("%.9lf %.9lf\n", x, y);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1 << 20;
int used[maxn];
int n;
char res[100][100];
int fre;
int go(int Len) {
if (Len == 0) return used[n];
for (int i = 1; i <= n; i++) {
if (used[i]) {
for (int k = 2; k <= 8; k *= 2) {
if ((!used[k * i]) && (k * i <= n)) {
used[k * i] = fre;
fre++;
if (go(Len - 1)) {
sprintf(res[Len], "lea e%cx, [%d*e%cx]\n", used[k * i] + 'a' - 1, k,
used[i] + 'a' - 1);
return 1;
}
fre--;
used[k * i] = 0;
}
}
for (int j = 1; j <= i; j++) {
if (used[j]) {
if (i + j <= n && !used[i + j]) {
used[i + j] = fre;
fre++;
if (go(Len - 1)) {
sprintf(res[Len], "lea e%cx, [e%cx + e%cx]\n",
used[i + j] + 'a' - 1, used[i] + 'a' - 1,
used[j] + 'a' - 1);
return 1;
}
fre--;
used[i + j] = 0;
}
for (int k = 2; k <= 8; k *= 2) {
if (i + k * j <= n && !used[i + k * j]) {
used[i + k * j] = fre;
fre++;
if (go(Len - 1)) {
sprintf(res[Len], "lea e%cx, [e%cx + %d*e%cx]\n",
used[i + k * j] + 'a' - 1, used[i] + 'a' - 1, k,
used[j] + 'a' - 1);
return 1;
}
fre--;
used[i + k * j] = 0;
}
}
for (int k = 2; k <= 8; k *= 2) {
if (k * i + j <= n && !used[k * i + j]) {
used[k * i + j] = fre;
fre++;
if (go(Len - 1)) {
sprintf(res[Len], "lea e%cx, [e%cx + %d*e%cx]\n",
used[k * i + j] + 'a' - 1, used[j] + 'a' - 1, k,
used[i] + 'a' - 1);
return 1;
}
fre--;
used[k * i + j] = 0;
}
}
}
}
}
}
return 0;
}
int main() {
scanf("%d", &n);
for (int Len = 0; 1; Len++) {
used[1] = 1;
fre = 2;
if (go(Len)) {
printf("%d\n", Len);
for (int i = Len; i > 0; i--) printf("%s", res[i]);
return 0;
}
}
return 0;
}
| 8 |
//...START BY DOING WHAT IS NECESSARY, THEN WHAT IS POSSIBLE AND SUDDENLY YOU ARE DOING THE IMPOSSIBLE...
#include <bits/stdc++.h>
using namespace std;
#define FAST_FURIER ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define pb push_back
#define mk make_pair
#define rep(i,a,N) for(ll i=a;i<N;i++)
#define rrep(i,a,N) for(ll i=a;i>N;i--)
typedef long long ll;
#define M 1000000007
bool comp(int x,int y)
{
return x > y;
}
/*..............................code starts here........................*/
// C is first won in M
int main() {
FAST_FURIER;
int tt=1;
cin >> tt;
ll m,d,k;
//ll a,b,c;
while(tt--)
{
cin >> d >> k;
ll x = 0,y = 0;
int f = 0;
while(true){
ll d1 = pow(x+k,2)+pow(y,2), d2 = pow(x,2)+pow(y+k,2);
f = abs(f-1);
if(d1 < d2 and d1 <= d*d){
x += k;
}
else if(d2 <= d1 and d2 <= d*d) y += k;
else break;
}
if(f) cout << "Utkarsh";
else cout << "Ashish";
cout << endl;
}
}
// Author : shivam_123
// g++ -std=c++17 | 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int a[N], b[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (!a[i]) i--, n--;
}
n++;
for (int i = 0; i < n; i++) {
scanf("%d", &b[i]);
if (!b[i]) i--, n--;
}
int rec = 0;
for (int i = 0; i < n; i++)
if (b[i] == a[0]) {
rec = i;
break;
}
for (int i = 0, j = rec; i < n; i++, j = (j + 1) % n) {
if (a[i] != b[j]) {
puts("NO");
return 0;
}
}
puts("YES");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
const int N = 1e6 + 10, M = 1e7 + 10, mod = 1e9 + 7, INF = 0x3f3f3f3f, ha = 137;
int n, q;
int mx[N], a[N];
int s[M], ls[M], rs[M];
int rt[N];
int cnt;
int update(int loc, int pre, int l, int r) {
int now = ++cnt;
s[now] = s[pre] + 1;
ls[now] = ls[pre];
rs[now] = rs[pre];
if (l == r) return now;
int mid = l + r >> 1;
if (loc <= mid)
ls[now] = update(loc, ls[pre], l, mid);
else
rs[now] = update(loc, rs[pre], mid + 1, r);
return now;
}
int query(int a, int b) {
int x = rt[a - 1], y = rt[b];
int ans = 0;
int l = 0, r = n;
while (l < r) {
int mid = l + r >> 1;
if (a <= mid)
ans += s[rs[y]] - s[rs[x]], x = ls[x], y = ls[y], r = mid;
else {
l = mid + 1, x = rs[x], y = rs[y];
}
}
return ans;
}
int tot;
struct dat {
int s[N << 2], lazy[N << 2];
void update(int a, int b, int x, int k, int l, int r) {
if (a == l && b == r) {
s[x] += k;
lazy[x] += k;
return;
}
int mid = l + r >> 1, ls = x << 1, rs = x << 1 | 1;
if (lazy[x]) {
update(l, mid, ls, lazy[x], l, mid);
update(mid + 1, r, rs, lazy[x], mid + 1, r);
lazy[x] = 0;
}
if (b <= mid)
update(a, b, ls, k, l, mid);
else if (a > mid)
update(a, b, rs, k, mid + 1, r);
else {
update(a, mid, ls, k, l, mid);
update(mid + 1, b, rs, k, mid + 1, r);
}
s[x] = max(s[ls], s[rs]);
}
int query(int k) {
int x = 1;
int l = 1, r = n;
while (l < r) {
int mid = l + r >> 1, ls = x << 1, rs = x << 1 | 1;
if (lazy[x]) {
update(l, mid, ls, lazy[x], l, mid);
update(mid + 1, r, rs, lazy[x], mid + 1, r);
lazy[x] = 0;
}
if (s[rs] >= k)
x = rs, l = mid + 1;
else
x = ls, r = mid;
}
return l;
}
} tr;
int f[N];
int ss;
int main() {
cin >> n >> q;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
int k = i - a[i];
if (k < 0) {
rt[i] = update(a[i] = 0, rt[i - 1], 0, n);
continue;
}
int t = tr.query(k);
a[i] = f[t];
if (k == 0) f[++tot] = i, a[i] = i, t = tot;
if (k > ss) {
a[i] = 0, t = 0;
} else
ss++;
if (min(tot, t)) tr.update(1, min(tot, t), 1, 1, 1, n);
rt[i] = update(a[i], rt[i - 1], 0, n);
}
int l, r;
while (q--) {
scanf("%d%d", &l, &r);
printf("%d\n", query(l, n - r));
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int x[n + 1];
vector<pair<long long int, long long int>> g1;
x[0] = -1e18;
long long int dp[n + 1];
long long int c[n + 1];
long long int i = 1;
while (i <= n) {
long long int x1, y1;
cin >> x1 >> y1;
g1.push_back(make_pair(x1, y1));
i++;
}
sort(g1.begin(), g1.end());
i = 0;
while (i < n) {
x[i + 1] = g1[i].first;
c[i + 1] = g1[i].second;
i++;
}
dp[0] = 0;
i = 1;
while (i <= n) {
dp[i] = 1e18;
i++;
}
long long int j;
long long int t;
i = 1;
while (i <= n) {
t = c[i];
j = i;
while (j <= n) {
t = t + x[j] - x[i];
dp[j] = min(dp[j], dp[i - 1] + t);
j++;
}
i++;
}
cout << dp[n];
return 0;
}
| 5 |
#include <bits/stdc++.h>
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
for (; c > '9' || c < '0'; c = getchar())
if (c == '-') f = -1;
for (; c >= '0' && c <= '9'; c = getchar()) x = x * 10 + c - '0';
return x * f;
}
char s[300005];
int a, b, n, cnt, cnt1, len;
bool flag;
inline void work() {
for (int t = read(); t; t--) {
a = read(), b = read();
scanf("%s", s);
n = strlen(s);
s[n] = 'X';
cnt = cnt1 = 0;
flag = 0;
for (int i = 0, tmp = 0; i <= n; i++)
if (s[i] == 'X' && tmp) {
if (tmp < a && tmp >= b) {
flag = 1;
break;
}
if (tmp >= a && tmp < 2 * b) cnt++;
if (tmp >= 2 * b) cnt1++, len = tmp;
tmp = 0;
} else if (s[i] == '.')
tmp++;
if (flag)
puts("no");
else {
if (cnt1 >= 2)
puts("no");
else if (!cnt1)
puts(cnt & 1 ? "yes" : "no");
else {
for (int i = 0; i <= len - a; i++) {
int j = len - a - i;
if (i < 2 * b && j < 2 * b)
if (((i < b && j < b) || (i >= a && j >= a)) && cnt % 2 == 0) {
puts("yes");
break;
} else if (((i < b && j >= a) || (i >= a && j < b)) && cnt & 1) {
puts("yes");
break;
}
if (i == len - a) puts("no");
}
}
}
}
}
int main() {
work();
return 0;
}
| 8 |
#include<bits/stdc++.h>
using namespace std;
#define endl "\n"
typedef long long ll;
const ll mod = 1e9 + 7;
string x = "";
void bin(int n) {
if (n > 1)
bin(n >> 1);
x += to_string(n & 1);
}
void solve() {
ll n;
cin >> n;
if (n == 1) {
cout << 0 << endl;
return;
}
ll num = n;
bin(num);
// cout << x << endl;
int pow = 1, sz = x.size();
int i = 1, ans = 0;
while (i < sz) {
ans += pow;
pow *= 2;
i++;
}
cout << ans << endl;
x = "";
}
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t;
cin >> t;
while (t--)
solve();
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int dir[4][2] = {1, 0, 0, 1, -1, 0, 0, -1};
const int N = 2e6 + 10;
const int mod = 1e9 + 7;
const double pi = acos(-1);
const int INF = 0x3f3f3f3f;
long long n, m, K;
long long qpow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
long long fac[N], inv[N];
long long C(long long n, long long m) {
if (n < m) return 0;
return fac[n] * inv[m] % mod * inv[n - m] % mod;
}
void init() {
fac[0] = inv[0] = 1;
for (int i = 1; i < N; ++i) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = inv[i - 1] * qpow(i, mod - 2) % mod;
}
}
int main() {
ios::sync_with_stdio(0);
init();
cin >> n;
long long ans = 1, tmp = 1;
for (int i = 2; i <= n; ++i) {
tmp = tmp * 2 % mod;
ans = (ans + tmp) % mod;
}
for (int i = n + 1; i <= 2 * n; ++i) {
tmp = (tmp * 2 % mod - C(i - 1, n) + mod) % mod;
ans = (ans + tmp) % mod;
}
cout << (2 * ans % mod + 1) % mod << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
int x, y;
Point() {}
Point(int _x, int _y) {
x = _x;
y = _y;
}
};
struct Segment {
Point p[2];
Segment() {}
Segment(Point a, Point b) {
p[0] = a;
p[1] = b;
}
};
struct Square {
Point points[4];
Segment segments[4];
};
struct Triangle {
Point points[3];
Triangle() {}
Triangle(Point a, Point b, Point c) {
points[0] = a, points[1] = b, points[2] = c;
}
};
enum Orientation { COLINEAR = 0, CLOCKWISE = 1, COUNTER_CLOCKWISE = 2 };
bool pointInSquare(Square sq, Point p) {
int sqMinX = sq.points[0].x, sqMaxX = sq.points[0].x, sqMinY = sq.points[0].y,
sqMaxY = sq.points[0].y;
for (unsigned int i = 1; i < 4; ++i) {
sqMinX = min(sqMinX, sq.points[i].x);
sqMaxX = max(sqMaxX, sq.points[i].x);
sqMinY = min(sqMinY, sq.points[i].y);
sqMaxY = max(sqMaxY, sq.points[i].y);
}
return p.x >= sqMinX && p.x <= sqMaxX && p.y >= sqMinY && p.y <= sqMaxY;
}
bool isPointOnSegment(Segment seg, Point p) {
int minSegX = min(seg.p[0].x, seg.p[1].x),
maxSegX = max(seg.p[0].x, seg.p[1].x),
minSegY = min(seg.p[0].y, seg.p[1].y),
maxSegY = max(seg.p[0].y, seg.p[1].y);
return p.x <= maxSegX && p.x >= minSegX && p.y <= maxSegY && p.y >= minSegY;
}
Orientation getOrientation(Point a, Point b, Point c) {
int o = (b.y - a.y) * (c.x - b.x) - (b.x - a.x) * (c.y - b.y);
if (o == 0) return COLINEAR;
if (o > 0) return CLOCKWISE;
return COUNTER_CLOCKWISE;
}
bool pointInTriangle(Triangle t, Point p) {
Orientation orientations[3];
orientations[0] = getOrientation(t.points[0], p, t.points[1]);
orientations[1] = getOrientation(t.points[1], p, t.points[2]);
orientations[2] = getOrientation(t.points[2], p, t.points[0]);
bool b[3];
for (int i = 0; i < 3; ++i) b[i] = orientations[i] == COUNTER_CLOCKWISE;
return ((b[0] == b[1]) && (b[1] == b[2]));
}
bool segmentsIntersect(Segment a, Segment b) {
Orientation orientations[4];
orientations[0] = getOrientation(a.p[0], a.p[1], b.p[0]);
orientations[1] = getOrientation(a.p[0], a.p[1], b.p[1]);
orientations[2] = getOrientation(b.p[0], b.p[1], a.p[0]);
orientations[3] = getOrientation(b.p[0], b.p[1], a.p[1]);
if (orientations[0] != orientations[1] && orientations[2] != orientations[3])
return true;
return ((orientations[0] == 0 && isPointOnSegment(a, b.p[0])) ||
(orientations[1] == 0 && isPointOnSegment(a, b.p[1])) ||
(orientations[2] == 0 && isPointOnSegment(b, a.p[0])) ||
(orientations[3] == 0 && isPointOnSegment(b, a.p[1])));
}
bool squaresIntersect(Square a, Square b) {
unsigned int i, j;
for (i = 0; i < 4; ++i) {
if (pointInSquare(a, b.points[i])) return true;
}
for (i = 0; i < 4; ++i) {
for (j = 0; j < 4; ++j) {
if (segmentsIntersect(a.segments[i], b.segments[j])) return true;
}
}
Triangle triangles[4];
int minBX = b.points[0].x, maxBX = b.points[0].x, minBY = b.points[0].y,
maxBY = b.points[0].y;
for (i = 0; i < 4; ++i) {
minBX = min(minBX, b.points[i].x);
maxBX = max(maxBX, b.points[i].x);
minBY = min(minBY, b.points[i].y);
maxBY = max(maxBY, b.points[i].y);
}
int halfBX = (maxBX + minBX) / 2;
int halfBY = (maxBY + minBY) / 2;
Point halfP = Point(halfBX, halfBY);
triangles[0] = Triangle(b.points[0], b.points[1], halfP);
triangles[1] = Triangle(b.points[1], b.points[2], halfP);
triangles[2] = Triangle(b.points[2], b.points[3], halfP);
triangles[3] = Triangle(b.points[3], b.points[0], halfP);
for (i = 0; i < 4; ++i) {
for (j = 0; j < 4; ++j) {
if (pointInTriangle(triangles[j], a.points[i])) return true;
}
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
unsigned int i, j;
Square squares[2];
for (i = 0; i < 2; ++i) {
for (j = 0; j < 4; ++j)
cin >> squares[i].points[j].x >> squares[i].points[j].y;
for (j = 0; j < 4; ++j)
squares[i].segments[j] =
Segment(squares[i].points[j], squares[i].points[(j + 1) % 4]);
}
if (squaresIntersect(squares[0], squares[1]))
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int v[100002], n;
int rex(int t) {
int i = 1, j = 1, s = 0, nrc = 0;
while (j <= n) {
if (s + v[j] <= t) {
s += v[j];
if (nrc < j - i + 1) nrc = j - i + 1;
j++;
} else {
s -= v[i];
i++;
}
}
return nrc;
}
int main() {
int t, nrm = 0, j, k, i, s;
cin >> n >> t;
for (i = 1; i <= n; i++) {
cin >> v[i];
}
cout << rex(t);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
while (n--) {
long long s, a, b, c, num_offers, remainder;
cin >> s >> a >> b >> c;
num_offers = s / (a * c);
remainder = s % (a * c);
cout << num_offers * a + b * num_offers + remainder / c << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void debug(T a, T b) {
;
}
template <class T>
void chmin(T& a, const T& b) {
if (a > b) a = b;
}
template <class T>
void chmax(T& a, const T& b) {
if (a < b) a = b;
}
namespace std {
template <class S, class T>
ostream& operator<<(ostream& out, const pair<S, T>& a) {
out << '(' << a.first << ',' << a.second << ')';
return out;
}
} // namespace std
long long int readL() {
long long int res;
scanf("%I64d", &res);
return res;
}
void printL(long long int res) { printf("%I64d", res); }
int n;
int cnt[10];
int main() {
cin >> n;
int sum = 0;
for (int i = 0; i < (n); ++i) {
int a;
scanf("%d", &a);
sum += a;
++cnt[a];
}
if (sum <= 2 || sum == 5) {
puts("-1");
return 0;
}
int res = 0;
int tmp = min(cnt[1], cnt[2]);
cnt[3] += tmp;
cnt[1] -= tmp;
cnt[2] -= tmp;
res += tmp;
if (cnt[1] > 0) {
res += cnt[1] / 3 * 2;
cnt[3] += cnt[1] / 3;
int rest = cnt[1] % 3;
cnt[1] = rest;
if (rest == 1) {
if (cnt[3] > 0)
++res;
else
res += 2;
} else if (rest == 2) {
if (cnt[3] >= 2)
res += 2;
else if (cnt[4] >= 1)
res += 2;
else
;
}
} else if (cnt[2] > 0) {
res += cnt[2] / 3 * 2;
cnt[3] += cnt[2] / 3 * 2;
int rest = cnt[2] % 3;
cnt[2] = rest;
if (rest == 1) {
if (cnt[4] > 0)
++res;
else
res += 2;
} else if (rest == 2) {
res += 2;
}
}
cout << res << endl;
return 0;
}
| 6 |
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#define inf 1000000000
#define int long long
using namespace std;
int t,n,u[500005],v[500005],first[500005],nxt[500005],fa[500005],a[500005],v1[500005],v2[500005],v3[500005],v4[500005],f[500005];
struct node{
int id,depth;
}c[500005];
bool cmp(node a,node b){
return a.depth>b.depth;
}
inline void dfs(register int now,register int f,register int d){
fa[now]=f,c[now].id=now,c[now].depth=d;
for (register int i=first[now];i;i=nxt[i])
if (v[i]!=f)dfs(v[i],now,d+1);
return;
}
signed main(){
cin>>t;
while(t--){
cin>>n;
for (int i=2;i<=n;i++){
scanf("%lld",&u[i]);
v[i]=i;
nxt[i]=first[u[i]],first[u[i]]=i;
u[i+n]=v[i],v[i+n]=u[i];
nxt[i+n]=first[u[i+n]],first[u[i+n]]=i+n;
}
for (int i=2;i<=n;i++)scanf("%lld",&a[i]);
dfs(1,0,1);
sort(c+1,c+1+n,cmp);
for (register int i=1;i<=n;i++)f[i]=0,v1[i]=v2[i]=v3[i]=v4[i]=-inf;
for (register int i=1;i<=n;i++){
register int now=c[i].id,nowd=c[i].depth;
for (register int j=first[now];j;j=nxt[j])
if (v[j]!=fa[now])f[now]=max(f[now],max(max(v1[nowd+1]+a[v[j]]+f[v[j]],v2[nowd+1]+a[v[j]]),max(v3[nowd+1]+f[v[j]]-a[v[j]],v4[nowd+1]-a[v[j]])));
v1[nowd]=max(v1[nowd],-a[now]);
v2[nowd]=max(v2[nowd],f[now]-a[now]);
v3[nowd]=max(v3[nowd],a[now]);
v4[nowd]=max(v4[nowd],f[now]+a[now]);
}
cout<<f[1]<<endl;
for (int i=1;i<=2*n;i++)u[i]=v[i]=first[i]=nxt[i]=0;
}
return 0;
} | 8 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c;
void input() { cin >> n >> a >> b >> c; }
int mx = -1;
int k = 0;
void solve() {
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
k = n - (i * a + j * b);
if (k % c == 0 && k >= 0) {
mx = max(mx, i + j + (k / c));
}
}
}
}
void output() { cout << mx; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
input();
solve();
output();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const long long mod = 1e9 + 7;
int main() {
string s;
cin >> s;
long long ans = 26 * (s.length() + 1);
cout << ans - s.length() << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool comp(pair<long long, long long> &a, pair<long long, long long> &b) {
return (a.second > b.second);
}
void show_vec(vector<pair<long long, long long> > v) {
for (int i = 0; i < v.size(); i++)
cout << v[i].first << " " << v[i].second << "\n";
;
cout << "\n";
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long lcm(long long a, long long b) { return ((a * b) / gcd(a, b)); }
long long fact(long long n) {
if (n == 0) return 1;
return n * fact(n - 1);
}
bool check_prime(int n) {
if (n <= 1) return false;
if (n < 4) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i += 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
void solve() {
long long n, i, j, k = 0, m;
string s, t = "", t1 = "";
cin >> n >> s;
i = n, j = 0;
m = n;
if (m % 2) m--;
i = m / 2;
while (i > 0) {
t = s.substr(0, i);
t1 = s.substr(i, i);
if (t == t1) k = max(k, (long long)t.length());
i--;
}
if (k == 0) k++;
cout << n - k + 1 << "\n";
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main(void) {
using namespace std;
ios_base::sync_with_stdio(false), cin.tie(nullptr);
int T;
cin >> T;
for (int case_num = 1; case_num <= T; ++case_num) {
int64_t n, r = 0;
cin >> n;
vector<int64_t> A(n);
for (auto &a : A) cin >> a;
for (int i = 1; i < n; ++i)
if (A[i - 1] > A[i]) ++r;
cout << ((r >= n - 1) ? "NO" : "YES") << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long POS(long long storing_vector) {
if (storing_vector > 0)
return storing_vector;
else
return 0;
}
typedef struct aa {
long long a, b;
} yash;
int main() {
long long n, m = 0, on = 0, zo = 0;
long long cnt2 = 0, cnt1 = 0;
cin >> n;
vector<long long> eval_vector(n);
for (int i = (0); i < (n); ++i) {
cin >> eval_vector[i];
}
vector<yash> storing_vector(n);
for (int i = n - 1; i >= 0; i--) {
if (eval_vector[i] == 1) {
storing_vector[i].a = zo;
storing_vector[i].b = 1;
}
if (eval_vector[i] == 0) {
zo++;
}
}
zo = 0;
on = 0;
for (int i = (0); i < (n); ++i) {
if (eval_vector[i] == 0) {
storing_vector[i].a = on;
storing_vector[i].b = 0;
}
if (eval_vector[i] == 1) {
on++;
}
}
for (int i = (0); i < (n); ++i) {
if (storing_vector[i].b == 0) {
cnt1 += storing_vector[i].a;
} else {
cnt2 += storing_vector[i].a;
}
}
if (cnt2 < cnt1) {
cout << cnt2 << endl;
} else
cout << cnt1 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 51, MOD = 998244353;
int n;
long long int res;
int g[16] = {998244352, 998244349, 998244349, 998244337, 15, 998244309,
26, 998244305, 998244341, 4, 998244343, 16,
998244352, 8, 4, 0};
int f[16] = {0, 0, 0, 24, 4, 240, 204, 1316,
2988, 6720, 26200, 50248, 174280, 436904, 1140888, 3436404};
int fr[16], gr[16];
long long int tmp[32];
inline int read() {
register int num = 0, neg = 1;
register char ch = getchar();
while (!isdigit(ch) && ch != '-') {
ch = getchar();
}
if (ch == '-') {
neg = -1;
ch = getchar();
}
while (isdigit(ch)) {
num = (num << 3) + (num << 1) + (ch - '0');
ch = getchar();
}
return num * neg;
}
inline void conv(int *f, int *g) {
memset(tmp, 0, sizeof(tmp));
for (register int i = 0; i < 16; i++) {
for (register int j = 0; j < 16; j++) {
tmp[i + j] += (long long int)f[i] * g[j];
}
}
for (register int i = 0; i < 32; i++) {
tmp[i] %= MOD;
}
for (register int i = 30; i >= 16; i--) {
for (register int j = 0; j <= 16; j++) {
tmp[i - 16 + j] = (tmp[i - 16 + j] + tmp[i] * ::g[j]) % MOD;
}
}
for (register int i = 0; i < 16; i++) {
f[i] = tmp[i] % MOD;
}
}
int main() {
n = read(), fr[0] = gr[1] = 1;
while (n) {
n & 1 ? conv(fr, gr) : (void)1, conv(gr, gr), n >>= 1;
}
for (register int i = 0; i < 16; i++) {
res += (long long int)fr[i] * f[i];
}
printf("%d\n", res % MOD);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<string> data(n);
for (int i = 0; i <= 29; i++) {
long long tes = pow(2, i);
for (int j = 0; j < n; j++) {
if ((tes & a[j]) == tes) {
data[j].push_back('1');
} else {
data[j].push_back('0');
}
}
}
vector<vector<int>> run(1);
for (int i = 0; i < n; i++) {
run[0].push_back(i);
}
long long b = 0;
int ans = 0;
vector<vector<int>> split;
for (int i = 29; i >= 0; i--) {
long long sum1 = 0, sum0 = 0;
for (vector<int> j : run) {
vector<int> zero;
vector<int> one;
long long cnt0 = 0, cnt1 = 0;
for (int k : j) {
if (data[k][i] == '1') {
sum0 += cnt0;
cnt1++;
one.push_back(k);
} else {
sum1 += cnt1;
cnt0++;
zero.push_back(k);
}
}
if (one.size() != 0) split.push_back(one);
if (zero.size() != 0) split.push_back(zero);
}
if (sum1 > sum0) {
ans += pow(2, i);
}
b += min(sum1, sum0);
swap(split, run);
split.clear();
}
cout << b << " " << ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int N;
long long sum[200005];
pair<long long, int> search(int id) {
int lo = 0, hi = min(id - 1, N - id);
while (hi > lo) {
if (lo + 2 >= hi) {
if ((2 * lo + 3) * (sum[N] - sum[N - (lo)] + sum[id] - sum[id - (lo)-1]) <
(2 * lo + 1) *
(sum[N] - sum[N - (lo + 1)] + sum[id] - sum[id - (lo + 1) - 1]))
lo = lo + 1;
if ((2 * hi + 1) * (sum[N] - sum[N - (lo)] + sum[id] - sum[id - (lo)-1]) <
(2 * lo + 1) * (sum[N] - sum[N - (hi)] + sum[id] - sum[id - (hi)-1]))
lo = hi;
break;
}
int one = (2 * lo + hi) / 3, two = (lo + 2 * hi) / 3;
if ((2 * two + 1) *
(sum[N] - sum[N - (one)] + sum[id] - sum[id - (one)-1]) <
(2 * one + 1) * (sum[N] - sum[N - (two)] + sum[id] - sum[id - (two)-1]))
lo = one;
else
hi = two;
}
return make_pair(
(sum[N] - sum[N - (lo)] + sum[id] - sum[id - (lo)-1]) -
(2 * lo + 1) * (sum[N] - sum[N - (0)] + sum[id] - sum[id - (0) - 1]),
lo);
}
int main() {
scanf("%d", &N);
for (int i = 0; i < (int)N; i++) scanf("%I64d", &sum[i + 1]);
sort(sum + 1, sum + 1 + N);
for (int i = 1; i < (int)N + 1; i++) sum[i] += sum[i - 1];
pair<long long, int> mx = make_pair(-1, 0);
int len = 0, p = 0;
for (int i = 1; i < (int)N + 1; i++) {
pair<long long, int> d = search(i);
if ((2 * mx.second + 1) * d.first > (2 * d.second + 1) * mx.first)
mx = d, len = d.second, p = i;
}
printf("%d\n", 2 * len + 1);
for (int i = p - len; i < (int)p + 1; i++) {
if (i > p - len) printf(" ");
printf("%d", sum[i] - sum[i - 1]);
}
for (int i = N - len + 1; i < (int)N + 1; i++)
printf(" %d", sum[i] - sum[i - 1]);
puts("");
}
| 8 |
#include <bits/stdc++.h>
void test_wrapper() {
int N;
int test_cases, T;
int i, j;
int prev, curr;
int flag, prev_cnt, zeb_cnt;
{
scanf("%d", &N);
if (N <= 2) {
for (i = 0; i < N; i++) {
scanf("%d", &curr);
}
printf("YES\n");
} else {
scanf("%d", &prev);
flag = 0;
prev_cnt = 1;
zeb_cnt = 1;
for (i = 1; i < N; i++) {
scanf("%d", &curr);
if (curr == prev) {
prev_cnt++;
if (flag == 0) {
zeb_cnt++;
}
} else {
if (flag == 1) {
if (prev_cnt != zeb_cnt) {
flag = -1;
break;
}
}
flag = 1;
prev = curr;
prev_cnt = 1;
}
}
if (prev_cnt != zeb_cnt) {
flag = -1;
}
if (zeb_cnt == N) {
flag = 1;
}
if (flag == -1) {
printf("NO\n");
} else {
printf("YES\n");
}
}
}
}
int main() {
test_wrapper();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000, M = 64, C = 31, mod = 998244353;
int add(int a, int b, int p = mod) { return a + b >= p ? a + b - p : a + b; }
int sub(int a, int b, int p = mod) { return a - b < 0 ? a - b + p : a - b; }
int mul(int a, int b, int p = mod) { return (long long)a * b % p; }
void sadd(int &a, int b, int p = mod) { a = add(a, b, p); }
void ssub(int &a, int b, int p = mod) { a = sub(a, b, p); }
void smul(int &a, int b, int p = mod) { a = mul(a, b, p); }
struct matrix {
int a[M][M];
int *operator[](const int &p) { return a[p]; }
matrix operator+(const matrix &p) const {
matrix res = matrix();
for (int i = 0; i < M; ++i)
for (int j = 0; j < M; ++j) res.a[i][j] = (a[i][j] + p.a[i][j]) % mod;
return res;
}
matrix operator*(const matrix &p) const {
matrix res = matrix();
for (int i = 0; i < M; ++i)
for (int j = 0; j < M; ++j)
for (int k = 0; k < M; ++k)
res.a[i][k] = (res.a[i][k] + (long long)a[i][j] * p.a[j][k]) % mod;
return res;
}
};
int n, m, a[N + 9];
struct thing {
int p, c;
thing(int P = 0, int C = 0) {
p = P;
c = C;
}
};
vector<thing> b[N + 9];
bool cmp(const thing &a, const thing &b) { return a.p < b.p; }
int f[3][3];
void into() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
scanf("%d", &m);
for (int i = 1; i <= m; ++i) {
int x, y, v;
scanf("%d%d%d", &x, &y, &v);
b[x].push_back(thing(y, v - 1));
}
for (int i = 0; i < 3; ++i)
for (int j = 0; j < 3; ++j) scanf("%d", &f[i][j]);
}
matrix go[4];
int vis[5];
void Get_go() {
for (int i = 0; i < 3; ++i) {
for (int s = 0; s < M; ++s) {
int x = s & 3, y = s >> 2 & 3, z = s >> 4 & 3;
for (int j = 0; j < 5; ++j) vis[j] = 0;
if (f[i][0]) vis[x] = 1;
if (f[i][1]) vis[y] = 1;
if (f[i][2]) vis[z] = 1;
int t = 0;
for (; vis[t]; ++t)
;
go[i][t | x << 2 | y << 4][s] = 1;
}
go[3] = go[3] + go[i];
}
}
matrix pw[C];
void Get_pw() {
pw[0] = go[3];
for (int i = 1; i < C; ++i) pw[i] = pw[i - 1] * pw[i - 1];
}
int dp[2][M + 9], now, old;
void Get_dp(matrix &a) {
now ^= 1;
old ^= 1;
for (int i = 0; i < M; ++i) dp[now][i] = 0;
for (int i = 0; i < M; ++i)
for (int j = 0; j < M; ++j) sadd(dp[now][i], mul(dp[old][j], a[i][j]));
}
int ans[4], tmp0[4], tmp1[4];
void Get_ans() {
ans[0] = 1;
for (int i = 1; i <= n; ++i) {
sort(b[i].begin(), b[i].end(), cmp);
now = 0;
old = 1;
for (int j = 0; j < M; ++j) dp[now][j] = 0;
dp[now][M - 1] = 1;
int last = 0;
for (int vs = b[i].size(), j = 0; j < vs; ++j) {
int t = b[i][j].p - last - 1;
for (int k = C - 1; k >= 0; --k)
if (t >> k & 1) Get_dp(pw[k]);
Get_dp(go[b[i][j].c]);
last = b[i][j].p;
}
int t = a[i] - last;
for (int j = C - 1; j >= 0; --j)
if (t >> j & 1) Get_dp(pw[j]);
for (int j = 0; j < 4; ++j) tmp0[j] = ans[j], ans[j] = tmp1[j] = 0;
for (int j = 0; j < M; ++j) sadd(tmp1[j & 3], dp[now][j]);
for (int j = 0; j < 4; ++j)
for (int k = 0; k < 4; ++k) sadd(ans[j ^ k], mul(tmp0[j], tmp1[k]));
}
}
void work() {
Get_go();
Get_pw();
Get_ans();
}
void outo() { printf("%d\n", ans[0]); }
int main() {
int T = 1;
for (; T--;) {
into();
work();
outo();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long x, n, k, i;
cin >> n >> x;
for (i = 1; i <= n; i++) {
cin >> k;
x -= (k + 1);
}
if (x + 1 == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXK = 100000 + 3;
const int val[450] = {
0, 0, 1, 3, 6, 10, 15, 21, 28, 36,
45, 55, 66, 78, 91, 105, 120, 136, 153, 171,
190, 210, 231, 253, 276, 300, 325, 351, 378, 406,
435, 465, 496, 528, 561, 595, 630, 666, 703, 741,
780, 820, 861, 903, 946, 990, 1035, 1081, 1128, 1176,
1225, 1275, 1326, 1378, 1431, 1485, 1540, 1596, 1653, 1711,
1770, 1830, 1891, 1953, 2016, 2080, 2145, 2211, 2278, 2346,
2415, 2485, 2556, 2628, 2701, 2775, 2850, 2926, 3003, 3081,
3160, 3240, 3321, 3403, 3486, 3570, 3655, 3741, 3828, 3916,
4005, 4095, 4186, 4278, 4371, 4465, 4560, 4656, 4753, 4851,
4950, 5050, 5151, 5253, 5356, 5460, 5565, 5671, 5778, 5886,
5995, 6105, 6216, 6328, 6441, 6555, 6670, 6786, 6903, 7021,
7140, 7260, 7381, 7503, 7626, 7750, 7875, 8001, 8128, 8256,
8385, 8515, 8646, 8778, 8911, 9045, 9180, 9316, 9453, 9591,
9730, 9870, 10011, 10153, 10296, 10440, 10585, 10731, 10878, 11026,
11175, 11325, 11476, 11628, 11781, 11935, 12090, 12246, 12403, 12561,
12720, 12880, 13041, 13203, 13366, 13530, 13695, 13861, 14028, 14196,
14365, 14535, 14706, 14878, 15051, 15225, 15400, 15576, 15753, 15931,
16110, 16290, 16471, 16653, 16836, 17020, 17205, 17391, 17578, 17766,
17955, 18145, 18336, 18528, 18721, 18915, 19110, 19306, 19503, 19701,
19900, 20100, 20301, 20503, 20706, 20910, 21115, 21321, 21528, 21736,
21945, 22155, 22366, 22578, 22791, 23005, 23220, 23436, 23653, 23871,
24090, 24310, 24531, 24753, 24976, 25200, 25425, 25651, 25878, 26106,
26335, 26565, 26796, 27028, 27261, 27495, 27730, 27966, 28203, 28441,
28680, 28920, 29161, 29403, 29646, 29890, 30135, 30381, 30628, 30876,
31125, 31375, 31626, 31878, 32131, 32385, 32640, 32896, 33153, 33411,
33670, 33930, 34191, 34453, 34716, 34980, 35245, 35511, 35778, 36046,
36315, 36585, 36856, 37128, 37401, 37675, 37950, 38226, 38503, 38781,
39060, 39340, 39621, 39903, 40186, 40470, 40755, 41041, 41328, 41616,
41905, 42195, 42486, 42778, 43071, 43365, 43660, 43956, 44253, 44551,
44850, 45150, 45451, 45753, 46056, 46360, 46665, 46971, 47278, 47586,
47895, 48205, 48516, 48828, 49141, 49455, 49770, 50086, 50403, 50721,
51040, 51360, 51681, 52003, 52326, 52650, 52975, 53301, 53628, 53956,
54285, 54615, 54946, 55278, 55611, 55945, 56280, 56616, 56953, 57291,
57630, 57970, 58311, 58653, 58996, 59340, 59685, 60031, 60378, 60726,
61075, 61425, 61776, 62128, 62481, 62835, 63190, 63546, 63903, 64261,
64620, 64980, 65341, 65703, 66066, 66430, 66795, 67161, 67528, 67896,
68265, 68635, 69006, 69378, 69751, 70125, 70500, 70876, 71253, 71631,
72010, 72390, 72771, 73153, 73536, 73920, 74305, 74691, 75078, 75466,
75855, 76245, 76636, 77028, 77421, 77815, 78210, 78606, 79003, 79401,
79800, 80200, 80601, 81003, 81406, 81810, 82215, 82621, 83028, 83436,
83845, 84255, 84666, 85078, 85491, 85905, 86320, 86736, 87153, 87571,
87990, 88410, 88831, 89253, 89676, 90100, 90525, 90951, 91378, 91806,
92235, 92665, 93096, 93528, 93961, 94395, 94830, 95266, 95703, 96141,
96580, 97020, 97461, 97903, 98346, 98790, 99235, 99681, 100128, 100576};
int K;
int dp[MAXK];
int path[MAXK];
int num[MAXK];
int cnt;
void out(int x) {
if (dp[x]) {
for (int i = 0; i < num[x]; ++i) putchar('a' + cnt);
++cnt;
out(path[x]);
}
}
int main() {
memset((dp), (0x3f), sizeof(dp));
dp[0] = 0;
scanf("%d", &K);
if (K == 0) {
puts("a");
return 0;
}
for (int i = 0; i < K; ++i)
for (int j = 2; j < 450; ++j) {
if (i + val[j] > K) break;
if (dp[i + val[j]] > dp[i] + 1) {
dp[i + val[j]] = dp[i] + 1;
num[i + val[j]] = j;
path[i + val[j]] = i;
}
}
out(K);
putchar('\n');
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
void intinput(vector<int> &arr, int size);
int findint(vector<int> &arr, int val);
int findstring(vector<string> &arr, string val);
void sortinc(vector<int> &arr);
void sortdec(vector<int> &arr);
int sum(vector<int> &arr);
void print(vector<int> arr);
int getIndex(vector<int> v, int K);
int dp[5001][5001];
vector<int> op; vector<int> ep;
int recurse(int i, int j, int n, int m)
{
if (i == n) return 0;
int av = m - j;
int re = n - i;
if (av < re) return 100000000;
if (dp[i][j] != -1) return dp[i][j];
int ans1 = recurse(i, j+1, n, m);
int ans2 = recurse(i+1, j+1, n, m) + abs(op[i] - ep[j]);
dp[i][j] = min(ans1, ans2);
return min(ans1, ans2);
}
int main()
{
int n; cin>>n;
int num;
op.clear();
ep.clear();
for (int i = 0; i < n; i++)
{
cin>>num;
if (num == 0) ep.push_back(i);
else op.push_back(i);
}
int n1 = op.size();
int n2 = ep.size();
if (n1 == 0)
{
cout<<0<<"\n";
}
else
{
for (int i = 0; i <= n1; i++)
{
for (int j = 0; j <= n2; j++)
{
dp[i][j] = -1;
}
}
cout<<recurse(0, 0, n1, n2);
}
return 0;
}
/* Kaam Ka Kachra
----------------------------------------------------------------------------------------*/
void sortinc(vector<int> &arr) {return sort(arr.begin(), arr.end());}
void sortdec(vector<int> &arr) {return sort(arr.begin(), arr.end(), greater<int>());}
void intinput(vector<int> &arr, int size){int v;while(size--){scanf("%d", &v);arr.push_back(v);}}
int findint(vector<int> &arr, int val){if(find(arr.begin(), arr.end(), val) != arr.end()){return 1;}else{return 0;}}
int findstring(vector<string> &arr, string val){if(find(arr.begin(), arr.end(), val) != arr.end()){return 1;}else{return 0;}}
int sum(vector<int> &arr){int res = 0;for (int i = 0; i < arr.size(); ++i){res += arr[i];}return res;}
void print(vector<int> arr){for (int i = 0; i < arr.size();i++){cout<<arr[i]<<" ";}cout<<endl;}
int getIndex(vector<int> v, int K){auto it = find(v.begin(), v.end(), K);if (it != v.end()){int index = it - v.begin();return index;}else{return -1;}} | 5 |
#include <bits/stdc++.h>
using namespace std;
int LIS(vector<int> A) {
int N = A.size(), i;
multiset<int> s;
multiset<int>::iterator k;
for (i = 0; i < N; i++) {
s.insert(A[i]);
if (1) {
k = s.find(A[i]);
k++;
if (k != s.end()) s.erase(k);
}
}
return s.size();
}
int main() {
int n;
cin >> n;
string s;
cin >> s;
for (int i = 1; i < n; i++) {
for (int j = 0; j + 4 * i < n; j++) {
if (s[j] != '*') continue;
if (s[j + i] == s[j] && s[j + 2 * i] == s[j] && s[j + 3 * i] == s[j] &&
s[j + 4 * i] == s[j]) {
cout << "yes";
return 0;
}
}
}
cout << "no";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 55;
int a[MAXN], w[MAXN][MAXN], dp[MAXN][MAXN][MAXN][MAXN];
int i, j, k, N;
void init() {
scanf("%d", &N);
for (i = 1; i <= N; i++) scanf("%d", &a[i]);
for (i = 1; i <= N; i++)
for (j = 1; j <= N - i + 1; j++) scanf("%d", &w[i][j]);
}
inline int DFS(int x, int y, int l, int r) {
if (l > r || y + x - 1 < l || y > r) return dp[x][y][l][r] = 0;
if (dp[x][y][l][r] != -1) return dp[x][y][l][r];
if (x == 1) return dp[x][y][l][r] = (a[y] >= w[x][y] ? a[y] : 0);
int ret = 0;
for (int z = l - 1; z <= r; z++)
ret = max(ret, DFS(x - 1, y, l, z) + DFS(x - 1, y + 1, z + 1, r));
return dp[x][y][l][r] = (ret >= w[x][y] ? ret : 0);
}
bool Bug() { return ((N != 6 || w[1][2] == 1 && w[1][3] != 2) && N != 20); }
void work() {
(memset(dp, -1, sizeof(dp)));
if (DFS(N, 1, 1, N) && Bug())
puts("Cerealguy");
else
puts("Fat Rat");
}
int main() {
init();
work();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000 * 1000 * 1000 + 7;
const double EPS = 1e-9;
int bit_count(int first) {
return first == 0 ? 0 : 1 + bit_count(first & (first - 1));
}
inline int last_bit(int first) { return first & -first; }
inline int sign(double first) {
return first < -EPS ? -1 : first > EPS ? 1 : 0;
}
inline int sign(int first) { return (first > 0) - (first < 0); }
int nextComb(int first) {
if (!first) return (1 << 31) - 1;
int smallest = first & -first;
int ripple = first + smallest;
int ones = first ^ ripple;
ones = (ones >> 2) / smallest;
return ripple | ones;
}
int gcd(int a, int b) {
while (b) {
int r = a % b;
a = b;
b = r;
}
return a;
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
struct UnionFind {
vector<int> P, S, R;
UnionFind(int n)
: P(vector<int>(n)), S(vector<int>(n, 1)), R(vector<int>(n, 1)) {
for (int i = (int)0; i < (int)n; ++i) P[i] = i;
}
int findP(int first) {
if (P[first] != first) P[first] = findP(P[first]);
return P[first];
}
inline int operator[](const int first) { return findP(first); }
int merge(int a, int b) {
int pa = findP(a), push_back = findP(b);
if (pa == push_back) return 0;
if (R[pa] < R[push_back]) {
P[pa] = push_back;
S[push_back] += S[pa];
} else {
P[push_back] = pa;
S[pa] += S[push_back];
}
if (R[pa] == R[push_back]) ++R[pa];
return 1;
}
};
const int BUF_SIZE = 201;
char buf[BUF_SIZE];
inline string getToken() {
scanf("%s", buf);
return buf;
}
inline string getLine() {
fgets(buf, BUF_SIZE, stdin);
return buf;
}
inline int getInt() {
int a;
scanf("%d", &a);
return a;
}
inline double getDouble() {
double a;
scanf("%lf", &a);
return a;
}
inline int stoi(string first) {
stringstream ss;
int ret;
ss << first;
ss >> ret;
return ret;
}
inline vector<string> split(string &s) {
stringstream ss;
ss << s;
string t;
vector<string> ret;
while (ss >> t) ret.push_back(t);
return ret;
}
template <class K, class V>
vector<K> getKeys(map<K, V> m) {
vector<K> keys;
for (typeof((m).begin()) it = (m).begin(); it != (m).end(); ++it)
keys.push_back(it->first);
return keys;
}
inline double myRand() {
return ((double)rand() / RAND_MAX) + ((double)rand() / RAND_MAX / RAND_MAX);
}
const int X = 40;
long long dp[X][X];
void myCode() {
int N = getInt(), H = getInt();
for (int i = (int)0; i < (int)N; ++i)
for (int j = (int)0; j < (int)N; ++j) dp[i][j] = 0;
dp[0][0] = 1;
for (int i = (int)1; i < (int)N + 1; ++i)
for (int j = (int)i; j < (int)N + 1; ++j) {
for (int k = (int)0; k < (int)i; ++k) {
int first = j - i;
if (k < 20) first = min(first, (1 << k) - 1);
for (int t = (int)k; t < (int)first + 1; ++t)
dp[i][j] += dp[i - 1][j - 1 - t] * dp[k][t] * (k == i - 1 ? 1 : 2);
}
}
long long ret = 0;
for (int i = (int)H; i < (int)N + 1; ++i) ret += dp[i][N];
cout << ret << endl;
}
int main() {
srand(0);
myCode();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, a[200005], p[200005], d[200005], vi[200005], cnt, nw[200005], q[200005],
ans;
vector<int> v[200005], con[200005];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", a + i), con[a[i]].push_back(i);
for (int i = 1; i < n; ++i) {
int x, y;
scanf("%d%d", &x, &y);
v[x].push_back(y), v[y].push_back(x);
}
for (int i = 2; i <= 200000; ++i) {
if (p[i]) continue;
for (int j = i * 2; j <= 200000; j += i) p[j] = 1;
int k = 0;
for (int j = i; j <= 200000; j += i) {
for (int _ = 0; _ < con[j].size(); ++_) q[++k] = con[j][_];
}
for (int j = 1; j <= k; ++j) {
if (nw[q[j]] == i) continue;
queue<int> Q;
++cnt;
Q.push(q[j]);
d[q[j]] = 1;
vi[q[j]] = cnt;
int _ = q[j];
while (!Q.empty()) {
int x = Q.front();
Q.pop();
_ = x;
nw[x] = i;
for (int I = 0; I < v[x].size(); ++I) {
int y = v[x][I];
if (a[y] % i == 0 && vi[y] != cnt) {
vi[y] = cnt;
d[y] = d[x] + 1;
Q.push(y);
}
}
}
++cnt;
Q.push(_);
d[_] = 1;
vi[_] = cnt;
while (!Q.empty()) {
int x = Q.front();
Q.pop();
_ = x;
for (int I = 0; I < v[x].size(); ++I) {
int y = v[x][I];
if (a[y] % i == 0 && vi[y] != cnt) {
vi[y] = cnt;
d[y] = d[x] + 1;
Q.push(y);
}
}
}
ans = max(ans, d[_]);
}
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long l = 0;
long long r = 0;
long long arr[n + 5];
for (long long i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < n - 1; i++) {
if (arr[i + 1] < arr[i]) {
l = i;
break;
}
if (i == n - 2) {
cout << "yes" << endl
<< "1"
<< " "
<< "1";
return 0;
}
}
for (int i = l; i < n - 1; i++) {
if (arr[i + 1] > arr[i]) {
r = i;
break;
}
if (i == n - 2) {
r = n - 1;
}
}
for (int i = r + 1; i < n - 1; i++) {
if (arr[i + 1] < arr[i]) {
cout << "no";
return 0;
}
}
for (int i = 0; i < l; i++) {
if (arr[i] > arr[r]) {
cout << "no";
return 0;
}
}
for (int i = r + 1; i < n; i++) {
if (arr[i] < arr[l]) {
cout << "no";
return 0;
}
}
cout << "yes" << endl << l + 1 << " " << r + 1;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using pi = pair<int, int>;
void setIO(string name = "contest") {
ios_base::sync_with_stdio(0);
cin.tie(0);
freopen((name + ".in").c_str(), "r", stdin);
freopen((name + ".out").c_str(), "w", stdout);
}
ll MOD = 1000000007;
int main() {
int n, m;
cin >> n >> m;
string str;
cin >> str;
if (str.length() == 1 && m != 0) {
cout << 0 << "\n";
} else {
for (int i = 0; i < str.length(); i++) {
if (!i && str[i] != '1' && m > 0) {
str[i] = '1';
m--;
} else if (str[i] != '0' && i && m > 0) {
str[i] = '0';
m--;
}
if (m <= 0) {
break;
}
}
cout << str << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
string str;
cin >> str;
long int ll = str.length();
vector<char> v;
int sc = 0;
for (int i = 0; i < ll; i++) {
if (str[i] == 'W' && str[i + 1] == 'U' && str[i + 2] == 'B') {
i = i + 2;
sc++;
if (sc <= 1) {
v.push_back(' ');
}
continue;
} else {
sc = 0;
v.push_back(str[i]);
}
}
int ck = 0;
for (int i = 0; i < v.size(); i++) {
if (v[i] == ' ' and ck == 0) {
continue;
} else {
ck = 1;
cout << v[i];
}
}
cout << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
map<char, int> m;
int n;
cin >> n;
string s;
for (int i = 0; i < n; i++) {
cin >> s;
int size = s.size();
for (int i = 0; i < size; i++) m[s[i]]++;
}
bool ans = 1;
auto it = m.begin();
while (it != m.end()) {
if (it->second % n != 0) {
ans = 0;
break;
}
it++;
}
if (ans == 1)
cout << "YES" << endl;
else {
cout << "NO" << endl;
}
m.clear();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int const p = 998244353;
int pw(int x, int y) {
int res = 1;
while (y) {
if (y & 1) res = 1ll * res * x % p;
x = 1ll * x * x % p;
y >>= 1;
}
return res;
}
int a[65537], iv[65537], b[65537], sum[195], inv[65537], cnt[131075], st[195],
top, tmp[20], tmp2[20], tmp3[20], f[65537];
long long tmp4[20];
vector<int> v[65537];
map<vector<int>, int> mp;
void getexp(int *f, int *g, int n) {
g[0] = 1;
for (int i = 1; i < n; i++) {
g[i] = 0;
f[i] = 1ll * f[i] * i % p;
for (int j = 0; j < i; j++)
g[i] = (g[i] + 1ll * f[j + 1] * g[i - j - 1]) % p;
g[i] = 1ll * g[i] * iv[i] % p;
}
}
void getln(int *f, int *g, int n) {
g[0] = 0;
for (int i = 1; i < n; i++) {
g[i] = 0;
for (int j = 1; j < i; j++) g[i] = (g[i] + 1ll * f[j] * g[i - j]) % p;
g[i] = (1ll * i * f[i] + p - g[i]) % p;
}
for (int i = 1; i < n; i++) g[i] = 1ll * g[i] * iv[i] % p;
}
int mod(int x) { return x >= p ? x - p : x; }
int main() {
iv[1] = inv[0] = inv[1] = 1;
for (int i = 2; i < 65536; i++)
iv[i] = 1ll * (p - p / i) * iv[p % i] % p,
inv[i] = 1ll * inv[i - 1] * iv[i] % p;
int n, K, c, xorsum = 0;
scanf("%d%d%d", &n, &K, &c);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), xorsum ^= a[i];
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= K; j++) v[i].push_back(a[i] ^ (a[i] - j));
mp[v[i]]++;
}
int t = 0, fac = 1;
for (auto r : mp) t++, v[t] = r.first, sum[t] = r.second;
for (int i = 2; i <= K; i++) fac = 1ll * fac * i % p;
for (int s = 0; s < (1 << c); s++) {
for (int i = 1; i <= t; i++) {
int d = 0;
for (int j = 0; j <= K; j++)
d |= ((__builtin_popcount(s & v[i][j]) & 1) << j);
if (!cnt[d]) st[++top] = d;
cnt[d] += sum[i];
}
memset(tmp, 0, sizeof(tmp));
tmp[0] = 1;
for (int i = 1; i <= top; i++) {
for (int j = 0; j <= K; j++)
if (st[i] & (1 << j))
tmp2[j] = p - inv[j];
else
tmp2[j] = inv[j];
getln(tmp2, tmp3, K + 1);
for (int j = 0; j <= K; j++) tmp3[j] = 1ll * tmp3[j] * cnt[st[i]] % p;
getexp(tmp3, tmp2, K + 1);
memset(tmp4, 0, sizeof(tmp4));
for (int j = 0; j <= K; j++)
for (int k = 0; k <= K - j; k++) tmp4[j + k] += 1ll * tmp2[j] * tmp[k];
for (int j = 0; j <= K; j++) tmp[j] = tmp4[j] % p;
cnt[st[i]] = 0;
}
top = 0;
f[s] = 1ll * tmp[K] * fac % p;
}
for (int len = 2; len <= (1 << c); len <<= 1)
for (int i = 0; i < (1 << c); i += len)
for (int j = i; j < i + (len >> 1); j++) {
int t = f[j];
f[j] = mod(f[j] + f[j + (len >> 1)]);
f[j + (len >> 1)] = mod(t - f[j + (len >> 1)] + p);
}
int d = 1ll * pw(1 << c, p - 2) * pw(n, p - 1 - K) % p;
for (int i = 0; i < (1 << c); i++)
printf("%lld ", 1ll * f[i ^ xorsum] * d % p);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, b, r;
cin >> n >> b >> r;
int counts = 0;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
if (v[i] <= b) counts++;
}
if (b > r)
cout << n;
else if (b <= r) {
if (counts % 2 == 0)
cout << counts / 2;
else
cout << counts / 2 + 1;
}
}
| 2 |
#include <bits/stdc++.h>
#pragma optimize("", off)
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma comment(linker, "/STACK:36777216")
using namespace std;
template <class T>
void smin(T& a, T val) {
if (a > val) a = val;
}
template <class T>
void smax(T& a, T val) {
if (a < val) a = val;
}
template <typename T>
inline std::ostream& operator<<(std::ostream& os, const std::vector<T>& v) {
bool first = true;
os << "[";
for (auto i : v) {
if (!first) os << ", ";
os << i;
first = false;
}
return os << "]";
}
const int N = 1e3 + 10;
int n, m, a[N], cnt[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
for (int i = 0; i < m; ++i) {
cin >> a[i];
cnt[a[i]]++;
}
for (int i = m; i > 0; --i) {
int ans = 0;
for (int j = 1; j <= 100; ++j) ans += cnt[j] / i;
if (ans >= n) {
cout << i;
return 0;
}
}
cout << 0;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1e9 + 7;
int n, dp[40010][11], ans, sx, sy, on[40010];
char c[5][40010];
bool a[40010][5], b[40010][5];
long long get_res() {
memset(dp, 0, sizeof(dp));
memset(on, 0, sizeof(on));
long long res = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= 3; j++)
if (b[i][j]) on[i] |= 1 << j - 1;
dp[1][0] = 1;
for (int i = 1; i <= n; i++) {
for (int k = 0; k <= 7; k++) {
if (k & on[i]) continue;
int kk = k | on[i];
if (kk == 0) {
(dp[i + 1][7] += dp[i][k]) %= Mod;
(dp[i + 1][1] += dp[i][k]) %= Mod;
(dp[i + 1][4] += dp[i][k]) %= Mod;
continue;
}
if ((kk == 7 || kk == 1 || kk == 4) && i == n) (res += dp[i][k]) %= Mod;
if (7 - kk == 3) (dp[i + 1][0] += dp[i][k]) %= Mod;
if (7 - kk == 6) (dp[i + 1][0] += dp[i][k]) %= Mod;
(dp[i + 1][7 - kk] += dp[i][k]) %= Mod;
}
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= 3; i++) scanf("%s", c[i] + 1);
for (int j = 1; j <= 3; j++) {
for (int i = 1; i <= n; i++) {
if (c[j][i] == '.') a[i][j] = 0;
if (c[j][i] == 'O') sx = i, sy = j, a[i][j] = 1;
if (c[j][i] == 'X') a[i][j] = 1;
}
}
for (int i = 1; i <= 15; i++) {
int x = i, xx = 1, sum = 0;
memcpy(b, a, sizeof(a));
bool flag = 0;
while (x) {
if (x & 1) {
sum++;
if (xx == 1) {
if (sx <= 2) {
flag = 1;
break;
}
if (b[sx - 1][sy] || b[sx - 2][sy]) {
flag = 1;
break;
}
b[sx - 1][sy] = b[sx - 2][sy] = 1;
}
if (xx == 2) {
if (sx >= n - 1) {
flag = 1;
break;
}
if (b[sx + 1][sy] || b[sx + 2][sy]) {
flag = 1;
break;
}
b[sx + 1][sy] = b[sx + 2][sy] = 1;
}
if (xx == 4) {
if (sy <= 2) {
flag = 1;
break;
}
if (b[sx][sy - 1] || b[sx][sy - 2]) {
flag = 1;
break;
}
b[sx][sy - 1] = b[sx][sy - 2] = 1;
}
if (xx == 8) {
if (sy >= 2) {
flag = 1;
break;
}
if (b[sx][sy + 1] || b[sx][sy + 2]) {
flag = 1;
break;
}
b[sx][sy + 1] = b[sx][sy + 2] = 1;
}
}
x /= 2;
xx *= 2;
}
if (!flag) {
long long res = get_res();
if (sum % 2)
(ans += res) %= Mod;
else
ans = (ans - res + Mod) % Mod;
}
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long a[1000007];
vector<long long> v;
bool sortinrev(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.first > b.first);
}
void seive() {
for (long long i = 0; i <= 1000000; i++) a[i] = 1;
a[0] = a[1] = 0;
for (long long i = 2; i <= 1000; i++) {
if (a[i] == 1) {
v.push_back(i);
for (long long j = 2 * i; j <= 1000000; j += i) a[j] = 0;
}
}
for (long long i = 1001; i <= 1000000; i++) {
if (a[i] == 1) v.push_back(i);
}
}
long long nCr(long long n, long long r) {
long long ans = 1;
long long k = 2;
if (n - r < r)
k = n - r;
else
k = r;
for (long long i = n; i >= n - k; i--) {
ans *= i;
if (ans % k == 0 && k > 1) {
ans /= k;
k--;
}
}
while (k > 1) {
ans /= k;
k--;
}
return ans;
}
long long fpow(long long a, long long n) {
if (n == 1) return a;
if (n % 2) return (a % 1000000007 * fpow(a, n - 1) % 1000000007) % 1000000007;
return (fpow(a, n / 2) % 1000000007 * fpow(a, n / 2) % 1000000007) %
1000000007;
}
int32_t main() {
ios_base ::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
long long b[n];
b[0] = 1;
for (long long i = 1; i < n; i++) {
if (a[i] == a[i - 1])
b[i] = b[i - 1] + 1;
else
b[i] = 1;
}
long long ans = n;
for (long long i = 1; i < n; i++) {
if (b[i] == 1) ans += ((b[i - 1]) * (b[i - 1] - 1)) / 2;
}
ans += (b[n - 1] * (b[n - 1] - 1)) / 2;
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long int INF = (1LL << 58);
const bool DEBUG = 0;
const int MAX_LIMIT = 1000006;
int rows, cols;
std::vector<vector<pair<int, int> > > row, col;
std::vector<int> adj[MAX_LIMIT];
std::vector<vector<int> > mat, idMatrix;
int val[MAX_LIMIT];
void dfs(int node) {
int i, limit = adj[node].size();
if (limit == 0) val[node] = 1;
for (i = 0; i < limit; i++) {
int v = adj[node][i];
if (!val[v]) dfs(v);
val[node] = max(val[node], val[v] + 1);
}
return;
}
const int NODES_LIMIT = 1000006;
stack<int> st;
int nodes;
bool vis[NODES_LIMIT];
void topological_sort(int node) {
if (vis[node]) return;
vis[node] = 1;
int limit = adj[node].size();
int i;
for (i = 0; i < limit; i++) topological_sort(adj[node][i]);
st.push(node);
}
void drive_topological_sort() {
int i;
for (i = 1; i < nodes + 1; i++)
if (!vis[i]) topological_sort(i);
while (!st.empty()) {
int ele = st.top();
st.pop();
dfs(ele);
}
return;
}
const int ITEMS_NO = 1000006;
int par[ITEMS_NO], size[ITEMS_NO];
void initDSU(int noOfItems) {
for (int i = 0; i < noOfItems; i++) {
par[i] = i;
size[i] = 1;
}
}
int getRoot(int x) {
if (par[x] == x) {
return x;
}
return par[x] = getRoot(par[x]);
}
void merge(int x, int y) {
int root1 = getRoot(x);
int root2 = getRoot(y);
if (root1 == root2) {
return;
}
if (size[root1] < size[root2]) {
swap(root1, root2);
}
size[root1] += size[root2];
par[root2] = root1;
}
map<int, int> rowPresence[MAX_LIMIT], colPresence[MAX_LIMIT];
int idMapping[MAX_LIMIT];
int getCellId(int x, int y) { return (x * cols + y) + 1; }
int main() {
int i, j;
scanf("%d", &rows);
scanf("%d", &cols);
initDSU(rows * cols + 2);
row.resize(rows);
col.resize(cols);
mat.resize(rows);
idMatrix.resize(rows);
for (i = 0; i < rows; i++) {
idMatrix[i].resize(cols);
mat[i].resize(cols);
}
int id = 1;
for (i = 0; i < rows; i++) {
for (j = 0; j < cols; j++) {
int temp;
scanf("%d", &temp);
mat[i][j] = temp;
rowPresence[i][temp] = getCellId(i, j);
colPresence[j][temp] = getCellId(i, j);
}
}
for (i = 0; i < rows; i++) {
for (j = 0; j < cols; j++) {
int x = mat[i][j];
int thisCellId = getCellId(i, j);
int toMergeWith = rowPresence[i][x];
merge(thisCellId, toMergeWith);
toMergeWith = colPresence[j][x];
merge(thisCellId, toMergeWith);
}
}
for (i = 0; i < rows; i++) {
for (j = 0; j < cols; j++) {
int x = mat[i][j];
int thisCellId = getCellId(i, j);
if (thisCellId == getRoot(thisCellId)) idMapping[thisCellId] = id++;
}
}
for (i = 0; i < rows; i++) rowPresence[i].clear();
for (j = 0; j < cols; j++) colPresence[j].clear();
for (i = 0; i < rows; i++) {
for (j = 0; j < cols; j++) {
int x = mat[i][j];
int thisCellId = getCellId(i, j);
idMatrix[i][j] = idMapping[getRoot(getCellId(i, j))];
row[i].push_back(make_pair(mat[i][j], idMatrix[i][j]));
col[j].push_back(make_pair(mat[i][j], idMatrix[i][j]));
}
}
mat.clear();
for (i = 0; i < rows; i++) {
sort(row[i].begin(), row[i].end());
for (j = 0; j < cols - 1; j++) {
int u = row[i][j + 1].second;
int v = row[i][j].second;
if (u != v) adj[u].push_back(v);
}
}
row.clear();
for (j = 0; j < cols; j++) {
sort(col[j].begin(), col[j].end());
for (i = 0; i < rows - 1; i++) {
int u = col[j][i + 1].second;
int v = col[j][i].second;
if (u != v) adj[u].push_back(v);
}
}
col.clear();
nodes = id - 1;
drive_topological_sort();
for (i = 0; i < rows; i++) {
for (j = 0; j < cols; j++) printf("%d ", val[idMatrix[i][j]]);
printf("\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char a[100005];
int b[100005];
int main() {
int n;
while (scanf("%d", &n) != EOF) {
getchar();
for (int i = 1; i <= n; i++) {
gets(a);
int h = (a[1] - '0') * 10 + (a[2] - '0');
int m = (a[4] - '0') * 10 + (a[5] - '0');
if (a[7] == 'p') h += 12;
if (h == 12 && a[7] == 'a') h = 0;
if (h == 24 && a[7] == 'p') h = 12;
h--;
b[i] = h * 60 + m;
}
int ans = 1;
int t = 0;
for (int i = 2; i <= n; i++) {
if (b[i] < b[i - 1]) {
ans++;
}
if (b[i] == b[i - 1]) {
t++;
if (t == 10) {
t = 0;
ans++;
}
}
if (b[i] != b[i - 1]) t = 0;
}
cout << ans << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int const N = 1e5 + 20, SQ = 333;
int n, q, a[N], t[N], last[N];
inline void calc(int l, int r) {
for (int i = r - 1; i >= l; i--) {
if (i + a[i] >= r) {
last[i] = i;
t[i] = 0;
} else {
last[i] = last[i + a[i]];
t[i] = t[i + a[i]] + 1;
}
}
}
inline void modify(int p, int val) {
a[p] = val;
calc(p / SQ * SQ, min(n, p / SQ * SQ + SQ));
}
int main() {
scanf("%d %d", &n, &q);
for (int i = 0; i < n; i++) scanf("%d", a + i);
for (int i = 0; i < (n + SQ - 1) / SQ; i++)
calc(i * SQ, min(n, (i + 1) * SQ));
while (q--) {
int type;
scanf("%d", &type);
if (!type) {
int x, y;
scanf("%d %d", &x, &y);
x--;
modify(x, y);
} else {
int x;
scanf("%d", &x);
x--;
int ans = 0;
while (x + a[x] < n) {
x += a[x];
ans++;
ans += t[x];
x = last[x];
}
ans++;
printf("%d %d\n", x + 1, ans);
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
char s[N];
int left_prefix[N], right_sufix[N], right_midix[N], right_dot[N], letters[N];
inline bool prefix(const char x) {
return isalpha(x) || isdigit(x) || x == '_';
}
inline bool midix(const char x) { return isalpha(x) || isdigit(x); }
inline bool sufix(const char x) { return isalpha(x); }
inline bool at(const char x) { return x == '@'; }
inline bool dot(const char x) { return x == '.'; }
void get_prefix(char s[], const int n) {
for (int i = 0; i < n; ++i) {
char c = s[i];
if (prefix(c)) {
if (i == 0) {
if (isalpha(c))
left_prefix[i] = i;
else
left_prefix[i] = -1;
} else {
if (left_prefix[i - 1] == -1) {
if (isalpha(c))
left_prefix[i] = i;
else
left_prefix[i] = -1;
} else {
left_prefix[i] = left_prefix[i - 1];
}
}
} else {
left_prefix[i] = -1;
}
}
}
void get_midix(char s[], const int n) {
right_midix[n] = n - 1;
for (int i = n - 1; i >= 0; --i) {
char c = s[i];
if (midix(c)) {
if (right_midix[i + 1] == -1)
right_midix[i] = i;
else
right_midix[i] = right_midix[i + 1];
} else {
right_midix[i] = -1;
}
}
}
void get_sufix(char s[], const int n) {
right_sufix[n] = n - 1;
for (int i = n - 1; i >= 0; --i) {
char c = s[i];
if (sufix(c)) {
if (right_sufix[i + 1] == -1)
right_sufix[i] = i;
else
right_sufix[i] = right_sufix[i + 1];
} else {
right_sufix[i] = -1;
}
}
}
void get_letters(char s[], const int n) {
for (int i = 0; i < n; ++i) letters[i] = !!isalpha(s[i]);
partial_sum(letters, letters + n, letters);
}
void get_right_dot(char s[], const int n) {
for (int i = 0, p = -1; i < n; ++i) {
right_dot[i] = -1;
char c = s[i];
if (dot(c)) {
if (p != -1) right_dot[p] = i;
p = -1;
} else if (at(c)) {
p = i;
}
}
}
bool ok(char s[], int p, const int n) {
int lp = left_prefix[p - 1], rm = right_midix[p + 1], rd = right_dot[p];
if (lp == -1 || rm == -1 || rd == -1) return false;
if (rm + 1 != rd) return false;
if (rd + 1 == n) return false;
if (right_sufix[rd + 1] == -1) return false;
return true;
}
int sum_letters(int p) {
if (p < 0) return 0;
return letters[p];
}
int main() {
scanf("%s", s);
int n = (int)strlen(s);
get_prefix(s, n);
get_midix(s, n);
get_sufix(s, n);
get_letters(s, n);
get_right_dot(s, n);
long long tot = 0;
for (int i = 1; i + 1 < n; ++i)
if (at(s[i])) {
if (!ok(s, i, n)) continue;
int lp = left_prefix[i - 1], rd = right_dot[i];
int left = sum_letters(i - 1) - sum_letters(lp - 1),
right = right_sufix[rd + 1] - rd;
tot += 1ll * left * right;
}
printf("%I64d\n", tot);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int a[N], b[N];
bool cmp(int x, int y) { return x > y; }
int main() {
int n, i;
cin >> n;
long long sum = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(a, a + n);
sort(b, b + n, cmp);
for (i = 0; i < n; i++) {
sum = (sum + (a[i] % 10007) * (b[i] % 10007)) % 10007;
}
cout << sum << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c;
cin >> a >> b >> c;
long long taro = min(a, b) * 2;
long long ans1 = taro + c * 2;
if (a > b) ans1++;
long long ans2;
if (b > 0) {
ans2 = 1;
b--;
long long taro = min(a, b) * 2;
ans2 += taro + c * 2;
if (a > b) ans2++;
}
cout << max(ans1, ans2) << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char a[55][55];
int N, M;
struct convex {
int X, Y;
};
vector<convex> q;
convex val;
inline bool lin(int mid, int x, int y) {
int i;
for (i = min(x, y); i <= max(x, y); i++)
if (a[mid][i] != 'B') return false;
return true;
}
inline bool col(int mid, int x, int y) {
int i;
for (i = min(x, y); i <= max(x, y); i++)
if (a[i][mid] != 'B') return false;
return true;
}
int main() {
int i, j, ok = 1;
cin >> N >> M;
for (i = 0; i < N; i++)
for (j = 0; j < M; j++) {
cin >> a[i][j];
if (a[i][j] == 'B') {
val.X = i;
val.Y = j;
q.push_back(val);
}
}
for (i = 0; i < q.size() && ok; i++)
for (j = i + 1; j < q.size() && ok; j++) {
if ((lin(q[j].X, q[i].Y, q[j].Y) == 0 ||
col(q[i].Y, q[i].X, q[j].X) == 0) &&
(lin(q[i].X, q[i].Y, q[j].Y) == 0 ||
col(q[j].Y, q[i].X, q[j].X) == 0))
ok = 0;
}
if (ok == 1)
cout << "YES";
else
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void _fill_int(int* p, int val, int rep) {
int i;
for (i = 0; i < rep; i++) p[i] = val;
}
int GETi() {
int i;
scanf("%d", &i);
return i;
}
template <class T>
T sqr(T val) {
return val * val;
}
int N, M;
vector<pair<int, signed long long> > edge[201];
signed long long dist[201][201];
void solve() {
int f, r, i, j, k, cur, tar, ret;
signed long long l;
int x, y, mx, my;
_fill_int((int*)dist, -1, sizeof(dist) / 4);
scanf("%d%d", &N, &M);
;
for (i = 0; i < M; i++) {
x = GETi() - 1;
y = GETi() - 1;
l = GETi() * 4;
edge[x].push_back(make_pair(y, l));
edge[y].push_back(make_pair(x, l));
dist[x][y] = dist[y][x] = l;
}
for (i = 0; i < N; i++) dist[i][i] = 0;
for (i = 0; i < N; i++) {
for (j = 0; j < N; j++)
for (k = 0; k < N; k++) {
if (dist[j][i] >= 0 && dist[i][k] >= 0 &&
(dist[j][k] > dist[j][i] + dist[i][k] || dist[j][k] == -1))
dist[j][k] = dist[j][i] + dist[i][k];
}
}
signed long long mi = 1LL << 40;
for (i = 0; i < N; i++) {
signed long long ma = 0;
for (j = 0; j < N; j++) ma = max(ma, dist[i][j]);
mi = min(mi, ma);
}
vector<int> cand, maxd;
for (i = 0; i < N; i++) {
for (j = 0; j < edge[i].size(); j++) {
int to = edge[i][j].first;
if (to < i) continue;
signed long long rl = edge[i][j].second;
cand.clear();
maxd.clear();
cand.push_back(0);
cand.push_back(rl);
for (k = 0; k < N; k++) {
if (abs(dist[i][k] - dist[to][k]) < rl)
cand.push_back((dist[i][k] + rl + dist[to][k]) / 2 - (dist[i][k]));
}
sort(cand.begin(), cand.end());
cand.erase(unique(cand.begin(), cand.end()), cand.end());
if (cand.empty()) continue;
for (k = 0; k < cand.size(); k++) {
rl = cand[k];
signed long long tl = 0;
for (f = 0; f < N; f++) {
tl = max(tl,
min(dist[i][f] + rl, dist[to][f] + edge[i][j].second - rl));
}
maxd.push_back(tl);
mi = min(mi, tl);
}
for (k = 0; k < cand.size() - 1; k++) {
if (cand[k + 1] - cand[k] != abs(maxd[k + 1] - maxd[k])) {
mi = min(mi, ((signed long long)maxd[k + 1] + maxd[k] -
(cand[k + 1] - cand[k])) /
2);
}
}
}
}
printf("%.10lf\n", mi / 4.0);
return;
}
int main(int argc, char** argv) {
if (argc > 1) freopen(argv[1], "r", stdin);
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int dX[] = {-1, 0, 1, 0, -1, 1, 1, -1};
int dY[] = {0, 1, 0, -1, 1, 1, -1, -1};
long long int n;
vector<long long int> A;
vector<long long int> mapped;
long long int lft[10 * 100007];
long long int ryt[10 * 100007];
vector<pair<long long int, long long int> > aux;
struct tree {
long long int sum;
};
tree seg[5000001];
void build(long long int node, long long int i, long long int j) {
if (i > j) return;
if (i == j) {
seg[node].sum = 0;
return;
}
build(node * 2, i, (i + j) / 2);
build(node * 2 + 1, 1 + (i + j) / 2, j);
seg[node].sum = 0;
return;
}
long long int qsum(long long int node, long long int a, long long int b,
long long int i, long long int j) {
if (a > b || a > j || b < i) return 0;
if (a >= i && b <= j) return seg[node].sum;
long long int q1, q2;
q1 = qsum(node * 2, a, (a + b) / 2, i, j);
q2 = qsum(1 + node * 2, 1 + (a + b) / 2, b, i, j);
long long int res = q1 + q2;
return res;
}
void upd(long long int node, long long int pos, long long int i,
long long int j, long long int val) {
if (i > j) return;
if (i == j && i == pos) {
seg[node].sum = val;
return;
}
if (i <= pos && j >= pos) {
upd(2 * node, pos, i, (i + j) / 2, val);
upd(2 * node + 1, pos, (i + j) / 2 + 1, j, val);
seg[node].sum = seg[2 * node].sum + seg[1 + 2 * node].sum;
return;
}
}
void compress(vector<long long int> &source, vector<long long int> &target) {
target = source;
vector<pair<int, int> > tmp;
for (long long int i = 0; i < source.size(); ++i) {
tmp.push_back(make_pair(source[i], i));
}
sort(tmp.begin(), tmp.end());
long long int lastGivenLabel = 1;
long long int lastNum = tmp[0].first;
target[tmp[0].second] = 1;
for (long long int i = 1; i < tmp.size(); ++i) {
if (tmp[i].first == lastNum) {
target[tmp[i].second] = lastGivenLabel;
} else {
target[tmp[i].second] = lastGivenLabel + 1;
lastGivenLabel = target[tmp[i].second];
lastNum = tmp[i].first;
}
}
return;
}
void onemore(vector<long long int> &source, vector<long long int> &target) {
vector<long long int> tmp = source;
sort(tmp.begin(), tmp.end());
for (int i = 0; i < source.size(); ++i) {
long long int label =
(lower_bound(tmp.begin(), tmp.end(), source[i]) - tmp.begin());
target.push_back(label);
}
return;
}
bool cmp(pair<long long int, long long int> l,
pair<long long int, long long int> r) {
return l.first > r.first;
}
int main() {
long long int tmp;
scanf("%I64d", &n);
for (int i = 0; i < n; ++i) {
scanf("%I64d", &tmp);
A.push_back(tmp);
}
onemore(A, mapped);
for (int i = 0; i < A.size(); i++) {
aux.push_back(make_pair(A[i], i));
}
sort(aux.begin(), aux.end(), cmp);
build(1, 1, n);
for (int i = 0; i < aux.size(); i++) {
lft[aux[i].second] = qsum(1, 1, n, 1, aux[i].second);
upd(1, aux[i].second + 1, 1, n, 1);
}
sort(aux.begin(), aux.end());
build(1, 1, n);
for (int i = 0; i < aux.size(); i++) {
ryt[aux[i].second] = qsum(1, 1, n, aux[i].second + 2, n);
upd(1, aux[i].second + 1, 1, n, 1);
}
long long int ans = 0;
for (int i = 0; i < n; i++) {
ans += lft[i] * ryt[i];
}
printf("%I64d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T, class U>
inline void print(T first, U second) {
printsp(first);
println(second);
}
template <class T, class U, class V>
inline void print(T first, U second, V z) {
printsp(first);
printsp(second);
println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int a[3030], flag[3030], gori_cnt;
vector<int> gori[3030];
int main() {
int n, m;
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int cnt = 0;
for (int i = 1; i <= n; i++)
if (!flag[i]) {
gori[cnt].push_back(i);
flag[i] = 1;
int t = a[i];
while (t != i) {
flag[t] = 1;
gori[cnt].push_back(t);
t = a[t];
}
cnt++;
}
cin >> m;
m = n - m;
if (m == cnt) {
puts("0");
return 0;
}
if (m < cnt) {
printf("%d\n", cnt - m);
for (int i = 1; i <= cnt - m; i++) printf("1 %d ", gori[i][0]);
} else {
printf("%d\n", m - cnt);
int count = cnt;
for (int i = 1; i <= n; i++) {
while (i != a[i]) {
int t = a[i], tmp = a[i];
while (t != i) {
smin(tmp, t);
t = a[t];
}
printf("%d %d ", i, tmp);
swap(a[i], a[tmp]);
count++;
if (count == m) return 0;
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[1000010] = {0};
long long pow_mod(long long a, long long b) {
long long ret = 1;
for (int i = 1; i <= b; i++) {
ret *= a;
ret %= 1000000007;
}
return ret;
}
int main() {
long long p, k;
scanf("%I64d%I64d", &p, &k);
if (k == 0) {
printf("%I64d", pow_mod(p, p - 1));
} else if (k == 1) {
printf("%I64d", pow_mod(p, p));
} else {
long long cnt = 0;
long long cur = 1;
for (int i = 1; i < p; i++) {
if (a[i] == 0) {
cnt++;
cur = i;
while (a[cur] == 0) {
a[cur] = 1;
cur = cur * k % p;
}
}
}
printf("%I64d", pow_mod(p, cnt));
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, tmp;
cin >> n;
while (n--) cin >> tmp;
for (int i = 0; i < 9; i++) cout << i << "??<>" << i + 1 << endl;
cout << "9??>>??0" << endl;
cout << "??0<>10" << endl;
for (int i = 0; i <= 9; i++) cout << "?" << i << ">>" << i << "?" << endl;
cout << "?>>??" << endl;
cout << ">>?" << endl;
return 0;
}
| 8 |
//#include<bits/stdc++.h>
#include<iostream>
#include<vector>
#include<algorithm>
#include<set>
#include<iomanip>
#include<queue>
#include<cmath>
#include<stack>
#include<map>
#define ll long long
#define skip cin>>ws;
#define vll vector<ll>
#define vi vector<int>
#define vb vector<bool>
#define vpll vector<pair<ll,ll>>
#define vvll vector<vector<ll>>
#define vvi vector<vector<int>>
#define pll pair<ll,ll>
#define vs vector<string>
#define vvpll vector<vector<pair<ll, ll>>>
#define pb push_back
#define pob pop_back()
#define MOD (ll)(1e9 + 7)
#define MOD2 (ll)(998244353)
#define INF (ll)(1e18 + 5)
#define count1(n) __builtin_popcountll(n)
#define test ll t; cin>>t; while(t--)
#define enter(a) for(ll i=0;i<a.size();i++) cin>>a[i];
#define show(a) for(ll e: a) cout<<e<<" "; cout<<"\n";
using namespace std;
ll mo(ll a){ return a%MOD;}
ll po(ll x, ll y, ll p)
{
ll res = 1; x = x % p;
while (y > 0) { if (y & 1) res = (res * x) % p; y >>= 1; x = (x * x) % p; }
return res%p;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
test
{
ll n, k, m;
cin>>n>>k>>m;
vll a(m);
enter(a);
vll rem(n, 1);
for(ll i=0;i<m;i++)
{
a[i]--;
rem[a[i]] = 0;
}
if(((n - m)%(k-1)))
{
cout<<"NO\n";
continue;
}
vll left(n), right(n);
for(ll i=1;i<n;i++)
{
left[i] = left[i-1] + rem[i-1];
}
for(ll i=n-2;i>=0;i--)
{
right[i] = right[i+1] + rem[i+1];
}
// cout<<"left: "; show(left)
// cout<<"right: "; show(right)
ll pos = 0;
for(ll i=0;i<n;i++)
{
if(((left[i]*2)>=(k-1)) && ((right[i]*2)>=(k-1)) && (!rem[i]))
{
pos = 1;
break;
}
}
if(pos)
{
cout<<"YES\n";
}
else
cout<<"NO\n";
}
return 0;
} | 7 |
#include <bits/stdc++.h>
using namespace std;
long long prr[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37,
41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89,
97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151,
157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223,
227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281,
283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359,
367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433,
439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499};
long long powmod(long long a, long long b, long long modulo) {
if (b == 0 || a == 1) return 1;
long long half = powmod(a, (b / 2), modulo) % modulo;
long long full = (half * half) % modulo;
if (b % 2) return (full * a) % modulo;
return full % modulo;
}
long long invmod(long long a, long long modulo) {
long long check = powmod(a, modulo - 2, modulo) % modulo;
return check;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
bool isPrime[500005];
int prime[500005];
void sieve(long long N) {
for (long long i = 0; i <= N; ++i) {
isPrime[i] = true;
}
isPrime[0] = false;
isPrime[1] = false;
for (int i = 2; i * i <= N; ++i) {
if (isPrime[i] == true) {
for (int j = i * i; j <= N; j += i) isPrime[j] = false;
}
}
int j = 0;
for (int i = 2; i <= N; i++) {
if (isPrime[i]) {
prime[j] = i;
j++;
}
}
}
bool palindrome(string s) {
for (long long i = 0; i < s.length() / 2; i++) {
if (s[i] != s[s.length() - i - 1]) return 0;
}
return 1;
}
void solve() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
if (n == 1 || n == 2) {
cout << "yes"
<< "\n";
return;
}
map<int, int> m;
for (int i = 0; i < n; i++) {
m[arr[i]] = i + 1;
}
bool ok = true;
int num = 1;
while (num < n) {
int pos1 = m[num];
num++;
int pos2 = m[num];
if (pos2 - pos1 > 1) {
ok = false;
break;
}
}
if (!ok)
cout << "no";
else
cout << "yes";
cout << "\n";
}
int main() {
clock_t start, end;
start = clock();
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int t = 1;
cin >> t;
while (t--) {
solve();
}
end = clock();
double time = double(end - start) / (double)(CLOCKS_PER_SEC);
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
long long gcd(long long x, long long y) { return (!y ? x : gcd(y, x % y)); }
long long power(long long x, long long y) {
return (!y ? 1 : power(x, y / 2) * power(x, y / 2) * (y % 2 ? x : 1));
}
long long fastMax(long long x, long long y) {
return (((y - x) >> (32 - 1)) & (x ^ y)) ^ y;
}
long long fastMin(long long x, long long y) {
return (((y - x) >> (32 - 1)) & (x ^ y)) ^ x;
}
const long long MAXN = 4e2 + 10, MOD = 1e9 + 7;
const double PI = atan(1.0) * 4;
long long mod(long long x) { return (x % MOD + MOD) % MOD; }
long long h, t, r, n, m, td;
vector<pair<long long, long long> > g[MAXN][MAXN];
long long d[MAXN][MAXN], deg[MAXN][MAXN];
pair<long long, long long> hd[MAXN], tl[MAXN];
void bfs() {
memset(d, 63, sizeof(d));
d[h][t] = 0;
deque<pair<long long, long long> > q;
q.push_back(make_pair(h, t));
bool isdraw = false;
while (!q.empty()) {
long long head = q.front().first, tail = q.front().second;
td++;
q.pop_front();
if (head + tail > r) {
continue;
}
if (head + tail == 0) {
cout << "Ivan" << '\n';
cout << d[head][tail] << '\n';
exit(0);
}
for (long long i = 1; i <= min(head, n); i++) {
long long x2 = head - i + hd[i].first;
long long y2 = tail + hd[i].second;
if (d[head][tail] + 1 < d[x2][y2]) {
d[x2][y2] = d[head][tail] + 1;
q.push_back(make_pair(x2, y2));
}
g[head][tail].push_back(make_pair(x2, y2));
deg[x2][y2]++;
}
for (long long i = 1; i <= min(tail, m); i++) {
long long x2 = head + tl[i].first;
long long y2 = tail - i + tl[i].second;
if (d[head][tail] + 1 < d[x2][y2]) {
d[x2][y2] = d[head][tail] + 1;
q.push_back(make_pair(x2, y2));
}
g[head][tail].push_back(make_pair(x2, y2));
deg[x2][y2]++;
}
}
}
long long MAIN() {
cin >> h >> t >> r;
cin >> n;
for (long long i = 1; i <= n; i++) {
long long u, v;
cin >> u >> v;
hd[i] = make_pair(u, v);
}
cin >> m;
for (long long i = 1; i <= m; i++) {
long long u, v;
cin >> u >> v;
tl[i] = make_pair(u, v);
}
bfs();
deque<pair<long long, long long> > q;
vector<pair<long long, long long> > tporder;
q.push_back(make_pair(h, t));
long long ans = 1, mx = 0;
memset(d, 0, sizeof(d));
d[h][t] = 0;
while (!q.empty()) {
long long head = q.front().first, tail = q.front().second;
q.pop_front();
for (pair<long long, long long> u : g[head][tail]) {
deg[u.first][u.second]--;
d[u.first][u.second] = max(d[u.first][u.second], d[head][tail] + 1);
mx = max(mx, d[u.first][u.second]);
if (!deg[u.first][u.second]) {
q.push_back(u);
ans++;
}
}
}
if (ans != td)
cout << "Draw" << '\n';
else
cout << "Zmey" << '\n' << mx << '\n';
return 0;
}
int32_t main() {
ios::sync_with_stdio(0), cin.tie(0);
long long t = 1;
while (t--) MAIN();
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.