solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
const int maxn = 1 << 18, mod = 998244353, proot = 3, base = (mod - 1) / maxn,
inv2 = mod + 1 >> 1;
int w[maxn], rw[maxn];
inline int pow_mod(int x, int n) {
int y = 1;
while (n) {
if (n & 1) {
y = 1ll * y * x % mod;
}
x = 1ll * x * x % mod;
n >>= 1;
}
return y;
}
void fft_init() {
w[0] = rw[0] = 1;
w[1] = pow_mod(proot, base);
rw[1] = pow_mod(w[1], mod - 2);
for (int i = 2; i < maxn; ++i) {
w[i] = 1ll * w[i - 1] * w[1] % mod;
rw[i] = 1ll * rw[i - 1] * rw[1] % mod;
}
return;
}
inline void swap(int &x, int &y) {
x ^= y;
y ^= x;
x ^= y;
return;
}
inline void dft(int n, int *a, int *W, bool rev = 0) {
for (int i = 0, j = 0; i < n; ++i) {
if (i > j) {
swap(a[i], a[j]);
}
for (int k = n >> 1; (j ^= k) < k; k >>= 1)
;
}
for (int hl = 1, l = 2, stp = maxn / l; l <= n; hl = l, l <<= 1, stp >>= 1) {
for (int i = 0; i < n; i += l) {
for (int j = i, k = i | hl, p = 0; j < (i | hl); ++j, ++k, p += stp) {
int t = 1ll * a[k] * W[p] % mod;
a[k] = (a[j] - t + mod) % mod;
(a[j] += t) %= mod;
}
}
}
if (rev) {
int inv = pow_mod(n, mod - 2);
for (int i = 0; i < n; ++i) {
a[i] = 1ll * a[i] * inv % mod;
}
}
return;
}
int a[maxn], b[maxn], c[maxn], tmp[maxn];
void inv(int N, int *a, int *b) {
memset(b, 0, sizeof(int) * N << 1);
b[0] = pow_mod(a[0], mod - 2);
for (int m = 1, n = 2, nn = 4; n <= N; m = n, n = nn, nn <<= 1) {
memcpy(tmp, a, sizeof(int) * n);
memset(tmp + n, 0, sizeof(int) * n);
dft(nn, b, w);
dft(nn, tmp, w);
for (int i = 0; i < nn; ++i) {
b[i] = 1ll * b[i] * ((2ll - 1ll * b[i] * tmp[i]) % mod + mod) % mod;
}
dft(nn, b, rw, 1);
memset(b + n, 0, sizeof(int) * n);
}
return;
}
void sqrrt(int N, int *a, int *b) {
b[0] = 1;
for (int m = 1, n = 2, nn = 4; n <= N; m = n, n = nn, nn <<= 1) {
inv(n, b, c);
memcpy(tmp, a, sizeof(int) * n);
memset(tmp + n, 0, sizeof(int) * n);
dft(nn, tmp, w);
dft(nn, c, w);
for (int i = 0; i < nn; ++i) {
tmp[i] = 1ll * tmp[i] * c[i] % mod;
}
dft(nn, tmp, rw, 1);
for (int i = 0; i < n; ++i) {
b[i] = 1ll * inv2 * (b[i] + tmp[i]) % mod;
}
}
return;
}
char s[10000000], *S;
inline void R(int &x) {
x = 0;
while (*S < '0' || *S > '9') {
++S;
}
while (*S >= '0' && *S <= '9') {
(x *= 10) += *S - '0';
++S;
}
return;
}
inline void W(int x) {
if (!x) {
*S++ = '0';
} else {
static char c[12];
char *t = c;
while (x) {
int y = x / 10;
*t++ = x - y * 10 + '0';
x = y;
}
while (t != c) {
*S++ = *--t;
}
}
*S++ = '\n';
return;
}
int main() {
fft_init();
int N, m, n;
fread(s, 1, 10000000, stdin);
S = s;
R(N);
R(m);
while (N--) {
int x;
R(x);
a[x] = 998244349;
}
a[0] = 1;
n = 1;
while (n <= m) {
n <<= 1;
}
sqrrt(n, a, b);
++b[0];
inv(n, b, a);
S = s;
for (int i = 1; i <= m; ++i) {
W((a[i] << 1) % mod);
}
fwrite(s, 1, S - s, stdout);
return 0;
}
| 11 |
#include <bits/stdc++.h>
#pragma GCC target("sse4.2")
using namespace std;
bool home = 1;
signed realMain();
signed main() {
home = 0;
if (home) {
freopen("tony_stark", "r", stdin);
} else {
ios::sync_with_stdio(0);
cin.tie(0);
}
realMain();
}
const long long B = 61;
const long long N = (long long)1e5 + 7;
const long long INF = (long long)1e18;
long long n, a[N], dp[B][N];
long long cnt[3];
signed realMain() {
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
for (long long i = 1; i <= n; i++) {
a[i] = a[n] - a[i];
}
for (long long b = 0; b < B; b++) {
for (long long i = 0; i < N; i++) {
dp[b][i] = INF;
}
}
{
long long ones = 0;
for (long long i = 1; i <= n; i++) {
if (a[i] % 2 == 1) {
ones++;
}
}
dp[0][0] = ones;
dp[0][ones] = min(dp[0][ones], n - ones);
}
for (long long b = 0; b + 1 < B; b++) {
cnt[0] = cnt[1] = cnt[2] = 0;
vector<pair<long long, long long>> ks;
vector<long long> k;
for (long long i = 1; i <= n; i++) {
ks.push_back({a[i] % (1LL << (b + 1)), i});
long long now = !!(a[i] & (1LL << (b + 1)));
cnt[now]++;
}
sort(ks.rbegin(), ks.rend());
for (auto &it : ks) k.push_back(it.second);
for (long long pre = 0; pre <= n; pre++) {
if (pre) {
long long now = !!(a[k[pre - 1]] & (1LL << (b + 1)));
cnt[now]--;
cnt[now + 1]++;
}
if (dp[b][pre] == INF) continue;
for (long long put = 0; put <= 1; put++) {
long long cntt = 0, relax = dp[b][pre];
for (long long bef = 0; bef <= 2; bef++) {
long long will_be = (bef + put) % 2;
long long will_carry = (bef + put) / 2;
relax += will_be * cnt[bef];
cntt += will_carry * cnt[bef];
}
dp[b + 1][cntt] = min(dp[b + 1][cntt], relax);
}
}
}
long long ret = dp[B - 1][0];
cout << ret << "\n";
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, neg = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') neg = -1;
c = getchar();
}
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
return x * neg;
}
inline void print(int x) {
if (x < 0) {
putchar('-');
print(abs(x));
return;
}
if (x <= 9)
putchar(x + '0');
else {
print(x / 10);
putchar(x % 10 + '0');
}
}
int n, m, k, a[3505], mx[100005];
inline void solve() {
cin >> n >> m >> k;
k = min(m, k);
memset(a, 0, sizeof(a));
memset(mx, 0, sizeof(mx));
for (int i = 1; i <= n; i++) a[i] = read();
if (m == k) {
int ans = 0;
for (int i = 1; i <= k; i++) ans = max(ans, a[i]);
for (int i = n - k + 1; i <= n; i++) ans = max(ans, a[i]);
cout << ans << endl;
return;
}
for (int i = 1; i <= m; i++) {
mx[i] = max(a[i], a[i + n - m]);
}
multiset<int> st;
for (int i = 1; i <= (n - k) - (n - m); i++) {
st.insert(mx[i]);
}
int l = 1, r = ((n - k) - (n - m));
int ans = 0;
while (r <= n) {
ans = max(ans, *st.begin());
st.erase(st.find(mx[l++]));
r++;
if (r == n + 1) break;
st.insert(mx[r]);
}
cout << ans << endl;
}
int main() {
int T = read();
while (T--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
const double PI = 2 * acos(0.0);
const long long MOD = 1000000007;
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
;
long long int n, i, j, index = 0, l, b_size = 0, c_size = 0, flag = 1,
cnt = 0;
string a, b, c;
cin >> a;
l = a.size();
for (i = l - 1; i >= 0; i--) {
if (a[i] == 'a') {
index = i;
flag = 0;
break;
}
b.push_back(a[i]);
}
if (flag) {
b.clear();
if (l % 2) {
cout << ":(" << endl;
} else {
for (i = 0; i < l / 2; i++) {
b.push_back(a[i]);
}
for (i = l / 2; i <= l - 1; i++) {
c.push_back(a[i]);
}
if (b == c) {
cout << b << endl;
} else {
cout << ":(" << endl;
}
}
return 0;
}
if (b.size()) {
b_size = b.size();
reverse(b.begin(), b.end());
}
for (i = 0; i < index + 1; i++) {
if (a[i] != 'a') {
c.push_back(a[i]);
}
}
c_size = c.size();
long long int k = b_size - c_size;
if (b_size == 0 && c_size == 0) {
cout << a << endl;
return 0;
}
if (k < 0) {
cout << ":(" << endl;
return 0;
}
for (i = index + 1, j = 1; j < k; i++, j++) {
if (b.size() <= c.size()) break;
c.push_back(a[i]);
b.erase(b.begin());
}
if (b != c) {
cout << ":(" << endl;
return 0;
} else {
for (i = 0; i < c_size; i++) {
b.erase(b.begin());
}
for (i = 0; i < index + 1; i++) {
cout << a[i];
}
cout << b;
}
cout << endl;
;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int a[N];
struct P {
int st, len;
bool operator<(const P &A) const {
if (len != A.len) return len < A.len;
return st < A.st;
}
};
struct P2 {
int st, len;
bool operator<(const P2 &A) const { return st < A.st; }
};
int main() {
int n;
cin >> n;
set<P> s;
set<P2> s2;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int i = 1, j = 1; i <= n; i = j) {
while (j <= n && a[j] == a[i]) j++;
s.insert(P{i, i - j});
s2.insert(P2{i, j - i});
}
int ans = 0;
while (!s.empty()) {
ans++;
auto p = s.begin();
int st = p->st;
s2.erase(P2{st, -p->len});
s.erase(s.begin());
auto pre = s2.lower_bound(P2{st, 0});
if (pre == s2.begin() || pre == s2.end()) continue;
auto nxt = pre--;
if (a[pre->st] == a[nxt->st]) {
int len = pre->len + nxt->len;
int len1 = pre->len, len2 = nxt->len;
int l = pre->st, r = nxt->st;
s2.erase(pre);
s2.erase(nxt);
s2.insert(P2{l, len});
s.insert(P{l, -len});
s.erase(P{l, -len1});
s.erase(P{r, -len2});
}
}
cout << ans << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
double ans(0);
int n, m;
double qp(double x, int y) {
double s = 1;
while (y > 0) {
if (y % 2 == 1) s = s * x;
y = y >> 1;
x = x * x;
}
return s;
}
int main() {
scanf("%d%d", &m, &n);
double mm = m;
for (int i = m; i; --i) {
ans += i * (qp(i / mm, n) - qp((i - 1) / mm, n));
}
printf("%.12lf", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long BIG = 1000ll * 1000 * 1000 * 1000 * 1000 * 1000;
long long c[100][100];
long long m;
int k;
long long get(long long a) {
long long val = 0;
int cur = 0;
for (int i = 62; ~i; --i)
if (a & (1ll << i)) {
if (k >= cur) val += c[i][k - cur];
++cur;
}
int c = 0;
while (a) c += a % 2, a /= 2;
if (c == k) ++val;
return val;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
c[0][0] = 1;
for (int i = 1; i < 64; ++i)
for (int j = 0; j <= i; ++j) {
if (!j)
c[i][j] = 1;
else
c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
}
cin >> m >> k;
long long L = 1, R = BIG;
while (L != R) {
long long mid = (L + R) / 2;
long long val = get(2 * mid) - get(mid);
if (val < m)
L = mid + 1;
else
R = mid;
}
cout << L << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
clock_t time_p = clock();
void dem() {
time_p = clock() - time_p;
cerr << "Time Taken : " << (float)(time_p) / CLOCKS_PER_SEC << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, k;
cin >> n >> k;
priority_queue<int> p;
for (int i = 30; i >= 0; --i)
if (n & (1 << i)) p.push(i);
while (p.size() < k) {
int t = p.top();
p.pop();
if (t == 0) break;
p.push(t - 1);
p.push(t - 1);
}
if (p.size() == k) {
cout << "YES";
cout << "\n";
while (p.size()) {
cout << (1 << p.top()) << " ";
p.pop();
}
} else
cout << "NO";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long dp[12];
signed main() {
long long n;
cin >> n;
for (long long i = 1; i <= 9; i++) {
dp[i] = -100000000000000000;
}
for (long long ii = 1; ii <= n; ii++) {
long long cnt;
cin >> cnt;
vector<long long> a[4];
for (long long i = 1; i <= cnt; i++) {
long long u, v;
cin >> u >> v;
a[u].push_back(v);
}
for (long long i = 1; i <= 3; i++) {
sort(a[i].begin(), a[i].end());
}
long long dp1[12];
for (long long i = 0; i <= 9; i++) dp1[i] = -1000000000000000;
long long sm1 = 0, mx1 = 0;
for (long long t1 = 0; t1 <= a[1].size(); t1++) {
if (t1 > 3) break;
if (t1 > 0) {
sm1 += a[1][a[1].size() - t1];
mx1 = max(mx1, a[1][a[1].size() - t1]);
}
long long sm2 = 0, mx2 = 0;
for (long long t2 = 0; t2 <= a[2].size(); t2++) {
if (t1 + 2 * t2 > 3) break;
if (t2 > 0) {
sm2 += a[2][a[2].size() - t2];
mx2 = max(mx2, a[2][a[2].size() - t2]);
}
long long sm3 = 0, mx3 = 0;
for (long long t3 = 0; t3 <= a[3].size(); t3++) {
if (t1 + 2 * t2 + 3 * t3 > 3) break;
if (t3 > 0) {
sm3 += a[3][a[3].size() - t3];
mx3 = max(mx3, a[3][a[3].size() - t3]);
}
for (long long j = 0; j <= 9; j++) {
long long nxt = (j + t1 + t2 + t3) % 10;
if (nxt < j)
dp1[nxt] = max(dp1[nxt],
dp[j] + sm1 + sm2 + sm3 + max(mx1, max(mx2, mx3)));
else
dp1[nxt] = max(dp1[nxt], dp[j] + sm1 + sm2 + sm3);
}
}
}
}
for (long long i = 0; i <= 9; i++) {
dp[i] = dp1[i];
}
}
long long ans = 0;
for (long long i = 0; i <= 9; i++) {
ans = max(ans, dp[i]);
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int a[N], sum[N];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
int xx = 0;
for (int i = n - 1; i >= 0; i--) {
xx = max(xx, a[i] + 1);
sum[i] = xx;
xx--;
}
long long int ans = 0, cnt = 0;
for (int i = 0; i < n; i++) {
if (cnt < sum[i]) cnt++;
ans += cnt - a[i] - 1;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
double PI = acos(-1);
struct base {
double a, b;
base(double _a = 0.0, double _b = 0.0) : a(_a), b(_b) {}
const base operator+(const base &c) const { return base(a + c.a, b + c.b); }
const base operator-(const base &c) const { return base(a - c.a, b - c.b); }
const base operator*(const base &c) const {
return base(a * c.a - b * c.b, a * c.b + b * c.a);
}
};
const int N = 1 << 18;
base w_pre[N | 1], w[N | 1];
int rev[N];
void calcw() {
for (int i = 0; i <= N; ++i)
w_pre[i] = base(cos(2 * PI / N * i), sin(2 * PI / N * i));
}
void calcrev(int n) {
int sz = 31 - __builtin_clz(n);
sz = abs(sz);
for (int i = 1; i < n - 1; ++i)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << sz - 1);
}
void fft(base *p, int n, int dir = 0) {
for (int i = 1; i < n - 1; i++)
if (i < rev[i]) swap(p[i], p[rev[i]]);
for (int h = 1; h < n; h <<= 1) {
int l = h << 1;
if (!dir)
for (int j = 0; j < h; ++j) w[j] = w_pre[N / l * j];
else
for (int j = 0; j < h; ++j) w[j] = w_pre[N - N / l * j];
for (int j = 0; j < n; j += l) {
base t, *wn = w;
base *u = p + j, *v = u + h, *e = v;
while (u != e) {
t = *v * *wn;
*v = *u - t;
*u = *u + t;
++u, ++v, ++wn;
}
}
}
if (dir)
for (int i = 0; i < n; ++i) p[i].a /= n;
}
const int M = 200010;
const int K = 8000;
char a[M], b[M];
base A[N], B[N];
short p[60][M];
int main(int argc, char const *argv[]) {
scanf("%s", a);
scanf("%s", b);
int n = strlen(a), m = strlen(b), t = m + K - 1, sz = 1;
while (sz < t) sz <<= 1;
calcw();
calcrev(sz);
for (int i = 0; i < m; i++) B[i] = base(b[i] == '0' ? -1 : 1, 0);
fft(B, sz);
for (int blc = 0; blc * K < n; blc++) {
int l = blc * K, r = (blc + 1) * K;
if (r > n) break;
for (int i = l; i < r; i++)
A[i - l] = base(a[r - i + l - 1] == '0' ? -1 : 1, 0);
for (int i = K; i < sz; i++) A[i] = base(0, 0);
fft(A, sz);
for (int i = 0; i < sz; i++) A[i] = A[i] * B[i];
fft(A, sz, 1);
for (int i = 0; i <= m - K; i++)
p[blc][i] = (K - (int)round(A[i + K - 1].a)) >> 1;
}
int Q;
scanf("%d", &Q);
while (Q--) {
int pa, pb, l;
scanf("%d %d %d", &pa, &pb, &l);
int l1 = pa, r1 = pa + l - 1;
int l2 = pb, r2 = pb + l - 1;
int ans = 0;
int L = l1 / K, R = r1 / K;
if (L == R) {
for (int i = l1; i <= r1; i++) ans += a[i] != b[i - l1 + l2];
} else {
for (int i = l1; i < (L + 1) * K; i++) ans += a[i] != b[i - l1 + l2];
for (int b = L + 1; b < R; b++) ans += p[b][b * K - l1 + l2];
for (int i = R * K; i <= r1; i++) ans += a[i] != b[i - l1 + l2];
}
printf("%d\n", ans);
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> graf[2000010];
int gle[2000010];
int P[2000010];
int pod[2000010];
int odl_1;
void dfs(int v) {
pod[v] = 1;
for (auto x : graf[v]) {
if (pod[x] == 0) {
P[x] = v;
gle[x] = gle[v] + 1;
dfs(x);
pod[v] += pod[x];
}
}
}
void centr(int v) {
for (auto x : graf[v]) {
if (pod[x] * 2 > pod[v]) {
P[v] = x;
P[x] = x;
int cat = pod[v];
pod[v] -= pod[x];
pod[x] = cat;
centr(x);
return;
}
}
cout << "d " << v << endl;
cout.flush();
int par;
cin >> par;
if (par == 0) {
cout << "! " << v << endl;
cout.flush();
exit(0);
}
if (par + gle[v] == odl_1) {
cout << "s " << v << endl;
cout.flush();
int x;
cin >> x;
if (x == -1) exit(0);
P[x] = x;
pod[v] = 0;
centr(x);
} else {
int szuk;
for (auto x : graf[v]) {
if (gle[x] < gle[v]) szuk = x;
}
P[szuk] = szuk;
pod[v] = 0;
centr(szuk);
}
}
int main() {
cin >> n;
for (int i = 0; i < (n - 1); ++i) {
int t1, t2;
cin >> t1 >> t2;
graf[t1].push_back(t2);
graf[t2].push_back(t1);
}
cout << "d 1" << endl;
cout.flush();
cin >> odl_1;
if (odl_1 == 0) {
cout << "! 1" << endl;
cout.flush();
return 0;
}
P[1] = 1;
dfs(1);
centr(1);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, sm, mx, mn, res, n;
int a, b;
void read() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> a >> b;
}
void solve() {
i = a;
j = b;
while (i) {
mx = max(mx, i % 10);
i /= 10;
}
while (j) {
mx = max(mx, j % 10);
j /= 10;
}
mx++;
while (a || b || k) {
k = (a % 10 + b % 10 + k) / mx;
a /= 10;
b /= 10;
res++;
}
cout << res;
}
int main() {
read();
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
node *left, *right;
node() {
left = NULL;
right = NULL;
}
} * root;
void insert(long long int num) {
node *current = root;
for (int i = 63; i >= 0; i--) {
bool bit = num & (1LL << i);
if (bit) {
if (current->right == NULL) {
current->right = new node();
}
current = current->right;
} else {
if (current->left == NULL) {
current->left = new node();
}
current = current->left;
}
}
}
long long int query(long long int num) {
long long int ans = 0;
node *current = root;
for (int i = 63; i >= 0; i--) {
bool bit = num & (1LL << i);
if (bit) {
if (current->left != NULL) {
ans = ans | (1LL << i);
current = current->left;
} else if (current->right != NULL) {
current = current->right;
}
} else {
if (current->right != NULL) {
ans = ans | (1LL << i);
current = current->right;
} else if (current->left != NULL) {
current = current->left;
}
}
}
return ans;
}
long long int ara[1000007];
int main(int argc, char const *argv[]) {
root = new node();
int n;
cin >> n;
long long int Xor = 0;
insert(Xor);
for (int i = 1; i <= n; i++) {
cin >> ara[i];
Xor = Xor ^ ara[i];
ara[i] = ara[i - 1] ^ ara[i];
}
long long int ans = 0;
for (int i = 1; i <= n; i++) {
long long int now = Xor ^ ara[i - 1];
ans = max(ans, max(ara[i], query(now)));
insert(ara[i]);
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
long long int a, i, j;
map<long long int, long long int> m;
map<long long int, long long int>::iterator o;
cin >> n;
while (n != 0) {
long long int x;
cin >> x;
if (m.find(x) != m.end()) {
o = m.find(x);
o->second++;
} else
m.insert(make_pair(x, 1));
n--;
}
a = m.rbegin()->first;
cout << a << " ";
for (i = 1; i * i <= a; i++) {
if (a % i == 0) {
if (i * i == a) {
o = m.find(i);
o->second--;
if (o->second == 0) m.erase(o);
} else {
o = m.find(i);
o->second--;
if (o->second == 0) m.erase(o);
o = m.find(a / i);
o->second--;
if (o->second == 0) m.erase(o);
}
}
}
cout << m.rbegin()->first;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename tp>
inline void read(tp &x) {
x = 0;
char c = getchar();
int f = 0;
for (; c < '0' || c > '9'; f |= c == '-', c = getchar())
;
for (; c >= '0' && c <= '9'; x = (x << 3) + (x << 1) + c - '0', c = getchar())
;
if (f) x = -x;
}
const int N = 3e5 + 233;
struct E {
int nxt, from, to;
} e[N << 2];
int head[N], e_cnt = 0;
int dep[N], fa[N], vis[N], cov[N], x = -1, y = -1;
int n, m;
inline void adde(int x, int y) {
e[++e_cnt] = (E){head[x], x, y};
head[x] = e_cnt;
}
inline void dfs(int u, int fat) {
dep[u] = dep[fa[u] = fat] + 1;
vis[u] = true;
for (register int i = head[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (v == fat) continue;
if (vis[v]) {
if (dep[v] > dep[u] && x == -1 && y == -1) {
for (int t = v; t != u; t = fa[t]) {
if (cov[t]) x = cov[t], y = i;
cov[t] = i;
}
}
} else {
dfs(v, u);
}
}
}
inline int LCA(int x, int y) {
while (x != y) {
if (dep[x] < dep[y]) swap(x, y);
x = fa[x];
}
return x;
}
vector<int> path(int x, int y, int rev = 0) {
assert(LCA(x, y) == y);
vector<int> ans;
while (x != y) ans.push_back(x), x = fa[x];
ans.push_back(x);
if (rev) reverse(ans.begin(), ans.end());
return ans;
}
vector<int> add(vector<int> x, vector<int> y) {
for (int i : y) x.push_back(i);
return x;
}
inline void print(vector<int> x) {
cout << x.size() << " ";
for (int i : x) cout << i << " ";
cout << "\n";
}
int main(void) {
read(n);
read(m);
for (register int i = 1; i <= (m); i++) {
int x, y;
read(x);
read(y);
adde(x, y);
adde(y, x);
}
for (register int i = 1; i <= (n); i++)
if (!vis[i]) {
x = -1;
y = -1;
dfs(i, 0);
if (x > 0 && y > 0) {
if (dep[e[x].from] > dep[e[y].from]) swap(x, y);
int v = LCA(e[x].to, e[y].to);
int u = e[y].from;
cout << "YES\n";
print(add({u}, path(e[y].to, v)));
print(add(path(e[y].from, e[x].from), path(e[x].to, v)));
print(path(v, e[y].from, 1));
return 0;
}
}
cout << "NO\n";
}
| 11 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
long long n;
vector<string> a(105);
vector<long long> b(105, 0), c(105, 0);
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a[i];
for (long long j = 0; j < n; j++)
if (a[i][j] == 'C') {
b[i]++;
c[j]++;
}
}
long long sum = 0;
for (long long i = 0; i < n; i++) {
sum += b[i] * (b[i] - 1) / 2 + c[i] * (c[i] - 1) / 2;
}
cout << sum;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 2e5 + 10, cut = 700;
int n, m, k, cnt[mx], lv, x[mx], y[mx], dead[mx];
vector<pair<int, int> > adj[mx];
vector<int> res;
void er(int a, int b) {
auto it = lower_bound(adj[a].begin(), adj[a].end(), make_pair(b, 0));
if (it->second) return;
it->second = 1;
cnt[a]--;
}
void f(int h) {
if (cnt[h] >= k || dead[h]) return;
dead[h] = 1;
lv--;
for (auto &it : adj[h])
if (!it.second) er(it.first, h);
for (auto &it : adj[h])
if (!it.second) f(it.first);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; i++) {
scanf("%d%d", x + i, y + i);
cnt[x[i]]++;
cnt[y[i]]++;
adj[x[i]].push_back({y[i], 0});
adj[y[i]].push_back({x[i], 0});
}
for (int i = 1; i <= n; i++) sort(adj[i].begin(), adj[i].end());
lv = n;
for (int i = 1; i <= n; i++) f(i);
for (int i = m; i--;) {
res.push_back(lv);
er(x[i], y[i]);
er(y[i], x[i]);
f(x[i]);
f(y[i]);
}
reverse(res.begin(), res.end());
for (auto &it : res) printf("%d\n", it);
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int N = 1010;
long long n, m, q, a[N][N], fr[N][N];
int cnt(long long x) {
int res = 0;
while (x) {
if (x & 1) res++;
x >>= 1;
}
return res;
}
long long sum(long long x, long long y) {
if (!x || !y) return 0;
long long res = 0, x_ = (x + n - 1) / n, y_ = (y + m - 1) / m;
res += (x_ - 1) * (y_ - 1) / 2 * n * m;
if (!(x_ & 1 || y_ & 1)) {
if (cnt(x_ - 2) + cnt(y_ - 2) & 1)
res += n * m - fr[n][m];
else
res += fr[n][m];
}
res += ((x_ - 1) >> 1) * n * (y - (y_ - 1) * m);
if (!(x_ & 1)) {
if (cnt(x_ - 2) + cnt(y_ - 1) & 1)
res += n * (y - (y_ - 1) * m) - fr[n][y - (y_ - 1) * m];
else
res += fr[n][y - (y_ - 1) * m];
}
res += ((y_ - 1) >> 1) * (x - (x_ - 1) * n) * m;
if (!(y_ & 1)) {
if (cnt(x_ - 1) + cnt(y_ - 2) & 1)
res += (x - (x_ - 1) * n) * m - fr[x - (x_ - 1) * n][m];
else
res += fr[x - (x_ - 1) * n][m];
}
if (cnt(x_ - 1) + cnt(y_ - 1) & 1)
res += (x - (x_ - 1) * n) * (y - (y_ - 1) * m) -
fr[x - (x_ - 1) * n][y - (y_ - 1) * m];
else
res += fr[x - (x_ - 1) * n][y - (y_ - 1) * m];
return res;
}
int main() {
register int i, j;
register long long t1, t2, t3, t4;
register char ch;
scanf("%lld%lld%lld", &n, &m, &q);
for (i = (1); i <= (n); i++)
for (j = (1); j <= (m); j++) scanf(" %c", &ch), a[i][j] = ch ^ 48;
for (i = (1); i <= (n); i++)
for (j = (1); j <= (m); j++)
fr[i][j] = a[i][j] + fr[i - 1][j] + fr[i][j - 1] - fr[i - 1][j - 1];
while (q--) {
scanf("%lld%lld%lld%lld", &t1, &t2, &t3, &t4);
printf("%lld\n", sum(t3, t4) - sum(t1 - 1, t4) - sum(t3, t2 - 1) +
sum(t1 - 1, t2 - 1));
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct comp {
bool operator()(const int& lhs, const int& rhs) const {
return (lhs % 10) > (rhs % 10);
}
};
int main() {
int numSkills, numImpr;
cin >> numSkills >> numImpr;
multiset<int, comp> skills;
for (int i = 0; i < numSkills; i++) {
int temp;
cin >> temp;
skills.insert(temp);
}
int charRating = 0;
auto iter = skills.cbegin();
while (iter != skills.cend()) {
int mod = *iter % 10;
if (numImpr <= 0) break;
if (*iter < 100) {
int add = min(10 - mod, numImpr);
int newSkill = *iter + add;
numImpr -= add;
auto temp = iter;
skills.erase(iter);
skills.insert(newSkill);
iter = skills.cbegin();
} else {
charRating += 10;
skills.erase(iter);
iter = skills.cbegin();
}
}
iter = skills.cbegin();
while (iter != skills.cend()) {
charRating += *iter / 10;
iter++;
}
cout << charRating << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int val[210000];
vector<int> wt[210000];
vector<int> dp[210000];
vector<pair<int, int> > adj[210000];
int n, k;
pair<int, int> totwt[210000][2];
int full[210000];
pair<int, int> notfull[210000][2];
int state[210000];
int rec(int v, int p, int goal);
void upd(int follow_idx, int v, int goal) {
int newv = adj[v][follow_idx].first;
int newp = adj[v][follow_idx].second;
rec(newv, newp, goal);
if (wt[newv][newp] >= goal) {
full[v] += dp[newv][newp];
} else {
if (notfull[v][1].second < dp[newv][newp])
notfull[v][1] = {dp[newv][newp], follow_idx};
if (notfull[v][0] < notfull[v][1]) swap(notfull[v][0], notfull[v][1]);
}
if (totwt[v][1].first > wt[newv][newp])
totwt[v][1] = {wt[newv][newp], follow_idx};
if (totwt[v][0] > totwt[v][1]) swap(totwt[v][0], totwt[v][1]);
}
int rec(int v, int p, int goal) {
int &ret = dp[v][p];
if (ret != -1) return ret;
if (val[v] < goal) return ret = 0;
if (state[v] == -1) {
for (int i = 1; i < (int)adj[v].size(); i++)
if (i != p) {
upd(i, v, goal);
}
state[v] = p;
} else if (state[v] && state[v] != p) {
upd(state[v], v, goal);
state[v] = 0;
}
wt[v][p] = (totwt[v][0].second != p ? totwt[v][0].first : totwt[v][1].first);
wt[v][p] = min(wt[v][p], val[v]);
ret = 1 + full[v] + notfull[v][0].first;
if (state[v] != p) {
if (notfull[v][0].second == p)
ret += (notfull[v][1].first - notfull[v][0].first);
if (wt[adj[v][p].first][adj[v][p].second] >= goal)
ret -= dp[adj[v][p].first][adj[v][p].second];
}
return ret;
}
bool check(int goal) {
for (int i = 1; i <= n; i++) {
state[i] = -1;
full[i] = 0;
notfull[i][0] = notfull[i][1] = {0, -1};
totwt[i][0] = totwt[i][1] = {1000000000, -1};
for (int j = 0; j < (int)adj[i].size(); j++) {
dp[i][j] = -1;
}
}
for (int i = 1; i <= n; i++) {
if (rec(i, 0, goal) >= k) return true;
}
return false;
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &val[i]);
for (int i = 1; i <= n; i++) adj[i].push_back({-1, -1});
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d %d", &u, &v);
int uT = adj[u].size();
int vT = adj[v].size();
adj[u].push_back({v, vT});
adj[v].push_back({u, uT});
}
for (int i = 0; i <= n; i++) {
wt[i].resize(adj[i].size(), -1);
dp[i].resize(adj[i].size(), -1);
}
int st = 0, ed = 1000000;
while (st < ed) {
int md = (st + ed + 1) / 2;
if (check(md))
st = md;
else
ed = md - 1;
}
printf("%d\n", st);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2345, mod = 998244353;
void add(int& x, int y) {
x += y;
if (x >= mod) {
x -= mod;
}
}
int mul(int x, int y) { return (long long)x * y % mod; }
int n, a[N], b[N], pa[N], pb[N], binom[N][N], s[N][N], fac[N], f[N], g[N], h[N],
result[N], new_result[N];
bool visita[N], visitb[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
pa[a[i]] = i;
}
for (int i = 1; i <= n; ++i) {
cin >> b[i];
pb[b[i]] = i;
}
int x = 0, y = 0, z = 0, w = 0;
for (int i = 1; i <= n; ++i) {
if (!a[i] && !b[i]) {
++z;
} else if (!visita[i] && !visitb[i]) {
bool foo, bar, loop = false;
int j = i;
while (1) {
if (a[j]) {
if (visita[j]) {
loop = true;
break;
}
visita[j] = true;
if (pb[a[j]]) {
visitb[pb[a[j]]] = true;
j = pb[a[j]];
} else {
foo = true;
break;
}
} else {
foo = false;
break;
}
}
if (loop) {
++w;
continue;
}
j = i;
while (1) {
if (b[j]) {
visitb[j] = true;
if (pa[b[j]]) {
visita[pa[b[j]]] = true;
j = pa[b[j]];
} else {
bar = true;
break;
}
} else {
bar = false;
break;
}
}
if (!b[i]) {
if (foo) {
++y;
} else {
++z;
}
} else if (!a[i]) {
if (bar) {
++x;
} else {
++z;
}
} else {
if (!foo && !bar) {
++z;
}
if (foo && !bar) {
++y;
}
if (!foo && bar) {
++x;
}
}
}
}
binom[0][0] = s[0][0] = fac[0] = 1;
for (int i = 1; i <= n; ++i) {
fac[i] = mul(fac[i - 1], i);
binom[i][0] = 1;
for (int j = 1; j <= i; ++j) {
binom[i][j] = (binom[i - 1][j] + binom[i - 1][j - 1]) % mod;
s[i][j] = (s[i - 1][j - 1] + mul(s[i - 1][j], i - 1)) % mod;
}
}
for (int i = 0; i <= x; ++i) {
for (int j = i; j <= x; ++j) {
add(f[i], mul(mul(binom[x][j], s[j][i]),
x - j ? mul(binom[x - j + z - 1][x - j], fac[x - j]) : 1));
}
}
for (int i = 0; i <= y; ++i) {
for (int j = i; j <= y; ++j) {
add(g[i], mul(mul(binom[y][j], s[j][i]),
y - j ? mul(binom[y - j + z - 1][y - j], fac[y - j]) : 1));
}
}
for (int i = 0; i <= z; ++i) {
h[i] = mul(fac[z], s[z][i]);
}
memset(new_result, 0, sizeof new_result);
for (int i = 0; i <= x; ++i) {
result[i] = f[i];
for (int j = 0; j <= y; ++j) {
add(new_result[i + j], mul(result[i], g[j]));
}
}
memcpy(result, new_result, sizeof new_result);
memset(new_result, 0, sizeof new_result);
for (int i = 0; i <= x + y; ++i) {
for (int j = 0; j <= z; ++j) {
add(new_result[i + j], mul(result[i], h[j]));
}
}
for (int i = 0; i < n; ++i) {
cout << (n - i - w >= 0 ? new_result[n - i - w] : 0) << " \n"[i + 1 == n];
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int v, w;
node(){};
node(int v_, int w_) : v(v_), w(w_){};
};
int n, m;
list<node> G[200007];
stack<int> S;
int color[200007] = {0};
int C[200007] = {0};
long long W[200007] = {0}, D[200007] = {0};
bool vis[200007] = {0};
long long f[200007][2] = {0}, g[200007][2] = {0};
bool dfs(int u, int from = -1) {
if (color[u] == 1) {
do {
C[++C[0]] = S.top();
S.pop();
} while (C[C[0]] != u);
return true;
}
if (color[u] == 2) return false;
S.push(u);
color[u] = 1;
for (auto e : G[u]) {
int v = e.v;
if (v == from) continue;
if (dfs(v, u)) return true;
}
color[u] = 2;
S.pop();
return false;
}
pair<long long, int> far(int u) {
vis[u] = true;
pair<long long, int> ans = make_pair(0, u);
for (auto e : G[u])
if (!vis[e.v]) {
pair<long long, int> r = far(e.v);
if (ans.first < r.first + e.w) ans = make_pair(r.first + e.w, r.second);
}
return ans;
}
void remove(int u, int v) {
for (auto it = G[u].begin(); it != G[u].end(); it++)
if (it->v == v) {
it = G[u].erase(it);
break;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
G[u].push_back(node(v, w));
G[v].push_back(node(u, w));
}
dfs(1);
m = C[0];
C[m + 1] = C[1];
for (int i = 1; i <= m; i++) {
int u = C[i], v = C[i + 1];
for (auto e : G[u])
if (e.v == v) {
W[i] = e.w;
break;
}
}
for (int i = 1; i <= m; i++) vis[C[i]] = true;
for (int i = 1; i <= m; i++) D[i] = (far(C[i])).first;
long long len = 0;
for (int i = 1; i <= m; i++) {
f[i][0] = max(f[i - 1][0], len + D[i]);
len += W[i];
}
len = 0;
for (int i = m; i >= 1; i--) {
len += W[i];
f[i][1] = max(f[i + 1][1], len + D[i]);
}
len = D[1];
for (int i = 2; i <= m; i++) {
g[i][0] = max(g[i - 1][0], len + W[i - 1] + D[i]);
len = max(len + W[i - 1], D[i]);
}
len = D[1];
for (int i = m; i >= 1; i--) {
g[i][1] = max(g[i + 1][1], len + W[i] + D[i]);
len = max(len + W[i], D[i]);
}
long long res = 0x7FFFFFFFFFFFFFFFLL;
int u = 0, v = 0;
for (int i = 1; i < m; i++) {
long long w = max(g[i][0], g[i + 1][1]);
w = max(w, f[i][0] + f[i + 1][1]);
if (w < res) u = C[i], v = C[i + 1], res = w;
}
if (g[m][0] < res) u = C[m], v = C[1], res = g[m][0];
remove(u, v);
remove(v, u);
memset(vis, 0, sizeof(vis));
pair<long long, int> e = far(1);
u = e.second;
memset(vis, 0, sizeof(vis));
e = far(u);
long long ans = e.first;
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
if (n & 1) {
int l = a[n / 2];
cout << a[n / 2] << ' ';
for (int i = 1; i <= n / 2; i++) {
{
cout << a[n / 2 - i] << ' ' << a[n / 2 + i] << ' ';
l = a[n / 2 + i];
}
}
} else {
int l = 0;
for (double i = 0; i < n / 2; i++) {
int a1 = n / 2 - i - 1, a2 = n / 2 + i;
cout << a[a2] << ' ' << a[a1] << ' ';
}
}
cout << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
int main() {
int i, j, arr[3][3];
for (i = 0; i < 3; i++)
for (j = 0; j < 3; j++) scanf("%d", &arr[i][j]);
arr[0][0] =
(arr[0][1] + arr[0][2] + arr[1][2] + arr[2][1] - arr[1][0] - arr[2][0]) /
2;
arr[1][1] =
(-arr[0][1] + arr[0][2] + arr[1][2] - arr[2][1] + arr[1][0] + arr[2][0]) /
2;
arr[2][2] =
(arr[0][1] - arr[0][2] - arr[1][2] + arr[2][1] + arr[1][0] + arr[2][0]) /
2;
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) printf("%d ", arr[i][j]);
printf("\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
string D[100], L, l, C;
int R[100];
int main() {
for (int i = 0; i < 100; ++i) {
R[i] = 0;
}
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> D[i];
for (int j = 0; j < D[i].size(); ++j) {
D[i][j] = tolower(D[i][j]);
}
}
cin >> L;
cin >> C;
for (int i = 0; i < L.size(); ++i) l += tolower(L[i]);
for (int i = 0; i < L.size(); ++i) {
for (int j = 0; j < n; ++j) {
if (D[j] == l.substr(i, D[j].size())) {
for (int k = 0; k < D[j].size(); ++k) {
R[i + k] = 1;
}
}
}
}
for (int i = 0; i < L.size(); ++i) {
if (R[i]) {
if (tolower(L[i]) == C[0]) {
if (isupper(L[i])) {
L[i] = (L[i] == 'A') ? 'B' : 'A';
} else {
L[i] = (L[i] == 'a') ? 'b' : 'a';
}
} else {
if (isupper(L[i])) {
L[i] = toupper(C[0]);
} else {
L[i] = C[0];
}
}
}
}
cout << L << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T poww(T b, T p) {
long long a = 1;
while (p) {
if (p & 1) {
a = (a * b);
}
p >>= 1;
b = (b * b);
}
return a;
}
template <class T>
inline T poww2(T b, int p) {
T a = 1;
while (p) {
if (p & 1) {
a = (a * b);
}
p >>= 1;
b = (b * b);
}
return a;
}
template <class T>
inline T modpoww(T b, T p, T mmod) {
long long a = 1;
while (p) {
if (p & 1) {
a = (a * b) % mmod;
}
p >>= 1;
b = (b * b) % mmod;
}
return a % mmod;
}
template <class T>
inline T gcd(T a, T b) {
if (b > a) return gcd(b, a);
return ((b == 0) ? a : gcd(b, a % b));
}
template <class T>
inline void scan(vector<T>& a, int n) {
T b;
int i;
for ((i) = 0; (i) < (n); (i) += 1) {
cin >> b;
a.push_back(b);
}
}
inline void scand(vector<int>& a, int n) {
int b;
int i;
for ((i) = 0; (i) < (n); (i) += 1) {
scanf("%d", &(b));
a.push_back(b);
}
}
int main() {
int i, j, k, t;
int n;
long long cod[4];
for ((i) = 0; (i) < (4); (i) += 1) cin >> cod[i];
cin >> n;
long long a, b, c;
int ans = 0;
for ((i) = 0; (i) < (n); (i) += 1) {
cin >> a >> b >> c;
long long s1 = (a * cod[2] + b * cod[3] + c);
long long s2 = (a * cod[0] + b * cod[1] + c);
if (s1 > 0 && s2 > 0)
continue;
else if (s1 < 0 && s2 < 0)
continue;
ans++;
}
cout << ans << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<long long> cost(n);
for (int i = 0; i < n; i++) {
cin >> cost[i];
}
vector<string> str(n);
vector<string> str2(n);
for (int i = 0; i < n; i++) {
cin >> str[i];
str2[i] = str[i];
reverse(str2[i].begin(), str2[i].end());
}
vector<vector<long long>> dp(2, vector<long long>(n, LLONG_MAX / 2));
dp[0][0] = 0;
dp[1][0] = cost[0];
for (int i = 1; i < n; i++) {
if (str[i] >= str[i - 1]) {
dp[0][i] = min(dp[0][i], dp[0][i - 1]);
}
if (str[i] >= str2[i - 1]) {
dp[0][i] = min(dp[0][i], dp[1][i - 1]);
}
if (str2[i] >= str[i - 1]) {
dp[1][i] = min(dp[1][i], dp[0][i - 1] + cost[i]);
}
if (str2[i] >= str2[i - 1]) {
dp[1][i] = min(dp[1][i], dp[1][i - 1] + cost[i]);
}
if (dp[0][i] == dp[1][i] && dp[1][i] == LLONG_MAX / 2) {
cout << -1;
return 0;
}
}
cout << min(dp[0][n - 1], dp[1][n - 1]) << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int k[26], t[26];
int main() {
int n, l = 0;
string s;
cin >> n;
cin >> s;
for (int i = 0; i < s.length() && l < n; i++) {
if (!k[s[i]]) {
k[s[i]] = 1;
t[l++] = i;
}
}
if (l == n)
cout << "YES";
else {
cout << "NO";
return 0;
}
l = 0;
for (int i = 0; i < s.length(); i++) {
if (t[l] == i) l++, cout << endl;
cout << s[i];
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int Read() {
char c;
while (c = getchar(), (c != '-') && (c < '0' || c > '9'))
;
bool neg = (c == '-');
int ret = (neg ? 0 : c - 48);
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + c - 48;
return neg ? -ret : ret;
}
const double pi = acos(-1);
int N;
double ang, x = 0, y = 0, d = 255;
int main() {
scanf("%d", &N);
if (N < 5) {
puts("No solution");
return 0;
}
ang = 2 * pi / N;
for (int i = 0; i <= N - 2; i++) {
if (i == (N + 1) / 2) d += 159;
printf("%lf %lf\n", x += d * cos(i * ang), y += d * sin(i * ang));
if (i == (N + 1) / 2) d -= 159;
d -= 0.01;
}
double tmp = y / sin(ang * (N - 1));
printf("%lf %lf\n", x -= tmp * cos(ang * (N - 1)),
y -= tmp * sin(ang * (N - 1)));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long phi(long long n) {
long long res = 1;
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) {
long long p = i;
n /= i;
res *= p - 1;
while (n % i == 0) n /= i, res *= p;
}
if (n > 1) res *= n - 1;
return res;
}
int main() {
long long n, k;
cin >> n >> k;
while (n != 1) {
if (k <= 0) break;
n = phi(n);
k -= 2;
}
cout << n % 1000000007LL << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e4 + 5, M = 1e5 + 5;
int n, m, ans[N], L[M], R[M];
vector<int> vec[N];
struct segment_tree_2D
{
struct node { int mn, ls, rs; } o[N * 300];
int rt[N << 2], tot;
void modify(int l, int r, int &u, int ml, int mr, int v)
{
if(!u) { u = ++tot; o[u].mn = INT_MAX; }
o[u].mn = min(o[u].mn, v);
if(l == r) return;
int mid = l + r >> 1;
if(mr <= mid) modify(l, mid, o[u].ls, ml, mr, v);
else modify(mid + 1, r, o[u].rs, ml, mr, v);
}
void Modify(int l, int r, int u, int ml, int mr, int v)
{
modify(1, n, rt[u], ml, mr, v);
if(l == r) return;
int mid = l + r >> 1;
if(ml <= mid) Modify(l, mid, u << 1, ml, mr, v);
else Modify(mid + 1, r, u << 1 | 1, ml, mr, v);
}
int query(int l, int r, int u, int ql, int qr)
{
if(!u) return INT_MAX;
if(ql <= l && r <= qr) return o[u].mn;
int mid = l + r >> 1, res = INT_MAX;
if(ql <= mid) res = min(res, query(l, mid, o[u].ls, ql, qr));
if(qr > mid) res = min(res, query(mid + 1, r, o[u].rs, ql, qr));
return res;
}
int Query(int l, int r, int u, int ql, int qr)
{
if(ql <= l && r <= qr) return query(1, n, rt[u], ql, qr);
int mid = l + r >> 1, res = INT_MAX;
if(ql <= mid) res = min(res, Query(l, mid, u << 1, ql, qr));
if(qr > mid) res = min(res, Query(mid + 1, r, u << 1 | 1, ql, qr));
return res;
}
} sgt;
int Solve(int l, int r)
{
if(l > r) return 0;
int res = sgt.Query(1, n, 1, l, r);
if(res == INT_MAX) return 0;
return R[res] - L[res] + 1 + Solve(l, L[res] - 1) + Solve(R[res] + 1, r);
}
int main()
{
ios::sync_with_stdio(false);
cin >> n >> m;
for(int i = 1; i <= m; i++)
{
cin >> L[i] >> R[i];
vec[R[i] - L[i] + 1].emplace_back(i);
}
for(int i = n; i; i--)
{
for(int v : vec[i]) sgt.Modify(1, n, 1, L[v], R[v], v);
ans[i] = Solve(1, n);
}
for(int i = 1; i <= n; i++) cout << ans[i] << endl;
return 0;
} | 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, m;
cin >> n >> m;
map<string, string> ipName;
for (int i = 0; i < n; i++) {
string name, ip;
cin >> name >> ip;
ipName[ip] = name;
}
while (m--) {
string s1, ip;
cin >> s1 >> ip;
ip.pop_back();
cout << s1 << " " << ip << "; #" << ipName[ip] << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char ch[200000];
int n;
int main() {
scanf("%s", ch);
n = strlen(ch);
for (int i = 0; i < n; ++i)
if (ch[i] != 'A' && ch[i] != 'H' && ch[i] != 'I' && ch[i] != 'M' &&
ch[i] != 'O' && ch[i] != 'T' && ch[i] != 'U' && ch[i] != 'V' &&
ch[i] != 'W' && ch[i] != 'X' && ch[i] != 'Y') {
printf("NO\n");
return 0;
}
for (int i = 0; i < n / 2; ++i)
if (ch[i] != ch[n - 1 - i]) {
printf("NO\n");
return 0;
}
printf("YES\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long one = 1;
long long mp[] = {0, 2, 3, 1};
long long solve(long long n) {
if (n < 4) return n;
long long _n = n;
n -= 4;
long long a, b, c;
for (int i = 2;; i += 2) {
long long can = 3 * (one << i);
if (n < can) {
a = (one << i) | (n / 3);
b = one << (i + 1);
n /= 3;
for (int j = i - 2; j >= 0; j -= 2) {
long long x = n / (one << j);
b |= mp[x] << j;
n -= x * (one << j);
}
break;
}
n -= can;
}
assert(n == 0);
c = a ^ b;
if (_n % 3 == 1) return a;
if (_n % 3 == 2) return b;
return c;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
cout << solve(n) << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a = 1;
cin >> n;
int ans;
for (int i = 1; i < 1000; i++) {
ans = i * n + 1;
for (int j = 2; j <= sqrt(ans); j++) {
if (ans % j == 0) {
cout << i;
return 0;
}
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
int n, a[200005];
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 2; i <= n; i++)
if (a[i] % a[1] != 0) return puts("-1");
printf("%d\n", n * 2 + 1);
printf("%d ", a[1]);
for (int i = 1; i <= n; i++) printf("%d %d ", a[1], a[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long ans[10] = {0, 1, 2, 9, 64, 625, 7776, 117649, 2097152};
long long opt = 1;
int n, m;
long long k = 1000000007;
int main() {
scanf("%d%d", &n, &m);
opt = ans[m];
long long p = n - m, b = n - m;
while (p) {
if (p & 1) opt *= b;
opt %= k;
b *= b;
b %= k;
p >>= 1;
}
cout << opt << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, i, j, x[1000], y[1000], a[1000], ans[1000], col[200010],
used[200010];
bool can = 0;
vector<int> pos[200010];
void update() {
for (i = 0; i <= 200010; i++) used[i] = col[i];
}
void clear() {
for (i = 0; i <= 200010; i++) used[i] = 0;
}
int myabs(long long i) {
if (i < 0) i *= -1;
return i;
}
void go(int z) {
clear();
int i = z;
int l = 0;
while (i < n) {
if (x[i] == x[i + 1])
l = myabs(y[i + 1] - y[i]);
else
l = myabs(x[i + 1] - x[i]);
if (x[i] == x[i - 1])
l += myabs(y[i - 1] - y[i]);
else
l += myabs(x[i - 1] - x[i]);
if (used[l] + 1 <= col[l]) {
ans[i] = pos[l][used[l]];
used[l]++;
ans[i - 1] = -1;
ans[i + 1] = -1;
} else {
can = 0;
return;
}
i += 2;
}
if (i == n) {
if (x[i] == x[1])
l = myabs(y[1] - y[i]);
else
l = myabs(x[1] - x[i]);
if (x[i] == x[i - 1])
l += myabs(y[i - 1] - y[i]);
else
l += myabs(x[i - 1] - x[i]);
if (used[l] + 1 <= col[l]) {
ans[i] = pos[l][used[l]];
used[l]++;
ans[i - 1] = -1;
ans[1] = -1;
} else {
can = 0;
return;
}
i += 2;
}
if (i == (n + 1)) {
if (x[1] == x[2])
l = myabs(y[2] - y[1]);
else
l = myabs(x[2] - x[1]);
if (x[1] == x[n])
l += myabs(y[n] - y[1]);
else
l += myabs(x[n] - x[1]);
if (used[l] + 1 <= col[l]) {
ans[1] = pos[l][used[l]];
used[l]++;
ans[n] = -1;
ans[2] = -1;
} else {
can = 0;
return;
}
i += 2;
}
can = 1;
}
int main() {
cin >> n >> m;
for (i = 1; i <= n; i++) {
cin >> x[i] >> y[i];
}
for (i = 1; i <= m; i++) {
cin >> a[i];
col[a[i]]++;
pos[a[i]].push_back(i);
}
go(2);
if (can == 0) go(3);
if (can) {
cout << "YES" << endl;
for (i = 1; i <= n; i++) cout << ans[i] << ' ';
cout << endl;
} else
cout << "NO" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
long long int n, m;
cin >> n >> m;
if (n == 1 || m == 1)
cout << "YES" << endl;
else if (n == 2 && m == 2)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b;
int X[100], Y[100];
int ok(int x1, int y1, int x2, int y2) {
if (x1 > a || x2 > a || y1 > b || y2 > b) return 0;
if (x1 + x2 > a && y1 + y2 > b) return 0;
return 1;
}
int main() {
scanf("%d %d %d", &n, &a, &b);
for (int i = 0; i < n; i++) {
scanf("%d %d", &X[i], &Y[i]);
}
int mx = 0;
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
int x1 = X[i], x2 = X[j];
int y1 = Y[i], y2 = Y[j];
if (ok(x1, y1, x2, y2) || ok(y1, x1, x2, y2) || ok(x1, y1, y2, x2) ||
ok(y1, x1, y2, x2)) {
mx = max(mx, x1 * y1 + x2 * y2);
}
}
}
printf("%d", mx);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 7;
int p[maxn][10];
int n;
void solve() {
cin >> n;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= 5; j++) cin >> p[i][j];
for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= 5; j++) {
if (i == j) continue;
int a = 0, b = 0, c = 0;
for (int k = 1; k <= n; k++)
if (p[k][i] && p[k][j])
c++;
else if (p[k][i] && !p[k][j])
a++;
else if (!p[k][i] && p[k][j])
b++;
if (a + c >= n / 2 && b + c >= n / 2 && a + b + c == n) {
cout << "YES" << endl;
return;
}
}
}
cout << "NO" << endl;
}
int main() {
int __;
cin >> __;
while (__--) solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int cnt = 0, cnt2 = 0;
for (int k = 0; k < s.size(); k++) {
if (s[k] != s[k + 1]) {
cnt++;
cnt2 = 0;
} else {
cnt2++;
}
if (cnt2 == 5) {
cnt++;
cnt2 = 0;
}
}
cout << cnt;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long a, b;
cin >> a >> b;
long long cnt = 0;
while (a != 0 && b != 0) {
if (a < b) {
swap(a, b);
}
cnt += (a / b);
a %= b;
}
cout << cnt << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int w[102][102];
int a[102];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
int d;
cin >> d;
w[i][i] = 1;
if (i + d <= n) w[i][i + d] = w[i + d][i] = 1;
if (i - d > 0) w[i][i - d] = w[i - d][i] = 1;
}
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (w[i][k] && w[k][j]) w[i][j] = 1;
bool f = true;
for (int i = 1; i <= n; i++)
if (!w[i][a[i]]) {
f = false;
break;
}
f ? cout << "YES" : cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double pi = 4 * atan(1);
const int inf = 1 << 30;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
int nCase = 0;
int dcmp(double x) {
if (fabs(x) < eps) return 0;
return x < 0 ? -1 : 1;
}
template <class T>
inline bool read(T& n) {
T x = 0, tmp = 1;
char c = getchar();
while ((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
if (c == EOF) return false;
if (c == '-') c = getchar(), tmp = -1;
while (c >= '0' && c <= '9') x *= 10, x += (c - '0'), c = getchar();
n = x * tmp;
return true;
}
template <class T>
inline void write(T n) {
if (n < 0) {
putchar('-');
n = -n;
}
int len = 0, data[20];
while (n) {
data[len++] = n % 10;
n /= 10;
}
if (!len) data[len++] = 0;
while (len--) putchar(data[len] + 48);
}
struct Statu {
int id, val, t;
bool operator<(const Statu& rhs) const { return val > rhs.val; }
};
int p[5010];
vector<Statu> vec[5010];
struct Edge {
int v, c, nxt;
} e[5010 * 2];
int head[5010], ecnt;
int a[5010];
int n;
int o;
void dfs(int u, int f, int c) {
if (~f) {
sort(vec[u].begin(), vec[u].end());
for (int i = 0; i < vec[u].size(); ++i) vec[u][i].t++;
while (c && vec[u].size()) {
c--;
vec[f].push_back(vec[u].back());
vec[u].pop_back();
}
}
for (int i = head[u]; i != -1; i = e[i].nxt) {
int v = e[i].v;
if (v == f) continue;
dfs(v, u, e[i].c);
}
}
int main(int argc, const char* argv[]) {
cin >> n;
for (int i = 1; i <= n; ++i) scanf("%d", &p[i]);
memset(head, -1, sizeof head), ecnt = 0;
int u, v, c;
for (int i = 1; i < n; ++i) {
scanf("%d%d%d", &u, &v, &c);
e[ecnt] = Edge{v, c, head[u]}, head[u] = ecnt++;
e[ecnt] = Edge{u, c, head[v]}, head[v] = ecnt++;
}
for (int i = 1; i <= n; ++i) {
vec[i].push_back(Statu{i, p[i], 0});
}
while (vec[1].size() != n) {
o++;
dfs(1, -1, INF);
}
for (int i = 0; i < n; ++i) {
int id = vec[1][i].id;
p[id] = vec[1][i].t;
}
for (int i = 1; i <= n; ++i) cout << p[i] << ' ';
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void gmax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
inline void gmin(T &a, T b) {
if (a > b) a = b;
}
int n, m, sym, id, lot[1000010], L[200010], R[200010];
struct SEGMENT {
int len, st, pos;
} cur;
struct cmp {
bool operator()(const SEGMENT a, SEGMENT b) {
if (a.len == b.len)
return a.pos < b.pos;
else
return a.len > b.len;
}
};
set<SEGMENT, cmp> seg;
SEGMENT Make_seg(int left, int right) {
SEGMENT res;
if (!left && right == n + 1)
res.len = 2147483647, res.st = 0, res.pos = 1;
else if (!left)
res.len = right - 1, res.st = 0, res.pos = 1;
else if (right == n + 1)
res.len = n - left, res.st = left, res.pos = n;
else
res.len = (right - left) >> 1, res.st = left, res.pos = left + res.len;
return res;
}
void Insert_seg(int left, int right) {
L[right] = left, R[left] = right;
seg.insert(Make_seg(left, right));
}
void Del_seg(int left, int right) { seg.erase(Make_seg(left, right)); }
int main() {
cin >> n >> m;
Insert_seg(0, n + 1);
while (m--) {
cin >> sym >> id;
if (sym == 1) {
cur = *seg.begin();
seg.erase(seg.begin());
lot[id] = cur.pos;
int pnt1 = cur.st, pnt2 = cur.pos, pnt3 = R[pnt1];
Insert_seg(pnt1, pnt2);
Insert_seg(pnt2, pnt3);
cout << lot[id] << endl;
} else {
int pnt1 = L[lot[id]], pnt2 = lot[id], pnt3 = R[pnt2];
Del_seg(pnt1, pnt2);
Del_seg(pnt2, pnt3);
Insert_seg(pnt1, pnt3);
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long get(long long num, long long cnt) {
long long val = num / cnt;
long long rem = num % cnt;
long long ans = ((val + 1) * (val + 1) * rem);
ans = ans + ((cnt - rem) * val * val);
return ans;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, k;
cin >> n >> k;
long long ans = 0;
multiset<pair<long long, pair<long long, long long>>> Set;
for (long long i = 0; i < n; ++i) {
long long elem;
cin >> elem;
ans = ans + (elem * elem);
long long val = get(elem, 2) - get(elem, 1);
Set.insert({val, {elem, 2}});
}
long long cnt = k - n;
while (cnt--) {
auto it = Set.begin();
ans = ans + ((*it).first);
long long elem = ((*it).second.first);
long long kk = ((*it).second.second);
long long val = get(elem, kk + 1) - get(elem, kk);
Set.erase(it);
Set.insert({val, {elem, kk + 1}});
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007LL;
struct plakat {
int v;
int s;
char c;
};
bool operator<(const plakat& lhs, const plakat& rhs) {
return (lhs.c) < (rhs.c);
}
bool operator>(const plakat& lhs, const plakat& rhs) {
return (lhs.c) > (rhs.c);
}
int poskusi(vector<plakat> t) {
while (next_permutation(t.begin(), t.end())) {
if (t[0].s != t[1].s) continue;
if (t[0].s != t[2].s) continue;
if (t[0].s != t[0].v + t[1].v + t[2].v) continue;
printf("%d\n", t[0].s);
for (int i = 0, _n = t[0].v; i < _n; i++) {
for (int j = 0, _n = t[0].s; j < _n; j++) printf("%c", t[0].c);
printf("\n");
}
for (int i = 0, _n = t[1].v; i < _n; i++) {
for (int j = 0, _n = t[1].s; j < _n; j++) printf("%c", t[1].c);
printf("\n");
}
for (int i = 0, _n = t[2].v; i < _n; i++) {
for (int j = 0, _n = t[2].s; j < _n; j++) printf("%c", t[2].c);
printf("\n");
}
return 1;
}
while (next_permutation(t.begin(), t.end())) {
if (t[0].v != t[1].v) continue;
if (t[0].v != t[2].v) continue;
if (t[0].v != t[0].s + t[1].s + t[2].s) continue;
printf("%d\n", t[0].v);
for (int i = 0, _n = t[0].v; i < _n; i++) {
for (int j = 0, _n = t[0].s; j < _n; j++) printf("%c", t[0].c);
for (int j = 0, _n = t[1].s; j < _n; j++) printf("%c", t[1].c);
for (int j = 0, _n = t[2].s; j < _n; j++) printf("%c", t[2].c);
printf("\n");
}
return 1;
}
while (next_permutation(t.begin(), t.end())) {
if (t[0].s != t[1].s + t[2].s) continue;
if (t[0].s != t[0].v + t[1].v) continue;
if (t[1].v != t[2].v) continue;
printf("%d\n", t[0].s);
for (int i = 0, _n = t[0].v; i < _n; i++) {
for (int j = 0, _n = t[0].s; j < _n; j++) printf("%c", t[0].c);
printf("\n");
}
for (int i = 0, _n = t[1].v; i < _n; i++) {
for (int j = 0, _n = t[1].s; j < _n; j++) printf("%c", t[1].c);
for (int j = 0, _n = t[2].s; j < _n; j++) printf("%c", t[2].c);
printf("\n");
}
return 1;
}
while (next_permutation(t.begin(), t.end())) {
if (t[0].v != t[1].v + t[2].v) continue;
if (t[0].v != t[0].s + t[1].s) continue;
if (t[1].s != t[2].s) continue;
printf("%d\n", t[0].v);
for (int i = 0, _n = t[0].v; i < _n; i++) {
for (int j = 0, _n = t[0].s; j < _n; j++) printf("%c", t[0].c);
if (t[1].v > i)
for (int j = 0, _n = t[1].s; j < _n; j++) printf("%c", t[1].c);
else
for (int j = 0, _n = t[2].s; j < _n; j++) printf("%c", t[2].c);
printf("\n");
}
return 1;
}
return 0;
}
int main() {
vector<plakat> t;
plakat pr;
t.push_back(pr);
t.push_back(pr);
t.push_back(pr);
scanf("%d%d%d%d%d%d", &t[0].s, &t[0].v, &t[1].s, &t[1].v, &t[2].s, &t[2].v);
t[0].c = 'A';
t[1].c = 'B';
t[2].c = 'C';
if (poskusi(t)) return 0;
swap(t[1].v, t[1].s);
if (poskusi(t)) return 0;
swap(t[2].v, t[2].s);
if (poskusi(t)) return 0;
swap(t[1].v, t[1].s);
if (poskusi(t)) return 0;
printf("-1\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<string> A;
string S;
int main() {
int M, N;
cin >> M >> N;
for (int i = 0; i < M; i++) {
cin >> S;
A.push_back(S);
}
int Ans = 1;
for (int i = 0; i < M; i++) {
bool Flag = true, T;
for (int j = 0; j < N; j++)
if (A[i][j] != '.') {
bool F = (A[i][j] == '1' || A[i][j] == '2') ^ (j & 1);
if (Flag) {
Flag = false;
T = F;
}
if (T ^ F) Ans = 0;
}
if (Flag) Ans = Ans * 2 % 1000003;
}
for (int j = 0; j < N; j++) {
bool Flag = true, T;
for (int i = 0; i < M; i++)
if (A[i][j] != '.') {
bool F = (A[i][j] == '1' || A[i][j] == '4') ^ (i & 1);
if (Flag) {
Flag = false;
T = F;
}
if (T ^ F) Ans = 0;
}
if (Flag) Ans = Ans * 2 % 1000003;
}
cout << Ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
typedef struct {
int sum, suf, pre, max;
} Node;
int toint(const string &s) {
stringstream ss;
ss << s;
int x;
ss >> x;
return x;
}
const int MAXN = 3010;
const int UP = 31;
const long long int mod = 1e9 + 7;
const long long int highest = 1e18;
const double pi = acos(-1);
const double Phi = 1.618033988749894;
const int logn = 20;
const double phi = 0.618033988749894;
const double root5 = 2.236067977;
const int N = 1e6 + 10;
vector<pair<int, int> > res;
int n;
int main() {
string s;
cin >> s;
reverse(s.begin(), s.end());
s += '0';
s += '0';
int last = 0;
for (int i = 0; i < s.length(); ++i) {
if (s[i] == 1 - last + '0') {
last = s[i + 1] - '0';
res.push_back(make_pair(i, (last == 0 ? 1 : -1)));
}
}
int x = (int)res.size();
cout << (x) << "\n";
for (int i = 0; i < x; ++i) {
if (res[i].second < 0) {
printf("-2^%d\n", res[i].first);
} else {
printf("+2^%d\n", res[i].first);
}
}
cout << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool prime[100005];
std::vector<int> vg[100005];
int main() {
std::ios::sync_with_stdio(0);
int dp[100005];
memset(dp, 0, sizeof(dp));
int n, k, m;
cin >> n >> k >> m;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
dp[x % m]++;
vg[x % m].push_back(x);
}
int id = -1;
for (int i = 0; i <= 100000; i++) {
if (dp[i] >= k) {
id = i;
}
}
if (id == -1)
cout << "No";
else {
cout << "Yes";
cout << "\n";
for (int i = 0; i < k; i++) cout << vg[id][i] << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int arr[1000000];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
int tot = 0, yo = 0, ti = 0;
bool is = true;
for (int i = 0; i < n; i++) {
tot += arr[i];
if (tot > 350 && tot <= 710) ti += tot - 350;
if (tot > 710) {
yo = i;
is = false;
cout << i << " ";
break;
}
}
if (is) cout << n << " ";
cout << ti;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 998244353;
long long int a[2005];
long long int dp[2005][4015];
long long int moves[2005][3];
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int n, k;
cin >> n >> k;
for (long long int i = 1; i <= n; i++) {
cin >> a[i];
}
for (long long int i = 1; i <= n; i++) {
long long int zzz = 0;
if (i == n) {
if (a[i] != a[1]) {
moves[i][0] = 1;
moves[i][1] = max(k - 2, zzz);
moves[i][2] = 1;
} else {
moves[i][1] = k;
}
} else {
if (a[i] != a[i + 1]) {
moves[i][0] = 1;
moves[i][1] = max(k - 2, zzz);
moves[i][2] = 1;
} else {
moves[i][1] = k;
}
}
}
dp[0][2003] = 1;
for (long long int i = 0; i <= n - 1; i++) {
for (long long int j = -n; j <= n; j++) {
dp[i + 1][j + 2003 + 1] += dp[i][j + 2003] * moves[i + 1][2];
dp[i + 1][j + 2003] += dp[i][j + 2003] * moves[i + 1][1];
dp[i + 1][j + 2003 - 1] += dp[i][j + 2003] * moves[i + 1][0];
if (dp[i + 1][j + 2003 + 1] >= mod) {
dp[i + 1][j + 2003 + 1] %= mod;
}
if (dp[i + 1][j + 2003] >= mod) {
dp[i + 1][j + 2003] %= mod;
}
if (dp[i + 1][j + 2003 - 1] >= mod) {
dp[i + 1][j + 2003 - 1] %= mod;
}
}
}
long long int x = dp[n][2003];
long long int ans = 1;
for (long long int i = 1; i <= n; i++) {
ans *= k;
ans %= mod;
}
ans -= x;
ans += mod;
ans %= mod;
ans = (ans * (power(2, mod - 2, mod))) % mod;
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, x, y;
cin >> a >> b;
if (a >= b) {
x = b;
y = (a - b) / 2;
} else {
x = a;
y = (b - a) / 2;
}
cout << x << " " << y << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int OO = 0x3f3f3f3f, NegOO = -1 * OO, N = 1e5 + 5, mod = 1e9 + 7;
int main() {
int t;
cin >> t;
while (t--) {
string x;
cin >> x;
int dif = 0;
sort(((x).begin()), ((x).end()));
for (int i = 1; i < ((int)((x).size())); ++i) {
if (x[i] != x[i - 1]) dif++;
}
if (!dif) {
cout << -1 << "\n";
continue;
}
cout << x << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct Treap {
int size, key, auxkey, val;
Treap *lf, *rg;
Treap(int _size, int _key, int _auxkey, int _val, Treap *_lf, Treap *_rg) {
size = _size;
key = _key;
auxkey = _auxkey;
val = _val;
lf = _lf;
rg = _rg;
}
};
Treap *nil = new Treap(0, 0, 0, 0, 0, 0);
Treap *root = nil;
void get_size(Treap *&nod) {
if (nod == nil) return;
nod->size = nod->lf->size + nod->rg->size + 1;
}
void rotate_lf(Treap *&nod) {
Treap *aux = nod->lf;
nod->lf = nod->lf->rg;
aux->rg = nod;
nod = aux;
get_size(nod->lf);
get_size(nod->rg);
get_size(nod);
}
void rotate_rg(Treap *&nod) {
Treap *aux = nod->rg;
nod->rg = nod->rg->lf;
aux->lf = nod;
nod = aux;
get_size(nod->lf);
get_size(nod->rg);
get_size(nod);
}
void balance(Treap *&nod) {
if (nod->lf->val > nod->val) rotate_lf(nod);
if (nod->rg->val > nod->val) rotate_rg(nod);
get_size(nod);
}
void insert(Treap *&nod, int key, int auxkey, int val) {
if (nod == nil) {
nod = new Treap(1, key, auxkey, val, nil, nil);
return;
}
if (nod->key > key)
insert(nod->lf, key, auxkey, val);
else
insert(nod->rg, key, auxkey, val);
balance(nod);
}
void erase(Treap *&nod, int key) {
if (nod->key > key) {
erase(nod->lf, key);
balance(nod);
} else if (nod->key < key) {
erase(nod->rg, key);
balance(nod);
} else {
if (nod->lf == nil && nod->rg == nil) {
delete nod;
nod = nil;
return;
}
if (nod->lf->val > nod->rg->val) {
rotate_lf(nod);
erase(nod->rg, key);
balance(nod);
} else {
rotate_rg(nod);
erase(nod->lf, key);
balance(nod);
}
}
}
int findt(Treap *&nod, int szn) {
if (nod->lf->size == szn) return nod->auxkey;
if (nod->lf->size > szn)
return findt(nod->lf, szn);
else
return findt(nod->rg, szn - nod->lf->size - 1);
}
int get_rand() {
int now = rand() * rand();
if (now < 0) now = -now;
if (now == 0) return 1;
return now;
}
int N, M;
int A[1000002], F[1000002], W[1000002];
set<int> S;
bool impossible;
int main() {
srand(time(0));
cin.sync_with_stdio(false);
cin >> N >> M;
for (int i = 1; i <= N; ++i) {
insert(root, i, i, get_rand() + 1);
W[i] = i;
}
for (int i = 1, what, where; i <= M; ++i) {
cin >> what >> where;
int pos = findt(root, where - 1);
erase(root, W[pos]);
W[pos] = --W[0];
insert(root, W[pos], pos, get_rand() + 1);
if (A[pos] == 0)
A[pos] = what;
else if (A[pos] != what)
impossible = true;
}
for (int i = 1; i <= N; ++i)
if (A[i] != 0) {
if (F[A[i]] == 1) impossible = true;
++F[A[i]];
}
for (int i = 1; i <= N; ++i)
if (F[i] == 0) S.insert(i);
if (impossible)
printf("-1\n");
else {
for (int i = 1; i <= N; ++i) {
if (A[i] == 0) {
A[i] = (*S.begin());
S.erase(S.begin());
}
printf("%d ", A[i]);
}
printf("\n");
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double pi = acos(-1.0);
int sign(double x) { return (x > eps) - (x < -eps); }
struct Point {
double x, y;
Point(double _x = 0, double _y = 0) { x = _x, y = _y; }
Point operator+(const Point &a) { return Point(x + a.x, y + a.y); }
Point operator-(const Point &a) { return Point(x - a.x, y - a.y); }
Point operator*(const double &a) { return Point(x * a, y * a); }
Point operator/(const double &a) { return Point(x / a, y / a); }
friend bool operator<(const Point &l, const Point &r) {
return l.y < r.y || (!sign(l.y - r.y) && l.x < r.x);
}
double angle() { return atan2(y, x); }
void input() { scanf("%lf%lf", &x, &y); }
} p[50030], q[200000], tp[200000];
int Minkowski(int n, int m) {
int s1 = 0, s2 = 0;
for (int i = 0; i < n; i++)
if (q[i] < q[s1]) s1 = i;
for (int i = 0; i < m; i++)
if (p[i] < p[s2]) s2 = i;
int cnt = 0;
tp[cnt++] = q[s1] + p[s2];
for (int i = 0, j = 0; i < n || j < m;) {
int f;
int k1 = (i + s1) % n, l1 = (k1 + 1) % n;
int k2 = (j + s2) % m, l2 = (k2 + 1) % m;
if (i == n)
f = 1;
else if (j == m)
f = 0;
else {
double a1 = (q[l1] - q[k1]).angle();
double a2 = (p[l2] - p[k2]).angle();
while (sign(a1) < 0) a1 += 2.0 * pi;
while (sign(a2) < 0) a2 += 2.0 * pi;
f = (a1 > a2);
}
if (!f) {
tp[cnt] = (q[l1] - q[k1]) + tp[cnt - 1];
i++;
cnt++;
} else {
tp[cnt] = (p[l2] - p[k2]) + tp[cnt - 1];
j++;
cnt++;
}
}
cnt--;
return cnt;
}
double mult(Point a, Point b, Point c) {
return (a.x - c.x) * (b.y - c.y) - (a.y - c.y) * (b.x - c.x);
}
int graham(Point pnt[], int n, Point res[]) {
int i, len, k = 0, top = 1;
sort(pnt, pnt + n);
if (n == 0) return 0;
res[0] = pnt[0];
if (n == 1) return 1;
res[1] = pnt[1];
if (n == 2) return 2;
res[2] = pnt[2];
for (i = 2; i < n; i++) {
while (top && sign(mult(pnt[i], res[top], res[top - 1])) >= 0) top--;
res[++top] = pnt[i];
}
len = top;
res[++top] = pnt[n - 2];
for (i = n - 3; i >= 0; i--) {
while (top != len && sign(mult(pnt[i], res[top], res[top - 1])) >= 0) top--;
res[++top] = pnt[i];
}
return top;
}
bool isin(const Point &a, int cnt, Point res[]) {
Point g = (res[0] + res[(cnt / 3)] + res[(2 * cnt / 3)]) / 3.0;
int l = 0, r = cnt;
while (l + 1 < r) {
int mid = (l + r) / 2;
double k = mult(res[l], res[mid], g);
double res1 = mult(res[l], a, g);
double res2 = mult(res[mid], a, g);
if (sign(k) > 0) {
if (sign(res1) >= 0 && sign(res2) < 0)
r = mid;
else
l = mid;
} else {
if (sign(res1) < 0 && sign(res2) >= 0)
l = mid;
else
r = mid;
}
}
r %= cnt;
int z = sign(mult(res[r], res[l], a));
if (z <= 0)
return 1;
else
return 0;
}
int n;
double area() {
double ret = 0;
for (int i = 1; i < n - 1; i++) ret += mult(q[i], q[i + 1], q[0]);
return fabs(ret) / 2.0;
}
int main() {
while (scanf("%d", &n) != EOF) {
for (int i = 0; i < n; i++) q[i].input();
for (int i = 1; i < 3; i++) {
int tmp;
scanf("%d", &tmp);
for (int j = 0; j < tmp; j++) p[j].input();
n = Minkowski(n, tmp);
n = graham(tp, n, q);
}
int Q;
scanf("%d", &Q);
for (int i = 0; i < Q; i++) {
int cnt = 0;
Point tmp;
tmp.input();
tmp = tmp * 3;
if (isin(tmp, n, q))
puts("YES");
else
puts("NO");
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long inf = 1e15;
const int N = 1e5 + 6;
int n, a[N], vis[N];
char s[N];
int main() {
memset(vis, 0, sizeof(vis));
scanf("%d", &n);
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
int pos = 1;
vis[1] = 1;
while (1) {
if (s[pos] == '>') {
if (pos + a[pos] > n) {
printf("FINITE\n");
return 0;
} else {
if (vis[pos + a[pos]]) {
printf("INFINITE\n");
return 0;
} else {
pos += a[pos];
vis[pos] = 1;
}
}
} else {
if (pos - a[pos] < 1) {
printf("FINITE\n");
return 0;
} else {
if (vis[pos - a[pos]]) {
printf("INFINITE\n");
return 0;
} else {
pos -= a[pos];
vis[pos] = 1;
}
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 2;
struct pii {
int name, first, second;
} q[N];
int n, m, k, ans[N], a[N], t[4 * N], adr[N], age[N], grp[N], u[N], v[N], r[N],
per[N], tmp[N], f[N];
bool by_r(int x, int y) { return r[x] < r[y]; }
bool by_second_r(pii x, pii y) { return r[x.second] < r[y.second]; }
bool by_a(int x, int y) { return a[x] < a[y]; }
void insert(int m) {
m++;
int b = m & -m;
while (m <= n) {
f[m]++;
while (m & b) {
m &= ~b;
b <<= 1;
}
m |= b;
}
}
void segment_insert(int n, int b, int e, int x, int k) {
if (b == e) {
t[n] = k;
return;
}
int l = n << 1, r = l | 1, m = b + e >> 1;
if (x <= m)
segment_insert(l, b, m, x, k);
else
segment_insert(r, m + 1, e, x, k);
t[n] = max(t[l], t[r]);
}
int query(int m) {
m++;
int res = 0;
while (m) {
res += f[m];
m -= m & -m;
}
return res;
}
int segment_query(int n, int b, int e, int u, int v) {
if (e < u || v < b) return -1;
if (u <= b && e <= v) return t[n];
int l = n << 1, r = l | 1, m = b + e >> 1;
return max(segment_query(l, b, m, u, v), segment_query(r, m + 1, e, u, v));
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
for (int i = 0; i < n; i++) per[i] = i;
for (int i = 0; i < n; i++) cin >> r[i];
for (int i = 0; i < n; i++) {
cin >> a[i];
tmp[i] = a[i];
}
sort(tmp, tmp + n);
for (int i = 0; i < n; i++) {
u[i] = lower_bound(tmp, tmp + n, a[i] - k) - tmp;
v[i] = upper_bound(tmp, tmp + n, a[i] + k) - 1 - tmp;
}
sort(per, per + n, by_a);
for (int i = 0; i < n; i++) age[per[i]] = i;
sort(per, per + n, by_r);
int p1 = 0, p2 = 0;
while (p1 < n) {
while (p2 < n && r[per[p1]] == r[per[p2]]) {
insert(age[per[p2]]);
p2++;
}
while (p1 < p2) {
grp[per[p1]] = query(v[per[p1]]) - query(u[per[p1]] - 1);
p1++;
}
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> q[i].first >> q[i].second;
q[i].first--, q[i].second--;
q[i].name = i;
if (r[q[i].first] > r[q[i].second]) swap(q[i].first, q[i].second);
}
sort(q, q + m, by_second_r);
fill(t, t + 4 * n + 2, -1);
for (int i = m - 1, p = n - 1; i >= 0; i--) {
while (p >= 0 && r[per[p]] >= r[q[i].second]) {
segment_insert(1, 0, n - 1, age[per[p]], grp[per[p]]);
p--;
}
int b = max(u[q[i].second], u[q[i].first]),
e = min(v[q[i].first], v[q[i].second]);
if (b > e)
ans[q[i].name] = -1;
else {
ans[q[i].name] = segment_query(1, 0, n - 1, b, e);
}
}
for (int i = 0; i < m; i++) cout << ans[i] << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "[";
for (int i = 0; i < v.size(); ++i) {
os << v[i];
if (i != v.size() - 1) os << ", ";
}
os << "]\n";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& v) {
os << "[";
for (auto it : v) {
os << it;
if (it != *v.rbegin()) os << ", ";
}
os << "]\n";
return os;
}
template <typename T, typename S>
ostream& operator<<(ostream& os, const map<T, S>& v) {
for (auto it : v) os << it.first << " : " << it.second << "\n";
return os;
}
template <typename T, typename S>
ostream& operator<<(ostream& os, const pair<T, S>& v) {
os << "(";
os << v.first << ", " << v.second << ")";
return os;
}
void go() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
int main() {
go();
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
int turn = 1;
while (1) {
int ok = 0;
if (s.size() == 1) break;
for (int i = 1; i < s.size(); i++) {
if ((s[i] == '1' and s[i - 1] == '0') or
(s[i] == '0' and s[i - 1] == '1')) {
string newstr = "";
turn++;
ok = 1;
for (int j = 0; j <= i - 2; j++) {
newstr += string(1, s[j]);
}
for (int j = i + 1; j < s.size(); j++) {
newstr += string(1, s[j]);
}
s = newstr;
break;
}
}
if (ok == 0) break;
}
cout << (turn % 2 == 0 ? "DA" : "NET") << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 45;
int n, m;
char G[maxn][maxn];
int sg[maxn][maxn][maxn][maxn][2];
int SG(int x0, int x1, int y0, int y1, int d) {
int &g = sg[x0][x1][y0][y1][d];
if (g != -1) return g;
char s[maxn * 2 + 1];
memset(s, 0, sizeof(s));
for (int y = 0; y < n; ++y) {
for (int x = 0; x < m; ++x) {
if (((x + y) & 1) == d) {
int x_ = y + x, y_ = y - x + m;
if (x0 <= x_ && x_ < x1 && y0 <= y_ && y_ < y1) {
int tmp;
if (G[y][x] == 'L')
tmp = SG(x0, x_, y0, y1, d) ^ SG(x_ + 1, x1, y0, y1, d);
if (G[y][x] == 'R')
tmp = SG(x0, x1, y0, y_, d) ^ SG(x0, x1, y_ + 1, y1, d);
if (G[y][x] == 'X') {
tmp = SG(x0, x_, y0, y_, d) ^ SG(x0, x_, y_ + 1, y1, d) ^
SG(x_ + 1, x1, y0, y_, d) ^ SG(x_ + 1, x1, y_ + 1, y1, d);
}
s[tmp] = 1;
}
}
}
}
while (s[++g])
;
return g;
}
int main() {
while (cin >> n >> m) {
for (int i = 0; i < n; ++i) cin >> G[i];
memset(sg, -1, sizeof sg);
if ((SG(0, n + m, 0, n + m, 0) ^ SG(0, n + m, 0, n + m, 1)) > 0)
printf("WIN\n");
else
printf("LOSE\n");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a, l[100001];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> k;
l[k] = l[k - 1] + 1;
a = max(a, l[k]);
}
cout << n - a << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 1;
bool fixed_pos[N];
int left_dis[N], right_dis[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
int n, k;
string s;
cin >> n >> k >> s;
for (int i = 0; i < n; ++i) {
if (s[i] == s[(i - 1 + n) % n] || s[i] == s[(i + 1) % n])
fixed_pos[i] = true, left_dis[i] = right_dis[i] = INT_MAX;
}
for (int i = 0; i < n; ++i) {
if (!fixed_pos[i]) continue;
left_dis[i] = right_dis[i] = 0;
for (int j = (i + 1) % n; !fixed_pos[j]; j = (j + 1) % n)
left_dis[j] = left_dis[(j - 1 + n) % n] + 1;
for (int j = (i + n - 1) % n; !fixed_pos[j]; j = (j + n - 1) % n)
right_dis[j] = right_dis[(j + 1) % n] + 1;
}
for (int i = 0; i < n; ++i) {
if (min(left_dis[i], right_dis[i]) > k) {
bool cur_char_is_w = (s[i] == 'W') ^ (k & 1);
cout << (cur_char_is_w ? 'W' : 'B');
} else {
int pos = (i - left_dis[i] + n) % n;
if (left_dis[i] > right_dis[i]) pos = (i + right_dis[i]) % n;
cout << s[pos];
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 5;
long long n, m, a[N], tr[N * 4], Mi[N * 4];
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long rd() {
long long x = 0, fl = 1;
char ch = getchar();
for (; ch < 48 || ch > 57; ch = getchar())
if (ch == '-') fl = -1;
for (; 48 <= ch && ch <= 57; ch = getchar())
x = (x << 3) + (x << 1) + (ch ^ 48);
return x * fl;
}
void build(long long nod, long long l, long long r) {
Mi[nod] = 3 * n;
if (l == r) {
tr[nod] = a[l];
return;
}
long long mid = (l + r) / 2;
build(nod * 2, l, mid);
build(nod << 1 | 1, mid + 1, r);
tr[nod] = max(tr[nod * 2], tr[nod << 1 | 1]);
}
long long find(long long nod, long long l, long long r, long long L,
long long R) {
if (l == L && r == R) return tr[nod];
long long mid = (l + r) / 2;
if (R <= mid)
return find(nod * 2, l, mid, L, R);
else if (L > mid)
return find(nod << 1 | 1, mid + 1, r, L, R);
else
return max(find(nod * 2, l, mid, L, mid),
find(nod << 1 | 1, mid + 1, r, mid + 1, R));
}
void push(long long nod) {
Mi[nod * 2] = min(Mi[nod * 2], Mi[nod]);
Mi[nod << 1 | 1] = min(Mi[nod << 1 | 1], Mi[nod]);
}
void chg(long long nod, long long l, long long r, long long L, long long R,
long long val) {
if (l == L && r == R) {
Mi[nod] = min(Mi[nod], val);
return;
}
push(nod);
long long mid = (l + r) / 2;
if (R <= mid)
chg(nod * 2, l, mid, L, R, val);
else if (L > mid)
chg(nod << 1 | 1, mid + 1, r, L, R, val);
else {
chg(nod * 2, l, mid, L, mid, val);
chg(nod << 1 | 1, mid + 1, r, mid + 1, R, val);
}
}
long long query(long long nod, long long l, long long r, long long L,
long long R) {
if (l == L && r == R) return Mi[nod];
push(nod);
long long mid = (l + r) / 2;
if (R <= mid)
return query(nod * 2, l, mid, L, R);
else if (L > mid)
return query(nod << 1 | 1, mid + 1, r, L, R);
else
return min(query(nod * 2, l, mid, L, mid),
query(nod << 1 | 1, mid + 1, r, mid + 1, R));
}
signed main() {
for (long long xmy = 1; xmy <= 10; xmy++)
;
n = rd();
long long ma = 0, mi = 1e18;
for (long long i = 1; i <= n; i++) {
a[i] = a[n + i] = a[n + n + i] = rd();
ma = max(ma, a[i]);
mi = min(mi, a[i]);
}
for (long long xmy = 1; xmy <= 10; xmy++)
;
build(1, 1, 3 * n);
if (mi * 2 >= ma) {
for (long long i = 1; i <= n; i++) printf("-1 ");
return 0;
}
for (long long xmy = 1; xmy <= 10; xmy++)
;
for (long long xmy = 1; xmy <= 10; xmy++)
;
for (long long i = 1; i <= 3 * n; i++) {
long long l = 1, r = i;
while (l < r) {
long long mid = (l + r + 1) / 2;
if (find(1, 1, 3 * n, mid, i) > a[i] * 2)
l = mid;
else
r = mid - 1;
}
if (find(1, 1, 3 * n, l, i) > a[i] * 2) chg(1, 1, 3 * n, 1, l, i);
}
for (long long xmy = 1; xmy <= 10; xmy++)
;
for (long long xmy = 1; xmy <= 10; xmy++)
;
for (long long i = 1; i <= n; i++)
printf("%lld ", query(1, 1, 3 * n, i, i) - i);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
string s1, s2;
cin >> s1;
cin >> s2;
int size = s1.size() - 1;
int it = size;
while (s1[it] == 'z') {
s1[it] = 'a';
--it;
}
s1[it] += 1;
if (s1 != s2) {
cout << s1;
} else {
cout << "No such string";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> k;
int min = 50;
for (int i = 0; i < n; ++i) {
int a;
cin >> a;
if (a < min) {
min = a;
}
k.push_back(a);
}
int suma = 0;
for (auto &i : k) {
if (i == min) {
suma++;
}
}
if (suma <= (n / 2))
cout << "Alice";
else
cout << "Bob";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, p;
long long h[100005], a[100005];
bool isPossible(long long v) {
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
fila;
long long foo[n];
for (int i = 0; i < n; i++) {
if (v - m * a[i] < 0) fila.push(pair<long long, int>(v / a[i] - 1, i));
foo[i] = v;
}
int availableHits = m * k;
int used = 0;
while (!fila.empty() && used < availableHits) {
pair<long long, int> bar = fila.top();
fila.pop();
int i = bar.second;
long long currentDay = used / k;
if (bar.first < currentDay) return false;
foo[i] += p;
used++;
if (foo[i] - m * a[i] < 0)
fila.push(pair<long long, int>(foo[i] / a[i] - 1, i));
}
for (int i = 0; i < n; i++) {
if (foo[i] - m * a[i] < h[i]) {
used += (h[i] - (foo[i] - m * a[i]) + p - 1) / p;
if (used > availableHits) return false;
}
}
return true;
}
int main() {
cin >> n >> m >> k >> p;
for (int i = 0; i < n; i++) cin >> h[i] >> a[i];
long long ini, fim, meio;
ini = 0;
fim = 1LL << 55;
while (fim - ini > 1) {
meio = (ini + fim) / 2LL;
if (isPossible(meio))
fim = meio;
else
ini = meio;
}
long long answer = ini;
if (isPossible(fim))
answer = fim;
else if (isPossible((ini + fim) / 2))
answer = (ini + fim) / 2;
cout << answer << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ns = 0;
int nh = 0;
for (int i = 0; i < n; i++) {
string a, b;
cin >> a >> b;
if (b == "soft") {
ns++;
} else {
nh++;
}
}
int k = 0;
while (k * k < (ns + nh) || (k * k + 1) / 2 < max(ns, nh)) {
k++;
}
cout << k << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int d, n;
cin >> d >> n;
long long int a[n];
for (long long int i = 0; i < n; i++) cin >> a[i];
long long int ans = 0;
for (long long int i = 0; i < n - 1; i++) {
ans += d - a[i];
}
cout << ans << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000,100000000")
using namespace std;
const double eps = 1e-8;
int dcmp(double d) { return d < -eps ? -1 : d > eps; }
struct Point {
double x, y;
Point() {}
Point(double _x, double _y) : x(_x), y(_y) {}
void input() { scanf("%lf %lf", &x, &y); }
inline Point operator-(const Point &p) const {
return Point(x - p.x, y - p.y);
}
inline Point operator+(const Point &p) const {
return Point(x + p.x, y + p.y);
}
inline double operator*(const Point &p) const { return x * p.y - y * p.x; }
inline double operator/(const Point &p) const { return x * p.x + y * p.y; }
inline Point operator*(const double d) const { return Point(x * d, y * d); }
inline Point operator/(const double d) const { return Point(x / d, y / d); }
inline Point turnLeft() { return Point(-y, x); }
} s, e;
struct Line {
Point a, b;
Line() {}
Line(Point _a, Point _b) : a(_a), b(_b) {}
void input() {
a.input();
b.input();
}
inline double operator*(const Point &p) const { return (b - a) * (p - a); }
inline double operator/(const Point &p) const { return (p - a) / (p - b); }
inline int SegCrossSeg(const Line &v) {
int d1 = dcmp((*this) * v.a);
int d2 = dcmp((*this) * v.b);
int d3 = dcmp(v * a);
int d4 = dcmp(v * b);
if ((d1 ^ d2) == -2 && (d3 ^ d4) == -2) return 2;
return ((d1 == 0 && dcmp((*this) / v.a) <= 0) ||
(d2 == 0 && dcmp((*this) / v.b) <= 0) ||
(d3 == 0 && dcmp(v / a) <= 0) || (d4 == 0 && dcmp(v / b) <= 0));
}
inline bool parallel(Line v) { return !dcmp((b - a) * (v.b - v.a)); }
inline Point CrossPoint(const Line &v) {
double s1 = v * a, s2 = v * b;
return (a * s2 - b * s1) / (s2 - s1);
}
inline Point PointToLine(const Point &p) {
return CrossPoint(Line(p, p + (a - b).turnLeft()));
}
inline Point SymPoint(const Point &p) { return PointToLine(p) * 2 - p; }
} wall, mirror;
int main() {
s.input();
e.input();
wall.input();
mirror.input();
if (wall.SegCrossSeg(Line(s, e)) == 0) {
if (mirror.SegCrossSeg(Line(s, e)) == 0 || mirror.parallel(Line(s, e))) {
puts("YES");
return 0;
}
}
Point t = mirror.SymPoint(e);
if (mirror.SegCrossSeg(Line(s, t)) >= 1) {
Point p = mirror.CrossPoint(Line(s, t));
if (wall.SegCrossSeg(Line(s, p)) == 0 &&
wall.SegCrossSeg(Line(p, e)) == 0) {
puts("YES");
return 0;
}
}
puts("NO");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long arr[60];
int pos[60];
void func(int st, int l, int r, long long m) {
if (l == r) {
pos[l] = st;
return;
}
int n = r - l + 1;
if (m <= arr[n - 1]) {
pos[l] = st;
func(st + 1, l + 1, r, m);
} else {
pos[r] = st;
func(st + 1, l, r - 1, m - arr[n - 1]);
}
}
int main() {
long long n, m;
scanf("%I64d %I64d", &n, &m);
arr[1] = 1;
for (int i = 2; i <= n; ++i) {
arr[i] = 2 * arr[i - 1];
}
func(1, 0, n - 1, m);
for (int i = 0; i < n; ++i) {
printf("%d ", pos[i]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int nn = 2e6 + 8;
const int Max = 2e6;
const long long mod = 1e9 + 7;
long long e[nn];
long long fac[nn];
long long x, y;
long long Pow(long long a, long long x) {
if (x == 0) return 1;
long long d = Pow(a, x >> 1);
d = (d * d) % mod;
if (x & 1) return (d * a) % mod;
return d;
}
long long nck(long long n, long long k) {
long long tmp = (fac[n - k] * fac[k]) % mod;
return (fac[n] * Pow(tmp, mod - 2)) % mod;
}
int main() {
fac[0] = 1;
for (int i = 1; i <= Max; i++) fac[i] = (fac[i - 1] * i) % mod;
for (int i = 2; i <= Max; i++) {
if (e[i] == 0) {
e[i] = i;
for (long long j = (long long)i * (long long)i; j <= Max; j += i)
e[j] = i;
}
}
int q;
cin >> q;
while (q--) {
scanf("%lld %lld", &x, &y);
long long res = 1;
while (x > 1) {
int p = e[x];
int cnt = 0;
while (x % p == 0) {
++cnt;
x /= p;
}
res = (res * nck(y + cnt - 1, cnt)) % mod;
}
printf("%lld\n", (res * Pow(2, y - 1)) % mod);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, k, ans = 0;
string s;
void change(int h) {
int c1;
if (h < n - 1) {
c1 = s[h + 1] - 'A';
} else {
c1 = s[h - 1] - 'A';
}
int c = s[h] - 'A';
for (int i = 0; i < k; i++) {
if (i != c && i != c1) {
s[h] = char('A' + i);
}
}
}
int main() {
cin >> n >> k >> s;
if (k == 2) {
int cn1 = 0, cn2 = 0;
for (int i = 0; i < n; i++) {
if (s[i] - 'A' != i % 2) {
cn1++;
} else {
cn2++;
}
}
if (cn1 < cn2) {
for (int i = 0; i < n; i++) {
if (s[i] - 'A' != i % 2) {
if (i % 2 == 0) {
s[i]--;
} else {
s[i]++;
}
}
}
cout << cn1 << endl << s << endl;
} else {
for (int i = 0; i < n; i++) {
if (s[i] - 'A' == i % 2) {
if (i % 2 == 0) {
s[i]++;
} else {
s[i]--;
}
}
}
cout << cn2 << endl << s << endl;
}
return 0;
}
for (int i = 1; i < n - 1; i++) {
if (s[i] == s[i - 1] && s[i] == s[i + 1]) {
change(i);
ans++;
}
}
for (int i = 1; i < n; i++) {
if (s[i] == s[i - 1]) {
change(i);
ans++;
}
}
cout << ans << endl << s << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int p, x, y;
cin >> p >> x >> y;
for (int s = y;; s++) {
if (s % 50 != x % 50) {
continue;
}
bool me = false;
int i = s / 50 % 475;
for (int j = 0; j < 25; j++) {
i = (i * 96 + 42) % 475;
if (i + 26 == p) {
me = true;
break;
}
}
if (me) {
printf("%d\n", (max(0, s - x) + 50) / 100);
break;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int Set(int mask, int pos) { return mask = mask | (1 << pos); }
bool check(int mask, int pos) { return (bool)(mask & (1 << pos)); }
int mark[1000005], arr[1000005];
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
arr[i]--;
}
int cnt = 0;
for (int i = 0; i < n; i++) {
if (!mark[i]) {
int pos = i;
cnt++;
while (!mark[pos]) {
mark[pos] = 1;
pos = arr[pos];
}
}
}
if ((n - cnt) % 2 == n % 2) {
cout << "Petr" << endl;
} else {
cout << "Um_nik" << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int a[N];
int main() {
int n;
cin >> n;
for (int i = 2; i <= n; i++) {
if (!a[i])
for (int j = i + i; j <= n; j += i) a[j] = i;
a[i] = i - a[i] + 1;
}
int ans = n;
for (int i = a[n]; i <= n; i++) ans = min(ans, a[i]);
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
int getbit(long long x, int y) { return (x >> y) & 1; }
long long getoff(long long x, int y) { return x ^ ((1ll) << y); }
using namespace std;
int n, res, a[1010], b[1010][9], c[1010][9], f[1010][256];
void dp(int kc) {
for (int i = 0; i <= n; ++i)
for (int mask = 1; mask < 256; ++mask) f[i][mask] = -1e9;
for (int i = 1; i <= n; ++i)
for (int mask = 1; mask < (1 << 8); ++mask) {
for (int j = 1; j <= 8; ++j)
if (getbit(mask, j - 1) == 1) {
int k;
int ts = b[i][j];
if (ts < kc) continue;
k = c[ts - kc][j];
f[i][mask] = max(f[i][mask], f[k][getoff(mask, j - 1)] + kc);
if (ts < kc + 1) continue;
k = c[ts - kc - 1][j];
f[i][mask] = max(f[i][mask], f[k][getoff(mask, j - 1)] + kc + 1);
}
f[i][mask] = max(f[i][mask], f[i - 1][mask]);
}
res = max(res, f[n][255]);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
for (int j = 1; j <= 8; ++j) b[i][j] = b[i - 1][j];
b[i][a[i]]++;
for (int j = 1; j <= 8; ++j) c[b[i][j]][j] = i;
}
for (int kc = 0; kc <= n / 8; ++kc) dp(kc);
cout << res;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int c[N], rr[N], ans[N];
struct node {
int l, r;
int id;
bool operator<(const node& a) const { return l == a.l ? r < a.r : l > a.l; }
} seg[N];
void add(int i) {
while (i < N) c[i]++, i += (i) & (-i);
}
int sum(int i) {
int ans = 0;
while (i) ans += c[i], i -= (i) & (-i);
return ans;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &seg[i].l, &seg[i].r);
rr[i] = seg[i].r;
seg[i].id = i;
}
sort(rr + 1, rr + 1 + n);
int k = unique(rr + 1, rr + 1 + n) - rr;
for (int i = 1; i <= n; i++)
seg[i].r = lower_bound(rr + 1, rr + k, seg[i].r) - rr;
sort(seg + 1, seg + 1 + n);
for (int i = 1; i <= n; i++) {
ans[seg[i].id] = sum(seg[i].r);
add(seg[i].r + 1);
}
for (int i = 1; i <= n; i++) printf("%d\n", ans[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
int bsf(int x) { return __builtin_ctz(x); }
int bsr(int x) { return 31 - __builtin_clz(x); }
using namespace std;
const double pi = 3.14159265358979323846;
const int inf = (int)2e+9 + 2;
const int mod = (int)1e+9 + 7;
const double eps = 1e-8;
const int N = 100000;
int n, m, k;
void solve() {
cin >> n >> k;
string s;
cin >> s;
for (auto i = 0; i < k; ++i) {
int l, r;
char c1, c2;
cin >> l >> r >> c1 >> c2;
--l;
--r;
for (int j = l; j <= r; ++j) {
if (s[j] == c1) {
s[j] = c2;
}
}
}
cout << s;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int test = 1;
for (; test; --test) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
long long t, n, f[N], dp1[N], dp2[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
f[1] = 1;
f[2] = 2;
for (int i = 3; i <= 91; i++) {
f[i] = f[i - 1] + f[i - 2];
}
cin >> t;
while (t--) {
cin >> n;
int cur = 91, q[100], sz = 0;
q[0] = 0;
while (n) {
if (n >= f[cur]) {
q[++sz] = cur;
n -= f[cur];
}
cur--;
}
reverse(q + 1, q + sz + 1);
dp1[0] = 1, dp2[0] = 0;
for (int i = 1; i <= sz; i++) {
dp1[i] = dp1[i - 1] + dp2[i - 1];
dp2[i] = dp1[i - 1] * ((q[i] - q[i - 1] - 1) / 2) +
dp2[i - 1] * ((q[i] - q[i - 1]) / 2);
}
cout << dp1[sz] + dp2[sz] << "\n";
}
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
pair<int, int> a[1010];
int n, m, p[1010];
double dp[1010];
double cal(int i, int j) { return sqrt(abs(a[j].first - a[i].first - m) + 0.); }
bool func(double t) {
dp[0] = 0;
for (int i = 1; i <= n; i++) dp[i] = 1000000007;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < i; j++) {
double v = dp[j] + cal(j, i);
if (dp[i] > v) p[i] = j, dp[i] = v;
}
dp[i] -= t * a[i].second;
}
return dp[n] <= 1e-8;
}
int main() {
int T, i, j, ca = 0, k;
while (~scanf("%d%d", &n, &m)) {
for (i = 1; i <= n; i++) scanf("%d%d", &a[i].first, &a[i].second);
a[0] = make_pair(0, 0);
double l = 0, r = 5 * 1e5, ans = r;
for (int it = 0; it < 50; it++) {
double first = (l + r) / 2;
if (func(first))
ans = first, r = first;
else
l = first;
}
func(ans);
vector<int> res;
i = n;
do {
res.push_back(i);
i = p[i];
} while (i);
for (i = res.size() - 1; i >= 0; i--) printf("%d ", res[i]);
puts("");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
struct node {
int x, y;
} e[maxn * 2];
struct node2 {
int u, v, next;
} edge[maxn * 2];
map<pair<int, int>, int> ma;
vector<int> vv[maxn];
vector<int> v2;
queue<int> q;
int head[maxn], cnt, vis[maxn], deg[maxn], k;
void add(int x, int y) {
edge[cnt].next = head[x];
edge[cnt].v = y;
head[x] = cnt++;
}
bool solve(int x) {
int v;
node e;
v2.clear();
v2.push_back(x);
for (int i = head[x]; i != -1; i = edge[i].next) {
v = edge[i].v;
if (vis[v]) continue;
v2.push_back(v);
}
if (v2.size() != k) return false;
for (int i = 0; i < v2.size(); i++) {
for (int j = i + 1; j < v2.size(); j++) {
int x = v2[i];
int y = v2[j];
if (x > y) swap(x, y);
e.x = x;
e.y = y;
if (!binary_search(vv[x].begin(), vv[x].end(), y)) return false;
}
}
return true;
}
int main() {
int T, v, n, m, u;
scanf("%d", &T);
while (T--) {
cnt = 0;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
head[i] = -1;
vv[i].clear();
deg[i] = 0;
vis[i] = 0;
}
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
if (u > v) swap(u, v);
e[i].x = u;
e[i].y = v;
vv[u].push_back(v);
add(u, v);
add(v, u);
deg[u]++;
deg[v]++;
}
for (int i = 1; i <= n; i++) {
sort(vv[i].begin(), vv[i].end());
}
int left = n;
for (int i = 1; i <= n; i++) {
if (deg[i] < k) {
q.push(i);
vis[i] = 1;
left--;
}
}
while (!q.empty()) {
u = q.front();
q.pop();
for (int i = head[u]; i != -1; i = edge[i].next) {
v = edge[i].v;
deg[v]--;
if (deg[v] < k && !vis[v]) {
q.push(v);
vis[v] = 1;
left--;
}
}
}
if (left) {
printf("%d %d\n", 1, left);
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
printf("%d ", i);
}
}
printf("\n");
continue;
}
int step = (int)sqrt(2 * m + 2) + 5;
if (k >= step) {
printf("-1\n");
continue;
}
for (int i = 1; i <= n; i++) {
vis[i] = 0;
deg[i] = 0;
}
for (int i = 1; i <= m; i++) {
u = e[i].x;
v = e[i].y;
deg[u]++;
deg[v]++;
}
left = n;
for (int i = 1; i <= n; i++) {
if (deg[i] < k - 1) {
q.push(i);
vis[i] = 1;
left--;
}
}
while (!q.empty()) {
u = q.front();
q.pop();
for (int i = head[u]; i != -1; i = edge[i].next) {
v = edge[i].v;
deg[v]--;
if (deg[v] < k - 1 && !vis[v]) {
q.push(v);
vis[v] = 1;
left--;
}
}
}
for (int i = 1; i <= n; i++) {
if (!vis[i] && deg[i] == k - 1) {
q.push(i);
}
}
int flag = 0;
while (!q.empty()) {
int i = q.front();
q.pop();
if (solve(i)) {
printf("%d\n", 2);
for (int j = head[i]; j != -1; j = edge[j].next) {
v = edge[j].v;
if (!vis[v]) {
printf("%d ", v);
}
}
printf("%d\n", i);
flag = 1;
break;
} else {
vis[i] = 1;
for (int j = head[i]; j != -1; j = edge[j].next) {
v = edge[j].v;
deg[v]--;
if (!vis[v]) {
if (deg[v] == k - 1 && !vis[v]) {
q.push(v);
}
}
}
}
}
while (!q.empty()) q.pop();
if (flag == 0) {
printf("-1\n");
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
string s, A = "", B = "";
cin >> n;
cin >> s;
if (n & 1) {
for (int i = 1; i < n; i++)
if (i & 1)
A = s[i] + A;
else
B = B + s[i];
cout << A + s[0] + B << endl;
} else {
for (int i = 0; i < n; i++)
if (i & 1)
B = B + s[i];
else
A = s[i] + A;
cout << A << B << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline string get() {
char ch[1000000];
scanf("%s", ch);
return ch;
}
template <class P, class Q>
inline P smin(P &a, Q b) {
if (b < a) a = b;
return a;
}
template <class P, class Q>
inline P smax(P &a, Q b) {
if (a < b) a = b;
return a;
}
const int MAX_LG = 17;
const long long INF = 1e9;
const long long maxn = 1e6 + 10;
bool mark[maxn];
long long a[maxn];
long long maxi, day;
int32_t main() {
long long n = in(), d = in();
for (long long i = 0; i < n; i++) a[i] = in();
sort(a, a + n);
for (long long i = 0; i < n; i++) {
for (long long j = maxn - 1; j >= 0; j--) {
if (mark[j] && j + a[i] < maxn) mark[j + a[i]] = true;
}
mark[a[i]] = true;
}
while (1) {
long long best = -INF;
for (long long i = maxi + d; i > maxi; i--) {
if (mark[i]) {
best = i;
break;
}
}
if (best == -INF) break;
maxi = best, day++;
}
cout << maxi << " " << day << "\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int y, p;
cin >> p >> y;
for (long long int i = y; i > p; i--) {
long long int cnt = 0;
for (long long int j = 2; j <= p; j++) {
if (j * j > i) break;
if (i % j == 0) {
cnt = 1;
break;
}
}
if (cnt == 0) {
cout << i;
return 0;
}
}
cout << -1;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
double EPS = 1e-10;
double EQ(double a, double b) { return abs(a - b) < EPS; }
void fast_stream() { std::ios_base::sync_with_stdio(0); }
template <class T>
string IntToString(T num) {
string res;
stringstream ss;
ss << num;
return ss.str();
}
long long StringToInt(string &str) {
long long res = 0;
for (int i = 0; i < (int)str.size(); i++) res = (res * 10 + str[i] - '0');
return res;
}
long long mod_pow(long long num, long long p, long long mod) {
long long mul = num;
long long res = 1;
while (p) {
if (p % 2) res = (res * mul) % mod;
p /= 2;
mul = (mul * mul) % mod;
}
return res;
}
int main() {
int n, m;
cin >> n >> m;
cout << (mod_pow(3, n, m) - 1 + m) % m << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int tot;
const int M = 1e6 + 6;
vector<int> g1[M], g2[M];
int vis[M];
void dfs1(int u) {
vis[u] = 1;
tot++;
for (int i = 0; i <= g1[u].size() - 1; ++i) {
int v = g1[u][i];
if (!vis[v]) dfs1(v);
}
}
void dfs2(int u) {
vis[u] = 1;
tot++;
for (int i = 0; i <= g2[u].size() - 1; ++i) {
int v = g2[u][i];
if (!vis[v]) dfs2(v);
}
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i <= n; i++) vis[i] = 0, g1[i].clear(), g2[i].clear();
while (m--) {
int u, v;
scanf("%d%d", &u, &v);
g1[u].push_back(v);
g2[v].push_back(u);
}
tot = 0;
int sign = 1;
dfs1(1);
if (tot == n) {
tot = 0;
sign = 0;
for (int i = 0; i <= n; i++) vis[i] = 0;
dfs2(1);
if (tot == n) {
puts("No");
continue;
}
tot = n - tot;
}
puts("Yes");
printf("%d %d\n", tot, n - tot);
for (int i = 1; i <= n; ++i)
if (vis[i] == sign) printf("%d ", i);
puts("");
for (int i = 1; i <= n; ++i)
if (vis[i] != sign) printf("%d ", i);
puts("");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pi = pair<int, int>;
using pll = pair<ll, ll>;
const int inf = 1e9;
void fail() {
cout << "NO" << endl;
exit(0);
}
int main() {
ios_base::sync_with_stdio(false);
cout << setprecision(12);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < int(n); i++) cin >> a[i];
vector<int> minasc(n, inf);
vector<int> maxdsc(n, -inf);
minasc[0] = -inf;
maxdsc[0] = inf;
vector<bool> flipasc(n);
vector<bool> flipdsc(n);
for (int i = 1; i < n; i++) {
if (a[i] > a[i - 1] && maxdsc[i - 1] > maxdsc[i]) {
maxdsc[i] = maxdsc[i - 1];
flipasc[i] = false;
}
if (a[i] < maxdsc[i - 1] && a[i - 1] < minasc[i]) {
minasc[i] = a[i - 1];
flipdsc[i] = true;
}
if (a[i] > minasc[i - 1] && a[i - 1] > maxdsc[i]) {
maxdsc[i] = a[i - 1];
flipasc[i] = true;
}
if (a[i] < a[i - 1] && minasc[i - 1] < minasc[i]) {
minasc[i] = minasc[i - 1];
flipdsc[i] = false;
}
}
if (minasc[n - 1] == inf && maxdsc[n - 1] == -inf) fail();
vector<bool> dsc(n);
dsc[n - 1] = minasc[n - 1] != inf;
for (int i = n - 2; i >= 0; i--) {
if (dsc[i + 1]) {
dsc[i] = !flipdsc[i + 1];
} else {
dsc[i] = flipasc[i + 1];
}
}
cout << "YES" << endl;
for (int i = 0; i < int(n); i++) cout << dsc[i] << " ";
cout << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class BidirIt>
BidirIt prev(BidirIt it,
typename iterator_traits<BidirIt>::difference_type n = 1) {
advance(it, -n);
return it;
}
template <class ForwardIt>
ForwardIt next(ForwardIt it,
typename iterator_traits<ForwardIt>::difference_type n = 1) {
advance(it, n);
return it;
}
const double EPS = 1e-9;
const double PI = 3.141592653589793238462;
template <typename T>
inline T sq(T a) {
return a * a;
}
const int MAXN = 4e5 + 5;
int ar[MAXN], sor[MAXN];
map<int, int> dummy;
bool visit[MAXN], proc[MAXN];
int nxt[MAXN];
vector<int> gr[MAXN];
vector<int> cur, tour[MAXN];
vector<vector<int> > cycles;
void addEdge(int u, int v) { gr[u].push_back(v); }
void dfs(int u) {
visit[u] = true;
cur.push_back(u);
while (nxt[u] < (int)gr[u].size()) {
int v = gr[u][nxt[u]];
nxt[u]++;
dfs(v);
}
if (cur.size() > 0) {
if (!tour[u].empty()) assert(false);
tour[u] = cur;
cur.clear();
}
}
void getcycle(int u, vector<int> &vec) {
proc[u] = true;
for (auto it : tour[u]) {
vec.push_back(it);
if (!proc[it]) getcycle(it, vec);
}
}
int main() {
int n, s;
scanf("%d %d", &n, &s);
for (int i = 1; i <= n; i++) {
scanf("%d", &ar[i]);
sor[i] = ar[i];
}
sort(sor + 1, sor + n + 1);
for (int i = 1; i <= n; i++) {
if (ar[i] != sor[i]) dummy[ar[i]] = 0;
}
int cnt = 0;
for (auto &it : dummy) it.second = n + (++cnt);
for (int i = 1; i <= n; i++) {
if (ar[i] == sor[i]) continue;
addEdge(dummy[sor[i]], i);
addEdge(i, dummy[ar[i]]);
}
for (int i = 1; i <= n + cnt; i++) {
if ((i > n || ar[i] != sor[i]) && !visit[i]) {
dfs(i);
vector<int> vec;
getcycle(i, vec);
vector<int> res;
for (auto it : vec)
if (it <= n) res.push_back(it);
res.pop_back();
cycles.push_back(res);
s -= (int)res.size();
}
}
for (int i = 1; i <= n + cnt; i++)
if (i > n || ar[i] != sor[i]) assert(proc[i]);
if (s < 0) {
puts("-1");
return 0;
}
int pos = 0;
if (s > 1 && cycles.size() > 1) {
printf("%d\n", max(2, (int)cycles.size() - s + 2));
int sum = 0;
while (s > 0 && pos < (int)cycles.size()) {
s--;
sum += (int)cycles[pos].size();
pos++;
}
printf("%d\n", sum);
vector<int> vec;
for (int i = 0; i < pos; i++) {
for (auto it : cycles[i]) printf("%d ", it);
vec.push_back(cycles[i][0]);
}
puts("");
reverse((vec).begin(), (vec).end());
printf("%d\n", (int)vec.size());
for (auto it : vec) printf("%d ", it);
puts("");
} else {
printf("%d\n", (int)cycles.size());
}
for (int i = pos; i < (int)cycles.size(); i++) {
printf("%d\n", (int)cycles[i].size());
for (auto it : cycles[i]) printf("%d ", it);
puts("");
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int Rand(int M) { return (((long long)rand()) * rand() + 3 * rand()) % M + 1; }
bool vis[1000000];
int getIndex(int M) {
int x;
while (1) {
x = Rand(M);
if (vis[x]) continue;
vis[x] = 1;
return x;
}
return -1;
}
int main() {
srand(time(NULL));
int n, s, x;
cin >> n >> s >> x;
if (n < 2000) {
while (1) {
cout << "? " << s << endl;
fflush(stdout);
int nxt, val;
cin >> val >> nxt;
if (val >= x) {
cout << "! " << val << endl;
fflush(stdout);
return 0;
}
if (nxt == -1) {
cout << "! -1" << endl;
fflush(stdout);
return 0;
}
s = nxt;
}
} else {
int best, nxt;
cout << "? " << s << endl;
fflush(stdout);
cin >> best >> nxt;
if (best >= x) {
cout << "! " << best << endl;
fflush(stdout);
return 0;
}
vis[1] = 1;
for (int i = 0; i < 998; i++) {
int X = getIndex(n);
cout << "? " << X << endl;
fflush(stdout);
int a, b;
cin >> a >> b;
if (a < x && a > best) best = a, nxt = b;
}
if (nxt == -1) {
cout << "! -1" << endl;
fflush(stdout);
return 0;
} else {
for (int i = 0; i < 1000; i++) {
cout << "? " << nxt << endl;
fflush(stdout);
int xt, val;
cin >> val >> xt;
if (val >= x) {
cout << "! " << val << endl;
fflush(stdout);
return 0;
}
if (xt == -1) {
cout << "! -1" << endl;
fflush(stdout);
return 0;
}
nxt = xt;
}
cout << "! -1" << endl;
fflush(stdout);
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000001;
const int M = 10;
const int D = 300;
int pr[10] = {2, 2, 2, 2, 2, 2, 2, 2, 2, 2};
vector<vector<char> > mp;
vector<char> cur(M);
int fp[N];
int calc(vector<char> &v) {
int res = 1;
for (auto x : v) res *= x + 1;
return res;
}
void gen(int i, int val) {
if (calc(cur) > D) return;
if (i == cur.size()) {
mp.push_back(cur);
return;
}
int p = 1;
for (char t = i ? cur[i - 1] : 0;; ++t) {
if (val * (long long)p > 1e9) break;
val *= p;
cur[i] = t;
gen(i + 1, val);
cur[i] = 0;
p = pr[i];
}
}
vector<char> get(int a) {
vector<char> cur;
while (a != 1) {
int p = fp[a];
if (p == 0) {
cur.push_back(1);
break;
}
cur.push_back(0);
while (a % p == 0) {
++cur.back();
a /= p;
}
}
cur.resize(M, 0);
sort(cur.begin(), cur.end());
return cur;
}
long long Hash(vector<char> &w) {
long long h = 0;
for (auto z : w) h = h * 64 + z;
return h;
}
int cost[D + 1][1024];
vector<vector<int> > g;
vector<int> F;
set<long long> good;
int q[1234], qf, ql;
int BFS(int src, int t) {
if (cost[t][src] != -1) return cost[t][src];
for (int d = 1; d <= D; ++d) {
cost[d][src] = 1e9;
}
int u = src;
q[qf = ql = 0] = u;
vector<int> vis(g.size(), -1);
vis[u] = 0;
while (qf <= ql) {
auto u = q[qf];
++qf;
cost[F[u]][src] = min(cost[F[u]][src], vis[u]);
for (auto v : g[u])
if (vis[v] == -1) {
vis[v] = vis[u] + 1;
q[++ql] = v;
}
}
return cost[t][src];
}
int main() {
reverse(pr, pr + 10);
gen(0, 1);
sort(mp.begin(), mp.end());
for (auto &v : mp) good.insert(Hash(v));
for (int i = 2; i < N; ++i)
if (fp[i] == 0)
for (int j = i + i; j < N; j += i)
if (fp[j] == 0) fp[j] = i;
for (int i = 0; i < mp.size(); ++i) F.push_back(calc(mp[i]));
g.resize(mp.size());
for (int i = 0; i < mp.size(); ++i) {
for (int j = 0; j < mp.size(); ++j) {
int freq[64] = {};
for (auto x : mp[i]) ++freq[x];
for (auto y : mp[j]) --freq[y];
int diff = 0;
int f = -1, l = -1;
for (int k = 0; k < 64; ++k) {
diff += abs(freq[k]);
if (freq[k])
if (f == -1) f = k;
if (freq[k]) l = k;
}
if (diff == 2 && abs(f - l) == 1) g[i].push_back(j);
}
}
memset(cost, -1, sizeof(cost));
clock_t T = clock();
int t;
scanf("%d", &t);
while (t--) {
int a, b;
scanf("%d%d", &a, &b);
auto A = lower_bound(mp.begin(), mp.end(), get(a)) - mp.begin();
auto B = lower_bound(mp.begin(), mp.end(), get(b)) - mp.begin();
int res = 1e9;
for (int d = 1; d <= D; ++d) res = min(res, BFS(A, d) + BFS(B, d));
printf("%d\n", res);
}
fprintf(stderr, "%.3lf\n", double(clock() - T) / CLOCKS_PER_SEC);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
string s;
cin >> n;
while (n--) {
cin >> s;
a = 0;
b = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '0') {
a++;
} else {
b++;
}
}
int minimum = min(a, b);
if (minimum % 2 == 0) {
cout << "NET\n";
} else {
cout << "DA\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
vector<int> pos[3];
const int MAX = 100005;
const int inf = 1e9 + 9;
bool zajete1[MAX], zajete2[MAX];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
string s;
int suma = 0;
cin >> s;
for (int i = 0; i < s.length(); i++) {
suma += (s[i] - '0');
pos[(s[i] - '0') % 3].push_back(i);
}
if (suma % 3 == 0) {
cout << s;
} else if (suma % 3 == 2) {
string s1 = "", s2 = "";
int ans1 = 0, ans2 = 0;
if (pos[2].size() >= 2) {
zajete1[pos[2].back()] = true;
} else if (pos[2].size() == 1) {
if (pos[2][0] == 0) {
zajete1[0] = true;
for (int i = 1; i < s.length() - 1; i++) {
if (s[i] != '0') {
break;
} else
zajete1[i] = true;
}
} else {
zajete1[pos[2][0]] = true;
}
} else
ans1 = inf;
if (pos[1].size() <= 1) {
ans2 = inf;
} else if (pos[1].size() >= 3) {
int l = pos[1].size();
zajete2[pos[1][l - 1]] = true;
zajete2[pos[1][l - 2]] = true;
} else {
int l = pos[1].size();
zajete2[pos[1][l - 1]] = true;
if (pos[1][l - 2] == 0) {
zajete2[0] = true;
if (pos[1][l - 1] == s.length() - 1) s.pop_back();
for (int i = 1; i < s.length() - 1; i++) {
if (zajete2[i]) continue;
if (s[i] != '0') break;
zajete2[i] = true;
}
} else {
zajete2[pos[1][l - 2]] = true;
}
}
for (int i = 0; i < s.length(); i++) {
if (!zajete2[i]) {
s2 += s[i];
} else
ans2++;
}
for (int i = 0; i < s.length(); i++) {
if (!zajete1[i]) {
s1 += s[i];
} else
ans1++;
}
if (s1 == "") ans1 = inf;
if (s2 == "") ans2 = inf;
if (ans1 >= inf && ans2 >= inf)
cout << "-1";
else if (ans1 < ans2)
cout << s1;
else
cout << s2;
} else {
string s1 = "", s2 = "";
int ans1 = 0, ans2 = 0;
if (pos[1].size() >= 2) {
zajete1[pos[1].back()] = true;
} else if (pos[1].size() == 1) {
if (pos[1][0] == 0) {
zajete1[0] = true;
for (int i = 1; i < s.length() - 1; i++) {
if (s[i] != '0') {
break;
} else
zajete1[i] = true;
}
} else {
zajete1[pos[1][0]] = true;
}
} else
ans1 = inf;
if (pos[2].size() <= 1) {
ans2 = inf;
} else if (pos[2].size() >= 3) {
int l = pos[2].size();
zajete2[pos[2][l - 1]] = true;
zajete2[pos[2][l - 2]] = true;
} else {
int l = pos[2].size();
zajete2[pos[2][l - 1]] = true;
if (pos[2][l - 1] == s.length() - 1) s.pop_back();
if (pos[2][l - 2] == 0) {
zajete2[0] = true;
for (int i = 1; i < s.length() - 1; i++) {
if (zajete2[i]) continue;
if (s[i] != '0') break;
zajete2[i] = true;
}
} else {
zajete2[pos[2][l - 2]] = true;
}
}
for (int i = 0; i < s.length(); i++) {
if (!zajete2[i]) {
s2 += s[i];
} else
ans2++;
}
for (int i = 0; i < s.length(); i++) {
if (!zajete1[i]) {
s1 += s[i];
} else
ans1++;
}
if (s1 == "") ans1 = inf;
if (s2 == "") ans2 = inf;
if (ans1 >= inf && ans2 >= inf)
cout << "-1";
else if (ans1 < ans2)
cout << s1;
else
cout << s2;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
template <class T>
bool scanff(T &ret) {
char c;
int sgn;
T bit = 0.1;
if (c = getchar(), c == EOF) return 0;
while (c != '-' && c != '.' && (c < '0' || c > '9')) c = getchar();
sgn = (c == '-') ? -1 : 1;
ret = (c == '-') ? 0 : (c - '0');
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c - '0');
if (c == ' ' || c == '\n') {
ret *= sgn;
return 1;
}
while (c = getchar(), c >= '0' && c <= '9') ret += (c - '0') * bit, bit /= 10;
ret *= sgn;
return 1;
}
using namespace std;
int q, h, w;
int c[666][666];
int main() {
scanff(q);
for (int cas = int(1); cas <= int(q); cas++) {
scanff(h);
scanff(w);
int pd = 0;
for (int i = int(1); i <= int(h); i++)
for (int j = int(1); j <= int(w); j++) scanff(c[i][j]);
for (int i = int(2); i <= int(h); i++) {
double cz = 0;
for (int j = int(1); j <= int(w); j++) {
double fm = 0;
int fz = 0;
for (int k = int(j - 1); k <= int(j + 1); k++) {
if (k >= 1 && k <= w) {
if (k != j)
fm += (double)(abs(c[i - 1][k] - c[i][j])) * 0.3, fz += 3;
if (k == j)
fm += (double)(abs(c[i - 1][k] - c[i][j])) * 0.4, fz += 4;
}
}
cz += fm / double(fz);
}
cz = cz / double(w);
if (cz >= 6.6) {
printf("YES\n");
pd = 1;
break;
}
}
if (!pd) printf("NO\n");
}
return 0;
}
| 5 |
#include <cstdio>
#include <iostream>
#include <cassert>
#include <string>
#include <algorithm>
#include <cstring>
#include <utility>
#include <vector>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <numeric>
#include <random>
#include <cmath>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <functional>
#include <chrono>
#define IOS ios_base::sync_with_stdio(false), cin.tie(nullptr);
using namespace std;
using LL = long long;
using pii = pair<int, int>;
using pll = pair<LL, LL>;
bool check(vector<vector<int>> &cnt, int ans, int K, string &S) {
int N = S.length();
//N + 1 mean that we can't do it
vector<vector<int>> nxt(N + 1, vector<int>(K, N + 1));
for (int i = N - 1; i >= 0; i--) {
for (int j = 0; j < K; j++) {
//printf("i = %d j = %d\n", i, j);
nxt[i][j] = nxt[i + 1][j];
}
if (N - i < ans) continue;
for (int j = 0; j < K; j++) {
int len = cnt[i][j] - cnt[i + ans][j];
if (len == ans)
nxt[i][j] = i + ans;
//printf("i = %d j = %d nxt = %d\n", i, j, nxt[i][j]);
}
}
vector<int> dp(1 << K, N + 1);
dp[0] = 0;
for (int S = 1; S < (1 << K); S++) {
for (int j = 0; j < K; j++) {
if (S & (1 << j)) {
int pre = S - (1 << j);
int pans = dp[pre];
if (pans == N + 1) continue;
dp[S] = min(dp[S], nxt[pans][j]);
}
}
//printf("S = %d dp = %d\n", S, dp[S]);
}
//printf("dp = %d\n", dp[(1 << K) - 1]);
return (dp[(1 << K) - 1] != N + 1);
}
int main() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
vector<vector<int>> suf(N + 1, vector<int>(K));
for (int i = N - 1; i >= 0; i--)
for (int j = 0; j < K; j++)
suf[i][j] = suf[i + 1][j] + (S[i] == '?' || (S[i] - 'a') == j);
int l = 0, r = N, ans = 0;
while (l <= r) {
int mid = (l + r) / 2;
if (check(suf, mid, K, S)) {
l = mid + 1;
ans = mid;
} else {
r = mid - 1;
}
}
printf("%d\n", ans);
return 0;
}
/* stuff you should look for
* int overflow, array bounds
* special cases (n=1?)
* do smth instead of nothing and stay organized
* WRITE STUFF DOWN
* DON'T GET STUCK ON ONE APPROACH
by Benq;
*/
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int N = 1e5 + 5;
long long a[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
long long m;
cin >> m;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
sort(a + 1, a + n + 1, greater<long long>());
long long ans = a[1] - 1, last = a[1] - 1;
for (int i = 2; i <= n; ++i) {
if (a[i] < last) {
ans -= (last - a[i]);
}
last = min(last - 1, a[i] - 1);
ans += a[i] - 1;
}
if (last > 0) ans -= last;
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k, res, div;
cin >> n >> k;
div = (n + 1) / 2;
if (k > div) {
k = k - div;
res = 2 * k;
} else {
res = 2 * k - 1;
}
cout << res;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long p, x, y, cur;
long long check(long long s) {
s = (s / 50) % 475;
long long n = 25;
while (n) {
s = (s * 96 + 42) % 475;
if (s + 26 == p) {
return 1;
}
n--;
}
return 0;
}
int main() {
cin >> p >> x >> y;
for (int i = x; i >= y; i -= 50) {
if (check(i)) {
cout << 0;
return 0;
}
}
for (int i = 50; i < 20000; i += 50) {
if (check(x + i)) {
if (i % 100 == 0) {
cout << i / 100;
} else {
cout << i / 100 + 1;
}
return 0;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const int maxn = 2000005, maxm = 29;
const double eps = 1e-9;
const double pi = acos(-1.0);
int cs(int x) {
int r = 0;
if (x <= 0) return 1;
while (x > 0) {
x /= 7;
++r;
}
return r;
}
int n, m, k, k1, k2;
int r = 0;
int sx[15];
void dfs(int dep, int v) {
int i, j;
if (dep == k) {
long long nt = 0, mt = 0;
for (i = 0; i < k1; i++) nt = nt * 7 + sx[i];
for (i = k1; i < k1 + k2; i++) mt = mt * 7 + sx[i];
if (nt < n && mt < m) {
++r;
}
return;
}
for (i = 0; i < 7; i++) {
if (!(v >> i & 1)) {
sx[dep] = i;
dfs(dep + 1, v | (1 << i));
}
}
}
int main() {
int i, j;
scanf("%d %d", &n, &m);
k1 = cs(n - 1), k2 = cs(m - 1);
if (k1 + k2 > 7) {
printf("0\n");
return 0;
}
k = k1 + k2;
dfs(0, 0);
printf("%d\n", r);
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.