solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
if (n % 2 == 0) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
long long int a[2 * n];
long long int i = 0;
for (long long int x = 0; x < n; x++) {
if (x % 2 == 0) {
a[x] = i + 1;
a[x + n] = i + 2;
} else {
a[x + n] = i + 1;
a[x] = i + 2;
}
i += 2;
}
for (long long int i = 0; i < 2 * n; i++) {
cout << a[i] << " ";
}
cout << '\n';
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
vector<long long> b_v;
void bin(unsigned long long n) {
if (n > 1) bin(n >> 1);
b_v.push_back(n & 1);
}
long long isPowerof2(long long x) { return (x && !(x & x - 1)); }
long long n, m;
long long a[200005];
bool check(long long x) {
long long res = 0;
for (long long(i) = (0); i < (n); i++) {
res += max(a[i] - i / x, (long long)0);
}
return (res >= m);
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ostream_iterator<long long> output(cout, " ");
cin >> n >> m;
for (long long(i) = (0); i < (n); i++) cin >> a[i];
sort(a, a + n);
reverse(a, a + n);
long long l = 1, r = n, mid, ans = -1;
while (l <= r) {
mid = (l + r) / 2;
if (check(mid)) {
ans = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-11;
template <class T>
inline void ckmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
inline void ckmax(T &a, T b) {
if (b > a) a = b;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
int main() {
int n, m, ptr = 0, ipt = 0, pt = 0, ct = 0;
cin >> n >> m;
string s[n];
for (int i = 0; i < (n); ++i) {
cin >> s[i];
for (int j = 0; j < (m); ++j)
if (s[i][j] == 'W') ipt = i;
}
int k = 0;
for (int i = 0; i < (n); ++i) {
ptr = pt = k;
if (i % 2 == 0) {
if (i == n - 1) {
for (int j = 0; j < (m); ++j)
if (s[i][j] == 'W') pt = j;
ct += pt - k;
} else {
for (int j = 0; j < (m); ++j)
if (s[i + 1][j] == 'W') ptr = j;
for (int j = 0; j < (m); ++j)
if (s[i][j] == 'W') pt = j;
for (int j = 0; j < (m); ++j)
if (j >= ptr && j >= pt) {
ct += j - k;
break;
}
k = max(ptr, pt);
}
} else {
if (i == n - 1) {
for (int j = m - 1; j >= 0; --j)
if (s[i][j] == 'W') pt = j;
ct += k - pt;
} else {
for (int j = m - 1; j >= 0; --j)
if (s[i + 1][j] == 'W') ptr = j;
for (int j = m - 1; j >= 0; --j)
if (s[i][j] == 'W') pt = j;
for (int j = m - 1; j >= 0; --j)
if (j <= ptr && j <= pt) {
ct += k - j;
break;
}
k = min(ptr, pt);
}
}
}
cout << ct + ipt;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int mat[2003][2003];
void solve() {
long long int n;
cin >> n;
long long int a = 0;
long long int k = 0;
while (k < n) {
long long int l = 0;
while (l < n) {
for (long long int i = 0; i < 4; i++) {
for (long long int j = 0; j < 4; j++) {
mat[k + i][l + j] = a++;
}
}
l += 4;
}
k += 4;
}
long long int x = 0;
for (long long int i = 0; i < n; i++) x = x ^ mat[0][i];
for (long long int i = 0; i < n; i++) {
long long int y = 0;
for (long long int j = 0; j < n; j++) {
cout << mat[i][j] << " ";
y = y ^ mat[j][i];
}
cout << endl;
}
}
signed main() {
long long int t = 1;
for (long long int tc = 1; tc <= t; tc++) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 300005;
int a[MX];
int ayy_lmao[MX], yeeet[MX];
int cnt[MX];
int solve() {
int n;
ignore = scanf("%d", &n);
for (int i = 1; i <= n; i++) {
ayy_lmao[i] = n + 1;
yeeet[i] = -1;
}
for (int i = 0; i < n; i++) {
ignore = scanf("%d", a + i);
ayy_lmao[a[i]] = min(ayy_lmao[a[i]], i);
yeeet[a[i]] = max(yeeet[a[i]], i);
}
for (int i = 1; i <= n; i++) {
cnt[i] = cnt[i - 1] + (ayy_lmao[i] != n + 1);
}
int ans = n;
deque<int> St;
int x = n;
for (int t = n, above = 0; t >= 1; t--) {
if (!St.empty() && St.front() == t + 1) St.pop_front();
while (x && (St.empty() || ayy_lmao[St.front()] > yeeet[x])) {
while (!St.empty() && ayy_lmao[x] < ayy_lmao[St.back()]) St.pop_back();
St.push_back(x);
x--;
}
ans = min(ans, above + cnt[x]);
above += (ayy_lmao[t] != n + 1);
}
return ans;
}
int main() {
int q;
ignore = scanf("%d", &q);
while (q--) {
printf("%d\n", solve());
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const static int inf = 0x3f3f3f3f;
const static int maxn = 2e5 + 10;
int n, m;
int a[maxn];
vector<int> ll[maxn];
vector<int> rr[maxn];
int l[maxn], r[maxn];
int p[maxn];
int tree[maxn];
int lowbit(int x) { return x & (-x); }
void add(int x) {
for (int i = x; i <= n; i += lowbit(i)) tree[i]++;
}
int query(int x) {
int ret = 0;
for (int i = x; i >= 1; i -= lowbit(i)) ret += tree[i];
return ret;
}
int ans[maxn];
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
p[a[i]] = i;
}
for (int i = 1; i <= m; i++) {
scanf("%d %d", &l[i], &r[i]);
ll[l[i]].push_back(i);
rr[r[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < ll[i].size(); j++)
ans[ll[i][j]] -= query(r[ll[i][j]]) - query(i - 1);
for (int j = 1; j * a[i] <= n; j++) add(p[a[i] * j]);
for (int j = 0; j < rr[i].size(); j++)
ans[rr[i][j]] += query(i) - query(l[rr[i][j]] - 1);
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline long long max(long long x, long long y) { return x > y ? x : y; }
inline long long min(long long x, long long y) { return x < y ? x : y; }
inline long long read() {
long long x = 0;
int ch = getchar(), f = 1;
while (!isdigit(ch) && (ch != '-') && (ch != EOF)) ch = getchar();
if (ch == '-') {
f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
int n, a, b, A, B, ans[1000010];
int main() {
n = read(), a = read(), b = read();
int l = n / a;
for (register int i = (0); i <= (l); i++)
if ((n - i * a) % b == 0) {
A = i, B = (n - i * a) / b;
break;
}
if (!A && !B) return printf("-1"), 0;
for (register int i = (1); i <= (A); i++) {
for (register int j = ((i - 1) * a + 2); j <= (i * a); j++) ans[j] = j - 1;
ans[(i - 1) * a + 1] = i * a;
}
int k = A * a;
for (register int i = (1); i <= (B); i++) {
for (register int j = (k + (i - 1) * b + 2); j <= (k + i * b); j++)
ans[j] = j - 1;
ans[k + (i - 1) * b + 1] = k + i * b;
}
for (register int i = (1); i <= (n); i++) printf("%d ", ans[i]);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int banyak, n, maks;
int main() {
cin>>n;
int h[n];
for (int i=0; i<n; i++) {
cin>>h[i];
}
for (int i=1; i<n; i++) {
if (h[i]<=h[i-1]) {
banyak++;
if (banyak>maks) maks=banyak;
}
else banyak=0;
}
cout<<maks<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long x, y, z, sol;
int a, b, p;
int exp(int w, int q) {
if (q == 0) return 1;
if (q == 1) return w;
int e = exp(1LL * w * w % p, q / 2);
if (q % 2 == 0) return e;
return (1LL * e * w % p);
}
int euclid(int a, int b, int *x, int *y) {
if (b == 0) {
*x = 1;
*y = 0;
return a;
}
int x0, y0;
int d = euclid(b, a % b, &x0, &y0);
*x = y0;
*y = x0 - (a / b) * y0;
return d;
}
int inversmodular(int a) {
int x, y;
int d = euclid(a, p, &x, &y);
return ((x + p) % p);
}
int main() {
int i, j;
scanf("%d %d %d %I64d", &a, &b, &p, &x);
for (j = 1; j < p; j++) {
y = j - 1LL * b * inversmodular(exp(a, j)) % p;
y = (y + p) % p;
if (x - j < 0) continue;
z = (x - j) / (p - 1);
z -= y;
if (z >= 0) {
sol += z / p + 1;
}
}
printf("%I64d", sol);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long i, n, mi, mx, x = 0, y = 0;
cin >> n;
long long a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
if (i == 0) {
mi = a[i];
mx = a[i];
continue;
}
if (a[i] < mi) mi = a[i];
if (a[i] > mx) mx = a[i];
}
for (i = 0; i < n; i++) {
if (a[i] == mi) x++;
if (a[i] == mx) y++;
}
if (mi == mx)
cout << mx - mi << " " << (n * (n - 1)) / 2 << "\n";
else
cout << mx - mi << " " << y * x << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int powm[100005];
int fact[100005];
int sum[100005];
string s;
void powers_of_10(int m) {
powm[0] = 1;
for (int i = 1; i <= m; i++) powm[i] = 1LL * powm[i - 1] * 10 % 1000000007;
}
void factorials(int m) {
fact[0] = 1;
for (int i = 1; i <= m; i++) fact[i] = 1LL * i * fact[i - 1] % 1000000007;
}
void sums(int m) {
sum[0] = s[0] - '0';
for (int i = 1; i < m; i++) {
sum[i] = sum[i - 1] + (s[i] - '0');
if (sum[i] >= 1000000007) sum[i] -= 1000000007;
}
}
void euclid(int a, int b, long long& x, long long& y) {
if (b == 0) {
x = 1;
y = 0;
} else {
long long x0, y0;
euclid(b, a % b, x0, y0);
x = y0;
y = x0 - (a / b) * y0;
}
}
int invers_modular(int n) {
long long x, y;
euclid(n, 1000000007, x, y);
while (x < 0) x += 1000000007;
return (int)x;
}
int comb(int n, int k) {
if (k > n) return 0;
int Ret = fact[n];
Ret = 1LL * Ret * invers_modular(fact[n - k]) % 1000000007;
Ret = 1LL * Ret * invers_modular(fact[k]) % 1000000007;
return Ret;
}
int main() {
ios_base::sync_with_stdio(false);
int n, k;
cin >> n >> k;
cin >> s;
powers_of_10(n);
factorials(n);
sums(n);
int FirstSum = 0;
int SecondSum = 0;
for (int i = 0; i < n; i++) {
FirstSum += 1LL * (s[i] - '0') * powm[n - 1 - i] * comb(i, k) % 1000000007;
if (FirstSum >= 1000000007) FirstSum -= 1000000007;
}
for (int i = 0; i <= n - 2; i++) {
SecondSum += 1LL * (1LL * sum[n - i - 2] * powm[i] % 1000000007) *
comb(n - i - 2, k - 1) % 1000000007;
if (SecondSum >= 1000000007) SecondSum -= 1000000007;
}
cout << (SecondSum + FirstSum) % 1000000007;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
map<int, int> res;
vector<int> l(n), r(n);
for (int i = 0; i < n; i++) {
cin >> l[i] >> r[i];
}
int t = 1;
for (int i = 0; i < n; i++) {
if (l[i] > t) t = l[i];
if (t > r[i])
cout << 0 << ' ';
else {
cout << t << ' ';
t++;
}
}
cout << endl;
}
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> f(n);
for (int i = 0; i < n; i++) cin >> f[i];
vector<vector<int> > gp(n), go(n), gi(n), gt(n);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
gi[a].push_back(go[b].size());
gp[a].push_back(b);
go[b].push_back(a);
gt[b].push_back(0);
}
queue<int> q;
vector<int> u(n);
for (int i = 0; i < n; i++)
if (f[i] == 1) {
u[i] = 1;
q.push(i);
}
while (!q.empty()) {
int v = q.front();
q.pop();
for (int i = 0; i < gp[v].size(); i++) {
int b = gp[v][i];
if (f[gp[v][i]] == 0 || f[gp[v][i]] == 2) gt[b][gi[v][i]] = 1;
if (u[b] == 0 && f[b] != 1) {
u[b] = 1;
q.push(b);
}
}
}
vector<int> e(n);
for (int i = 0; i < n; i++)
if (f[i] == 2 && u[i]) {
e[i] = 1;
q.push(i);
}
while (!q.empty()) {
int v = q.front();
q.pop();
for (int i = 0; i < go[v].size(); i++) {
int b = go[v][i];
if (gt[v][i] == 1 && e[b] == 0) {
e[b] = 1;
q.push(b);
}
}
}
for (int i = 0; i < n; i++) cout << e[i] << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, n;
cin >> c >> a >> b;
n = c / 2;
if ((n > a && n > b) || (n > a && n < b) || (n == a && n + 1 < b) ||
(n + 1 < a && n == b) || (n < a && n > b) || (n < a && n + 1 < b) ||
(n == a && n > b)) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| 2 |
#include<bits/stdc++.h>
#define ll long long
#define ld long double
using namespace std;
int main()
{
int n;
cin >> n;
ll t;
ld ans = 1;
for (int i = 0; i < n; i++)
{
cin >> t;
if (ans != -1)
ans *= t;
if (ans > 1000000000000000000 || ans < 0)
ans = -1;
if (t == 0)
ans = 0;
}
cout<<(ll)ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
long long int gcd(long long int a, long long int b) {
if (!b)
return a;
else
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
long long int s, n, k;
cin >> s >> n >> k;
if (s < k) {
cout << "NO" << '\n';
continue;
}
if (s == k) {
cout << "YES" << '\n';
continue;
}
long long int cnt = s + k;
long long int st = s - k + 1;
long long int r = s % k + 1;
long long int q = (st - 1) / k;
if (q % 2 == 1)
cnt -= k - r;
else
cnt -= r;
if (cnt < 2 * n + 1)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t, i, j, k, n, m,
a = 1, b = 1, ctr = 0, ctu = 0, c, p, prev, q, r, width, len, o, rc,
height, mx = -9999999999, mn = 99999999, ct = 0, ans = 0, flag = 1,
sum = 0, pos, pos2;
cin >> t;
std::vector<long long int> v(2000);
while (t--) {
cin >> n;
for (i = 0; i < n; i++) {
cin >> v[i];
if (v[i] == 1) pos = i;
}
flag = 1;
for (j = 0; j < n; j++) {
if (v[(j + pos) % n] != j + 1) flag = 0;
}
if (flag)
cout << "YES\n";
else {
flag = 1;
for (j = 0; j < n; j++) {
if (v[(j + pos) % n] != (n - j) % n + 1) flag = 0;
}
if (flag)
cout << "YES\n";
else
cout << "NO\n";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
map<int, int> mp;
void solve(int x) {
for (int i = 2; i <= x / i; i++) {
int cnt = 0;
if (x % i == 0) {
while (x % i == 0) x /= i, cnt++;
mp[i] = cnt;
}
}
if (x != 1) {
mp[x] = 1;
}
}
long long pow(int x, int y) {
long long ans = 1;
while (y) {
if (y & 1) ans = ans * x;
x = x * x;
y /= 2;
}
return ans;
}
long long ask(long long n, long long m) {
while (n % m == 0) {
n /= m;
}
return n;
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
mp.clear();
long long n;
int m;
scanf("%lld %d", &n, &m);
if (n % m != 0) {
printf("%lld\n", n);
} else {
solve(m);
long long ans = 0;
map<int, int>::iterator it;
for (it = mp.begin(); it != mp.end(); it++) {
int x = it->first, y = it->second;
long long tmp = n, tmp1 = 1;
while (tmp % x == 0) tmp /= x;
tmp1 = tmp;
for (int i = 1; i < y; i++) {
tmp1 *= x;
}
ans = max(ans, tmp1);
}
printf("%lld\n", ans);
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char C[1005];
int main() {
char x, a, b, c, d;
C['6'] = 1;
C['7'] = 2;
C['8'] = 3;
C['9'] = 4;
C['T'] = 5;
C['J'] = 6;
C['Q'] = 7;
C['K'] = 8;
C['A'] = 9;
cin >> x >> a >> b >> c >> d;
if ((x == b && x != d) || (b == d && C[a] > C[c]))
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<long long int, int> m;
int main(void) {
int n;
scanf("%d", &n);
int i, a, ans = n;
long long int sum = 0;
for (i = 0; i < n; i++) {
scanf("%d", &a);
sum += a;
m[sum]++;
ans = min(ans, n - m[sum]);
}
printf("%d\n", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char str[400400];
int nxt[400400];
int v[400400];
int main() {
scanf(" %s", str);
int n = strlen(str);
for (int i = 0; i < n; i++) v[i] = (str[i] == '1');
long long ans = 0;
for (int i = 1; i <= 100; i++) {
long long S = 0;
vector<long long> vv;
for (int j = 0; j < n; j++) {
vv.push_back(S);
if (v[j] == 1)
S += (i - 1);
else
S--;
}
vv.push_back(S);
sort(vv.begin(), vv.end());
long long cur = 1;
for (int j = 1; j < vv.size(); j++) {
if (vv[j] == vv[j - 1])
cur++;
else {
ans += (cur * cur - cur) / 2;
cur = 1;
}
}
ans += (cur * cur - cur) / 2;
}
nxt[n] = n;
for (int i = n - 1; i >= 0; i--) {
if (v[i])
nxt[i] = i;
else
nxt[i] = nxt[i + 1];
}
for (int ini = 0; ini < n; ini++) {
int last = nxt[ini];
if (last == n) break;
int qtd = 1;
while (1) {
int prox = nxt[last + 1];
int Fi = ini + (100 + 1) * qtd;
if (Fi <= last) {
int add = last - Fi + 1;
int dv = add / qtd;
if (add % qtd) dv++;
Fi += dv * qtd;
}
if (Fi <= prox) {
int jmp = prox - Fi;
ans += 1 + (jmp / qtd);
}
if (prox >= n) break;
if (Fi >= n) break;
last = prox;
qtd++;
}
}
printf("%lld\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3;
const long double eps = 1e-12;
int n, ted;
bool bad;
long double x[maxn], y[maxn], r[maxn], dis, tmp, a, b, A, B, C;
vector<pair<long double, long double> > t[maxn], fin[maxn], v;
long double gdis(long double x1, long double y1, long double x2,
long double y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
bool eq(long double x1, long double y1, long double x2, long double y2) {
if (abs(x1 - x2) < eps && abs(y1 - y2) < eps) return 1;
return 0;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x[i] >> y[i] >> r[i];
for (int j = 0; j < i; j++) {
dis = gdis(x[i], y[i], x[j], y[j]);
if (abs(dis - r[i] - r[j]) < eps ||
abs(max(r[i], r[j]) - min(r[i], r[j]) - dis) < eps) {
if (abs(y[i] - y[j]) < eps) {
a = ((r[j] * r[j] - r[i] * r[i]) - (x[j] * x[j] - x[i] * x[i])) /
((x[i] - x[j]) * 2);
t[i].push_back({a, y[i]});
t[j].push_back({a, y[i]});
continue;
}
a = (x[j] - x[i]) / (y[i] - y[j]);
b = ((x[i] * x[i] - x[j] * x[j]) + (y[i] * y[i] - y[j] * y[j]) -
(r[i] * r[i] - r[j] * r[j])) /
((y[i] - y[j]) * 2);
A = a * a + 1;
B = a * b * 2 - x[i] * 2 - a * y[i] * 2;
C = x[i] * x[i] + b * b + y[i] * y[i] - b * y[i] * 2 - r[i] * r[i];
t[i].push_back({-B / (A * 2), a * (-B / (A * 2)) + b});
t[j].push_back({-B / (A * 2), a * (-B / (A * 2)) + b});
} else if (r[i] + r[j] > dis && dis > max(r[i], r[j]) - min(r[i], r[j])) {
if (abs(y[i] - y[j]) < eps) {
a = ((r[j] * r[j] - r[i] * r[i]) - (x[j] * x[j] - x[i] * x[i])) /
((x[i] - x[j]) * 2);
b = sqrt((r[i] * r[i]) - (a - x[i]) * (a - x[i]));
t[i].push_back({a, y[i] - b});
t[j].push_back({a, y[i] - b});
t[i].push_back({a, y[i] + b});
t[j].push_back({a, y[i] + b});
continue;
}
a = (x[j] - x[i]) / (y[i] - y[j]);
b = ((x[i] * x[i] - x[j] * x[j]) + (y[i] * y[i] - y[j] * y[j]) -
(r[i] * r[i] - r[j] * r[j])) /
((y[i] - y[j]) * 2);
A = a * a + 1;
B = a * b * 2 - x[i] * 2 - a * y[i] * 2;
C = x[i] * x[i] + b * b + y[i] * y[i] - b * y[i] * 2 - r[i] * r[i];
t[i].push_back({(-B - sqrt(B * B - A * C * 4)) / (A * 2),
a * ((-B - sqrt(B * B - A * C * 4)) / (A * 2)) + b});
t[j].push_back({(-B - sqrt(B * B - A * C * 4)) / (A * 2),
a * ((-B - sqrt(B * B - A * C * 4)) / (A * 2)) + b});
t[i].push_back({(-B + sqrt(B * B - A * C * 4)) / (A * 2),
a * ((-B + sqrt(B * B - A * C * 4)) / (A * 2)) + b});
t[j].push_back({(-B + sqrt(B * B - A * C * 4)) / (A * 2),
a * ((-B + sqrt(B * B - A * C * 4)) / (A * 2)) + b});
} else
continue;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < ((int(t[i].size()))); j++) {
bad = 0;
for (int k = 0; k < ((int(fin[i].size()))); k++) {
if (eq(t[i][j].first, t[i][j].second, fin[i][k].first,
fin[i][k].second)) {
bad = 1;
break;
}
}
if (!bad) fin[i].push_back(t[i][j]);
bad = 0;
for (int k = 0; k < ((int(v.size()))); k++) {
if (eq(t[i][j].first, t[i][j].second, v[k].first, v[k].second)) {
bad = 1;
break;
}
}
if (!bad) v.push_back(t[i][j]);
}
}
bad = 0;
for (int i = 0; i < n; i++) {
if (((int(fin[i].size()))) > 0) {
bad = 1;
break;
}
}
if (!bad) {
cout << n + 1;
return 0;
}
bad = 0;
for (int i = 0; i < n; i++) {
if (((int(fin[i].size()))) == 0) {
bad = 1;
break;
}
}
for (int i = 0; i < n; i++) ted += ((int(fin[i].size())));
if (bad) {
cout << ted - ((int(v.size()))) + 3;
return 0;
}
cout << ted - ((int(v.size()))) + 2;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int num_cnt;
vector<pair<int, int> > query;
vector<int> block;
void clear(int size, int start) {
if (size == 1) {
return;
}
if (size == 2) {
query.push_back(make_pair(start, start + 1));
} else {
clear(size / 2, start);
clear(size / 2, start + size / 2);
for (int i = 0; i < size / 2; ++i) {
query.push_back(make_pair(start + i, start + size / 2 + i));
}
}
}
void block_init(int n) {
int power = 1;
while (n > 0) {
if (n % 2 == 1) {
block.push_back(power);
}
power *= 2;
n /= 2;
}
int top = block.back();
block.pop_back();
block.insert(block.begin(), top);
int curr_index = 1;
for (int i = 0; i < block.size(); ++i) {
clear(block[i], curr_index);
curr_index += block[i];
}
}
void join() {
for (int i = 1; i <= block[1]; ++i) {
query.push_back(make_pair(block[0] + i, block[0] + block[1] + i));
}
block[1] *= 2;
block.erase(block.begin() + 2);
}
void drag() {
for (int i = 1; i <= block[1]; ++i) {
query.push_back(make_pair(block[0] - block[1] + i, block[0] + i));
}
block[0] -= block[1];
block[1] *= 2;
}
void resolve(int n) {
block_init(n);
while (n > 0) {
if (block.size() <= 2) {
break;
}
if (block[1] != block[2]) {
drag();
} else {
join();
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> num_cnt;
resolve(num_cnt);
cout << query.size() << "\n";
for (int i = 0; i < query.size(); ++i) {
cout << query[i].first << " " << query[i].second << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9 + 7;
const long long LINF = (long long)1e18 + 7;
template <typename Type1, typename Type2>
Type1 mypow(Type1 n, Type2 k) {
if (k < 0) return (Type1)1;
Type1 ans = (Type1)1;
while (k) {
k--;
ans *= n;
}
return ans;
}
template <typename T1, typename T2>
T1 mylog(T1 x, T2 y) {
T1 ans = 0;
while (x) {
x /= y;
ans++;
}
return ans;
}
template <typename T1, typename T2>
T1 mymax(T1 x, T2 y) {
return x < (T1)y ? y : x;
}
template <typename T>
T myabs(T x) {
return x < 0 ? -x : x;
}
template <typename T>
void vv(vector<T> &v) {
for (int i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << "\n";
}
unsigned long long sum(unsigned long long i) {
if (i > 2 * 1e9) return LINF;
return i * (i + 1) / 2;
}
int main() {
unsigned long long n, m;
cin >> n >> m;
if (n <= m) {
cout << n;
return 0;
}
unsigned long long l = 0, r = LINF;
while (r - l > 1) {
unsigned long long mid = (r + l) / 2;
if (n <= sum(mid) + m) {
r = mid;
} else
l = mid;
}
cout << m + r;
}
| 3 |
#include<cmath>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define MAXN 200000
#define INF 0x7fffffff
int N,A,B;
int main(){
scanf("%d",&N);
bool flag=0;
long long All=0,Rest=INF;
for(int i=1;i<=N;i++){
scanf("%d%d",&A,&B);
All+=B;
flag|=A!=B;
if(A>B)
Rest=min(Rest,1ll*B);
}
printf("%lld",flag*(All-Rest));
}
| 0 |
#include <bits/stdc++.h>
std::vector<int> getLeftFall(const std::vector<int>& x, int h) {
std::vector<int> result(x.size());
result[0] = 0;
for (size_t i = 1; i < x.size(); i++) {
if (x[i] - x[i - 1] < h) {
result[i] = result[i - 1];
} else {
result[i] = i;
}
}
return result;
}
std::vector<int> getRightFall(const std::vector<int>& x, int h) {
std::vector<int> result(x.size());
result[x.size() - 1] = x.size() - 1;
for (size_t i = x.size() - 1; i-- > 0;) {
if (x[i + 1] - x[i] < h) {
result[i] = result[i + 1];
} else {
result[i] = i;
}
}
return result;
}
void run(std::istream& in, std::ostream& out) {
int n, h;
in >> n >> h;
double p;
in >> p;
std::vector<int> x(n);
for (int i = 0; i < n; i++) {
in >> x[i];
}
std::sort(x.begin(), x.end());
std::vector<std::vector<std::array<double, 4>>> dyn(n);
for (int i = 0; i < n; i++) {
dyn[i].resize(i + 1);
}
std::vector<int> leftFall = getLeftFall(x, h);
std::vector<int> rightFall = getRightFall(x, h);
std::vector<int> rightDist0(n);
std::vector<int> rightDist1(n);
std::vector<int> leftDist0(n);
std::vector<int> leftDist1(n);
for (int i = 0; i < n - 1; i++) {
rightDist0[i] = std::min(h, x[i + 1] - x[i]);
rightDist1[i] = std::min(h, x[i + 1] - x[i] - h);
}
rightDist0[n - 1] = h;
rightDist1[n - 1] = h;
for (int i = 1; i < n; i++) {
leftDist0[i] = std::min(h, x[i] - x[i - 1]);
leftDist1[i] = std::min(h, x[i] - x[i - 1] - h);
}
leftDist0[0] = h;
leftDist1[0] = h;
for (int len = 0; len < n; len++) {
for (int right = len; right < n; right++) {
int left = right - len;
std::array<double, 4>& ans = dyn[right][left];
int rDist0 = rightDist0[right];
int rDist1 = rightDist1[right];
int lDist0 = leftDist0[left];
int lDist1 = leftDist1[left];
double add, add0, add1;
int fallIndex;
ans[0] += lDist0 * p / 2;
ans[1] += lDist0 * p / 2;
ans[2] += lDist1 * p / 2;
ans[3] += lDist1 * p / 2;
if (right > left) {
add0 = dyn[right][left + 1][0];
add1 = dyn[right][left + 1][1];
ans[0] += add0 * p / 2;
ans[1] += add1 * p / 2;
ans[2] += add0 * p / 2;
ans[3] += add1 * p / 2;
}
ans[0] += rDist0 * (1 - p) / 2;
ans[1] += rDist1 * (1 - p) / 2;
ans[2] += rDist0 * (1 - p) / 2;
ans[3] += rDist1 * (1 - p) / 2;
if (right > left) {
add0 = dyn[right - 1][left][0];
add1 = dyn[right - 1][left][2];
ans[0] += add0 * (1 - p) / 2;
ans[1] += add0 * (1 - p) / 2;
ans[2] += add1 * (1 - p) / 2;
ans[3] += add1 * (1 - p) / 2;
}
fallIndex = rightFall[left];
if (fallIndex >= right) {
add = (x[right] - x[left]) * (1 - p) / 2;
add0 = add + rDist0 * (1 - p) / 2;
add1 = add + rDist1 * (1 - p) / 2;
ans[0] += add0;
ans[1] += add1;
ans[2] += add0;
ans[3] += add1;
} else {
add = (x[fallIndex] - x[left] + h) * (1 - p) / 2;
add0 = add + dyn[right][fallIndex + 1][2] * (1 - p) / 2;
add1 = add + dyn[right][fallIndex + 1][3] * (1 - p) / 2;
ans[0] += add0;
ans[1] += add1;
ans[2] += add0;
ans[3] += add1;
}
fallIndex = leftFall[right];
if (fallIndex <= left) {
double add = (x[right] - x[left]) * p / 2;
add0 = add + lDist0 * p / 2;
add1 = add + lDist1 * p / 2;
ans[0] += add0;
ans[1] += add0;
ans[2] += add1;
ans[3] += add1;
} else {
add = (x[right] - x[fallIndex] + h) * p / 2;
add0 = add + dyn[fallIndex - 1][left][1] * p / 2;
add1 = add + dyn[fallIndex - 1][left][3] * p / 2;
ans[0] += add0;
ans[1] += add0;
ans[2] += add1;
ans[3] += add1;
}
}
}
out.precision(10);
out << dyn[n - 1][0][0] << std::endl;
}
int main() {
std::cin.sync_with_stdio(false);
std::cin.tie(nullptr);
run(std::cin, std::cout);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, sub1, sub2;
cin >> s;
int arr[4];
if (s.find('h') != -1 && s.find('e') != -1 && s.find('l') != -1 &&
s.find('o') != -1) {
arr[0] = s.find_first_of('h');
arr[1] = s.find_last_of('o');
sub1 = s.substr(arr[0], (arr[1] - arr[0]) + 1);
if (sub1.find('e') != -1 && sub1.find('l') != -1) {
arr[2] = sub1.find_first_of('e');
arr[3] = sub1.find_last_of('l');
sub2 = sub1.substr(arr[2], (arr[3] - arr[2]));
} else {
cout << "NO" << endl;
return 0;
}
if (sub2.find('l') != -1)
cout << "YES" << endl;
else
cout << "NO" << endl;
} else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 8e5 + 7;
const double pi = acos(-1);
complex<double> a[N], b[N];
int Hash[300], mp[N][5], ans[N], L, R[N], n, m, len, res[N], S[N], T[N], tot, i,
j, K, nxt;
char ch;
int id(char ch) { return Hash[ch]; }
void fft(complex<double>* x, int type) {
for (int i = 0; i < n; ++i)
if (i < R[i]) swap(x[i], x[R[i]]);
for (int i = 1; i < n; i <<= 1) {
complex<double> wn(cos(pi / i), sin(type * pi / i));
for (int p = i << 1, j = 0; j < n; j += p) {
complex<double> w(1, 0);
for (int k = 0; k < i; ++k, w *= wn) {
complex<double> l = x[j + k], r = w * x[j + k + i];
x[j + k] = l + r;
x[j + k + i] = l - r;
}
}
}
}
int main() {
Hash['A'] = 1;
Hash['T'] = 2;
Hash['C'] = 3;
Hash['G'] = 4;
for (scanf("%d%d%d", &n, &len, &K), n--, i = 0; i <= n; ++i)
scanf(" %c", &ch), S[i] = id(ch);
for (len--, i = 0; i <= len; ++i) scanf(" %c", &ch), T[i] = id(ch);
for (i = 1; i <= 4; ++i) {
for (nxt = -N, j = 0; j <= n; ++j) {
if (S[j] == i) nxt = j;
if (j - nxt <= K) mp[j][i] = 1;
}
for (nxt = N, j = n; j >= 0; --j) {
if (S[j] == i) nxt = j;
if (nxt - j <= K) mp[j][i] = 1;
}
}
for (m = n * 2, n = 1; n <= m; n <<= 1) L++;
for (i = 0; i < n; ++i) R[i] = (R[i >> 1] >> 1) | ((i & 1) << (L - 1));
for (j = 1; j <= 4; ++j) {
for (i = 0; i <= m / 2; ++i) a[i] = mp[m / 2 - i][j];
for (i = 0; i <= len; ++i) b[i] = T[i] == j;
fft(a, 1);
fft(b, 1);
for (i = 0; i < n; ++i) a[i] = a[i] * b[i];
fft(a, -1);
for (i = 0; i <= m / 2; ++i) res[i] += int(a[m / 2 - i].real() / n + 0.5);
for (i = 0; i < n; ++i) a[i] = b[i] = 0;
}
for (i = 0; i <= m / 2; ++i)
if (res[i] == len + 1) tot++;
return 0 * printf("%d\n", tot);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[100003], b[1000003];
int main() {
int n, k, x;
cin >> n >> k;
for (int i = 1; i <= k; ++i) {
cin >> x;
b[x] = i;
if (!a[x]) a[x] = i;
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (i > 1 && (a[i] == 0 || a[i] > b[i - 1])) ++ans;
if (i < n && (a[i] == 0 || a[i] > b[i + 1])) ++ans;
if (a[i] == 0) ++ans;
}
cout << ans << "\n";
}
| 3 |
#include<iostream>
#include<vector>
using namespace std;
int main()
{
int n;
cin>>n;
vector<int> p(n);
for(int i=0;i<n;i++)
{
int x;
cin>>x;
x--;
p[x]=i;
}
int t=1,ans=1;
for(int i=1;i<n;i++)
{
if(p[i]>p[i-1]) t++;
else t=1;
ans=max(ans,t);
}
cout<<n-ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int x, y;
cin >> x >> y;
double d = 0;
n--;
while (n--) {
int x1, y1;
cin >> x1 >> y1;
d += sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
x = x1;
y = y1;
}
printf("%f", (d * k) / 50);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int A[505050];
vector<pair<int, int> > V;
int ans[505050];
int F[505050];
int N;
void upd(int x) {
for (int i = x; i <= N; i += i & -i) F[i]++;
}
int query(int x) {
int ret = 0;
for (int i = x; i; i -= i & -i) ret += F[i];
return ret;
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
V.clear();
scanf("%d", &N);
for (int i = 1; i <= N; i++) scanf("%d", &A[i]);
for (int i = 1; i <= N; i++) ans[i] = -1;
for (int i = 1; i <= N; i++) F[i] = 0;
bool ok = true;
for (int i = 1; i <= N; i++)
if (A[i] != -1 && A[i] <= i) ok = false;
if (!ok) {
puts("-1");
continue;
}
for (int i = 1; i <= N; i++) V.push_back({A[i], -i});
sort(V.begin(), V.end());
reverse(V.begin(), V.end());
int id = N;
for (int i = 0; i < V.size(); i++) {
if (V[i].first != -1 && query(V[i].first - 1) - query((-V[i].second)) > 0)
ok = false;
if (V[i].first == N + 1) {
ans[-V[i].second] = id;
id--;
upd(-V[i].second);
continue;
}
if (V[i].first != -1 && ans[V[i].first] == -1) {
ans[V[i].first] = id;
id--;
upd(V[i].first);
}
if (ans[-V[i].second] != -1) continue;
ans[-V[i].second] = id;
id--;
upd(-V[i].second);
}
if (!ok) {
puts("-1");
continue;
}
for (int i = 1; i <= N; i++) printf("%d ", ans[i]);
puts("");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline long long add(long long a, long long b) {
return ((a % 1000000007) + (b % 1000000007)) % 1000000007;
}
inline long long mul(long long a, long long b) {
return ((a % 1000000007) * (b % 1000000007)) % 1000000007;
}
inline long long sub(long long a, long long b) {
return ((a % 1000000007) - (b % 1000000007) + 1000000007) % 1000000007;
}
void solve() {
long long n, k;
cin >> n >> k;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
long long ans = 0;
vector<long long> v;
for (long long i = n - 1; i >= 0; i--) {
ans += a[i];
if (i) v.push_back(ans);
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
;
for (long long i = 0; i < k - 1; i++) ans += v[i];
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
for (long long a = 0; a < t; a++) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool static cmp(long long int a, long long int b) { return a > b; }
int main() {
int test;
cin >> test;
while (test--) {
long long int n, l;
cin >> n >> l;
string ip;
cin >> ip;
long long int sum = 0;
long long int lose = 0;
vector<long long int> w;
for (int i = 0; i < n; i++)
if (ip[i] == 'L')
++lose;
else
w.push_back(i);
if (l >= lose) {
sum = 1 + 2 * (n - 1);
cout << sum << endl;
continue;
} else if (lose == n && l) {
sum = 1 + 2 * (l - 1);
cout << sum << endl;
continue;
}
sum = ip[0] == 'W' ? 1 : 0;
for (int i = 1; i < n; i++) {
if (ip[i] == 'W') {
if (ip[i - 1] == 'W')
sum += 2;
else
sum += 1;
}
}
if (l == 0) {
cout << sum << endl;
continue;
}
long long int start = 0;
vector<long long int> gp;
if (w[0] != 0) start = w[0];
if (w[w.size() - 1] != n - 1) start += n - w[w.size() - 1];
for (int i = 1; i < w.size(); i++) {
long long int gap = w[i] - w[i - 1] - 1;
if (gap == 0) continue;
gp.push_back(gap);
}
sort(gp.begin(), gp.end());
int i = 0;
while (l > 0 && i < gp.size()) {
if (l >= gp[i]) {
l -= gp[i];
sum += 2 * gp[i] + 1;
} else {
sum += 2 * l;
l = 0;
}
++i;
}
if (l > 0 && start > 0) {
int g = min(l, start);
sum += 2 * g;
}
cout << sum;
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 400005;
template <typename T>
inline void read(T &AKNOI) {
T x = 0, flag = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') flag = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
AKNOI = flag * x;
}
int n, nn, a[MAXN], stk[MAXN], top, L[MAXN], R[MAXN];
int mx[MAXN << 2], tag[MAXN << 2];
inline void puttag(int rt, int tg) {
mx[rt] += tg;
tag[rt] += tg;
}
inline void pushdown(int rt) {
if (!tag[rt]) return;
puttag((rt << 1), tag[rt]);
puttag((rt << 1) | 1, tag[rt]);
tag[rt] = 0;
}
void Update(int rt, int b, int e, int l, int r, int v) {
if (l <= b && e <= r) {
puttag(rt, v);
return;
}
int mid = (b + e) >> 1;
pushdown(rt);
if (l <= mid) Update((rt << 1), b, mid, l, r, v);
if (r > mid) Update((rt << 1) | 1, mid + 1, e, l, r, v);
mx[rt] = max(mx[(rt << 1)], mx[(rt << 1) | 1]);
}
int Query(int rt, int b, int e, int l, int r) {
if (l <= b && e <= r) return mx[rt];
int mid = (b + e) >> 1;
pushdown(rt);
if (r <= mid) return Query((rt << 1), b, mid, l, r);
if (l > mid) return Query((rt << 1) | 1, mid + 1, e, l, r);
return max(Query((rt << 1), b, mid, l, r),
Query((rt << 1) | 1, mid + 1, e, l, r));
}
void init() {
read(n);
nn = n + n;
for (int i = 1; i <= n; ++i) {
read(a[i]);
a[n + i] = a[i];
}
a[0] = a[nn + 1] = 0;
for (int i = 1; i <= nn + 1; ++i) {
while (top && a[stk[top]] >= a[i]) {
R[stk[top--]] = i - 1;
}
stk[++top] = i;
}
top = 0;
for (int i = nn; i >= 0; --i) {
while (top && a[stk[top]] >= a[i]) {
L[stk[top--]] = i + 1;
}
stk[++top] = i;
}
}
void solve() {
for (int i = 1; i <= n; ++i) {
Update(1, 1, nn, L[i], R[i], 1);
}
int ans = Query(1, 1, nn, 1, n), anspos = 0;
for (int i = 1; i < n; ++i) {
Update(1, 1, nn, L[i], R[i], -1);
Update(1, 1, nn, L[n + i], R[n + i], 1);
int cur = Query(1, 1, nn, i + 1, n + i);
if (cur < ans) {
ans = cur;
anspos = i;
}
}
printf("%d %d\n", ans, anspos);
}
int main() {
init();
solve();
return 0;
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
const int Q=998244353;
inline int inv(int x){
int r=1,y=Q-2;
while(y){
if(y&1) r=1LL*r*x%Q;
x=1LL*x*x%Q;
y>>=1;
}
return r;
}
int main(){
int n,p3=1,cur=2;
scanf("%d",&n);
for(int i=0;i<n;i++){
p3=p3*3LL%Q;
}
for(int i=0;i<n/2;i++){
p3=(p3+Q-cur)%Q;
cur=2LL*cur*(n-i)%Q*inv(i+1)%Q;
}
printf("%d\n",p3);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
bool chmin(T1 &a, T2 b) {
return b < a && (a = b, true);
}
template <class T1, class T2>
bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
int main() {
int n;
cin >> n;
vector<int> a(n), b(n);
for (int i = 0; i < (n); i++) scanf("%d", &a[i]);
for (int i = 0; i < (n); i++) scanf("%d", &b[i]);
a.erase(find(a.begin(), a.end(), 0));
b.erase(find(b.begin(), b.end(), 0));
rotate(a.begin(), find(a.begin(), a.end(), 1), a.end());
rotate(b.begin(), find(b.begin(), b.end(), 1), b.end());
cout << (a == b ? "YES" : "NO") << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x[2], y[2];
for (int i = 0; i < 2; i++) cin >> x[i] >> y[i];
int n;
cin >> n;
int ans = 0;
long long a, b, c;
for (int i = 0; i < n; i++) {
cin >> a >> b >> c;
if ((a * x[0] + b * y[0] + c) < 0 && (a * x[1] + b * y[1] + c) > 0)
ans++;
else if ((a * x[0] + b * y[0] + c) > 0 && (a * x[1] + b * y[1] + c) < 0)
ans++;
}
cout << ans;
}
| 1 |
#include<bits/stdc++.h>
#define For(i,j,k)for(int i=j;i<=k;++i)
using namespace std;
const int N=2010;
int A[N];
bool cmp(int x,int y){
return A[x]<A[y];
}
int bel[N],cnt[N],rk[N],n,k,q;
int main(){
scanf("%d%d%d",&n,&k,&q);
For(i,1,n)scanf("%d",&A[i]),rk[i]=i;
sort(rk+1,rk+n+1,cmp);
int ans=1e9;
For(i,1,n-q+1){
For(j,0,n)cnt[j]=0;
For(j,0,n){
bel[j]=A[j]<A[rk[i]]?j:bel[j-1];
if(bel[j]!=j)++cnt[bel[j]];
}
int ret=0;
For(j,i,n){
if(cnt[bel[rk[j]]]>=k){
++ret,--cnt[bel[rk[j]]];
if(ret>=q){
ans=min(ans,A[rk[j]]-A[rk[i]]);
break;
}
}
}
}
printf("%d\n",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
cout << s.substr(0, 3);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.14159265359;
const double E = 2.718281828459;
const long long MOD = 1000000007;
pair<long long, long long> solve(long long x1, long long x2, long long a,
long long b) {
pair<long long, long long> ans;
long long dist = x2 - x1;
if (dist < 0)
ans.first = 0;
else if (dist == 0 && a == 0) {
ans.first = 1, ans.second = x2;
} else {
long long q = dist / (a + b);
long long res = dist % (a + b);
if (res == 0)
ans.first = -1;
else {
if (res < a || res > b)
ans.first = 0;
else
ans.first = 1, ans.second = x1 + res;
}
}
return ans;
}
int main() {
long long x1, x2, a, b;
scanf("%I64d %I64d %I64d %I64d", &x1, &x2, &a, &b);
long long state;
long long ans, X1, X2, A, B;
if (a <= 0 && 0 <= b) {
if (x1 <= x2) {
if (x1 + b >= x2)
state = 1, ans = x2;
else
state = 0;
} else {
if (x1 + a <= x2)
state = 1, ans = x2;
else
state = 0;
}
} else {
X1 = x1, X2 = x2, A = a, B = b;
if (a <= 0 && b <= 0) X1 = -x1, X2 = -x2, A = -b, B = -a;
pair<long long, long long> couple = solve(X1, X2, A, B);
state = couple.first, ans = couple.second;
if (a <= 0 && b <= 0) ans = -ans;
}
if (state == 0)
printf("DRAW");
else if (state == -1)
printf("SECOND");
else
printf("FIRST\n%d", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};
using namespace std;
const int MAXN = 333;
int a[MAXN];
bool isin[MAXN];
void print(vector<pair<int, int> > G) {
for (auto p : G) {
cout << p.first + 1 << " " << p.second + 1 << endl;
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, k, m;
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
cin >> a[i];
a[i]--;
isin[a[i]] = true;
}
int cnt = 0;
vector<pair<int, int> > G;
vector<int> out, in;
for (int i = 0; i < n; i++) {
if (isin[i])
in.push_back(i);
else
out.push_back(i);
}
int insize = in.size(), outsize = out.size();
if (outsize == 0) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < insize; i++) {
G.emplace_back(out[0], in[i]);
cnt++;
}
for (int i = 1; i < outsize; i++) {
G.emplace_back(out[0], out[i]);
cnt++;
}
if (cnt >= m) {
print(G);
return 0;
}
for (int i = 0; i < insize; i++) {
if (cnt >= m) break;
for (int j = 1; j < outsize; j++) {
G.emplace_back(in[i], out[j]);
cnt++;
if (cnt >= m) break;
}
}
if (cnt >= m) {
print(G);
return 0;
}
for (int i = 1; i < outsize - 1; i++) {
if (cnt >= m) break;
for (int j = i + 1; j < outsize; j++) {
G.emplace_back(out[i], out[j]);
cnt++;
if (cnt >= m) break;
}
}
if (cnt >= m) {
print(G);
return 0;
}
for (int i = 1; i < insize; i++) {
if (cnt >= m) break;
for (int j = i + 1; j < insize; j++) {
G.emplace_back(in[i], in[j]);
cnt++;
if (cnt >= m) break;
}
}
if (cnt >= m) {
print(G);
return 0;
}
cout << -1 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, i, j, a[100000], t = 0, c1, c2, count = 0, max = 0;
string s;
cin >> n >> k;
for (i = 0; i < k; i++) {
cin >> s;
c1 = 0;
c2 = 0;
for (j = 0; s[j] != '\0'; j++) {
if (s[j] == '0') c1++;
}
if (c1 > 0) {
a[t] = 0;
t++;
} else {
a[t] = 1;
t++;
}
}
for (t = 0; t < k; t++) {
if (a[t] == 0) {
count++;
if (count > max) max = count;
} else {
if (count > max) max = count;
count = 0;
}
}
cout << max;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 105;
int p[MAX_N], used[MAX_N];
int main() {
int n;
long long m;
cin >> n >> m;
int is_max = 0;
int last_val = -1;
for (int i = 0; i < n; i++)
if (is_max == 1) {
int pos = i;
for (int j = n - 1; j >= 0; j--)
if (!used[j]) p[pos++] = j;
break;
} else {
long long x = 0, pred_x = 0;
for (int j = last_val + 1; j < n; j++)
if (!used[j]) {
long long cnt = 0;
for (int k = 0; k < n; k++)
if (!used[k] && k > j) cnt++;
if (cnt == 0)
x++;
else
x += 1LL << (cnt - 1);
if (x >= m) {
used[j] = 1;
p[i] = j;
m -= pred_x;
if (j == n - 1) is_max = 1;
last_val = j;
break;
}
pred_x = x;
}
}
for (int i = 0; i < n; i++) cout << (p[i] + 1) << " ";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(){
long long N,x,ans=999999999999999999;
cin >> N >> x;
vector<long long> a(N);
for(auto &i:a)cin >> i;
long long m[N][N];
for(int i=0;i<N;i++)m[i][0]=a[i];
for(int k=1;k<N;k++){
for(int i=0;i<N;i++){
m[i][k]=min(m[i][k-1],a[(i+N-k)%N]);
}
}
for(int k=0;k<N;k++){
long long tmp=x*k;
for(int i=0;i<N;i++)tmp+=m[i][k];
ans=min(ans,tmp);
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int r, c;
cin >> r >> c;
string str[10];
for (int i = 0; i < r; i++) cin >> str[i];
int R = 0;
int C = 0;
for (int i = 0; i < r; i++) {
int j = 0;
for (; j < c; j++) {
if (str[i][j] == 'S') break;
}
if (j == c) R++;
}
for (int j = 0; j < c; j++) {
int i = 0;
for (; i < r; i++) {
if (str[i][j] == 'S') break;
}
if (i == r) C++;
}
cout << R * c + C * r - R * C << endl;
}
| 1 |
#include<iostream>
#include<cstdio>
#include<string>
using namespace std;
int main()
{
string ss;
int ans=0;
while(cin >> ss){
for(int i=0;i<ss.length();i++){
if(ss[i]!=ss[ss.length()-1-i])goto next;
}
ans++;
next:;
}
cout << ans << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 500010;
int d, n, m, x[nmax], p[nmax];
int t[nmax * 4];
void build(int v, int tl, int tr) {
if (tl == tr)
t[v] = p[tl];
else {
int m = (tl + tr) >> 1;
build(v + v, tl, m);
build(v + v + 1, m + 1, tr);
t[v] = min(t[v + v], t[v + v + 1]);
}
}
int get(int v, int tl, int tr, int l, int r) {
if (tl > tr) return 2000000000;
if (l > r) return 2000000000;
if (tl == l && tr == r) return t[v];
int m = (tl + tr) >> 1;
if (r <= m) return get(v + v, tl, m, l, r);
if (l > m) return get(v + v + 1, m + 1, tr, l, r);
return min(get(v + v, tl, m, l, m), get(v + v + 1, m + 1, tr, m + 1, r));
return min(get(v + v, tl, m, l, min(m, r)),
get(v + v + 1, m + 1, tr, max(m + 1, l), r));
}
void out() {
puts("-1");
exit(0);
}
int main() {
ios::sync_with_stdio(0);
cin >> d >> n >> m;
vector<pair<int, int> > v;
for (int i = 1; i <= m; i++) {
cin >> x[i] >> p[i];
v.push_back({x[i], p[i]});
}
sort(v.begin(), v.end());
for (int i = 1; i <= m; i++) {
x[i] = v[i - 1].first;
p[i] = v[i - 1].second;
}
x[m + 1] = d;
p[m + 1] = -1;
build(1, 1, m + 1);
long long ost = n - x[1], pos = x[1], sum = 0;
if (x[1] > n) out();
for (int i = 1; i <= m; i++) {
int l = i + 1, r = m + 1;
while (l + 1 < r) {
int mid = (l + r) >> 1;
if (get(1, 1, m + 1, i + 1, mid) < p[i])
r = mid;
else
l = mid;
}
if (get(1, 1, m + 1, i + 1, l) < p[i]) r = l;
if (get(1, 1, m + 1, i + 1, r) < p[i] && pos + n >= x[r]) {
int len = x[r] - pos - ost;
if (len > 0) {
int up = min(n - ost, 1ll * len);
ost += up;
sum += 1ll * up * p[i];
}
if (pos + ost < x[r]) out();
ost -= x[r] - pos;
pos = x[r];
i = r - 1;
} else {
if (pos + n >= d && get(1, 1, m + 1, i + 1, m) > p[i]) {
int len = d - pos - ost;
if (len > 0) {
int up = min(n - ost, 1ll * len);
ost += up;
sum += 1ll * up * p[i];
}
ost -= d - pos;
pos = d;
break;
}
int len = n - ost;
if (len > 0) {
int up = min(n - ost, 1ll * len);
ost += up;
sum += 1ll * up * p[i];
}
if (pos + ost < x[i + 1]) out();
ost -= x[i + 1] - pos;
pos = x[i + 1];
}
}
if (pos + ost < d) out();
cout << sum << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const int mod = 1e9 + 7;
int addmod(int x, int y) {
if (y < 0)
x += y;
else
x = x - mod + y;
if (x < 0) x += mod;
return x;
}
int qpow(int a, int b, int mo) {
int res = 1;
while (b) {
if (b & 1) res = 1ll * res * a % mo;
a = 1ll * a * a % mo;
b >>= 1;
}
return res;
}
int invfac2[N], invfac[N], fac[N];
void init() {
fac[0] = 1;
for (int i = 1; i < N; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
invfac[N - 1] = qpow(fac[N - 1], mod - 2, mod);
invfac[0] = 1;
for (int i = N - 2; i >= 1; i--)
invfac[i] = 1ll * invfac[i + 1] * (i + 1) % mod;
invfac2[1] = qpow(2, mod - 2, mod);
for (int i = 2; i < N; i++)
invfac2[i] = 1ll * invfac2[i - 1] * invfac2[1] % mod;
}
int Calc(int n, int m) {
if (n > m)
return 0;
else
return 1ll * fac[m] * invfac[n] % mod * invfac[m - n] % mod;
}
int n, ans;
long long T, t[N];
bool Flag = 0;
int main() {
init();
scanf("%d%lld", &n, &T);
for (int i = 1; i <= n; i++) scanf("%lld", &t[i]);
long long sum = 0;
int s = 2;
int r = n;
for (int i = 1; i <= n; i++) {
sum += t[i];
if (T - sum >= i)
ans = addmod(1, ans);
else if (T - sum < 0)
break;
else {
for (int j = T - sum + 1; j <= r; j++) s = addmod(s, -Calc(j, i));
ans = addmod(1ll * s * invfac2[i] % mod, ans);
r = T - sum;
Flag = 1;
}
s = 2ll * s % mod;
;
if (Flag) s = addmod(s, -Calc(r, i));
}
printf("%d\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long min(long long a, long long b, long long c) {
return min(a, min(b, c));
}
template <class T>
const T& max(const T& a, const T& b, const T& c) {
return max(a, max(b, c));
}
template <class T>
const T& min(const T& a, const T& b, const T& c) {
return min(a, min(b, c));
}
struct sp {
bool operator()(const pair<string, int>& a, const pair<string, int>& b) {
if (a.second != b.second) {
return (a.second > b.second);
}
return (a.first < b.first);
}
};
long long stoi(string& str) {
istringstream second(str);
long long i;
second >> i;
return i;
}
string itos(long long i) {
stringstream second;
second << i;
return second.str();
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
int a[100001];
vector<int> v;
void dfs(long long i) {
if (i > pow(10, 9)) return;
if (i > 0) v.push_back(i);
dfs(i * 10 + 4);
dfs(i * 10 + 7);
}
int main() {
map<long long, long long> m1, m2, m3;
long long x;
long long n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
m1[x]++;
}
for (int i = 0; i < n - 1; i++) {
cin >> x;
m2[x]++;
}
for (int i = 0; i < n - 2; i++) {
cin >> x;
m3[x]++;
}
for (auto itr = m1.begin(); itr != m1.end(); ++itr)
if (itr->second != m2[itr->first]) {
cout << itr->first << endl;
break;
}
for (auto itr = m2.begin(); itr != m2.end(); ++itr)
if (itr->second != m3[itr->first]) {
cout << itr->first << endl;
break;
}
return 0;
}
| 2 |
#include <iostream>
using namespace std;
int main(){
int a,b;
cin>>a>>b;
cout<<max(0,a-b-b);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 100;
template <class nmsl>
inline void read(nmsl &x) {
x = 0;
char ch = getchar(), w = 0;
while (!isdigit(ch)) w = (ch == '-'), ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
x = w ? -x : x;
}
map<int, int> mp;
int val[N], n, sum[2010], pol;
int ans = 2e9;
int s[2010][2010];
inline int check(int x) {
for (register int i = 1; i <= n; i++) {
for (register int j = i; j <= i + x - 1; j++) {
sum[mp[val[j]]]--;
}
int flag = 0;
for (register int j = 1; j <= pol; j++) {
if (sum[j] > 1) {
flag = 1;
break;
}
}
for (register int j = i; j <= i + x - 1; j++) {
sum[mp[val[j]]]++;
}
if (!flag) return 1;
}
return 0;
}
int main() {
read(n);
for (register int i = 1; i <= n; i++) {
read(val[i]);
if (!mp[val[i]]) mp[val[i]] = ++pol;
sum[mp[val[i]]]++;
for (register int j = 1; j <= pol; j++) s[i][j] = sum[j];
}
int l = 0, r = n;
while (l < r) {
int mid = (l + r) >> 1;
if (check(mid))
r = mid;
else
l = mid + 1;
}
cout << r;
return 0;
}
| 2 |
#include <bits/stdc++.h>
const uint64_t c_mod = 1000000007;
uint64_t ov[2048][2048];
uint64_t ps[2048];
int main() {
std::ios_base::sync_with_stdio(false);
int n, k;
std::cin >> n >> k;
std::string s;
std::cin >> s;
ov[0][0] = 1;
ps[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= k; j++) {
for (int p = 0; p < i && (p + 1) * (n - i + 1) <= j; p++) {
ov[i][j] +=
(('z' - s[i - 1]) * ov[i - p - 1][j - (p + 1) * (n - i + 1)]) %
c_mod;
ov[i][j] %= c_mod;
}
ov[i][j] += ((s[i - 1] - 'a') * ps[j]) % c_mod;
ov[i][j] %= c_mod;
ps[j] += ov[i][j];
ps[j] %= c_mod;
}
}
std::cout << ps[k] << std::endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll MOD = 1e9 + 7, N = 1e5 + 10;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
ll d, k, a, b, t;
cin >> d >> k >> a >> b >> t;
if (d <= k) {
cout << a * d << '\n';
} else if (t + a * k > k * b) {
cout << a * k + (d - k) * b << '\n';
} else {
ll c = d / k;
cout << k * c * a + (c - 1) * t + min(t + (d % k) * a, (d % k) * b) << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf_int = 1e8;
const long long inf_ll = 1e16;
const double pi = 3.1415926535898;
bool debug = 0;
const int MAXN = 1e5 + 10;
const int LOG = 20;
const int mod = 1e9 + 7;
vector<int> g[MAXN];
int tin[MAXN];
int tout[MAXN];
int timer;
int up[MAXN][LOG];
int h[MAXN];
void dfs(int v, int p) {
tin[v] = ++timer;
up[v][0] = p;
for (int i = 1; i < LOG; ++i) {
up[v][i] = up[up[v][i - 1]][i - 1];
}
for (int to : g[v]) {
if (to == p) continue;
h[to] = h[v] + 1;
dfs(to, v);
}
tout[v] = timer;
}
int lca(int a, int b) {
if (h[a] < h[b]) swap(a, b);
int dif = h[a] - h[b];
for (int i = 0; i < LOG; ++i) {
if (dif & (1 << i)) a = up[a][i];
}
assert(h[a] == h[b]);
if (a == b) return a;
for (int i = LOG - 1; i >= 0; --i) {
if (up[a][i] != up[b][i]) {
a = up[a][i];
b = up[b][i];
}
}
return up[a][0];
}
const int MX = 1e7 + 5;
int mn[MX];
void sieve() {
for (int i = 2; i < MX; ++i) {
if (!mn[i]) {
mn[i] = i;
if (1ll * i * i < MX) {
for (int e = i * i; e < MX; e = e + i) {
if (!mn[e]) mn[e] = i;
}
}
}
}
}
int a[MAXN];
int ans[MAXN];
pair<int, int> query[MAXN];
vector<pair<pair<int, int>, int>> add_ver;
vector<pair<pair<int, int>, int>> add_quer;
void process_ver(int v) {
int x = a[v];
while (x > 1) {
int cur = mn[x];
int cnt = 0;
while (mn[x] == cur) {
cnt++;
x /= cur;
}
add_ver.push_back({{cur, cnt}, v});
}
}
void process_quer(int val, int ind) {
int x = val;
while (x > 1) {
int cur = mn[x];
int cnt = 0;
while (mn[x] == cur) {
cnt++;
x /= cur;
}
add_quer.push_back({{cur, cnt}, ind});
}
}
struct Fenwick_tree {
int t[MAXN];
Fenwick_tree() { memset(t, 0, sizeof t); }
inline void add(int pos, int val) {
for (; pos < MAXN; pos |= pos + 1) {
t[pos] += val;
}
}
inline int get(int pos) {
int res = 0;
for (; pos > 0; pos = (pos & (pos + 1)) - 1) {
res += t[pos];
}
return res;
}
inline void add(int l, int r, int x) {
add(r + 1, -x);
add(l, x);
}
} tree;
int POW[MX];
int was_added[MAXN];
void solve() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n - 1; ++i) {
int a, b;
scanf("%d %d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
dfs(1, 1);
sieve();
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
process_ver(i);
}
int q;
scanf("%d", &q);
for (int i = 1; i <= q; ++i) {
int a, b, x;
scanf("%d %d %d", &a, &b, &x);
ans[i] = 1;
query[i] = {a, b};
process_quer(x, i);
}
for (auto x : add_ver) {
if (debug)
cout << x.first.first << " " << x.first.second << " " << x.second << endl;
}
sort(add_quer.begin(), add_quer.end());
sort(add_ver.begin(), add_ver.end());
POW[0] = 1;
for (int top_v = 0, top_q = 0;
top_v < (int(add_ver.size())) && top_q < (int(add_quer.size()));) {
int mx = max(add_quer[top_q].first.first, add_ver[top_v].first.first);
while (top_q < (int(add_quer.size())) && add_quer[top_q].first.first < mx)
++top_q;
while (top_v < (int(add_ver.size())) && add_ver[top_v].first.first < mx)
++top_v;
if (top_q == (int(add_quer.size())) || top_v == (int(add_ver.size())) ||
add_quer[top_q].first.first != mx || add_ver[top_v].first.first != mx)
continue;
int l = top_v, r = top_v;
while (r < (int(add_ver.size())) && add_ver[r].first.first == mx) ++r;
int mx_power = 0;
int POW_TOP = 0;
while (top_q < (int(add_quer.size())) &&
add_quer[top_q].first.first == mx) {
int cur_power = add_quer[top_q].first.second;
if (cur_power > mx_power) {
for (int i = l; i < r; ++i) {
if (add_ver[i].first.second > mx_power) {
int v = add_ver[i].second;
int temp = min(add_ver[i].first.second, cur_power) - mx_power;
tree.add(tin[v], tout[v], temp);
was_added[v] += temp;
}
}
mx_power = cur_power;
}
int id = add_quer[top_q].second;
int a, b;
tie(a, b) = query[id];
int res = 0;
int lc = lca(a, b);
res = tree.get(tin[a]) + tree.get(tin[b]) - tree.get(tin[lc]);
if (lc != 1) res = res - tree.get(tin[up[lc][0]]);
while (POW_TOP < res) {
++POW_TOP;
POW[POW_TOP] = (1ll * POW[POW_TOP - 1] * mx) % mod;
}
assert(res < MX);
if (debug) cout << "val " << mx << " quer " << id << " " << res << endl;
ans[id] = (1ll * POW[res] * ans[id]) % mod;
++top_q;
}
for (int i = l; i < r; ++i) {
int v = add_ver[i].second;
tree.add(tin[v], tout[v], -was_added[v]);
was_added[v] = 0;
}
top_v = r;
}
for (int i = 1; i <= q; ++i) {
printf("%d\n", ans[i]);
}
}
signed main() {
int t = 1;
while (t--) solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a;
cin >> n;
vector<int> v;
int cont1 = 0;
int cont2 = 0;
for (int i = 0; i < n; i++) {
cin >> a;
v.push_back(a);
if (a > 0) cont1++;
if (a < 0) cont2++;
}
int mid = (n / 2) + n % 2;
if (cont1 >= mid)
cout << 1 << endl;
else if (cont2 >= mid)
cout << -1 << endl;
else
cout << 0 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll a[214514];
int main(){
ll n,k;
cin>>n>>k;
ll ma=0;
for(int i=0;i<n;i++){
cin>>a[i];
ma=max(ma,a[i]);
}
ll ok=ma,ng=0;
while(ok-ng>1){
ll mid=(ok+ng)/2;
ll cnt=0;
for(int i=0;i<n;i++)cnt+=(a[i]+mid-1)/mid-1;
if(cnt<=k)ok=mid;
else ng=mid;
}
cout<<ok;
return 0;
}
| 0 |
#include <iostream>
#include <map>
using namespace std;
typedef long long ll;
ll com[52][52];
ll c[52][52];
int main()
{
int n, k, s, t;
cin >> n >> k >> s >> t;
int a[52];
for(int i = 0; i < n; i++){
cin >> a[i];
if((a[i] & t) < a[i] || (a[i] | s) > a[i]){
i--;
n--;
}
}
com[0][0] = 1;
for(int i = 0; i < n; i++){
for(int j = 0; j < n; j++){
com[i + 1][j] += com[i][j];
com[i + 1][j + 1] += com[i][j];
}
}
for(int i = 1; i <= n; i++){
for(int j = 1; j <= i; j++){
c[i][j] = c[i][j - 1] + com[i][j];
}
}
int l = 0;
int r[52]{0};
for(int i = 0; i < 18; i++){
if(((s >> i) & 1) == 1 && ((t >> i) & 1) == 0){
cout << 0 << endl;
return 0;
}
if(((s >> i) & 1) == 0 && ((t >> i) & 1) == 1){
for(int j = 0; j < n; j++){
if((a[j] >> i) & 1) r[j] += (1 << l);
}
l++;
}
}
ll ans = 0;
for(int b = 0; b < (1 << l); b++){
map<int, int> mp;
int d[52]{0};
ll p = 0;
for(int j = 0; j < l; j++){
if((b >> j) & 1){
p++;
for(int i = 0; i < n; i++){
if((r[i] >> j) & 1) d[i] += (1 << j);
}
}
}
for(int i = 0; i < n; i++) mp[d[i]]++;
ll s = 0;
for(auto itr = mp.begin(); itr != mp.end(); itr++){
s += c[itr->second][min(itr->second, k)];
}
if(p % 2) ans -= s;
else ans += s;
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int size = 1000007;
const long long modulo = 1000000007;
const long long INF = 1e9;
const double EPS = 1e-10;
int main() {
cin.sync_with_stdio(0);
int n, m, k;
cin >> n >> m >> k;
int ans = 0;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (a == 1) {
if (m > 0)
--m;
else
++ans;
} else {
if (k > 0)
--k;
else if (m > 0)
--m;
else
++ans;
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
long long n,m;
int ans=1;
int main()
{
scanf("%lld%lld",&n,&m);
for(int i=2;1ll*i*i<=n;i++)
if(n%i==0)
{
while(n%i==0)
n/=i;
if(m%i==0)
ans++;
while(m%i==0)
m/=i;
}
if(n!=1)
if(m%n==0)
ans++;
printf("%d",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int cnt1[200010], cnt2[200010], cnt3[200010], dp[200010][5];
int main() {
ios_base::sync_with_stdio(0);
int n1, n2, n3;
cin >> n1 >> n2 >> n3;
int n = n1 + n2 + n3;
for (int i = 1; i <= n; i++) {
cnt1[i] = 1;
cnt2[i] = 1;
cnt3[i] = 1;
}
for (int i = 1; i <= n1; i++) {
int l;
cin >> l;
cnt1[l] = 0;
}
for (int i = 1; i <= n2; i++) {
int l;
cin >> l;
cnt2[l] = 0;
}
for (int i = 1; i <= n3; i++) {
int l;
cin >> l;
cnt3[l] = 0;
}
for (int i = 1; i <= n; i++) {
dp[i][1] = dp[i - 1][1] + cnt1[i];
dp[i][2] = min(dp[i - 1][2], dp[i - 1][1]) + cnt2[i];
dp[i][3] = min(min(dp[i - 1][2], dp[i - 1][1]), dp[i - 1][3]) + cnt3[i];
}
cout << min(dp[n][1], min(dp[n][2], dp[n][3]));
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void to1(string a, string b) {
a = 'R' + a + 'C';
long long n = 0;
for (long long i = 0; i < b.size(); i++) {
n += pow(26, b.size() - 1 - i) * (b[i] - 'A' + 1);
}
cout << a << n << endl;
}
void to2(string a, string b) {
long long n = 0;
for (long long i = b.size() - 1; i >= 0; i--)
n += pow(10, b.size() - 1 - i) * (b[i] - '0');
b = "";
while (n) {
long long x = (--n) % 26;
char i = x + 'A';
b = i + b;
n /= 26;
}
cout << b << a << endl;
}
void solve(long long ii) {
string s;
cin >> s;
string a, b;
long long t = 2;
if (s[0] == 'R' and s[1] <= '9') {
long long i = 1;
while (i < s.size() and s[i] >= '0' and s[i] <= '9') i++;
if (i != s.size()) t = 1;
}
if (t == 1) {
for (long long i = 1; i < s.size() and s[i] != 'C'; i++) a += s[i];
for (long long i = s.size() - 1; i > 0 and s[i] != 'C'; i--) b = s[i] + b;
to2(a, b);
} else {
for (long long i = 0; i < s.size() and s[i] > '9'; i++) a += s[i];
for (long long i = s.size() - 1; i > 0 and s[i] <= '9'; i--) b = s[i] + b;
to1(b, a);
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long tt, ii = 0;
cin >> tt;
while (ii++ < tt) solve(ii);
cerr << "[Execution : " << (1.0 * clock()) / CLOCKS_PER_SEC << "s]\n";
return 0;
}
| 2 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <algorithm>
using namespace std;
typedef long long ll;
const int N = 1005;
ll arr_x[N], arr_y[N];
int main(){
int t;
cin >> t;
while(t --){
int n;
cin >> n;
for(int i = 1;i <= n;i ++){
scanf("%lld%lld", &arr_x[i], &arr_y[i]);
}
ll x_r = 1, y_r = 1;
if((n & 1) == 0){
sort(arr_x + 1, arr_x + n + 1);
sort(arr_y + 1, arr_y + n + 1);
x_r = arr_x[n / 2 + 1] - arr_x[n / 2] + 1;
y_r = arr_y[n / 2 + 1] - arr_y[n / 2] + 1;
}
cout << x_r * y_r << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
printf("%d ", n);
for (int i = 2; n != 1; i = 2) {
while (n % i != 0) i++;
n /= i;
printf("%d ", n);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
class ModEq {
public:
void start() {
set<int> s;
int a, b;
scanf("%d %d", &a, &b);
if (a == b) {
printf("infinity\n");
return;
}
int res = 0;
int root = sqrt(a - b);
if (root * root != (a - b)) root++;
root++;
for (int i = 1; i < root; i++) {
if ((a - b) % i == 0) {
int other = (a - b) / i;
if (i > b) s.insert(i);
if (other > b) s.insert(other);
}
}
printf("%d\n", s.size());
}
};
ModEq meq;
int main(int argc, char **argv) {
meq.start();
return 0;
}
| 2 |
#include<iostream>
using namespace std;
int card[1000], tmp[1000], n, r;
int main()
{
loop:
cin >> n >> r;
if(!n && !r)
return 0;
for(int i = n; i > 0; i--)
card[n - i] = i;
for(int i = 0; i < r; i++)
{
int c, p;
cin >> p >> c;
for(int j = 0; j < p - 1; j++)
tmp[j] = card[j];
for(int j = 0; j < c; j++)
card[j] = card[j + p - 1];
for(int j = 0; j < p - 1; j++)
card[j + c] = tmp[j];
}
cout << card[0] << endl;
goto loop;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
template <typename T_container, typename T = typename enable_if<
!is_same<T_container, string>::value,
typename T_container::value_type>::type>
ostream &operator<<(ostream &os, const T_container &v) {
os << '{';
string sep;
for (const T &x : v) os << sep << x, sep = ", ";
return os << '}';
}
void dbg_out() { cout << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cout << ' ' << H;
dbg_out(T...);
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long tt;
cin >> tt;
while (tt--) {
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
long long sum = accumulate((a).begin(), (a).end(), 0ll);
if ((sum * 2) % n) {
cout << 0 << "\n";
continue;
}
long long req = (2 * sum) / n;
map<long long, long long> m;
long long ans = 0;
for (long long i = 0; i < n; i++) {
ans += m[req - a[i]];
m[a[i]]++;
}
cout << ans << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int n, tot;
int ans[500010];
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
if (n % 2 == 0) {
for (int i = 1; i <= n; i += 2) {
ans[++tot] = i;
}
for (int i = 2; i <= n; i += 2) {
ans[++tot] = i;
}
for (int i = 1; i <= n; i += 2) {
ans[++tot] = i;
}
} else {
for (int i = 2; i <= n; i += 2) {
ans[++tot] = i;
}
for (int i = 1; i <= n; i += 2) {
ans[++tot] = i;
}
for (int i = 2; i <= n; i += 2) {
ans[++tot] = i;
}
}
cout << tot << "\n";
for (int i = 1; i <= tot; ++i) cout << ans[i] << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &a) {
in >> a.first >> a.second;
return in;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &out, pair<T1, T2> a) {
out << a.first << " " << a.second;
return out;
}
template <typename T, typename T1>
T maxs(T &a, T1 b) {
if (b > a) a = b;
return a;
}
template <typename T, typename T1>
T mins(T &a, T1 b) {
if (b < a) a = b;
return a;
}
const long long MOD = 1000000007;
struct mod_int {
long long val;
mod_int(long long v = 0) {
if (v < 0) v = v % MOD + MOD;
if (v >= MOD) v %= MOD;
val = v;
}
static long long mod_inv(long long a, long long m = MOD) {
long long g = m, r = a, first = 0, second = 1;
while (r != 0) {
long long q = g / r;
g %= r;
swap(g, r);
first -= q * second;
swap(first, second);
}
return first < 0 ? first + m : first;
}
explicit operator long long() const { return val; }
mod_int &operator+=(const mod_int &other) {
val += other.val;
if (val >= MOD) val -= MOD;
return *this;
}
mod_int &operator-=(const mod_int &other) {
val -= other.val;
if (val < 0) val += MOD;
return *this;
}
static unsigned fast_mod(uint64_t first, unsigned m = MOD) {
return first % m;
unsigned x_high = first >> 32, x_low = (unsigned)first;
unsigned quot, rem;
asm("divl %4\n" : "=a"(quot), "=d"(rem) : "d"(x_high), "a"(x_low), "r"(m));
return rem;
}
mod_int &operator*=(const mod_int &other) {
val = fast_mod((uint64_t)val * other.val);
return *this;
}
mod_int &operator/=(const mod_int &other) { return *this *= other.inv(); }
friend mod_int operator+(const mod_int &a, const mod_int &b) {
return mod_int(a) += b;
}
friend mod_int operator-(const mod_int &a, const mod_int &b) {
return mod_int(a) -= b;
}
friend mod_int operator*(const mod_int &a, const mod_int &b) {
return mod_int(a) *= b;
}
friend mod_int operator/(const mod_int &a, const mod_int &b) {
return mod_int(a) /= b;
}
mod_int &operator++() {
val = val == MOD - 1 ? 0 : val + 1;
return *this;
}
mod_int &operator--() {
val = val == 0 ? MOD - 1 : val - 1;
return *this;
}
mod_int operator++(int32_t) {
mod_int before = *this;
++*this;
return before;
}
mod_int operator--(int32_t) {
mod_int before = *this;
--*this;
return before;
}
mod_int operator-() const { return val == 0 ? 0 : MOD - val; }
bool operator==(const mod_int &other) const { return val == other.val; }
bool operator!=(const mod_int &other) const { return val != other.val; }
mod_int inv() const { return mod_inv(val); }
mod_int pow(long long p) const {
assert(p >= 0);
mod_int a = *this, result = 1;
while (p > 0) {
if (p & 1) result *= a;
a *= a;
p >>= 1;
}
return result;
}
friend ostream &operator<<(ostream &stream, const mod_int &m) {
return stream << m.val;
}
friend istream &operator>>(istream &stream, mod_int &m) {
return stream >> m.val;
}
};
const long long N = 1e5 + 5;
vector<long long> g[N], in[N], out[N];
mod_int p[N];
pair<long long, long long> dp[4 * N][22];
long long te = 0, temp = 0;
long long tin[N], LOG[4 * N], dep[N];
mod_int last = 1;
void dfs(long long u, long long p) {
dep[u] = dep[p] + 1;
te++;
tin[u] = te;
dp[te][0] = {dep[u], u};
for (auto i : g[u]) {
if (i != p) {
dfs(i, u);
te++;
dp[te][0] = {dep[u], u};
}
}
}
long long lca(long long u, long long v) {
long long l = min(tin[u], tin[v]);
long long r = max(tin[u], tin[v]);
long long j = LOG[r - l + 1];
pair<long long, long long> p = min(dp[l][j], dp[r - (1 << j) + 1][j]);
return p.second;
}
long long dis(long long u, long long v) {
return dep[u] + dep[v] - 2 * dep[lca(u, v)];
}
long long ctree[N];
long long sz[N];
long long vis[N];
mod_int dp1[N], dp2[N];
mod_int dp3[N], dp4[N];
void dfs1(long long u, long long par) {
sz[u] = 1;
temp++;
for (auto i : g[u]) {
if (i != par && !vis[i]) {
dfs1(i, u);
sz[u] += sz[i];
}
}
}
long long dfs2(long long u, long long par) {
for (auto i : g[u]) {
if (i != par && sz[i] > temp / 2 && !vis[i]) {
return dfs2(i, u);
}
}
return u;
}
void decompose(long long u, long long par) {
temp = 0;
dfs1(u, u);
long long centroid = dfs2(u, u);
ctree[centroid] = par;
vis[centroid] = 1;
for (auto i : g[centroid]) {
if (vis[i]) continue;
decompose(i, centroid);
}
}
mod_int t = 0;
void insert(long long u) {
t += p[u] * dp1[u];
dp2[u] += p[u];
long long i = u;
while (ctree[i] > 0) {
long long par = ctree[i];
mod_int d = dis(u, par);
t = t + d * p[u] * (dp2[par] - dp4[i]) + p[u] * (dp1[par] - dp3[i]);
dp2[par] += p[u], dp4[i] += p[u];
dp1[par] += p[u] * d, dp3[i] += p[u] * d;
i = ctree[i];
}
}
void remove(long long u) {
long long i = u;
t -= p[u] * dp1[u];
dp2[u] -= p[u];
while (ctree[i] > 0) {
long long par = ctree[i];
mod_int d = dis(u, par);
dp2[par] -= p[u];
dp4[i] -= p[u];
dp1[par] -= p[u] * d;
dp3[i] -= p[u] * d;
t = t - d * p[u] * (dp2[par] - dp4[i]) - p[u] * (dp1[par] - dp3[i]);
i = ctree[i];
}
}
long long solve() {
long long n;
cin >> n;
long long mx = 0;
for (long long i = 1; i < n + 1; i++) {
long long l;
long long r;
cin >> l >> r;
in[l].push_back(i), out[r].push_back(i);
mod_int val = r - l + 1;
p[i] = val.inv();
last *= val;
maxs(mx, r);
}
for (long long i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1, 1);
mod_int ans = 0;
for (long long j = 1; j <= 20; j++) {
for (long long i = 1; i + (1 << (j - 1)) <= te; i++) {
dp[i][j] = min(dp[i][j - 1], dp[i + (1 << (j - 1))][j - 1]);
}
}
decompose(1, 0);
for (long long i = 1; i <= mx; i++) {
for (auto j : in[i]) {
insert(j);
}
ans += t;
for (auto j : out[i]) {
remove(j);
}
}
cout << ans * last << "\n";
return 0;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
for (long long i = 2; i < 4 * N; i++) {
LOG[i] = 1 + LOG[i / 2];
}
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int t;
std::cin >> t;
while (t--) {
std::set<int> all;
int n;
std::cin >> n;
while (n--) {
int tmp;
std::cin >> tmp;
while ((tmp & 1) == 0) {
all.insert(tmp);
tmp >>= 1;
}
}
printf("%d\n", (int)all.size());
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct RMQ {
vector<vector<pair<int, int>>> d;
RMQ(vector<int>& A) : d(A.size(), vector<pair<int, int>>(20)) {
int n = A.size();
for (int i = 0; i < n; ++i) d[i][0] = {A[i], i};
for (int j = 1; (1 << j) <= n; ++j) {
for (int i = 0; i + (1 << j) - 1 < n; ++i) {
d[i][j] = max(d[i][j - 1], d[i + (1 << (j - 1))][j - 1]);
}
}
}
pair<int, int> query(int L, int R) {
int k = 0;
while ((1 << (k + 1)) <= R - L + 1) ++k;
return max(d[L][k], d[R - (1 << k) + 1][k]);
}
vector<pair<int, int>>& operator[](int x) { return d[x]; }
};
long long divide_and_conquer(RMQ& rmq, int l, int r) {
if (l == r)
return rmq[l][0].first;
else if (r < l)
return 0;
else {
auto p = rmq.query(l, r);
auto val = p.first;
auto pos = p.second;
return divide_and_conquer(rmq, l, pos - 1) +
(long long)(pos - l + 1) * (r - pos + 1) * val +
divide_and_conquer(rmq, pos + 1, r);
}
}
int main() {
int n, q;
while (scanf("%d%d", &n, &q) == 2) {
vector<int> arr(n);
for (auto& x : arr) scanf("%d", &x);
vector<int> tmp(n - 1);
for (int i = 1; i < n; ++i) {
tmp[i - 1] = abs(arr[i] - arr[i - 1]);
}
RMQ rmq(tmp);
while (q--) {
int a, b;
scanf("%d%d", &a, &b);
--a;
--b;
cout << divide_and_conquer(rmq, a, b - 1) << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int d1, d2, d3;
cin >> d1 >> d2 >> d3;
long long int min1 = LONG_MAX;
min1 = min(2 * (d1 + d2), 2 * (d1 + d3));
min1 = min(min1, 2 * (d2 + d3));
min1 = min(min1, d1 + d2 + d3);
cout << min1 << endl;
return 0;
}
| 1 |
#include <iostream>
#include <vector>
#include <map>
using namespace std;
int main(void) {
int num, a, b, i, k = 0, sum = 0;
long long H, W, ss;
cin >> H >> W >> num;
ss = (H - 2) * (W - 2);
vector<pair<int, int>> list(9 * num);
vector<int> ans(10, 0);
map<pair<int, int>, int> mp;
pair<int, int> p;
for (i = 0; i < num; i++) {
scanf("%d%d", &a, &b);
for (int j = -1; j < 2; j++) {
for (int l = -1; l < 2; l++) {
p = make_pair(a + j, b + l);
if (mp[p] == 0)
list[k++] = p;
mp[p]++;
}
}
}
for (i = 0; i < 9 * num; i++) {
if (list[i].first > 1 && list[i].first < H && list[i].second > 1 && list[i].second < W) {
ans[mp[list[i]]]++;
sum++;
}
}
cout << ss - sum << "\n";
for (i = 1; i < 10; i++)
cout << ans[i] << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int N = 100010;
int crivo[30], t, v[20];
map<pair<int, int>, int> aux;
void sieve() {
for (int i = 2; i < 30; i++) {
if (!crivo[i]) {
crivo[i] = i;
for (int j = i * i; j < 30; j += i) {
crivo[j] = i;
}
}
}
}
long long comb(int top, int bot) {
if (aux.count(make_pair(top, bot))) return aux[make_pair(top, bot)];
map<int, int> mapa;
for (int i = top; i > max(bot, top - bot); i--) {
int k = i;
while (k > 1) {
mapa[crivo[k]]++;
k /= crivo[k];
}
}
for (int i = 1; i <= min(bot, top - bot); i++) {
int k = i;
while (k > 1) {
mapa[crivo[k]]--;
k /= crivo[k];
}
}
long long tot = 1;
for (auto it : mapa) {
for (int k = 0; k < it.second; k++) tot *= it.first;
}
return aux[make_pair(top, top - bot)] = tot;
}
int vis[50][20], viscnt;
long long dp[50][20];
long long solve1(int n, int at) {
if (n < 0) return 0;
if (at == 16) return (n ? 0 : 1);
if (vis[n][at] == viscnt) return dp[n][at];
vis[n][at] = viscnt;
long long ret = solve1(n, at + 1);
for (int i = 1; i <= t - v[at] and i <= (!at ? n - 1 : n); i++) {
if (!at)
ret += comb(n - 1, i) * solve1(n - i, at + 1);
else
ret += comb(n, i) * solve1(n - i, at + 1);
}
return dp[n][at] = ret;
}
long long solve(int n, int at) {
if (n < 0) return 0;
if (at == 16) return (n ? 0 : 1);
if (vis[n][at] == viscnt) return dp[n][at];
vis[n][at] = viscnt;
long long ret = solve(n, at + 1);
for (int i = 1; i <= t - v[at]; i++) {
ret += comb(n, i) * solve(n - i, at + 1);
}
return dp[n][at] = ret;
}
int s[N];
int n;
void converte(long long value) {
vector<int> v;
while (value) {
v.push_back(value % 16);
value /= 16;
}
n = v.size();
for (int i = 0; i < n; i++) {
s[i] = v[i];
}
}
long long f(long long mid) {
converte(mid);
memset(v, 0, sizeof v);
long long tot = 0;
for (int i = n - 1; i >= 1; i--) {
++viscnt;
tot += solve1(i, 0);
}
for (int i = n - 1; i >= 0; i--) {
for (int j = (i == n - 1 ? 1 : 0); j < s[i]; j++) {
v[j]++;
if (v[j] > t) {
v[j]--;
continue;
}
++viscnt;
tot += solve(i, 0);
v[j]--;
}
v[s[i]]++;
if (v[s[i]] > t) break;
}
for (int k = 0; k < 16; k++) {
if (v[k] > t) {
return tot;
}
}
return tot + 1;
}
int main(void) {
sieve();
int m;
cin >> m >> t;
long long tot = 0;
long long lo = 1, hi = 800000000000LL, ans = -1;
while (lo <= hi) {
long long mid = (hi + lo) / 2;
if (f(mid) >= m) {
ans = mid;
hi = mid - 1;
} else {
lo = mid + 1;
}
}
converte(ans);
for (int i = n - 1; i >= 0; i--) {
if (s[i] >= 10) {
printf("%c", s[i] - 10 + 'a');
} else {
printf("%c", s[i] + '0');
}
}
return 0;
}
| 6 |
/*
もう寝よう！
*/
#include <cstdio>
#include <cstring>
#include <cctype>
#include <vector>
using namespace std;
#define B1 (810893ULL)
#define B2 (65521ULL)
#define MOD (4294967291ULL)
typedef unsigned long long int ULLI;
int w;
int h;
int p;
int len;
int ans;
char buf[200];
ULLI line[100];
ULLI lhash[1000][1000];
ULLI sqhash[1000][1000];
bool tmpvec[100][100];
bool pattern[100][100];
bool image[1000][1000];
bool used[1000][1000];
void append(bool *v, int &idx, int k) {
for (int i=5; i>=0; i--) {
int t = (k >> i) & 1;
v[idx++] = t;
}
}
void input(bool *vecs, int length, int w, int h) {
for (int i=0; i<h; i++) {
int idx = 0;
scanf("%s", buf);
len = strlen(buf);
for (int j=0; j<len; j++) {
if (isupper(buf[j])) {
append(vecs+length*i, idx, buf[j]-'A');
} else if (islower(buf[j])) {
append(vecs+length*i, idx, buf[j]-'a' + 26);
} else if (isdigit(buf[j])) {
append(vecs+length*i, idx, buf[j]-'0' + 52);
} else if (buf[j] == '+') {
append(vecs+length*i, idx, 62);
} else if (buf[j] == '/') {
append(vecs+length*i, idx, 63);
}
}
}
}
void rotate() {
for (int i=0; i<p; i++) {
for (int j=0; j<p; j++) {
tmpvec[p-1-j][i] = pattern[i][j];
}
}
for (int i=0; i<p; i++) {
for (int j=0; j<p; j++) {
pattern[i][j] = tmpvec[i][j];
}
}
}
void mirror() {
for (int i=0; i<p; i++) {
for (int j=0; j<p; j++) {
tmpvec[p-1-i][j] = pattern[i][j];
}
}
for (int i=0; i<p; i++) {
for (int j=0; j<p; j++) {
pattern[i][j] = tmpvec[i][j];
}
}
}
void count() {
ULLI hash = 0ULL;
int ret = 0;
for (int i=0; i<p; i++) {
line[i] = 0ULL;
for (int j=0; j<p; j++) {
line[i] = (line[i]*B1 + (ULLI)pattern[i][j]) % MOD;
}
hash = (hash*B2 + line[i]) % MOD;
}
for (int i=0; i<=h-p; i++) {
for (int j=0; j<=w-p; j++) {
if (sqhash[i][j] == hash && !used[i][j]) {
++ans;
used[i][j] = true;
}
}
}
}
int main() {
while (1) {
scanf("%d%d%d", &w, &h, &p);
if (w == 0 && h == 0 && p == 0) return 0;
input((bool*)image, 1000, w, h);
input((bool*)pattern, 100, p, p);
if (w < p || h < p) {
puts("0");
continue;
}
for (int i=0; i<h; i++) {
for (int j=0; j<w; j++) {
lhash[i][j] = 0ULL;
sqhash[i][j] = 0ULL;
}
}
for (int i=0; i<h; i++) {
ULLI sub = 1ULL;
for (int j=0; j<p; j++) {
lhash[i][0] = (lhash[i][0]*B1 + (ULLI)image[i][j]) % MOD;
sub = (sub*B1) % MOD;
}
for (int j=p; j<w; j++) {
lhash[i][j-p+1] = (lhash[i][j-p]*B1 + (ULLI)image[i][j]) % MOD;
lhash[i][j-p+1] = (lhash[i][j-p+1]+MOD - sub*(ULLI)image[i][j-p]%MOD)%MOD;
}
}
for (int j=0; j<=w-p; j++) {
ULLI sub = 1ULL;
for (int i=0; i<p; i++) {
sqhash[0][j] = (sqhash[0][j]*B2 + (ULLI)lhash[i][j]) % MOD;
sub = (sub*B2) % MOD;
}
for (int i=p; i<h; i++) {
sqhash[i-p+1][j] = (sqhash[i-p][j]*B2 + (ULLI)lhash[i][j]) % MOD;
sqhash[i-p+1][j] = (sqhash[i-p+1][j]+MOD - sub*(ULLI)lhash[i-p][j]%MOD)%MOD;
}
}
ans = 0;
for (int i=0; i<h; i++) {
for (int j=0; j<w; j++) {
used[i][j] = false;
}
}
for (int i=0; i<4; i++) {
count();
rotate();
}
mirror();
for (int i=0; i<4; i++) {
count();
rotate();
}
printf("%d\n", ans);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, a[((long long)105)], sum, ans, maxi;
long long calc(long long x) {
long long res = 0;
for (int i = 0; i < n; i++) res += ((a[i] + x - 1) / x) * x - a[i];
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i], sum += a[i], maxi = max(maxi, a[i]);
if (maxi * n - sum <= k) return cout << maxi + (k - (maxi * n - sum)) / n, 0;
for (int i = 1; i <= ((long long)600 * 1000); i++)
if (calc(i) <= k) ans = max(ans, (long long)i);
for (int j = n + 1; j <= ((long long)600 * 1000); j++) {
long long ex = (sum + k) / j;
if (!ex) break;
if (calc(ex) <= k) ans = max(ans, (long long)ex);
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
int t, n, son[maxn];
vector<pair<int, int> > g[maxn];
long long ans = 0, res = 0;
void dfs(int u, int fa, int w) {
son[u] = 1;
for (auto it : g[u]) {
if (it.first == fa) continue;
dfs(it.first, u, it.second);
son[u] += son[it.first];
}
if (son[u] % 2 == 1) ans += w;
res += 1ll * w * min(son[u], 2 * n - son[u]);
}
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
ans = 0, res = 0;
for (int i = 1; i <= 2 * n; i++) g[i].clear();
for (int i = 1; i < 2 * n; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
g[x].push_back(pair<int, int>(y, z));
g[y].push_back(pair<int, int>(x, z));
}
dfs(1, 0, 0);
printf("%lld %lld\n", ans, res);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int tc, bil, res, temp;
vector<long long int> all;
cin >> tc;
for (int i = 1; i <= tc; i += 1) {
cin >> bil;
cout << fixed << setprecision(0);
cout << powl(2, __builtin_popcount(bil)) << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, u[100005], v[100005], c[100005], R, L, d[100005], o[100005], on;
vector<int> E[100005], ans;
queue<int> Q;
bool check(int x) {
for (int i = 1; i <= n; i++) d[i] = 0, E[i].clear();
for (int i = 1; i <= m; i++)
if (c[i] > x) E[u[i]].push_back(v[i]), d[v[i]]++;
for (int i = 1; i <= n; i++)
if (d[i] == 0) Q.push(i);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (int j : E[u])
if (--d[j] == 0) Q.push(j);
}
for (int i = 1; i <= n; i++)
if (d[i] > 0) return false;
return true;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++)
scanf("%d%d%d", &u[i], &v[i], &c[i]), R = max(R, c[i]);
while (L < R)
if (check((L + R >> 1)))
R = (L + R >> 1);
else
L = (L + R >> 1) + 1;
for (int i = 1; i <= n; i++) E[i].clear(), d[i] = 0;
for (int i = 1; i <= m; i++)
if (c[i] > L) E[u[i]].push_back(v[i]), d[v[i]]++;
for (int i = 1; i <= n; i++)
if (d[i] == 0) Q.push(i), o[i] = ++on;
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (int j : E[u])
if (--d[j] == 0) Q.push(j), o[j] = ++on;
}
for (int i = 1; i <= m; i++)
if (c[i] <= L && o[u[i]] > o[v[i]]) ans.push_back(i);
printf("%d %d\n", L, ans.size());
for (auto i : ans) printf("%d ", i);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(void){
int n;
cin >> n;
cout << (180*(n-2)) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int t, n;
char s[5005];
int dp[5005];
int a[5005][5005];
int ans;
void sol() {
cin >> n;
scanf("%s ", s + 1);
ans = n;
for (int i = 1; i <= n + 1; ++i)
for (int j = i + 1; j <= n + 1; ++j) a[i][j] = 0;
s[n + 1] = 'a' - 1;
for (int i = n; i >= 1; --i)
for (int j = i + 1; j <= n; ++j)
if (s[i] != s[j])
a[i][j] = 0;
else
a[i][j] = a[i + 1][j + 1] + 1;
dp[1] = n;
for (int i = 2; i <= n; ++i) {
dp[i] = n - i + 1;
for (int j = 1; j < i; ++j) {
int k = a[j][i];
if (s[i + k] - 'a' > s[j + k] - 'a')
dp[i] = max(dp[i], dp[j] + n - i + 1 - k);
}
ans = max(ans, dp[i]);
}
printf("%d\n", ans);
}
int main() {
cin >> t;
while (t--) sol();
}
| 5 |
#include <cstdio>
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <limits>
#include <climits>
#include <cfloat>
#include <functional>
using namespace std;
class Edge
{
public:
int to, cost;
Edge(int to0, int cost0){
to = to0;
cost = cost0;
}
};
int main()
{
int n, m, k, p;
cin >> n >> m >> k >> p;
vector<vector<Edge> > edges(n+1);
for(int i=0; i<m; ++i){
int x, y, w;
cin >> x >> y >> w;
edges[x].push_back(Edge(y, w));
edges[y].push_back(Edge(x, w));
}
vector<int> mail(n+1, -1), delivery(n+1, -1);
for(int i=0; i<k; ++i){
int s, t;
cin >> s >> t;
mail[s] = i;
delivery[t] = i;
}
vector<vector<vector<int> > > dp(n+1, vector<vector<int> >(1<<k, vector<int>(1<<k, INT_MAX)));
multimap<int, tuple<int, int, int> > mm;
dp[p][0][0] = 0;
mm.insert(make_pair(0, make_tuple(p, 0, 0)));
while(!mm.empty()){
int cost = mm.begin()->first;
int curr, isMail, isDelivery;
tie(curr, isMail, isDelivery) = mm.begin()->second;
mm.erase(mm.begin());
if(dp[curr][isMail][isDelivery] < cost)
continue;
for(const Edge& e : edges[curr]){
int to = e.to;
int cost2 = cost + e.cost;
int isMail2 = isMail;
int isDelivery2 = isDelivery;
if(mail[to] != -1)
isMail2 |= 1 << mail[to];
if((isMail2 & (1 << delivery[to])) && delivery[to] != -1)
isDelivery2 |= 1 << delivery[to];
if(cost2 < dp[to][isMail2][isDelivery2]){
dp[to][isMail2][isDelivery2] = cost2;
mm.insert(make_pair(cost2, make_tuple(to, isMail2, isDelivery2)));
}
}
}
int ans = INT_MAX;
for(int i=1; i<=n; ++i)
ans = min(ans, dp[i].back().back());
if(ans < INT_MAX)
cout << ans << endl;
else
cout << "Cannot deliver" << endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;cin>>n;
cout<<(n+1)/2*(n/2);
}
| 0 |
#include <bits/stdc++.h>
int main() {
int n, b;
scanf("%d %d\n", &n, &b);
std::vector<int> price(n);
for (int p = 0; p < n; p++) {
scanf("%d\n", &price[p]);
}
int ans(b);
for (int u = 0; u < n; u++) {
for (int v = u + 1; v < n; v++) {
int candidate = b - (b / price[u]) * price[u] + (b / price[u]) * price[v];
if (candidate > ans) {
ans = candidate;
}
}
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
int xx=0, mx=-1;
for(char x: s){
if(x=='R') xx++;
else { xx=0;}
mx=max(mx, xx);
}
cout<<(mx ==-1 ? 0 : mx);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int powm(long long int x, long long int y,
long long int m = 1000000007) {
x = x % m;
long long int res = 1;
while (y) {
if (y & 1) res = res * x;
res %= m;
y = y >> 1;
x = x * x;
x %= m;
}
return res;
}
long long int modi(long long int a, long long int m = 1000000007) {
return powm(a, m - 2, m);
}
void pre() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int32_t main() {
pre();
long long int test;
cin >> test;
while (test--) {
long long int n;
cin >> n;
long long int ct = n / 4;
if (n % 4 != 0) ct++;
long long int rm = n - ct;
while (rm > 0) {
cout << 9;
rm--;
}
while (ct--) cout << 8;
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1e5 + 1;
const long long MOD = 1e9 + 7;
const long long INF = 1e9;
void solve() {}
int main() {
int i, t, n, x;
int arr[102][102];
set<pair<int, int>> s;
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> arr[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j || (i + j) == (n - 1) || i == ((n - 1) / 2) ||
j == ((n - 1) / 2)) {
s.insert(make_pair(i, j));
}
}
}
int r = 0;
for (auto i : s) {
r += arr[i.first][i.second];
}
cout << r;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int k;
int a[20];
int main() {
scanf("%d", &k);
for (int i = 1; i <= 12; i++) scanf("%d", &a[i]);
sort(a + 1, a + 13);
int sum = 0;
if (sum >= k) {
cout << 0 << endl;
return 0;
}
for (int i = 12; i >= 1; i--) {
sum += a[i];
if (sum >= k) {
cout << 13 - i << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
int a, b, x, y;
cin >> x >> y >> a >> b;
int lcd = x / gcd(x, y) * y;
int ans = b / lcd - (a / lcd - (a % lcd == 0 ? 1 : 0));
cout << ans << endl;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
int main(){
int l,r,d;scanf("%d%d%d",&l,&r,&d);
printf("%d",r/d-(l-1)/d);
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int N = 205;
const int MOD = 1000000007;
int dp[N][3105], a[N], b[N], t[N];
int main() {
int n, l, i, j, k;
scanf("%d%d", &n, &l);
k = n;
for (i = 1; i <= n; i++) {
scanf("%d%d", a + i, b + i);
t[i] = i;
if (a[i] != b[i]) {
a[++k] = b[i];
b[k] = a[i];
t[k] = i;
}
}
n = k;
for (i = 1; i <= n; i++) {
dp[i][a[i]] = 1;
}
for (i = 0; i <= l; i++) {
for (j = 1; j <= n; j++) {
int v = dp[j][i];
if (!v) continue;
for (k = 1; k <= n; k++) {
if (t[k] == t[j]) continue;
if (a[k] == b[j]) dp[k][i + a[k]] = (dp[k][i + a[k]] + v) % MOD;
}
}
}
int r = 0;
for (i = 1; i <= n; i++) r = (r + dp[i][l]) % MOD;
printf("%d\n", r);
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
struct fd {
int ind;
ll typ,del;
bool operator<(const fd& masik) const {
return del<masik.del;
}
};
int main() {
int n,k;
cin>>n>>k;
vector<fd> t(n);
for(int i=0;i<n;++i) {
cin>>t[i].typ>>t[i].del;
t[i].ind=i;
}
sort(t.begin(), t.end());
stack<ll> st; ll szum=0;
vector<int> volt(n+1); ll distinct=0;
ll ans=0;
for(int i=n-1;i>=0;i--) {
if(!volt[t[i].typ]) {
distinct++;
volt[t[i].typ]=1;
szum+=t[i].del;
}else {
st.push(t[i].del);
szum+=t[i].del;
}
while(distinct+(int)st.size()>k && !st.empty()) {
szum-=st.top();
st.pop();
}
if(distinct+(int)st.size()>k) break ;
ans=max(ans, szum+distinct*distinct);
}
cout<<ans<<"\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, m, y;
cin >> n >> x >> m >> y;
if (x == y) {
cout << max(n, m) + 1 << endl;
return 0;
}
if (x > y) {
swap(x, y);
swap(n, m);
}
long long res = 1;
for (int i = 1; i <= n; i++) {
int l = max(y - x - i, i - (y - x) - 1) + 1;
int ll = max(l, 1);
int h = y - x + i;
int hh = min(h, m);
if (hh >= ll) res += hh - ll + 1;
ll++;
h--;
hh = min(h, m);
if (hh >= ll) res += hh - ll + 1;
}
for (int i = 1; i <= n; i++) {
if (x - i < y - m) res++;
}
for (int i = 1; i <= m; i++) {
if (y + i > x + n) res++;
}
cout << res << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
long long n, m;
vector<vector<long long> > a(N);
long long par[N], depth[N];
bool mark[N];
long long S;
vector<long long> order;
void dfs(long long u, long long p) {
par[u] = p;
for (auto v : a[u]) {
if (par[v]) {
if (depth[u] - depth[v] + 1 >= S) {
order.clear();
while (true) {
order.push_back(u);
if (u == v) break;
u = par[u];
}
throw 1;
}
} else {
depth[v] = depth[u] + 1;
dfs(v, u);
}
}
if (!mark[u]) {
order.push_back(u);
mark[u] = true;
for (auto v : a[u]) mark[v] = true;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
S = sqrt(n);
if (S * S < n) S++;
for (long long i = (long long)1; i <= (long long)m; i++) {
long long u, v;
cin >> u >> v;
a[u].push_back(v);
a[v].push_back(u);
}
try {
dfs(1, 1);
} catch (...) {
cout << 2 << '\n';
cout << order.size() << '\n';
for (auto it : order) cout << it << ' ';
cout << '\n';
return 0;
}
cout << 1 << '\n';
for (long long i = (long long)0; i <= (long long)S - 1; i++)
cout << order[i] << ' ';
cout << '\n';
return 0;
}
| 4 |
#include <iostream>
#include <fstream>
#include <stdio.h>
#include <math.h>
#include <time.h>
#include <string>
#include <tuple>
#include <vector>
#include <map>
#include <list>
#include <set>
#include <stack>
#include <queue>
#include <cstdlib>
#include <algorithm>
#include <random>
#include <cassert>
using namespace std;
#define LL long long
#undef INT_MIN
#undef INT_MAX
#define INT_MIN -2147483648
#define INT_MAX 2147483647
#define LL_MIN -9223372036854775808
#define LL_MAX 9223372036854775807
#define segment_size 65536
#define ROOP() while (true)
int main(){
int F;
cin >> F;
cout << (F-30)/2 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout<<#x" = "<<((x))<<endl
template<class T,class U> ostream& operator<<(ostream& o, const pair<T,U> &p){o<<"("<<p.fi<<","<<p.se<<")";return o;}
template<class T> ostream& operator<<(ostream& o, const vector<T> &v){o<<"[";for(T t:v){o<<t<<",";}o<<"]";return o;}
/* 基本要素 */
typedef complex<double> Point;
typedef pair<Point, Point> Line;
typedef vector<Point> VP;
const double PI = acos(-1);
const double EPS = 1e-9; // 許容誤差^2
#define X real()
#define Y imag()
#define LE(n,m) ((n) - (m) < EPS)
#define GE(n,m) (EPS > (m) - (n))
#define EQ(n,m) (abs((n)-(m)) < EPS)
// 点集合を含む最小の円の中心
Point minEnclosingCircle(const VP& ps) {
Point c;
double move = 0.5;
rep(i,30) { // 2^(-39-1) \approx 0.9e-12
rep(t,30) {
double max = 0;
int k = 0;
rep (j, ps.size()) if (max < norm(ps[j]-c)) {
max = norm(ps[j]-c);
k = j;
}
c += (ps[k]-c) * move;
}
move /= 2;
}
return c;
}
Point READ(){
int x,y;
cin >>x >>y;
return Point(x,y);
}
const int N = 14;
const int INF = 19191919;
int dp[1<<N];
int main(){
int n,m;
cin >>n >>m;
VP p(n);
rep(i,n) p[i] = READ();
vector<double> r(1<<n);
for(int mask=1; mask<(1<<n); ++mask){
VP pts;
rep(i,n)if(mask>>i&1) pts.pb(p[i]);
Point c = minEnclosingCircle(pts);
for(Point pp:pts) r[mask] = max(r[mask], abs(pp-c));
}
auto check = [&](double lim){
rep(i,1<<n) dp[i] = INF;
dp[(1<<n)-1] = 0;
for(int mask = (1<<n)-1; mask>0; --mask){
int sub = mask;
do{
sub = sub-1;
sub &= mask;
int tgt = mask^sub;
if(r[tgt] <= lim) dp[sub] = min(dp[sub], dp[mask]+1);
}while(sub>0);
}
return dp[0]<=m;
};
double ng=0, ok = 500000;
rep(loop,100){
double mid = (ng+ok)/2;
if(check(mid)) ok = mid;
else ng = mid;
}
printf("%.10f\n", ok);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
cin >> k;
vector<vector<char>> bus;
for (int i = 0; i < 11; i++) {
vector<char> column;
for (int j = 0; j < 4; j++) column.push_back('#');
bus.push_back(column);
}
for (int i = 0; i < 4 && k > 0; i++) {
bus[0][i] = 'O';
k--;
}
for (int i = 0; k > 0; i++) {
if (i % 4 == 2)
bus[i / 4 + 1][2] = '.';
else {
bus[i / 4 + 1][i % 4] = 'O';
k--;
}
}
for (int i = 1; i < 11; i++) bus[i][2] = '.';
cout << "+------------------------+\n";
for (int j = 0; j < 4; j++) {
cout << '|';
for (int i = 0; i < 11; i++) {
cout << bus[i][j];
cout << '.';
}
if (j != 2)
cout << '|';
else
cout << '.';
if (j == 0)
cout << 'D';
else
cout << '.';
cout << '|';
if (j == 0 || j == 3) cout << ')';
cout << '\n';
}
cout << "+------------------------+";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int N;
int T[100010][4];
set<pair<int, int> > S;
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) {
int v;
scanf("%d", &v);
auto itr = S.insert(make_pair(v, -i)).first;
if (i == 1) continue;
itr++;
if (itr != S.end() && T[(-itr->second)][1] == 0) {
T[i][0] = (itr->first);
T[(-itr->second)][1] = v;
}
itr--;
if (itr != S.begin()) {
itr--;
if (T[(-itr->second)][2] == 0) {
T[i][0] = (itr->first);
T[(-itr->second)][2] = v;
}
}
}
for (int i = 2; i <= N; i++) printf("%d%c", T[i][0], i == N ? '\n' : ' ');
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1000000000")
using ll = long long;
using ld = long double;
using namespace std;
const int MAXN = 3001;
struct node {
int left;
int right;
int parent;
int id;
};
node nodes[MAXN];
int nodec = 1;
bool block[MAXN];
int n;
int sz[MAXN];
int askcount = 0;
int ask(int x, int y, int z) {
assert(++askcount <= 10 * n);
cout << y << " " << z << " " << x << endl;
cout.flush();
string s;
cin >> s;
if (s == "X") return 0;
if (s == "Y") return 1;
if (s == "Z") return 2;
}
void addfrom(int curn, int old) {
int n2 = curn;
int n1 = n + curn - 1;
int oldpar = nodes[old].parent;
nodes[n1] = {old, n2, oldpar, curn};
nodes[n2] = {0, 0, n1, curn};
nodes[old].parent = n1;
if (oldpar != 0) {
if (nodes[oldpar].left == old)
nodes[oldpar].left = n1;
else
nodes[oldpar].right = n1;
}
nodec += 2;
}
bool leav(int x) { return nodes[x].left == 0; }
bool bleav(int x) { return block[x] || leav(x); }
vector<int> visit;
void dfs1(int v) {
if (bleav(v)) {
sz[v] = 1;
return;
}
visit.push_back(v);
sz[v] = 1;
dfs1(nodes[v].left);
dfs1(nodes[v].right);
sz[v] += sz[nodes[v].left];
sz[v] += sz[nodes[v].right];
}
void add(int curid, int curroot) {
if (bleav(curroot)) {
addfrom(curid, curroot);
return;
}
visit.clear();
dfs1(curroot);
int tot = sz[curroot];
int ms = curroot;
for (int i = 0; i < visit.size(); i++) {
int u = visit[i];
if ((sz[u] * 2 >= tot) && (sz[u] < sz[ms])) {
ms = u;
}
}
int f = ask(curid, nodes[nodes[ms].left].id, nodes[nodes[ms].right].id);
block[ms] = true;
if (f == 0) {
add(curid, curroot);
}
if (f == 1) {
add(curid, nodes[ms].right);
}
if (f == 2) {
add(curid, nodes[ms].left);
}
}
int root;
int main() {
ios_base::sync_with_stdio(0);
cout.setf(ios::fixed);
cout.precision(20);
cin >> n;
nodes[nodec++] = node{0, 0, 0, 1};
root = 1;
for (int i = 2; i <= n; i++) {
memset(block, 0, sizeof(block));
block[0] = true;
add(i, root);
while (nodes[root].parent != 0) root = nodes[root].parent;
}
cout << -1 << endl;
nodes[root].parent = -1;
for (int i = 1; i <= 2 * n - 1; i++) cout << nodes[i].parent << " ";
cout << endl;
cout.flush();
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int n;
int udc[3] = {0};
int output;
scanf("%d", &n);
for (int i = 0; i < n + 1; i++) {
udc[2] = i % 100 % 10;
if (i > 9) {
udc[1] = (i % 100) / 10;
if (i > 99) udc[0] = i / 100;
}
if (udc[2] == 4 || udc[2] == 7) {
if (i < 9 && n % i == 0) {
printf("YES");
return 0;
}
if (udc[1] == 4 || udc[1] == 7) {
if (i < 99 && n % i == 0) {
printf("YES");
return 0;
}
if (udc[0] == 4 || udc[0] == 7) {
if (n % i == 0) {
printf("YES");
return 0;
}
}
}
}
}
printf("NO");
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.