solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
int main() {
int t;
scanf("%d", &t);
int i;
for (i = 0; i < t; i++) {
char x[10000];
scanf("%s", x);
char last = x[strlen(x) - 1];
switch (last) {
case 'o':
printf("FILIPINO\n");
break;
case 'u':
printf("JAPANESE\n");
break;
case 'a':
printf("KOREAN\n");
break;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, s, a[N];
int main() {
scanf("%d %d", &n, &s);
--s;
int have = 0, res = 0;
for (int i = (int)0; i <= (int)n - 1; ++i) {
scanf("%d", a + i);
if (a[i] == 0 && i != s) ++have, ++res;
}
int cur = 1;
multiset<int> st;
for (int i = (int)0; i <= (int)n - 1; ++i)
if (a[i] && i - s) st.insert(a[i]);
while (!st.empty() && cur <= *st.rbegin()) {
if (st.count(cur)) {
++cur;
continue;
}
if (have)
--have;
else {
++res;
st.erase(--st.end());
}
++cur;
}
cout << res + (a[s] != 0) << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 10, MAX = 1e6 + 1e4, MOD = 1e9 + 7, MAXL = 25;
void OUT(long double o, int x) {
cout << fixed << setprecision(x) << o;
return;
}
int a[MAX], ans[MAX], dp[MAX], seg[4 * MAX];
vector<pair<int, int> > v[MAX];
map<int, int> last;
void upd(int id, int b, int e, int p) {
if (e - b == 1) {
seg[id] ^= a[b];
return;
}
int mid = (b + e) / 2;
if (p < mid)
upd(id * 2, b, mid, p);
else
upd(id * 2 + 1, mid, e, p);
seg[id] = seg[2 * id] ^ seg[2 * id + 1];
return;
}
int geta(int id, int b, int e, int l, int r) {
if (e <= l || r <= b) return 0;
if (l <= b && e <= r) return seg[id];
int mid = (b + e) / 2;
return geta(id * 2, b, mid, l, r) ^ geta(id * 2 + 1, mid, e, l, r);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), dp[i] = dp[i - 1] ^ a[i];
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
v[y].push_back({x, i});
}
for (int i = 1; i <= n; i++) {
if (last[a[i]] != 0) upd(1, 1, n + 1, last[a[i]]);
last[a[i]] = i;
upd(1, 1, n + 1, i);
for (pair<int, int> j : v[i])
ans[j.second] =
dp[i] ^ dp[j.first - 1] ^ geta(1, 1, n + 1, j.first, i + 1);
}
for (int i = 0; i < m; i++) printf("%d\n", ans[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T Abs(T a) {
return a > 0 ? a : -a;
}
void split(string s, string seps, vector<string> &res, bool doEmpty = false) {
int start = 0;
res.clear();
for (int i = 0; i < s.size(); i++) {
if (seps.find(s[i]) != string::npos) {
if (doEmpty || i - start > 0) res.push_back(s.substr(start, i - start));
start = i + 1;
}
}
if (doEmpty || s.size() - start > 0)
res.push_back(s.substr(start, s.size() - start));
}
string Union(vector<string> s, int start = 0) {
string res;
for (int i = start; i < s.size(); i++) res.append(s[i]);
return res;
}
int main() {
int n;
long long k;
cin >> n >> k;
vector<long long> a(n);
vector<long long> aa(n);
long long sum = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
aa[i] = a[i];
sum += a[i];
}
sort(aa.begin(), aa.end());
int curmin = 0;
long long s = 0;
long long cur = 0;
int res = -1;
int ind = 0;
bool tt = false;
if (sum < k) {
cout << "-1";
return 0;
}
while (!tt && ind < n && k > 0) {
long long m = aa[ind];
long long mm = (m - curmin);
if (mm * (n - ind) > k) {
mm = k / (n - ind);
tt = true;
}
if (mm > 0) {
k -= mm * (n - ind);
curmin += mm;
if (!tt)
while (ind < n && aa[ind] == curmin) ind++;
}
}
if (ind < n) {
curmin++;
int i = 0;
int is = -1;
if (k > 0) {
for (; i < n && k > 0; i++)
if (a[i] >= curmin) k--;
is = i;
if (i == n) i = 0;
}
for (int j = 0; j < n; j++, i = (i + 1) % n)
if (a[i] >= curmin + (i < is)) printf("%d ", (i + 1));
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[200005];
vector<pair<int, int> > b;
int n, t;
int cnt[200005];
bool p[200005];
bool check(int k) {
int res = 0;
for (int i = 0; i <= (int)b.size() - 1; ++i) {
res += b[i].first / k;
if (res >= t) return 1;
}
return 0;
}
int main() {
scanf("%d%d", &n, &t);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) ++cnt[a[i]];
for (int i = 1; i <= n; ++i)
if (!p[a[i]]) b.push_back(make_pair(cnt[a[i]], a[i])), p[a[i]] = 1;
sort(b.begin(), b.end(), greater<pair<int, int> >());
int l = 0;
int r = (n / t) + 1;
while (l + 1 < r) {
int m = (l + r) / 2;
if (check(m))
l = m;
else
r = m;
}
for (int i = 0; i <= b.size() - 1; ++i) {
while (b[i].first >= l) {
printf("%d ", b[i].second);
b[i].first -= l;
--t;
if (!t) return 0;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int p = 1;
int count = 0;
vector<int> res;
while (n) {
int x = n % 10;
if (x != 0) {
res.push_back(x * p);
count++;
}
p *= 10;
n /= 10;
}
cout << count << endl;
for (int i = 0; i < res.size(); i++) {
cout << res[i] << " ";
}
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 3e5 + 10;
int n, m;
vector<int> vec[mx];
char ns[mx];
int dep[mx], sz[mx], a[mx], b[mx][26], cnt;
pair<int, int> tp[mx];
void dfs2(int u, int rt, int d) {
for (int v : vec[u]) {
if (b[rt][ns[v] - 'a'])
dfs2(v, b[rt][ns[v] - 'a'], d), ++a[d];
else {
b[rt][ns[v] - 'a'] = v;
tp[++cnt] = make_pair(rt, ns[v] - 'a');
}
}
}
void dfs(int u) {
sz[u] = 1;
int rt = 0;
for (int v : vec[u]) {
dep[v] = dep[u] + 1;
dfs(v);
sz[u] += sz[v];
if (sz[rt] < sz[v]) {
rt = v;
}
}
cnt = 0;
for (int v : vec[u]) {
if (v != rt) {
dfs2(v, rt, dep[v]);
}
}
for (int i = 1; i <= cnt; ++i) {
b[tp[i].first][tp[i].second] = 0;
}
}
int main() {
int u, v;
char s[2];
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
scanf("%d%d%s", &u, &v, s);
vec[u].push_back(v);
ns[v] = s[0];
b[u][s[0] - 'a'] = v;
}
dep[1] = 0, sz[0] = -0x3f3f3f3f;
dfs(1);
for (int i = 1; i <= n; ++i) {
++a[dep[i]];
}
int ans = n, res = 0;
for (int i = 1; i <= n && a[i]; ++i) {
if (n - a[i] < ans) {
ans = n - a[i], res = i;
}
}
printf("%d\n%d\n", ans, res);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF32M = 0x3f3f3f3f;
const long long INF64M = 0x3f3f3f3f3f3f3f3f;
int main() {
ios::sync_with_stdio(false);
int n, i, flag = 0;
cin >> n;
string s;
cin >> s;
int m = s.size();
for (i = 0; i < m - 1; i++)
if (s[i] != s[i + 1]) {
flag = 1;
break;
}
if (flag)
cout << "YES" << endl << s[i] << s[i + 1] << endl;
else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const double eps = 1e-8;
const int N = 2005;
struct node {
double x, y, k;
int px, py;
} a[N * N];
double mid_x, mid_y;
int n, x[N], y[N], ans, k, t, p[N], die[N], X[N], Y[N], cnt, lst, pos;
bool cmp(const node &A, const node &B) { return A.k < B.k; }
bool operator==(const node &A, const node &B) { return A.x * B.y == A.y * B.x; }
bool check(int x, double b1, double b2) {
double dx = mid_y - Y[x], dy = -mid_x + X[x];
return fabs(dy * b1 - b2 * dx) < eps;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d%d", &x[i], &y[i]), mid_x += x[i], mid_y += y[i];
mid_x /= n;
mid_y /= n;
for (int i = 1; i < n; i++)
if (!die[i])
for (int j = i + 1; j <= n; j++)
if (!die[j] && fabs(x[i] + x[j] - 2 * mid_x) < eps &&
fabs(y[i] + y[j] - 2 * mid_y) < eps) {
die[i] = die[j] = 1;
break;
}
for (int i = 1; i <= n; i++)
if (!die[i]) X[++t] = x[i], Y[t] = y[i];
if (t < 2) return puts("-1"), 0;
for (int i = 1; i < t; i++)
for (int j = i + 1; j <= t; j++) {
double dx = mid_y - (Y[i] + Y[j]) / 2.0,
dy = -mid_x + (X[i] + X[j]) / 2.0;
if (dx < 0) dx = -dx, dy = -dy;
if (dx == 0) dy = fabs(dy);
if (dy == 0) dx = fabs(dx);
a[++cnt].x = dx, a[cnt].y = dy;
a[cnt].px = i;
a[cnt].py = j;
a[cnt].k = atan2(dy, dx);
}
sort(a + 1, a + cnt + 1, cmp);
lst = 1;
for (int i = 1; i <= cnt; i++)
if (i == cnt || !(a[i] == a[i + 1])) {
if (i - lst + 1 >= t / 2) {
for (int j = 1; j <= t; j++) p[j] = 1;
for (; lst <= i; lst++)
if (p[a[lst].px] && p[a[lst].py]) p[a[lst].px] = p[a[lst].py] = 0;
pos = 0;
for (int j = 1; j <= t; j++)
if (p[j]) pos = j;
if (!pos || check(pos, a[i].x, a[i].y)) ans++;
}
lst = i + 1;
}
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using ld = double;
using namespace std;
const double eps = (1e-12);
const int INF = 2e9 + 9;
const int logn = 21;
const double pi = acos(-1.0);
long long dep[200005];
long long father[200005];
long long vis[200005];
vector<vector<long long> > g(200005);
long long flag = 0;
map<long long, long long> mp;
void dfs(long long u) {
if (vis[u]) return;
vis[u] = true;
bool leaf = true;
for (long long i = 0; i < g[u].size(); i++) {
long long v = g[u][i];
if (!vis[v]) {
dep[v] = dep[u] + 1;
dfs(v);
leaf = false;
}
}
if (leaf) {
flag = dep[u] % 2;
}
}
long long nums[200005];
signed main() {
long long n;
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) scanf("%lld", &nums[i]);
for (long long i = 2; i <= n; i++) {
long long p;
scanf("%lld", &p);
father[i] = p;
g[i].push_back(p);
g[p].push_back(i);
}
dfs(1);
long long sum = 0;
long long cnt = 0;
for (long long i = 1; i <= n; i++) {
if (dep[i] % 2 == flag) {
sum = sum ^ nums[i];
cnt++;
} else {
mp[nums[i]]++;
}
}
long long ans = 0;
if (sum == 0) ans += cnt * (cnt - 1) / 2 + (n - cnt) * (n - cnt - 1) / 2;
for (long long i = 1; i <= n; i++) {
if (dep[i] % 2 == flag) {
sum = sum ^ nums[i];
ans += mp[sum];
sum = sum ^ nums[i];
}
}
printf("%lld", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, m, w, h;
long long a[100005], p = 1;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
cin >> m;
for (int i = 0; i < m; i++)
cin >> w >> h, p = max(p, a[w - 1]) + h, cout << p - h << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[1 << 16], *S, *T;
if (S == T) {
T = (S = buf) + fread(buf, 1, 1 << 16, stdin);
if (T == S) return EOF;
}
return *S++;
}
inline int read() {
int x = 0, f = 1;
char ch = gc();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = gc();
}
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = gc();
return x * f;
}
int n, K, m, fa[100010];
bool e[100010][6];
inline int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
struct node {
int l[6], r[6], tot, R, L;
node() {
memset(l, 0, sizeof(l));
memset(r, 0, sizeof(r));
}
friend node operator+(node a, node b) {
node res;
res.tot = a.tot + b.tot;
res.R = b.R;
res.L = a.L;
int lena = a.R - a.L + 1, lenb = b.R - b.L + 1;
for (int i = 1; i <= K; ++i)
fa[a.l[i]] = a.l[i], fa[a.r[i]] = a.r[i], fa[b.l[i]] = b.l[i],
fa[b.r[i]] = b.r[i];
if (lena < K && lenb < K) {
for (int i = 1; i <= lena; ++i) {
int x = a.L + i - 1;
for (int j = 1; j <= lenb; ++j) {
int y = b.L + j - 1;
if (y - x > K) break;
if (!e[x][y - x]) continue;
int xx = find(a.r[i]), yy = find(b.l[j]);
if (xx != yy) fa[xx] = yy, --res.tot;
}
}
for (int i = 1; i <= lena; ++i) res.l[i] = find(a.l[i]);
for (int i = 1; i + lena <= K && i <= lenb; ++i)
res.l[i + lena] = find(b.l[i]);
int mx = min(lena + lenb, K);
for (int i = lenb; i >= 1; --i) res.r[mx--] = find(b.r[i]);
for (int i = lena; i >= 1 && mx; --i) res.r[mx--] = find(a.r[i]);
return res;
}
if (lena < K) {
for (int i = 1; i <= lena; ++i) {
int x = a.L + i - 1;
for (int j = 1; j <= K; ++j) {
int y = b.L + j - 1;
if (y - x > K) break;
if (!e[x][y - x]) continue;
int xx = find(a.r[i]), yy = find(b.l[j]);
if (xx != yy) fa[xx] = yy, --res.tot;
}
}
for (int i = 1; i <= lena; ++i) res.l[i] = find(a.l[i]);
for (int i = 1; i + lena <= K; ++i) res.l[i + lena] = find(b.l[i]);
for (int i = 1; i <= K; ++i) res.r[i] = find(b.r[i]);
return res;
}
if (lenb < K) {
for (int i = 1; i <= K; ++i) {
int x = a.R - (K - i);
for (int j = 1; j <= lenb; ++j) {
int y = b.L + j - 1;
if (y - x > K) break;
if (!e[x][y - x]) continue;
int xx = find(a.r[i]), yy = find(b.l[j]);
if (xx != yy) fa[xx] = yy, --res.tot;
}
}
for (int i = 1; i <= K; ++i) res.l[i] = find(a.l[i]);
int mx = K;
for (int i = lenb; i >= 1; --i) res.r[mx--] = find(b.r[i]);
for (int i = K; i >= 1 && mx; --i) res.r[mx--] = find(a.r[i]);
return res;
}
for (int i = 1; i <= K; ++i) {
int x = a.R - (K - i);
for (int j = 1; j <= K; ++j) {
int y = b.L + j - 1;
if (y - x > K) break;
if (!e[x][y - x]) continue;
int xx = find(a.r[i]), yy = find(b.l[j]);
if (xx != yy) fa[xx] = yy, --res.tot;
}
}
for (int i = 1; i <= K; ++i)
res.l[i] = find(a.l[i]), res.r[i] = find(b.r[i]);
return res;
}
} tr[100010 << 2];
inline void build(int p, int l, int r) {
if (l == r) {
tr[p].l[1] = tr[p].r[1] = l;
tr[p].tot = 1;
tr[p].L = l;
tr[p].R = r;
return;
}
int mid = l + r >> 1;
build(p << 1, l, mid);
build(p << 1 | 1, mid + 1, r);
tr[p] = tr[p << 1] + tr[p << 1 | 1];
}
inline node ask(int p, int l, int r, int x, int y) {
if (x <= l && r <= y) return tr[p];
int mid = l + r >> 1;
if (y <= mid) return ask(p << 1, l, mid, x, y);
if (x > mid) return ask(p << 1 | 1, mid + 1, r, x, y);
return ask(p << 1, l, mid, x, mid) + ask(p << 1 | 1, mid + 1, r, mid + 1, y);
}
int main() {
n = read();
K = read();
m = read();
while (m--) {
int x = read(), y = read();
if (x > y) swap(x, y);
e[x][y - x] = 1;
}
build(1, 1, n);
m = read();
while (m--) {
int l = read(), r = read();
printf("%d\n", ask(1, 1, n, l, r).tot);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
stack<int> st;
char s[2];
char ss[100005 * 2];
int main() {
int n;
scanf("%d", &n);
int cnt = 0;
for (int i = 0; i < (n << 1); i++) {
scanf("%s", s);
ss[i] = s[0];
if (s[0] == '+') {
st.push(++cnt);
} else {
if (st.size()) {
int x = st.top();
st.pop();
int y;
scanf("%d", &y);
a[x] = y;
} else {
printf("NO\n");
return 0;
}
}
}
cnt = 0;
for (int i = 0; i < (n << 1); i++) {
if (ss[i] == '+') {
++cnt;
if (st.size()) {
int x = st.top();
if (x < a[cnt]) {
printf("NO\n");
return 0;
}
}
st.push(a[cnt]);
} else {
st.pop();
}
}
printf("YES\n");
for (int i = 1; i <= n; i++) {
printf("%d ", a[i]);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
unsigned int ar[MAXN];
int n;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%u", ar + i);
int best = -1;
unsigned int an[32];
int sm[32] = {0};
memset(an, 0xff, sizeof(an));
for (int i = 0; i < n; i++) {
for (int k = 1 << 30, b = 30; k > 0; (k >>= 1, b--)) {
if (ar[i] & k) {
an[b] &= ar[i];
sm[b]++;
}
}
}
for (int i = 0; i < 31; i++) {
int mask = (1 << i) - 1;
if ((an[i] & (mask)) == 0) best = i;
}
printf("%d\n", sm[best]);
bool f = true;
int bb = 1 << best;
for (int i = 0; i < n; i++)
if (ar[i] & bb)
if (f)
printf("%d", ar[i]), f = false;
else
printf(" %d", ar[i]);
printf("\n");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int modify(int a[], int l, int r) {
if (l == r)
return 0;
else if (a[l] == a[r]) {
for (int i = l + 1; i < r; i++) a[i] = a[l];
return (r - l) / 2;
} else {
int m = (l + r + 1) / 2;
for (int i = l + 1; i < m; i++) a[i] = a[l];
for (int i = m; i < r; i++) a[i] = a[r];
return (r - l - 1) / 2;
}
}
int main() {
int n, i, j;
scanf("%d", &n);
int a[n];
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int ans = 0, lb = 0;
for (i = 0; i < n; i++) {
if (i == n - 1 || a[i] == a[i + 1]) {
ans = max(ans, modify(a, lb, i));
lb = i + 1;
}
}
printf("%d\n", ans);
for (i = 0; i < n; i++) {
printf("%d ", a[i]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> nums(n);
bool possible = true;
for(int i = 0; i < n; ++i) {
cin >> nums[i];
if(nums[i] < 0) {
possible = false;
}
}
if(!possible) {
cout << "NO\n";
return;
}
cout << "YES\n" << 101 << '\n';
for(int i = 0; i <= 100; ++i) {
cout << i << ' ';
}
cout << '\n';
}
int main() {
cin.tie(0); ios_base::sync_with_stdio(0);
// write code here.
int test_cases = 1;
std::cin >> test_cases;
while(test_cases--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int c1, c2, c3, c4, c5, a;
cin >> c1 >> c2 >> c3 >> c4 >> c5;
a = c1 + c2 + c3 + c4 + c5;
if (a > 0 && a % 5 == 0)
cout << a / 5 << endl;
else
cout << "-1" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, Q, cnt, top, head[1000100], vis[1000100], que[1000100 * 2],
lst[1000100 * 4], sta[1000100];
struct point {
int x, y, z, l, r, p;
} q[1000100 * 2];
struct edge {
int x, y, z;
};
struct bcj {
int fa, dis, sz;
} b[1000100], ys[1000100];
struct xxj {
int d[32];
void insert(int x) {
for (int i = 30; i >= 0; i--)
if (x & (1 << i)) {
if (!d[i]) d[i] = x;
x ^= d[i];
}
}
int get_min(int x) {
for (int i = 30; i >= 0; i--)
if (x & (1 << i)) x ^= d[i];
return x;
}
} D[25];
vector<edge> v[1000100 * 8];
map<pair<int, int>, int> mp;
int get_dis(int x, int &ret) {
while (x != b[x].fa) ret ^= b[x].dis, x = b[x].fa;
return x;
}
void modify(int x, int l, int r, int L, int R, edge p) {
if (l >= L && r <= R) return v[x].push_back(p), void();
int mid = (l + r) >> 1;
if (L <= mid) modify(x << 1, l, mid, L, R, p);
if (R > mid) modify(x << 1 | 1, mid + 1, r, L, R, p);
}
void add(int x, int l, int r, int pos) {
vis[x] = 1;
int mid = (l + r) >> 1;
if (l == r) return;
if (pos <= mid)
add(x << 1, l, mid, pos);
else
add(x << 1 | 1, mid + 1, r, pos);
}
void solve(int x, int l, int r, int d) {
lst[x] = top;
D[d] = D[d - 1];
for (int i = 0; i < v[x].size(); i++) {
edge now = v[x][i];
int fx, fy, dis1 = 0, dis2 = 0;
fx = get_dis(now.x, dis1), fy = get_dis(now.y, dis2);
sta[++top] = fx;
ys[top] = b[fx];
sta[++top] = fy;
ys[top] = b[fy];
if (fx == fy)
D[d].insert(dis1 ^ dis2 ^ now.z);
else {
if (b[fx].sz < b[fy].sz) swap(fx, fy);
b[fy].fa = fx;
b[fy].dis = dis1 ^ dis2 ^ now.z;
b[fx].sz += b[fy].sz;
}
}
if (l == r) {
int L = q[que[l]].x, R = q[que[l]].y, w = 0;
get_dis(L, w);
get_dis(R, w);
printf("%d\n", D[d].get_min(w));
return;
}
int mid = (l + r) >> 1;
if (vis[x << 1]) solve(x << 1, l, mid, d + 1);
if (vis[x << 1 | 1]) solve(x << 1 | 1, mid + 1, r, d + 1);
while (top > lst[x]) b[sta[top]] = ys[top--];
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, x, y, z; i <= m; i++) {
scanf("%d%d%d", &x, &y, &z);
mp[make_pair(x, y)] = ++cnt;
q[cnt].x = x;
q[cnt].y = y;
q[cnt].z = z;
q[cnt].l = 1;
}
scanf("%d", &Q);
for (int i = 1, opt, x, y, z; i <= Q; i++) {
scanf("%d%d%d", &opt, &x, &y);
if (opt == 1) {
scanf("%d", &z);
mp[make_pair(x, y)] = ++cnt;
q[cnt].x = x;
q[cnt].y = y;
q[cnt].z = z;
q[cnt].l = i;
} else if (opt == 2)
q[mp[make_pair(x, y)]].r = i;
else
q[++cnt].x = x, q[cnt].y = y, q[cnt].p = i;
}
for (int i = 1; i <= cnt; i++)
if (!q[i].p && !q[i].r) q[i].r = Q;
for (int i = 1; i <= cnt; i++)
if (!q[i].p)
modify(1, 1, Q, q[i].l, q[i].r, (edge){q[i].x, q[i].y, q[i].z});
else
add(1, 1, Q, q[i].p), que[q[i].p] = i;
for (int i = 1; i <= n; i++) b[i].fa = i, b[i].sz = 1;
solve(1, 1, Q, 1);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int conversion(string p) {
int o;
o = atoi(p.c_str());
return o;
}
string toString(int h) {
stringstream ss;
ss << h;
return ss.str();
}
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
long long lcm(long long a, long long b) { return (a * (b / gcd(a, b))); }
long long toi(string p) {
long long x;
istringstream in(p);
in >> x;
return x;
}
int main() {
int a, b, c, d, x, y, ab;
cin >> a >> b >> c >> d >> x >> y;
ab = min(a, min(b, min(c, d)));
if (x < ab && y < ab)
cout << abs(x - y) + 1 << endl;
else if (x > ab)
cout << 0 << endl;
else
cout << abs(x - ab) << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-7;
const double PI = acos(-1);
const int MOD = 998244353;
const int INF = 0x3f3f3f3f;
const int N = 1e3 + 7;
int n, k;
int c[N], res[N], vis[N];
vector<int> s[N];
int query(const int &l, const int &r) {
static int x;
cout << "? " << r - l + 1 << " ";
for (int i = l; i <= r; ++i) cout << i << " ";
cout << endl;
cin >> x;
if (x == -1) exit(0);
return x;
}
inline bool answer() {
static string check;
cout << "! ";
for (int i = 1; i <= k; ++i) cout << res[i] << " ";
cout << endl;
cin >> check;
return check == "Correct";
}
inline void solve() {
cin >> n >> k;
for (int i = 1; i <= k; ++i) {
cin >> c[i];
s[i].resize(c[i]);
for (int j = 0; j < c[i]; ++j) {
cin >> s[i][j];
}
}
int mv = query(1, n);
int l = 1, r = n;
while (l < r) {
int mid = (l + r) >> 1;
if (query(l, mid) == mv)
r = mid;
else
l = mid + 1;
}
for (int i = 1, flag; i <= k; ++i) {
flag = 0;
for (int j = 0; j < c[i]; ++j) {
if (s[i][j] == l) flag = 1;
}
if (flag) {
memset(vis + 1, 0, sizeof(int) * n);
for (int j = 0; j < c[i]; ++j) vis[s[i][j]] = 1;
cout << "? " << n - c[i] << " ";
for (int j = 1; j <= n; ++j) {
if (!vis[j]) cout << j << " ";
}
cout << endl;
cin >> res[i];
} else {
res[i] = mv;
}
}
if (!answer()) exit(0);
for (int i = 1; i <= k; ++i) {
vector<int>().swap(s[i]);
}
}
signed main() {
int T = 1;
cin >> T;
for (int t = 1; t <= T; ++t) {
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char str[100005];
long long int dp[11], nxt[11];
int main() {
scanf("%s", &str);
int n = strlen(str);
memset(dp, 0, sizeof(dp));
long long int ret = 0;
for (int i = 0; i < n; i++) {
int c = str[i] - '0';
memset(nxt, 0, sizeof(nxt));
for (int j = c + 1; j < 11; j++) {
int to = (j * j - j - 2) / 2 + c;
if (to < 0) to += 11;
to %= 11;
nxt[to] += dp[j];
}
if (c > 0) nxt[c]++;
for (int j = 0; j < 11; j++) {
ret += nxt[j];
dp[j] = nxt[j];
}
}
printf("%lld\n", ret);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, m, query;
int l[N], d[N][3], dia[N];
vector<long long> sum[N];
vector<int> a[N], c[N];
map<pair<int, int>, double> mymap;
map<pair<int, int>, int> check;
int root(int u) { return (l[u] < 0 ? u : (l[u] = root(l[u]))); }
void doJoin(int u, int v) {
u = root(u);
v = root(v);
if (u == v) return;
if (l[u] > l[v]) swap(u, v);
l[u] += l[v];
l[v] = u;
}
void read() {
cin >> n >> m >> query;
for (int i = 1; i <= n; i++) l[i] = -1;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
a[u].push_back(v);
a[v].push_back(u);
doJoin(u, v);
}
}
void visit(int u, int t) {
for (int i = 1; i <= a[u].size(); i++) {
int v = a[u][i - 1];
if (d[v][t] == 0) {
d[v][t] = d[u][t] + 1;
visit(v, t);
}
}
}
bool cmp(int u, int v) { return d[u][0] < d[v][0]; }
void update(int cpn) {
if (c[cpn].size() == 1) {
sum[cpn].push_back(0);
return;
}
d[c[cpn][0]][1] = 1;
visit(c[cpn][0], 1);
int r1 = c[cpn][0], r2 = c[cpn][0];
for (int i = 1; i <= c[cpn].size(); i++)
if (d[c[cpn][i - 1]][1] > d[r1][1]) r1 = c[cpn][i - 1];
for (int i = 1; i <= c[cpn].size(); i++) d[c[cpn][i - 1]][1] = 0;
d[r1][1] = 1;
visit(r1, 1);
for (int i = 1; i <= c[cpn].size(); i++)
if (d[c[cpn][i - 1]][1] > d[r2][1]) r2 = c[cpn][i - 1];
d[r2][2] = 1;
visit(r2, 2);
dia[cpn] = d[r1][2] - 1;
for (int i = 1; i <= c[cpn].size(); i++) {
int u = c[cpn][i - 1];
d[u][0] = max(d[u][1], d[u][2]) - 1;
}
sort(c[cpn].begin(), c[cpn].end(), cmp);
int tmp = 0;
for (int i = 1; i <= c[cpn].size(); i++) {
sum[cpn].push_back(tmp + d[c[cpn][i - 1]][0]);
tmp += d[c[cpn][i - 1]][0];
}
}
double cal(int u, int v) {
double P = 0, Q = (double)c[u].size() * c[v].size();
if (c[u].size() > c[v].size()) swap(u, v);
int pos = c[v].size();
for (int i = 1; i <= c[u].size(); i++) {
int iu = c[u][i - 1];
int len = max(dia[u], dia[v]);
while (pos > 0 && d[c[v][pos - 1]][0] >= len - d[iu][0] - 1) pos--;
P +=
(double)(sum[v][sum[v].size() - 1] - (pos == 0 ? 0 : sum[v][pos - 1])) +
(double)len * pos;
P += (c[v].size() - pos) * (1 + d[iu][0]);
}
if (u > v) swap(u, v);
check[pair<int, int>(u, v)] = 1;
return mymap[pair<int, int>(u, v)] = P / Q;
}
void solve() {
for (int i = 1; i <= n; i++) {
root(i);
if (l[i] > 0)
c[l[i]].push_back(i);
else
c[i].push_back(i);
}
for (int i = 1; i <= n; i++)
if (l[i] < 0) update(i);
cout.precision(7);
for (int i = 1; i <= query; i++) {
int u, v;
cin >> u >> v;
u = root(u);
v = root(v);
if (u > v) swap(u, v);
if (u == v)
cout << -1 << '\n';
else if (c[u].size() == 1 && c[v].size() == 1)
cout << "1.0000000\n";
else if (check[pair<int, int>(u, v)])
cout << fixed << mymap[pair<int, int>(u, v)] << '\n';
else {
cout << fixed << cal(u, v) << '\n';
}
}
}
int main() {
ios_base::sync_with_stdio(0);
read();
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5000;
char str[MAXN + 10];
long long sfy[MAXN + 10][MAXN + 10];
int len;
long long ans = 0;
int findl(int in) {
while (in > 0 && str[in - 1] == '*') in -= 2;
return in;
}
int findr(int in) {
while (in < len - 1 && str[in + 1] == '*') in += 2;
return in;
}
int main(void) {
scanf("%s", str);
len = strlen(str);
for (int i = 0; i < len; i += 2) {
long long mul = str[i] - '0';
sfy[i][i] = mul;
for (int j = i + 1; j < len; j += 2) {
if (str[j] == '*') {
sfy[i][j + 1] = sfy[i][j - 1] + mul * (str[j + 1] - '0' - 1);
mul *= str[j + 1] - '0';
} else {
mul = str[j + 1] - '0';
sfy[i][j + 1] = sfy[i][j - 1] + str[j + 1] - '0';
}
}
}
for (int i = 0; i < len; i += 2)
for (int j = i; j < len; j += 2) {
int l = findl(i), r = findr(j);
long long p1, p2, p3;
p2 = sfy[i][j];
if (l < i) p2 *= sfy[l][i - 2];
if (r > j) p2 *= sfy[j + 2][r];
if (l == 0)
p1 = 0;
else
p1 = sfy[0][l - 2];
if (r == len - 1)
p3 = 0;
else
p3 = sfy[r + 2][len - 1];
p2 += p1 + p3;
if (p2 > ans) ans = p2;
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int prime[200], vis[200], m;
void init() {
for (int i = 2; i <= 100; i++) {
if (!vis[i]) prime[++m] = i;
for (int j = i; j <= 100; j += i) vis[j] = 1;
}
}
long long D, B;
int k;
int calc(long long B) {
if ((D - 1) % B == 0) return 3;
if ((D + 1) % B == 0) return 11;
long long tmp = D;
k = 0;
for (; tmp <= 1e16; tmp *= D) {
++k;
if (tmp % B == 0) return 2;
}
return -1;
}
int main() {
init();
cin >> D >> B;
int res = calc(B);
if (res != -1) {
if (res == 2) {
cout << "2-type" << '\n';
cout << k << '\n';
return 0;
} else if (res == 3) {
cout << "3-type" << '\n';
return 0;
} else if (res == 11) {
cout << "11-type" << '\n';
return 0;
}
return 0;
}
for (int i = 1; i <= m; i++)
if (B % prime[i] == 0) {
long long tmp = 1;
while (B % prime[i] == 0) B /= prime[i], tmp *= prime[i];
int res = calc(tmp);
if (res == -1) {
cout << "7-type" << '\n';
return 0;
}
}
cout << "6-type" << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
scanf("%i", &n);
char s[n + 2];
scanf("%s", s + 1);
vector<int> answers[26];
for (int j = 0; j < 26; j++) {
char ch = j + 'a';
vector<int> p(n + 1);
for (int i = 1; i <= n; i++) {
p[i] = p[i - 1];
if (s[i] == ch) p[i]++;
}
vector<int> ans(n + 1);
for (int m = 1; m <= n; m++) {
int r = 1;
for (int i = 1; i <= n; i++) {
while (i - r + 1 - (p[i] - p[r - 1]) > m) {
r++;
}
ans[m] = max(ans[m], i - r + 1);
}
}
answers[j] = ans;
}
int q;
scanf("%i", &q);
while (q--) {
int m;
char ch;
scanf("%i %c", &m, &ch);
printf("%i\n", answers[ch - 'a'][m]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
long long int f[200002], a[1000], s = 0;
int main() {
long int n, x, l, r, v, t, m, i;
scanf("%ld%ld", &n, &m);
for (i = 1; i <= n; i++) scanf("%lld", &a[i]);
f[0] = 1;
f[1] = 1;
for (i = 2; i <= 20000; i++) {
f[i] = (f[i - 1] % 1000000000 + f[i - 2] % 1000000000) % 1000000000;
}
while (m--) {
scanf("%ld", &t);
if (t == 1) {
scanf("%ld%ld", &x, &v);
a[x] = v;
}
if (t == 2) {
scanf("%ld%ld", &l, &r);
for (i = 0; i <= r - l; i++) {
s = (s % 1000000000 + (f[i] * a[l + i]) % 1000000000) % 1000000000;
s = s % 1000000000;
}
printf("%lld\n", s);
s = 0;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int b[2005];
int main() {
int a[2005], i, n, c[2005], k;
cin >> n;
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) b[a[i]]++;
k = 2000;
while (b[k] == 0) k--;
c[k] = 1;
for (i = k - 1; i > 0; i--) c[i] = c[i + 1] + 1 + (b[i + 1] - 1);
for (i = 1; i <= n; i++) cout << c[a[i]] << " ";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, j, i, t;
cin >> a >> b;
i = min(a, b);
j = (max(a, b) - i) / 2;
cout << i << " " << j;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int MOD(int a, int b) {
if (a > b)
return a - b;
else
return b - a;
}
long long int max3(long long int a, long long int b, long long int c) {
return max(c, max(a, b));
}
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 max(long long int a, long long int b) { return (a > b) ? a : b; }
long long int min(long long int a, long long int b) { return (a < b) ? a : b; }
long long int gcd(long long int a, long long int b) {
if (b == 1)
return 1;
else if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k, i, j;
cin >> n >> k;
char ch[n + 1];
for (i = 1; i < n + 1; i++) cin >> ch[i];
int ctr = 0;
int currpos = 1;
while (currpos != n) {
for (i = min(n, currpos + k); i >= currpos + 1; i--) {
if (ch[i] == '.') {
currpos = i;
ctr++;
break;
}
}
if (ctr == 0) {
cout << "NO\n";
return 0;
}
ctr = 0;
}
cout << "YES\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, k;
cin >> n >> m >> k;
long long r, l, mid, d;
l = 0;
r = m;
m -= n;
for (int i = 0; i < 100; ++i) {
mid = (r + l) / 2;
d = mid * n;
d -= ((k - 1) * k) / 2;
if (k - 1 > mid) {
d += (k - 1 - mid) * (k - mid) / 2;
}
d -= ((n - k) * (n - k + 1)) / 2;
if (n - k > mid) {
d += (n - k - mid) * (n - k - mid + 1) / 2;
}
if (d > m) {
r = mid;
} else {
l = mid;
}
}
cout << l + 1;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000;
int i, j, n, m, x, y, s[N], ans, col[N], v[N];
vector<int> g[N], ice[N], a;
void dfs(int x, int fa) {
for (auto y : ice[x])
if (col[y])
v[col[y]] = 1;
else
a.push_back(y);
int cnt = 1;
for (auto y : a) {
while (v[cnt]) cnt++;
col[y] = cnt++;
}
for (auto y : ice[x]) v[col[y]] = 0;
a.clear();
for (auto y : g[x])
if (y != fa) dfs(y, x);
}
int main() {
scanf("%d%d", &n, &m);
ans = 1;
for (i = 1; i <= n; i++) {
scanf("%d", &s[i]);
if (s[i] > ans) ans = s[i];
for (j = 1; j <= s[i]; j++) scanf("%d", &x), ice[i].push_back(x);
}
for (i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
g[y].push_back(x);
g[x].push_back(y);
}
dfs(1, -1);
printf("%d\n", ans);
for (i = 1; i <= m; i++) printf("%d ", col[i] ? col[i] : 1);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int w0, w1, a0, a1;
int a[200005], b[200005];
int dp[3005][3005];
int fpow(int a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret = 1ll * ret * a % mod;
a = 1ll * a * a % mod;
b >>= 1;
}
if (ret < 0) ret += mod;
return ret;
}
int ans[200005];
inline int read() {
char c = getchar();
int x = 0;
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x;
}
int main() {
int w1 = 0, w0 = 0, a0 = 0, a1 = 0;
int n = read(), m = read();
for (int i = 1; i <= n; ++i) a[i] = read();
for (int i = 1; i <= n; ++i) b[i] = read();
for (int i = 1; i <= n; ++i)
if (a[i])
w1 += b[i];
else
w0 += b[i];
int fw1 = fpow(w1, mod - 2), fw0 = fpow(w0, mod - 2);
dp[0][0] = 1;
for (int i = 0; i <= m; ++i) {
for (int j = 0; j <= m; ++j) {
if (i + j > m) continue;
dp[i][j] += 1ll * (w1 + i - 1) * fpow(w0 + w1 + i - 1 - j, mod - 2) %
mod * dp[i - 1][j] % mod;
dp[i][j] += 1ll * (w0 - j + 1) * fpow(w0 + w1 + i - j + 1, mod - 2) %
mod * dp[i][j - 1] % mod;
while (dp[i][j] > mod) dp[i][j] -= mod;
}
}
for (int i = 0; i <= m; ++i) {
a0 += 1ll * (m - i) * dp[i][m - i] % mod;
a1 += 1ll * i * dp[i][m - i] % mod;
if (a0 > mod) a0 -= mod;
if (a1 > mod) a1 -= mod;
}
for (int i = 1; i <= n; ++i) {
if (a[i])
ans[i] = b[i] + 1ll * a1 * b[i] % mod * fw1 % mod;
else
ans[i] = b[i] - 1ll * a0 * b[i] % mod * fw0 % mod;
while (ans[i] > mod) ans[i] -= mod;
if (ans[i] < 0) ans[i] += mod;
printf("%d\n", ans[i]);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void solve1();
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long power(long long x, long long y) {
long long res = 1;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long fib(long long s1) {
long long s2, s4, s5, s3;
s2 = s3 = 1;
s4 = s5 = 0;
while (s1 > 0) {
if (s1 % 2 == 0) {
long long s6 = s3 * s3;
s3 = 2 * s5 * s3 + s6;
s5 = s5 * s5 + s6;
s1 /= 2;
} else {
long long s6 = s2 * s3;
s2 = s4 * s3 + s6 + s2 * s5;
s4 = s4 * s5 + s6;
s1 -= 1;
}
}
return s4;
}
long long sum(long long arr[], long long a, long long n) {
long long zz = 0;
for (long long i = a; i < n; i++) {
zz += arr[i];
}
return zz;
}
void solve() {
long long t;
cin >> t;
while (t--) {
solve1();
}
}
bool allprime[10000001] = {0};
vector<long long> sieve_of_primes_upto_10e6() {
long long n = 10000000;
vector<long long> set_of_primes;
set_of_primes.push_back(2);
long long p;
for (p = 2; p * p <= n; p++) {
if (allprime[p] == 0) {
set_of_primes.push_back(p);
for (long long i = p * p; i <= n; i += p) {
allprime[i] = 1;
}
}
}
for (p; p <= n; p += 2) {
if (allprime[p] == 0) {
set_of_primes.push_back(p);
}
}
return set_of_primes;
}
signed main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
vector<long long> vec = sieve_of_primes_upto_10e6();
solve();
return 0;
}
void solve1() {
long long n, m, a = 0, b;
cin >> n;
allprime[1] = 1;
long long arr[n][n];
for (long long i = n + 1; i < 200000; i++) {
if (allprime[i] == 0 && allprime[i + 1 - n] == 1) {
a = i;
break;
}
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < n; j++) {
arr[i][j] = 1;
}
arr[i][i] = a + 1 - n;
}
for (long long j = 0; j < n; j++) {
for (long long i = 0; i < n; i++) cout << arr[j][i] << " ";
cout << "\n";
;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j = 0, k = 0, n, d, c, e, f;
cin >> n >> d;
string s;
for (i = 0; i < d; i++) {
cin >> s;
e = 1;
for (c = 0; c < n; c++) {
if (s[c] == '0') {
e = 0;
break;
}
}
if (e == 0) {
k++;
}
if (e == 1) {
k = 0;
}
if (k > j) {
j = k;
}
}
cout << j << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long LINF = 1e18;
const int INF = 0x3f3f3f3f;
const int MAXE = 5000050;
const int MAXN = 5050;
const int bk_sz = 3420;
mt19937 rnd(114514);
int a[MAXN];
int dp[MAXN][MAXN];
int pre[MAXN], pos[MAXN];
void mainwork(int T) {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
pos[i] = 0;
}
int t = unique(a + 1, a + n + 1) - a - 1;
n = t;
for (int i = 1; i <= n; i++) {
if (pos[a[i]]) {
pre[i] = pos[a[i]];
}
pos[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dp[i][j] = INF;
}
}
for (int i = 1; i <= n; i++) dp[i][i] = 0;
for (int i = 1; i < n; i++) dp[i][i + 1] = 1;
for (int len = 2; len <= n; len++) {
for (int i = 1; i + len - 1 <= n; i++) {
int j = i + len - 1;
dp[i][j] = min(dp[i][j - 1] + 1, dp[i + 1][j] + 1);
if (a[i] == a[j]) {
dp[i][j] = min(dp[i][j], dp[i + 1][j - 1] + 1);
for (int k = pre[j]; k > i; k = pre[k]) {
dp[i][j] = min(dp[i][j], dp[i][k - 1] + dp[k + 1][j]);
}
} else {
for (int k = pre[j]; k > i; k = pre[k]) {
dp[i][j] = min(dp[i][j], dp[i][k - 1] + dp[k][j] + 1);
}
}
}
}
printf("%d\n", dp[1][n]);
}
signed main() {
int t = 1;
scanf("%d", &t);
for (int i = 1; i <= t; i++) {
mainwork(i);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXC = 30;
int cc[MAXC], pf[MAXC], sf[MAXC], n;
int lcc[MAXC], rcc[MAXC];
void getdet(string &a) {
for (int i = 0; i < MAXC; i++) cc[i] = pf[i] = sf[i] = 0;
int cnt = 0;
for (int i = 0; i < a.size(); i++) {
if (i == 0 || a[i] == a[i - 1])
cnt++;
else
cnt = 1;
cc[a[i] - 'a'] = max(cc[a[i] - 'a'], cnt);
}
for (char t = 'a'; t <= 'z'; t++) {
cnt = 0;
for (int i = 0; i < a.size(); i++) {
if (a[i] != t) break;
cnt++;
}
pf[t - 'a'] = cnt;
cnt = 0;
for (int i = (int)a.size() - 1; i >= 0; i--) {
if (a[i] != t) break;
cnt++;
}
sf[t - 'a'] = cnt;
}
}
int main() {
cin >> n;
for (int q = 0; q < n; q++) {
string tmp;
cin >> tmp;
getdet(tmp);
if (q == 0) {
swap(lcc, cc);
continue;
}
for (int i = 0; i < MAXC; i++) rcc[i] = 0;
for (char t = 'a'; t <= 'z'; t++) {
rcc[t - 'a'] = cc[t - 'a'];
if (lcc[t - 'a'] > 0)
rcc[t - 'a'] = max(rcc[t - 'a'], 1 + pf[t - 'a'] + sf[t - 'a']);
if (pf[t - 'a'] == tmp.size())
rcc[t - 'a'] = max(rcc[t - 'a'],
lcc[t - 'a'] + (lcc[t - 'a'] + 1) * (int)tmp.size());
}
swap(rcc, lcc);
}
int ans = 0;
for (int i = 0; i < MAXC; i++) ans = max(ans, lcc[i]);
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9 + 7;
struct Node {
int low, high, F;
};
Node tree[4 * 100001];
vector<int> arr(100001);
void build(int l, int r, int idx) {
if (l == r) {
if (l == 0) {
tree[idx].low = INF;
tree[idx].high = -INF;
tree[idx].F = 0;
return;
}
tree[idx].F = INF;
tree[idx].low = tree[idx].high = arr[l];
return;
}
build(l, ((l + r) / 2), (2 * idx + 1));
build(((l + r) / 2) + 1, r, (2 * idx + 2));
tree[idx].low = min(tree[(2 * idx + 1)].low, tree[(2 * idx + 2)].low);
tree[idx].high = max(tree[(2 * idx + 1)].high, tree[(2 * idx + 2)].high);
tree[idx].F = INF;
}
int get_min(int l, int r, int qe, int qr, int idx, char a) {
if (r < qe || qr < l) return INF;
if (qe <= l && r <= qr) return (a == 'F' ? tree[idx].F : tree[idx].low);
return min(get_min(l, ((l + r) / 2), qe, qr, (2 * idx + 1), a),
get_min(((l + r) / 2) + 1, r, qe, qr, (2 * idx + 2), a));
}
int get_max(int l, int r, int qe, int qr, int idx) {
if (r < qe || qr < l) return -INF;
if (qe <= l && r <= qr) return tree[idx].high;
return max(get_max(l, ((l + r) / 2), qe, qr, (2 * idx + 1)),
get_max(((l + r) / 2) + 1, r, qe, qr, (2 * idx + 2)));
}
void update(int l, int r, int qe, int idx, int val) {
if (r < qe || l > qe) return;
if (l == qe && r == qe) {
tree[idx].F = min(tree[idx].F, val);
return;
}
update(l, ((l + r) / 2), qe, (2 * idx + 1), val);
update(((l + r) / 2) + 1, r, qe, (2 * idx + 2), val);
tree[idx].F = min(tree[(2 * idx + 1)].F, tree[(2 * idx + 2)].F);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int N, i, j, S, least;
cin >> N >> S >> least;
for (i = 1; i <= N; ++i) cin >> arr[i];
build(0, N, 0);
update(0, N, 0, 0, 0);
for (i = least; i <= N; ++i) {
int l = 0, r = i, mid;
while (l < r) {
mid = (r + l + 1) / 2;
if (get_max(0, N, mid, i, 0) - get_min(0, N, mid, i, 0, 'S') > S)
l = mid;
else
r = mid - 1;
}
if (l + 1 <= i - least + 1) {
update(0, N, i, 0, get_min(0, N, l, i - least, 0, 'F') + 1);
}
}
int val = get_min(0, N, N, N, 0, 'F');
if (val != INF)
cout << val << "\n";
else
cout << -1 << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long ask(vector<long long> v) {
cout << "? " << v.size() << ' ';
for (auto it : v) cout << it << ' ';
cout << endl;
cout.flush();
long long rt;
cin >> rt;
return rt;
}
void solve() {
long long n, k, i;
cin >> n >> k;
vector<long long> qu[k], ans;
for (i = 0; i < k; i++) {
long long j, x;
cin >> x;
qu[i].resize(x);
for (j = 0; j < x; j++) cin >> qu[i][j];
}
vector<long long> nxt;
for (i = 1; i <= n; i++) nxt.push_back(i);
long long mx = ask(nxt);
long long st = 0, ed = k - 1, mid, idx = 0;
while (st <= ed) {
long long mid = (st + ed) / 2;
nxt.clear();
for (i = st; i <= mid; i++) {
for (auto it : qu[i]) nxt.push_back(it);
}
long long tmx = ask(nxt);
if (mx == tmx) {
idx = mid;
ed = mid - 1;
} else
st = mid + 1;
}
map<long long, long long> mp;
for (auto it : qu[idx]) mp[it] = 1;
nxt.clear();
for (i = 1; i <= n; i++)
if (!mp[i]) nxt.push_back(i);
long long mm = ask(nxt);
cout << "! ";
for (i = 0; i < k; i++)
if (i == idx)
cout << mm << ' ';
else
cout << mx << ' ';
cout << endl;
string s;
cin >> s;
}
int main() {
long long t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double a1, b1, c1, a2, b2, c2;
while (scanf("%lf%lf%lf%lf%lf%lf", &a1, &b1, &c1, &a2, &b2, &c2) != EOF) {
if (a1 == 0 && b1 == 0 && c1 != 0 || a2 == 0 && b2 == 0 && c2 != 0) {
printf("0\n");
break;
}
if (a1 * b2 == a2 * b1) {
if (a1 == 0 && a2 == 0) {
if (c1 * b2 == c2 * b1)
printf("-1\n");
else
printf("0\n");
} else {
if (c1 * a2 == c2 * a1)
printf("-1\n");
else
printf("0\n");
}
} else {
printf("1\n");
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct ele {
int to, val;
};
ele a[100001];
int cmp(ele a, ele b) { return a.val < b.val; }
int n;
int sum = 0;
vector<int> voter[100001], v;
int len = 0;
int jundge(int x) {
int total = 0;
int need = x - sum;
v.clear();
for (int i = 1; i <= len; i++) {
for (int j = 0; j < voter[i].size(); j++) {
if (voter[i].size() - j >= x) {
total += voter[i][j];
need--;
} else {
v.push_back(voter[i][j]);
}
}
}
sort(v.begin(), v.end());
for (int i = 0; i < need; i++) {
total += v[i];
}
return total;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int to, val;
cin >> to >> val;
if (to == 0) {
sum++;
} else {
voter[to].push_back(val);
len = max(len, to);
}
}
for (int i = 1; i <= len; i++) {
sort(voter[i].begin(), voter[i].end());
}
int l = 0, r = n;
while (r - l > 1) {
int mid = (l + r) >> 1;
int mmid = (mid + r) >> 1;
int sum1 = jundge(mid);
int sum2 = jundge(mmid);
if (sum1 >= sum2) {
l = mid;
} else {
r = mmid;
}
}
int Min = jundge(l);
cout << Min << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
namespace Solution {
int p[((long long)1e6 + 10)] = {0};
void sieve() {
for (long long i = 2; i < ((long long)1e6 + 10); ++i)
if (p[i] == 0) {
p[i] = i;
for (long long f = i * i; f < ((long long)1e6 + 10); f += i) p[f] = i;
}
}
vector<vector<int> > dp;
void preprocess() {
dp.resize(((long long)1e6 + 10), vector<int>((20), 2));
dp[0][0] = 1;
for (int i = 1; i < ((long long)1e6 + 10); ++i) {
dp[i][0] = 1;
for (int f = 1; f < (20); ++f)
dp[i][f] = ((long long)dp[i - 1][f] + (long long)dp[i][f - 1]) %
((long long)1e9 + 7);
}
}
long long f(int r, int n) {
map<int, int> fcnt;
long long ans = 1;
for (; n > 1; n /= p[n]) fcnt[p[n]]++;
for (pair<int, int> i : fcnt) {
ans = (ans * dp[r][i.second]) % ((long long)1e9 + 7);
}
return ans;
}
int main() {
sieve();
preprocess();
int t;
cin >> t;
while (t--) {
int n, r;
cin >> r >> n;
cout << f(r, n) << '\n';
}
return 0;
}
} // namespace Solution
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
return Solution::main();
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
bool Max(T1& a, T2 b) {
return a < b ? a = b, 1 : 0;
}
template <typename T1, typename T2>
bool Min(T1& a, T2 b) {
return a > b ? a = b, 1 : 0;
}
const int N = 1000001;
bool prime[N];
vector<long long> pri;
vector<pair<long long, long long> > nv, sv;
long long n, m, s;
long long rec(long long i, long long prod) {
if (i == sv.size()) return 1;
long long ret = 0;
auto& cur = sv[i];
for (int j = 0; j < (cur.second + 1); ++j) {
ret += rec(i + 1, prod);
if ((prod *= cur.first) > n) break;
}
return ret;
}
long long pow(long long a, long long p) {
long long ret = 1;
while (p) {
if (p & 1) ret *= a;
a *= a;
p >>= 1;
}
return ret;
}
void solve() {
long long v;
n = 1;
for (int i = 0; i < (3); ++i) {
cin >> v;
n *= v;
}
m = 1;
for (int i = 0; i < (3); ++i) {
cin >> v;
m *= v;
}
s = 2;
for (int i = 0; i < (3); ++i) {
cin >> v;
s *= v;
}
long long ts = s, tn = n;
nv.clear();
sv.clear();
for (auto& e : pri) {
if (e * e > ts) break;
long long cnt = 0;
while (ts % e == 0) {
cnt++;
ts /= e;
}
if (cnt) sv.emplace_back(e, cnt);
}
if (ts > 1) sv.emplace_back(ts, 1);
for (auto& e : pri) {
if (e * e > tn) break;
long long cnt = 0;
while (tn % e == 0) {
cnt++;
tn /= e;
}
if (cnt) nv.emplace_back(e, cnt);
}
if (tn > 1) nv.emplace_back(tn, 1);
long long ans = rec(0, 1);
sv.emplace_back(N, 1);
vector<long long> tmp;
long long i = 0;
for (auto& e : nv) {
while (sv[i].first < e.first) i++;
if (sv[i].first > e.first) {
tmp.emplace_back(e.first);
} else {
if (sv[i].second < e.second)
tmp.emplace_back(pow(e.first, sv[i].second + 1));
i++;
}
}
long long sz = tmp.size();
for (int sub = 0; sub < (1 << sz); ++sub) {
long long t = 1;
bool add = 1;
for (int i = 0; i < (sz); ++i)
if ((sub >> i) & 1) {
t *= tmp[i];
add ^= 1;
}
if (add)
ans += m / t;
else
ans -= m / t;
}
cout << ans << '\n';
}
void init() {
for (int i = 2; i <= (N - 1); ++i)
if (!prime[i]) {
pri.emplace_back(i);
for (long long j = (long long)i * i; j < N; j += i) prime[j] = 1;
}
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.setf(ios::fixed);
cout.precision(20);
init();
int TC;
cin >> TC;
for (int TI = 1; TI <= (TC); ++TI) {
solve();
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
if (n == 0) {
cout << 0 << " " << 0 << " " << 0 << endl;
return 0;
}
if (n == 1) {
cout << 0 << " " << 1 << " " << 0 << endl;
return 0;
}
if (n == 2) {
cout << 1 << " " << 1 << " " << 0 << endl;
return 0;
}
long long int Fibo[1007];
Fibo[0] = 0;
Fibo[1] = 1;
for (long long int i = 2;; i++) {
Fibo[i] = Fibo[i - 1] + Fibo[i - 2];
if (Fibo[i] == n) {
cout << Fibo[i - 1] << " " << Fibo[i - 3] << " " << Fibo[i - 4] << endl;
return 0;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int test;
scanf("%d", &test);
while (test--) {
int k, n;
string ans = "", s;
scanf("%d%d", &n, &k);
cin >> s;
sort(s.begin(), s.end());
if (s[k - 1] != s[0]) {
printf("%c\n", s[k - 1]);
continue;
}
ans += s[0];
if (s[k] == s[n - 1]) {
int t = (n - k) / k;
if ((n - k) % k == 0) t--;
for (int i = k; i <= t + k; i++) ans += s[i];
} else {
for (int i = k; i < n; i++) ans += s[i];
}
cout << ans << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int n;
cin >> n;
string s;
cin >> s;
int ans = 0;
for (int j = n - 1; j >= 0; j--) {
if (s[j] - '0' > 0 and j != n - 1) ans++;
ans += s[j] - '0';
}
cout << ans << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2001;
struct EDGE {
int nxt, to;
EDGE() { nxt = to = 0; }
} edge[MAXN * MAXN << 1];
int n, totedge, totscc, top, dfnnum;
int mtx[MAXN][MAXN], head[MAXN];
int bel[MAXN], dfn[MAXN], low[MAXN], stk[MAXN];
bool ins[MAXN];
inline void add(int x, int y) {
edge[++totedge].to = y;
edge[totedge].nxt = head[x];
head[x] = totedge;
return;
}
void tarjan(int x) {
dfn[x] = low[x] = ++dfnnum;
stk[++top] = x;
ins[x] = true;
for (int i = head[x]; i; i = edge[i].nxt) {
int y = edge[i].to;
if (!dfn[y]) {
tarjan(y);
low[x] = min(low[x], low[y]);
} else if (ins[y])
low[x] = min(low[x], dfn[y]);
}
if (dfn[x] == low[x]) {
int y;
++totscc;
do {
y = stk[top--];
ins[y] = false;
bel[x] = totscc;
} while (x != y);
}
return;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
scanf("%d", &mtx[i][j]);
if (mtx[i][j]) add(i, j);
}
}
for (int i = 1; i <= n; ++i)
if (!dfn[i]) tarjan(i);
if (totscc == 1)
puts("YES");
else
puts("NO");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a[44] = {
"Washington", "Adams", "Jefferson", "Madison", "Monroe",
"Adams", "Jackson", "Van Buren", "Harrison", "Tyler",
"Polk", "Taylor", "Fillmore", "Pierce", "Buchanan",
"Lincoln", "Johnson", "Grant", "Hayes", "Garfield",
"Arthur", "Cleveland", "Harrison", "Cleveland", "McKinley",
"Roosevelt", "Taft", "Wilson", "Harding", "Coolidge",
"Hoover", "Roosevelt", "Truman", "Eisenhower", "Kennedy",
"Johnson", "Nixon", "Ford", "Carter", "Reagan"};
int n;
cin >> n;
cout << a[n - 1];
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void fastInOut() {
ios_base::sync_with_stdio(0);
cin.tie(NULL), cout.tie(NULL);
}
int dx[] = {0, 0, 1, -1, -1, -1, 1, 1};
int dy[] = {1, -1, 0, 0, -1, 1, -1, 1};
int main() {
fastInOut();
int n, a, b;
cin >> n;
long long fin = 0;
map<int, int> x, y;
map<pair<int, int>, int> rep;
for (int i = 0; i < n; ++i) {
cin >> a >> b;
fin += x[a];
fin += y[b];
fin -= rep[make_pair(a, b)];
x[a]++;
y[b]++;
rep[make_pair(a, b)]++;
}
cout << fin;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[7] = {0}, n, i, an[100010], num[100010] = {0}, j, re[100010] = {0}, cnt;
char x[10], no[10][10] = {"S", "M", "L", "XL", "XXL", "XXXL"}, *lo;
int main() {
for (i = 0; i < 6; i++) {
scanf("%d", &a[i]);
}
memset(re, -1, sizeof(re));
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%s", x);
lo = strchr(x, ',');
if (lo != NULL) {
*lo = '\0';
for (j = 0; j < 6; j++) {
if (strcmp(x, no[j]) == 0) {
num[j]++;
re[i] = j;
break;
}
}
} else {
for (j = 0; j < 6; j++) {
if (strcmp(x, no[j]) == 0) {
an[i] = j;
a[j]--;
break;
}
}
}
memset(x, 0, sizeof(x));
}
for (i = 0; i < 6; i++) {
if (a[i] < 0) {
printf("NO");
return 0;
}
}
for (i = 0; i < 6; i++) {
if (a[i] >= num[i]) {
for (j = 0; j < n; j++) {
if (re[j] == i) {
an[j] = i;
}
}
a[i] -= num[i];
num[i] = 0;
} else {
cnt = a[i];
for (j = 0; j < n; j++) {
if (re[j] == i) {
if (cnt > 0) {
an[j] = i;
cnt--;
} else {
an[j] = i + 1;
}
}
}
num[i] -= a[i];
a[i] = 0;
a[i + 1] -= num[i];
}
if (a[i] < 0 || a[i + 1] < 0) {
printf("NO");
return 0;
}
}
printf("YES\n");
for (i = 0; i < n; i++) {
if (an[i] == 0)
printf("S\n");
else if (an[i] == 1)
printf("M\n");
else if (an[i] == 2)
printf("L\n");
else if (an[i] == 3)
printf("XL\n");
else if (an[i] == 4)
printf("XXL\n");
else if (an[i] == 5)
printf("XXXL\n");
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = int(1e9) + 7;
const long long int MOD64 = (long long int)(1e18) + 7;
const int INF = 0x7fffffff;
const long long int INF64 = 0x7fffffffffffffff;
const int N = 5e5 + 10;
long long int a[N], m[N];
long long int lin[N], rin[N];
long long int l[N], r[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = int(1); i < int(n + 1); i++) cin >> a[i];
stack<pair<long long int, long long int> > st;
while (!st.empty()) st.pop();
st.push(make_pair(0, 0));
for (int i = int(1); i < int(n + 1); i++) {
while (a[i] < st.top().first) st.pop();
lin[i] = st.top().second;
st.push(make_pair(a[i], i));
l[i] = l[lin[i]] + a[i] * (i - lin[i]);
}
while (!st.empty()) st.pop();
st.push(make_pair(0, n + 1));
for (int i = n; i > 0; i--) {
while (a[i] < st.top().first) st.pop();
rin[i] = st.top().second;
st.push(make_pair(a[i], i));
r[i] = r[rin[i]] + a[i] * (rin[i] - i);
}
long long int ans = 0;
long long int ind = 0;
for (int i = int(1); i < int(n + 1); i++) {
if (ans < l[i] + r[i] - a[i]) {
ans = l[i] + r[i] - a[i];
ind = i;
}
}
long long int tmp = a[ind];
for (int i = ind; i > 0; i--) {
if (a[i] >= tmp)
m[i] = tmp;
else {
m[i] = a[i];
tmp = a[i];
}
}
tmp = a[ind];
for (int i = ind + 1; i <= n; i++) {
if (a[i] >= tmp)
m[i] = tmp;
else {
m[i] = a[i];
tmp = m[i];
}
}
for (int i = int(1); i < int(n + 1); i++) cout << m[i] << ' ';
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int n, k;
vector<pair<long long int, long long int> > que;
long long int righ[400005];
long long int lef[400005];
long long int ck[200005];
map<long long int, long long int> inde;
set<long long int> second;
vector<long long int> uniqu;
vector<long long int> coun;
pair<long long int, long long int> ieuclid(long long int a, long long int b) {
long long int r0 = a;
long long int r1 = b;
long long int s0 = 1;
long long int s1 = 0;
long long int t0 = 0;
long long int t1 = 1;
while (r1 != 0) {
long long int q = r0 / r1;
long long int r2 = r0 - q * r1;
long long int s2 = s0 - q * s1;
long long int t2 = t0 - q * t1;
r0 = r1;
r1 = r2;
s0 = s1;
s1 = s2;
t0 = t1;
t1 = t2;
}
return make_pair(s0, t0);
}
void set_ck() {
ck[k] = 1;
for (int i = k + 1; i <= n; i++) {
ck[i] = (ck[i - 1] * i) % 1000000007;
pair<long long int, long long int> tem = ieuclid(i - k, 1000000007);
if (tem.first < 0) tem.first += 1000000007;
ck[i] = (ck[i] * tem.first) % 1000000007;
}
}
int main() {
cin >> n >> k;
memset(lef, 0, sizeof(lef));
memset(righ, 0, sizeof(righ));
for (int i = 0; i < n; i++) {
long long int a, b;
cin >> a >> b;
if (second.find(a) == second.end()) {
second.insert(a);
uniqu.push_back(a);
coun.push_back(0);
}
if (second.find(b) == second.end()) {
second.insert(b);
uniqu.push_back(b);
coun.push_back(0);
}
que.push_back(make_pair(a, b));
}
sort(uniqu.begin(), uniqu.end());
for (int i = 0; i < uniqu.size(); i++) inde[uniqu[i]] = i;
for (int i = 0; i < que.size(); i++) {
long long int i1 = inde[que[i].first];
long long int i2 = inde[que[i].second];
righ[i1]++;
lef[i2]++;
coun[i1]++;
if (i2 != coun.size() - 1) coun[i2 + 1]--;
}
for (int i = 1; i < coun.size(); i++) coun[i] = coun[i] + coun[i - 1];
memset(ck, 0, sizeof(ck));
set_ck();
long long int fans = 0;
for (int i = 0; i < coun.size(); i++)
fans = (fans + ck[coun[i]]) % 1000000007;
for (int i = 0; i < coun.size() - 1; i++) {
long long int x = coun[i] - lef[i];
fans = (fans +
(ck[x] * (uniqu[i + 1] - uniqu[i] - 1) % 1000000007) % 1000000007) %
1000000007;
}
cout << fans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
const int MOD = 1e9 + 7;
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
short int t, n, i;
cin >> t;
string x, y;
while (t--) {
cin >> n;
cin >> x;
cin >> y;
bool b = 1;
for (i = 0; i < n; i++) {
if (x[i] == '1' && y[i] == '1') {
b = 0;
break;
}
}
cout << ((b == 1) ? ("YES\n") : ("NO\n"));
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
if (n == 2)
puts("2");
else
puts("1");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const int INF = 2147483647;
const int INF2 = 0x3f3f3f3f;
const long long INF64 = 3e18;
const double INFD = 1e30;
const double EPS = 1e-10;
const long double PI = acosl(-1);
const int MOD = 1e9 + 7;
template <typename T>
inline T read() {
T X = 0, w = 0;
char ch = 0;
while (!isdigit(ch)) {
w |= ch == '-';
ch = getchar();
}
while (isdigit(ch)) X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
return w ? -X : X;
}
const int MAXN = 105;
const int MAXV = 60;
int n, m, k;
int dr[4] = {1, 0, -1, 0};
int dc[4] = {0, 1, 0, -1};
int dr2[8] = {1, 1, 1, -1, -1, -1, 0, 0};
int dc2[8] = {1, 0, -1, 1, 0, -1, 1, -1};
int CASE = 1;
bitset<102> mat[MAXN];
bitset<102> b;
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int x = read<int>();
if (x) mat[i].set(j);
}
}
int ans = INF2;
if (n <= k) {
for (int s = 0; s < (1 << n); s++) {
int t = 0;
for (int i = 0; i < m; i++) {
int cnt = 0;
for (int j = 0; j < n; j++) {
cnt += (mat[j][i] != ((s >> j) & 1));
}
t += min(cnt, n - cnt);
}
ans = min(ans, t);
}
} else {
for (int i = 0; i < n; i++) {
int t = 0;
for (int j = 0; j < n; j++) {
if (j != i) {
auto t1 = mat[i] ^ mat[j];
t += min(t1.count(), m - t1.count());
}
}
ans = min(ans, t);
}
}
if (ans > k) {
printf("-1");
} else {
printf("%d\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 5e5 + 100;
int last[N][5];
struct Node {
int l, r;
int sum, lazy;
} tree[N << 2];
void pushup(int k) {
if (tree[k].lazy)
tree[k].sum = 0;
else if (tree[k].l == tree[k].r)
tree[k].sum = 1;
else
tree[k].sum = tree[k << 1].sum + tree[k << 1 | 1].sum;
}
void build(int k, int l, int r) {
tree[k].l = l;
tree[k].r = r;
tree[k].sum = tree[k].lazy = 0;
if (l == r) return;
int mid = l + r >> 1;
build(k << 1, l, mid);
build(k << 1 | 1, mid + 1, r);
}
void update(int k, int l, int r, int val) {
if (tree[k].r < l || tree[k].l > r) return;
if (tree[k].l >= l && tree[k].r <= r) {
tree[k].lazy += val;
pushup(k);
return;
}
update(k << 1, l, r, val);
update(k << 1 | 1, l, r, val);
pushup(k);
}
int main() {
int n;
scanf("%d", &n);
build(1, 1, n);
long long ans = 0;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
for (int j = 4; j > 0; j--) last[x][j] = last[x][j - 1];
last[x][0] = i;
update(1, i, i, 0);
update(1, last[x][1] + 1, last[x][0], 1);
if (last[x][3] + 1 <= last[x][2]) update(1, last[x][3] + 1, last[x][2], -1);
if (last[x][4] + 1 <= last[x][3]) update(1, last[x][4] + 1, last[x][3], 1);
ans += tree[1].sum;
}
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char c;
cin >> c;
string s;
cin >> s;
map<char, char> right;
map<char, char> left;
right.insert({'q', 'w'});
right.insert({'w', 'e'});
right.insert({'e', 'r'});
right.insert({'r', 't'});
right.insert({'t', 'y'});
right.insert({'u', 'i'});
right.insert({'i', 'o'});
right.insert({'o', 'p'});
right.insert({'a', 's'});
right.insert({'s', 'd'});
right.insert({'d', 'f'});
right.insert({'f', 'g'});
right.insert({'g', 'h'});
right.insert({'h', 'j'});
right.insert({'j', 'k'});
right.insert({'l', ';'});
right.insert({'z', 'x'});
right.insert({'x', 'c'});
right.insert({'c', 'v'});
right.insert({'v', 'b'});
right.insert({'b', 'n'});
right.insert({'n', 'm'});
right.insert({'m', ','});
right.insert({',', '.'});
right.insert({'.', '/'});
right.insert({'k', 'l'});
right.insert({'y', 'u'});
right.insert({'k', 'l'});
left.insert({'w', 'q'});
left.insert({'e', 'w'});
left.insert({'r', 'e'});
left.insert({'t', 'r'});
left.insert({'d', 's'});
left.insert({';', 'l'});
left.insert({'y', 't'});
left.insert({'f', 'd'});
left.insert({'x', 'z'});
left.insert({'u', 'y'});
left.insert({'g', 'f'});
left.insert({'c', 'x'});
left.insert({'i', 'u'});
left.insert({'h', 'g'});
left.insert({'v', 'c'});
left.insert({'o', 'i'});
left.insert({'j', 'h'});
left.insert({'b', 'v'});
left.insert({'p', 'o'});
left.insert({'k', 'j'});
left.insert({'n', 'b'});
left.insert({'s', 'a'});
left.insert({'l', 'k'});
left.insert({'m', 'n'});
left.insert({',', 'm'});
left.insert({'.', ','});
left.insert({'/', '.'});
if (c == 'R') {
for (int i = 0; i < s.size(); i++) {
char a = s[i];
cout << left[a];
}
} else {
for (int i = 0; i < s.size(); i++) {
char a = s[i];
cout << right[a];
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
long long d, m;
cin >> d >> m;
long long ans = 1, i = 0;
while ((1 << i + 1) <= d) ans = (ans * (1 + (1 << i++))) % m;
ans = (ans * (1 + (d - (1 << i) + 1))) % m;
cout << (ans + m - 1) % m << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char a[100][100];
char an[100][100];
string s[100];
void gene() {
char x = 'A';
char y = 'a';
for (int i = 0; i < 26; i++) {
a[i][0] = x;
x++;
}
x = 'A';
for (int i = 26; i < 52; i++) {
a[i][0] = x;
a[i][1] = y;
y++;
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
s[i] = "Aa";
s[i][0] += i / 26;
s[i][1] += i % 26;
}
string b;
for (int i = 0; i < n - m + 1; i++) {
cin >> b;
if (b[0] == 'N') {
s[i + m - 1] = s[i];
}
}
for (int i = 0; i < n; i++) {
cout << s[i];
printf(" ");
}
printf("\n");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, ai[100], xi, yi;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> ai[i];
}
cin >> m;
while (m--) {
cin >> xi >> yi;
ai[xi - 1] += (yi - 1);
ai[xi + 1] += (ai[xi] - yi);
ai[xi] = 0;
}
for (int i = 1; i <= n; i++) {
cout << ai[i] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 100;
const long double pi = acos(-1.0);
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while ((ch < '0') || (ch > '9')) {
if (ch == '-') f = -1;
ch = getchar();
}
while ((ch >= '0') && (ch <= '9')) {
x = x * 10 + (ch - '0');
ch = getchar();
}
return x * f;
}
inline long long readll() {
long long x = 0;
int f = 1;
char ch = getchar();
while ((ch < '0') || (ch > '9')) {
if (ch == '-') f = -1;
ch = getchar();
}
while ((ch >= '0') && (ch <= '9')) {
x = x * 10 + (ch - '0');
ch = getchar();
}
return x * f;
}
struct node {
int h, m, id;
} p[N << 1];
bool cmp(node p, node q) { return p.m < q.m; }
int n, h, m, k;
int main() {
n = read();
h = read();
m = read();
k = read();
for (register int i = 1; i <= n; i++) {
p[i].h = read();
p[i].m = read();
p[i].id = i;
}
for (register int i = 1; i <= n; i++) p[i].m %= (m >> 1);
sort(p + 1, p + 1 + n, cmp);
for (register int i = 1; i <= n; i++) {
p[i + n] = p[i];
p[i + n].m += (m / 2);
}
sort(p + 1, p + 1 + n * 2, cmp);
int ansr = 0, ansl = 0, ans = n * 2;
int l = 1;
for (register int i = n + 1; i <= n * 2; i++) {
while ((l < i) && (p[i].m > p[l].m + k - 1)) {
l++;
}
if (i - l < ans) {
ans = i - l;
ansl = l;
ansr = i;
}
}
printf("%d %d\n", ans, p[ansr].m - (m >> 1));
for (register int i = ansl; i <= ansr - 1; i++) printf("%d ", p[i].id);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
while (T--) {
int n, m, k;
cin >> n >> m >> k;
if (m <= n / k) {
cout << m << endl;
} else {
m -= n / k;
cout << n / k - m / (k - 1) - (m % (k - 1) != 0) << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int main() {
int n, c1 = 0, c2 = 0, mx = 0, mn = 1000000007;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
mx = max(mx, a[i]), mn = min(mn, a[i]);
}
for (int i = 0; i < n; i++) {
if (a[i] == mx) c1++;
if (a[i] == mn) c2++;
}
if (mx == mn)
cout << 0;
else
cout << (n - c1 - c2);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tt;
cin >> tt;
while (tt--) {
long long n, s, t;
cin >> n >> s >> t;
cout << max(n - s + 1, n - t + 1) << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
unsigned long long n, l, m, arr[N], arrEx[N], mod = 1e9 + 7, freqEn[111],
freq[111], cnt[111], freqEx[111];
vector<vector<unsigned long long>> mul(vector<vector<unsigned long long>> &a,
vector<vector<unsigned long long>> &b) {
int n = a.size(), m = b[0].size();
vector<vector<unsigned long long>> res =
vector<vector<unsigned long long>>(n, vector<unsigned long long>(m, 0));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < n; k++) {
res[i][j] =
(res[i][j] % mod + ((a[i][k] % mod) * (b[k][j] % mod)) % mod) % mod;
}
}
}
return res;
}
vector<vector<unsigned long long>> matrix_fp(
vector<vector<unsigned long long>> &a, unsigned long long p) {
if (p == 1) return a;
vector<vector<unsigned long long>> res = matrix_fp(a, p / 2);
res = mul(res, res);
if (p % 2) res = mul(res, a);
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> l >> m;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
freqEn[x % m]++;
}
for (int i = 1; i <= n; i++) {
cin >> arr[i];
int x = arr[i];
freq[x % m]++;
}
for (int i = 1; i <= n; i++) {
cin >> arrEx[i];
int x = arrEx[i];
freqEx[x % m]++;
}
vector<vector<unsigned long long>> a = vector<vector<unsigned long long>>(
m, vector<unsigned long long>(1, 0)),
M = vector<vector<unsigned long long>>(
m, vector<unsigned long long>(m, 0));
for (int i = 0; i < m; i++) {
a[i][0] = freqEn[i];
for (int j = 0; j < m; j++) {
int from = i, to = (i + j) % m;
M[to][from] = freq[j];
}
}
for (int i = 1; i <= n; i++) {
int tmp = (arr[i] + arrEx[i]) % m;
cnt[tmp]++;
}
if (l > 2) {
M = matrix_fp(M, l - 2);
a = mul(M, a);
}
unsigned long long ans = 0;
for (int i = 0; i < m; i++) {
int need = 0;
if (i) need = m - i;
ans += cnt[need] * a[i][0];
ans %= mod;
}
cout << ans << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &n) {
n = 0;
T f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-') f = -1, c = getchar();
while (isdigit(c)) n = n * 10 + c - '0', c = getchar();
n *= f;
}
template <typename T>
void write(T n) {
if (n < 0) putchar('-'), n = -n;
if (n > 9) write(n / 10);
putchar(n % 10 + '0');
}
struct edge {
int x, y, id;
long long w;
friend bool operator<(edge a, edge b) { return a.w < b.w; }
} e[500005];
int n, cnt;
int head[500005], vet[500005], Next[500005], fa[500005];
long long a[500005];
int find(int x) {
if (x == fa[x]) return x;
return fa[x] = find(fa[x]);
}
void add(int x, int y) {
cnt++;
Next[cnt] = head[x];
head[x] = cnt;
vet[cnt] = y;
}
int T, in[500005], out[500005];
void dfs(int x, int fa) {
if (x != 1 && !Next[head[x]]) {
in[x] = out[x] = ++T;
return;
}
in[x] = n + 1, out[x] = 0;
for (int i = head[x]; i; i = Next[i]) {
int v = vet[i];
if (v == fa) continue;
dfs(v, x);
in[x] = min(in[x], in[v]);
out[x] = max(out[x], out[v]);
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) read(a[i]);
int x, y;
for (int i = 1; i < n; i++) {
read(x), read(y);
add(x, y), add(y, x);
}
dfs(1, 0);
for (int i = 1; i <= n; i++) {
e[i] = (edge){in[i], out[i] + 1, i, a[i]};
}
sort(e + 1, e + n + 1);
for (int i = 1; i <= n + 1; i++) fa[i] = i;
vector<int> v;
int last = 1;
long long ans = 0;
while (last <= n) {
int p = last;
while (p < n && e[p + 1].w == e[p].w) p++;
for (int i = last; i <= p; i++) {
x = find(e[i].x), y = find(e[i].y);
if (x != y) {
v.push_back(e[i].id);
}
}
for (int i = last; i <= p; i++) {
x = find(e[i].x), y = find(e[i].y);
if (x != y) {
ans += e[i].w;
fa[x] = y;
}
}
last = p + 1;
}
cout << ans << " " << v.size() << endl;
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) write(v[i]), putchar(' ');
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline void EnableFileIO(const string& fileName) {
if (fileName.empty()) return;
freopen((fileName + ".in").c_str(), "r", stdin);
freopen((fileName + ".out").c_str(), "w", stdout);
return;
}
const int INF = (1 << 30) - 1;
const long long LINF = (1LL << 61) - 1;
const double EPS = 1e-10;
const int N = 12, MASK = 2048, P = 1e9 + 7;
int n, m, k;
int field[N][N];
int col[N][N], vis[N];
long long ans;
long long calc(int x, int y) {
if (x == n) {
return 1;
}
if (y == m) {
return calc(x + 1, 0);
}
col[x][y] = (x ? col[x - 1][y] : 0) | (y ? col[x][y - 1] : 0);
int& mask = col[x][y];
int used = 0;
for (int i = 1; i <= k; i++) {
if (mask >> i & 1) used++;
}
if (((n - x) + (m - y) - 1) > (k - used)) return 0;
if (field[x][y]) {
if (mask >> field[x][y] & 1) return 0;
mask ^= 1 << field[x][y];
long long r = calc(x, y + 1);
mask ^= 1 << field[x][y];
return r;
} else {
long long lazy = -1;
long long r = 0;
for (int num = 1; num <= k; num++) {
if (mask >> num & 1) continue;
mask ^= 1 << num, vis[num]++;
if (vis[num] == 1) {
if (lazy == -1) {
lazy = calc(x, y + 1);
}
r += lazy;
} else {
r += calc(x, y + 1);
}
mask ^= 1 << num, vis[num]--;
}
return r;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
EnableFileIO("");
cin >> n >> m >> k;
if (n + m - 1 > k) {
cout << 0 << endl;
return 0;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> field[i][j];
if (field[i][j]) vis[field[i][j]]++;
}
}
cout << calc(0, 0) % P << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, k, lasta[10005], a[10005];
struct node {
int num, w;
} b[10005];
int find(int now) {
int l = 1, r = n;
for (int mid = (l + r >> 1); l < r; mid = (l + r >> 1))
if (b[mid].w < now)
l = mid + 1;
else
r = mid;
while (b[l].w > now) l--;
return b[l].num;
}
bool cmp(node u, node v) { return u.w < v.w; }
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) a[i] = 1;
a[n] = 0;
for (int t = 1; t <= k; t++) {
for (int i = 1; i <= n; i++) {
b[i].num = i;
b[i].w = a[i];
lasta[i] = a[i];
}
sort(b + 1, b + n + 1, cmp);
for (int i = 1; i <= n; i++) {
int tmp = find(n - i - a[i]);
printf("%d ", tmp);
a[i] = a[i] + lasta[tmp];
}
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long ans = 0;
long long t[200005];
int h[200005], deg[200005], in[200005], out[200005];
bool vis[200005];
long long dp[2][200005];
vector<int> adj[200005];
void dfs(int n, int par) {
vis[n] = 1;
vector<long long> val;
int chi = 0;
long long tot = 0;
for (int v : adj[n]) {
if (v != par) {
chi++;
dfs(v, n);
val.push_back(dp[0][v] - dp[1][v]);
tot += dp[1][v];
}
}
sort(val.begin(), val.end());
reverse(val.begin(), val.end());
if (!par) {
dp[0][n] = tot + t[n] * min(in[n], out[n] + chi);
} else {
dp[0][n] = tot + t[n] * min(in[n], out[n] + chi + 1);
dp[1][n] = tot + t[n] * min(in[n] + 1, out[n] + chi);
}
for (int i = 0; i < val.size(); i++) {
if (i) val[i] += val[i - 1];
if (!par) {
dp[0][n] =
max(dp[0][n],
val[i] + tot + t[n] * min(in[n] + i + 1, out[n] + (chi - i - 1)));
} else {
dp[0][n] = max(
dp[0][n],
val[i] + tot + t[n] * min(in[n] + i + 1, out[n] + 1 + (chi - i - 1)));
dp[1][n] = max(
dp[1][n],
val[i] + tot + t[n] * min(in[n] + 1 + i + 1, out[n] + (chi - i - 1)));
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> t[i];
for (int i = 1; i <= n; i++) cin >> h[i];
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
deg[a]++, deg[b]++;
if (h[a] == h[b]) {
adj[a].push_back(b);
adj[b].push_back(a);
} else {
if (h[a] < h[b])
out[a]++, in[b]++;
else
in[a]++, out[b]++;
}
}
for (int i = 1; i <= n; i++) ans += t[i] * deg[i];
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
dfs(i, 0);
ans -= dp[0][i];
}
}
cout << ans << "\n";
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 202;
int n, m, l;
long long k;
int a[MAXN];
int d[MAXN];
char s[MAXN];
long long f[MAXN][MAXN];
bool opr_sort(const int &i, const int &j) { return a[i] < a[j]; }
int main() {
cin >> n >> m >> k;
l = n + m - 1;
for (int i = 0; i < l; i++) {
a[i] = n * m;
d[i] = i;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int x;
scanf("%d", &x);
if (x < a[i + j]) a[i + j] = x;
}
}
sort(d, d + l, opr_sort);
for (int I = 0; I < l; I++) {
s[d[I]] = '(';
f[0][0] = 1;
for (int i = 0; i < l; i++)
for (int j = 0; j <= l; j++)
if (f[i][j]) {
if (f[i][j] > k) f[i][j] = k;
if (s[i] != ')') f[i + 1][j + 1] += f[i][j];
if (s[i] != '(' && j) f[i + 1][j - 1] += f[i][j];
f[i][j] = 0;
}
if (k > f[l][0]) {
k -= f[l][0];
s[d[I]] = ')';
}
f[l][0] = 0;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%c", s[i + j]);
printf("\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
ifstream in("input.in");
ofstream out("output.out");
const long long nmx = 2e5 + 5;
const long long MOD = 1e9 + 7;
long long n, m, a, b, cnt[nmx] = {};
bitset<nmx> vis;
vector<long long> li[nmx];
queue<long long> q;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
cin >> n >> m >> a >> b;
for (int i = 1; i <= n; ++i) {
li[i].clear();
cnt[i] = 0;
}
vis.reset();
for (int i = 1; i <= m; ++i) {
long long x, y;
cin >> x >> y;
li[x].push_back(y);
li[y].push_back(x);
}
q.push(a);
while (!q.empty()) {
long long f = q.front();
q.pop();
for (auto k : li[f]) {
if (vis[k] == 0 && k != b && k != a) {
++cnt[k];
vis[k] = 1;
q.push(k);
}
}
}
vis.reset();
q.push(b);
while (!q.empty()) {
long long f = q.front();
q.pop();
for (auto k : li[f]) {
if (vis[k] == 0 && k != a && k != b) {
++cnt[k];
vis[k] = 1;
q.push(k);
}
}
}
long long fromA = 0;
q.push(a);
vis.reset();
while (!q.empty()) {
long long f = q.front();
q.pop();
for (auto k : li[f]) {
if (vis[k] == 0 && cnt[k] == 1) {
vis[k] = 1;
q.push(k);
++fromA;
}
}
}
long long fromB = 0;
q.push(b);
vis.reset();
while (!q.empty()) {
long long f = q.front();
q.pop();
for (auto k : li[f]) {
if (vis[k] == 0 && cnt[k] == 1) {
vis[k] = 1;
q.push(k);
++fromB;
}
}
}
cout << fromA * fromB << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<long long> a;
int main() {
scanf("%d", &n);
a.resize(n);
for (auto &ll : a) scanf("%lld", &ll);
map<long long, int> cnt;
for (auto &ll : a) cnt[ll]++;
map<long long, int> summand;
int seq_cnt_bound = n;
priority_queue<long long> remains;
for (long long i = 1; i < (long long)(1e13); i <<= 1) {
seq_cnt_bound = min(seq_cnt_bound, cnt[i]);
summand[i] = seq_cnt_bound;
for (int j = 0; j < cnt[i] - summand[i]; j++) {
remains.push(i);
}
}
for (auto &ll : a) {
if (__builtin_popcountll(ll) > 1) remains.push(ll);
}
auto check = [&](int x, priority_queue<long long> r,
map<long long, int> summand) -> bool {
for (long long i = 1; i < (long long)(1e13); i <<= 1) {
for (int j = 0; j < (summand[i] - min(summand[i], x)); j++) r.push(i);
}
while (not r.empty()) {
long long rtop = r.top();
r.pop();
if (!x) return false;
x--;
long long largest_pwr2 = 1;
for (long long i = 1; i < (long long)(1e16); i <<= 1) {
if (summand[i] > 0) {
summand[i]--;
largest_pwr2 <<= 1;
} else
break;
}
if (rtop > largest_pwr2) return false;
}
return true;
};
int upper = cnt[1];
int lower = upper;
if (check(upper, remains, summand)) {
} else {
printf("-1\n");
return 0;
}
int lo = 0, hi = upper;
while (hi - lo > 1) {
int mid = (hi + lo) / 2;
if (check(mid, remains, summand)) {
hi = mid;
lower = hi;
} else {
lo = mid;
}
}
while (lower <= upper) {
printf("%d ", lower);
lower++;
}
printf("\n");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int s = 0;
int a[5001];
cin >> n;
int i;
for (i = 1; i <= n; i++) {
cin >> a[i];
}
for (i = 1; i <= n; i++) {
if (a[i] == a[a[a[a[i]]]]) s = s + 1;
}
if (s != 0) {
cout << "YES";
} else
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q, n, x, y, A, B, C, D, i, u, d, l, r;
scanf("%d", &q);
while (q) {
q--;
u = 100000, d = -100000, l = -100000, r = 100000;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d %d %d %d %d %d", &x, &y, &A, &B, &C, &D);
if (!A) l = max(l, x);
if (!B) u = min(u, y);
if (!C) r = min(r, x);
if (!D) d = max(d, y);
}
if (u >= d && l <= r)
printf("1 %d %d\n", l, d);
else
printf("0\n");
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool umin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool umax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
long long POW(long long a, long long p, long long M) {
if (!p) return 1LL;
long long T = POW(a, p / 2, M);
T = T * T % M;
if (p & 1) T = T * (a % M) % M;
return T;
}
long long SQRT(long long a) {
long long b = (long long)sqrtl(((double)a) + 0.5);
while (b * b < a) ++b;
while (b * b > a) --b;
return (b * b == a) ? b : -1;
}
const long long MOD = 1e9 + 7;
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed;
long long s[2];
long long n;
cin >> n;
cin >> s[0] >> s[1];
vector<pair<long long, long long>> vv(n);
for (long long i = 0; i < n; i++) cin >> vv[i].first >> vv[i].second;
long long f = 0;
long long ff[2];
for (long long i = 0; i < 2; i++)
for (long long j = -1; j <= 1; j += 2) {
long long fff[2];
fff[0] = s[0];
fff[1] = s[1];
fff[i] += j;
if (fff[0] >= 0 && fff[1] >= 0 && fff[0] <= 1e9 && fff[1] <= 1e9) {
long long xf = 0;
for (long long x = 0; x < n; x++) {
if (fff[0] >= min(vv[x].first, s[0]) &&
fff[0] <= max(vv[x].first, s[0]) &&
fff[1] >= min(vv[x].second, s[1]) &&
fff[1] <= max(vv[x].second, s[1]))
xf++;
}
if (xf > f) {
f = xf;
ff[0] = fff[0];
ff[1] = fff[1];
}
}
}
cout << f << endl;
cout << ff[0] << " " << ff[1] << endl;
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void Get(int &T) {
char C;
bool F = 0;
for (; C = getchar(), C < '0' || C > '9';)
if (C == '-') F = 1;
for (T = C - '0'; C = getchar(), C >= '0' && C <= '9'; T = T * 10 + C - '0')
;
F && (T = -T);
}
void Get(long long &T) {
char C;
bool F = 0;
for (; C = getchar(), C < '0' || C > '9';)
if (C == '-') F = 1;
for (T = C - '0'; C = getchar(), C >= '0' && C <= '9'; T = T * 10 + C - '0')
;
F && (T = -T);
}
int U[50005];
int V[50005];
int W[50005];
int W2[50005];
int Order[50005];
int N, M;
bool Cmp(int X, int Y) { return W2[X] < W2[Y]; }
long long C1, C2;
void Init() {
Get(N);
Get(M);
Get(C1);
Get(C2);
for (int i = 1; i <= M; i++) {
Get(U[i]);
Get(V[i]);
Get(W[i]);
Get(W2[i]);
Order[i] = i;
}
std::sort(Order + 1, Order + M + 1, Cmp);
}
bool Delete[100005];
struct E {
int V, W, Next;
} Edge[100005];
int EdgeTop = 1;
int Head[205];
void Add(int U, int V, int W) {
Edge[++EdgeTop] = (E){V, W, Head[U]};
Head[U] = EdgeTop;
}
int Visited[205];
int Time;
int StackAns[205];
int StackX[205];
int Stacki[205];
multiset<int> Hash;
int DFS(int X, int Y) {
int Top = 1, i;
StackX[Top] = X;
Call:
X = StackX[Top];
if (X == Y) {
int Max = StackAns[1];
for (int i = 2; i < Top; i++) {
if (Edge[StackAns[i]].W > Edge[Max].W) Max = StackAns[i];
}
return Max;
}
Visited[X] = Time;
for (; Delete[Head[X]]; Head[X] = Edge[Head[X]].Next)
;
for (i = Head[X]; i; i = Edge[i].Next) {
if (Visited[Edge[i].V] != Time) {
StackAns[Top] = i;
StackX[Top + 1] = Edge[i].V;
Stacki[Top] = i;
Top++;
goto Call;
Return:
Top--;
X = StackX[Top];
i = Stacki[Top];
}
for (; Delete[Edge[i].Next]; Edge[i].Next = Edge[Edge[i].Next].Next)
;
}
if (Top >= 2) goto Return;
return -1;
}
long long Ans;
void Work() {
Ans = 0x2f2f2f2f2f2f2f2fll;
for (int k = 1, i; k <= M; k++) {
i = Order[k];
if (U[i] == V[i]) continue;
Time++;
int Max = DFS(U[i], V[i]);
if (Max == -1) {
Hash.insert(W[i]);
Add(U[i], V[i], W[i]);
Add(V[i], U[i], W[i]);
} else if (Edge[Max].W > W[i]) {
Delete[Max] = Delete[Max ^ 1] = 1;
Hash.erase(Hash.find(Edge[Max].W));
Hash.insert(W[i]);
Add(U[i], V[i], W[i]);
Add(V[i], U[i], W[i]);
}
if (Hash.size() == N - 1) {
long long Ans0 = *Hash.rbegin() * C1 + W2[i] * C2;
if (Ans > Ans0) Ans = Ans0;
}
}
}
void Output() {
if (Ans >= 0x2f2f2f2f2f2f2f2fll)
puts("-1");
else
printf("%I64d\n", Ans);
}
int main() {
Init();
Work();
Output();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long i, j, c = 0, x = 1, y = 1, r = 0, result = 0, ans = 1, temp = 0,
sum = 1, d, n, m, t;
string str, str1, str2, s1, s2, s3 = " ";
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
bool isprime(int n) {
if (n == 1) return 0;
if (n == 2 || n == 3) return 1;
if (n % 2 == 0 || n % 3 == 0) return 0;
for (long long i = 5; i * i <= n; i += 6) {
if (n % i == 0 || n % (i + 2) == 0) return 0;
return 1;
}
}
long long divisors(long long n) {
long long i;
for (i = 1; i < sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i)
cout << i << " ";
else
cout << i << " " << n / i << " ";
}
}
}
void sieve(int n) {
vector<bool> isprime(n + 1, true);
{
for (i = 2; i <= n; i++) {
if (isprime[i]) {
cout << i << " ";
for (j = i * i; j <= n; j += i) {
isprime[j] = false;
}
}
}
}
}
int power(long long n, long long m) {
for (i = 0; i < m; i++) {
sum = sum * n;
}
cout << sum;
}
long long powe(long long n, long long m) {
while (m > 0) {
if (m & 1) ans *= n;
n *= n;
m = m >> 1;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> t;
while (t--) {
c = -1;
string s;
cin >> n >> s;
if (n == 1) {
if (s[0] == '?') {
s[0] = 'B';
cout << s << "\n";
continue;
} else {
cout << s << "\n";
continue;
}
}
for (i = 0; i < n; i++) {
if (s[i] != '?') {
c = i;
break;
}
}
if (c == -1) {
s[0] = 'B';
c = 0;
}
for (i = c - 1; i >= 0; i--) {
if (s[i] == '?') {
if (s[i + 1] == 'B') {
s[i] = 'R';
} else {
s[i] = 'B';
}
}
}
for (i = c + 1; i < n; i++) {
if (s[i] == '?') {
if (s[i - 1] == 'B') {
s[i] = 'R';
} else {
s[i] = 'B';
}
}
}
cout << s << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3fffffff;
const int SINF = 0x7fffffff;
const long long LINF = 0x3fffffffffffffff;
const long long SLINF = 0x7fffffffffffffff;
const int MAXN = 200007;
const int MAXS = MAXN * 4;
const int MAX = 262144;
class stT {
public:
stT() {
memset(data, 0, sizeof(data));
memset(sum, 0, sizeof(sum));
for (int i = 0; i < MAXS; ++i)
maxi[i] = make_pair(0, 0), mini[i] = make_pair(SINF, 0);
memset(wc, false, sizeof(wc));
}
pair<int, int> getmax() { return maxi[1]; }
pair<int, int> getmin() { return mini[1]; }
int getsum() { return sum[1]; }
void setwc(int pos, bool val, int now = 1, int l = 1, int r = MAX) {
if (!pos) return;
if (pos == l && pos == r) {
wc[pos] = val;
if (val)
mini[now] = make_pair(data[now], pos), maxi[now] = make_pair(0, 0),
sum[now] = (data[now] + 1) >> 1;
else
mini[now] = make_pair(SINF, 0), maxi[now] = make_pair(data[now], pos),
sum[now] = data[now];
} else if (pos >= l && pos <= r) {
int mid = (l + r) >> 1;
setwc(pos, val, now << 1, l, mid);
setwc(pos, val, now << 1 ^ 1, mid + 1, r);
sum[now] = sum[now << 1] + sum[now << 1 ^ 1];
maxi[now] =
(((maxi[now << 1]) > (maxi[now << 1 ^ 1])) ? (maxi[now << 1])
: (maxi[now << 1 ^ 1]));
mini[now] =
(((mini[now << 1]) < (mini[now << 1 ^ 1])) ? (mini[now << 1])
: (mini[now << 1 ^ 1]));
}
}
void setpl(int pos, bool val, int now = 1, int l = 1, int r = MAX) {
if (pos == l && pos == r) {
if (val) {
sum[now] = data[now];
maxi[now] = make_pair(data[now], pos);
} else {
sum[now] = 0;
wc[pos] = false;
mini[now] = make_pair(SINF, 0), maxi[now] = make_pair(0, 0);
}
} else if (pos >= l && pos <= r) {
int mid = (l + r) >> 1;
setpl(pos, val, now << 1, l, mid);
setpl(pos, val, now << 1 ^ 1, mid + 1, r);
sum[now] = sum[now << 1] + sum[now << 1 ^ 1];
maxi[now] =
(((maxi[now << 1]) > (maxi[now << 1 ^ 1])) ? (maxi[now << 1])
: (maxi[now << 1 ^ 1]));
mini[now] =
(((mini[now << 1]) < (mini[now << 1 ^ 1])) ? (mini[now << 1])
: (mini[now << 1 ^ 1]));
}
}
void setd(int pos, int val, int now = 1, int l = 1, int r = MAX) {
if (pos == l && pos == r)
data[now] = val;
else if (pos >= l && pos <= r) {
int mid = (l + r) >> 1;
setd(pos, val, now << 1, l, mid);
setd(pos, val, now << 1 ^ 1, mid + 1, r);
}
}
private:
int data[MAXS], sum[MAXS];
pair<int, int> maxi[MAXS], mini[MAXS];
bool wc[MAXS];
} st;
int n, w, k;
int a[MAXN], t[MAXN];
int pre[MAXN];
bool wc[MAXN];
void init();
void input();
void work();
int main() {
init();
input();
work();
}
void init() { ios::sync_with_stdio(false); }
void input() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) scanf("%d", &t[i]);
}
void work() {
pre[0] = 0;
for (int i = 1; i <= n; ++i) pre[i] = pre[i - 1] + a[i];
t[n + 1] = 0;
for (int i = 1; i <= n + 1; ++i) st.setd(i, t[i]);
int l = 0, r = 0, ans = 0;
pair<int, int> nm;
memset(wc, false, sizeof(wc));
while (1) {
while (r <= n && st.getsum() <= k) {
++r;
st.setpl(r, true);
if (r - l <= w)
st.setwc(r, true), wc[r] = true;
else {
nm = st.getmin();
if (t[r] > nm.first) {
st.setwc(nm.second, false), wc[nm.second] = false;
st.setwc(r, true), wc[r] = true;
}
}
}
ans = (((ans) > (pre[r - 1] - pre[l])) ? (ans) : (pre[r - 1] - pre[l]));
if (r > n) break;
++l;
st.setpl(l, false);
if (wc[l]) {
wc[l] = false;
nm = st.getmax();
st.setwc(nm.second, true);
wc[nm.second] = true;
}
}
printf("%d\n", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int p[100010];
int find(int a) { return p[a] == a ? a : (p[a] = find(p[a])); }
bool uni(int a, int b) {
a = find(a), b = find(b);
if (a == b) return false;
p[a] = b;
return true;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < (int)n; i++) p[i] = i;
int ans = 1;
for (int i = 0; i < (int)m; i++) {
int a, b;
cin >> a >> b;
if (!uni(a, b)) ans = ans * 2 % 1000000009;
cout << (ans - 1 + 1000000009) % 1000000009 << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, d[1000001], a[1000001];
bool cmp(int a, int b) { return d[(a + 1) >> 1] > d[(b + 1) >> 1]; }
vector<int> v[100001];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &d[i]);
for (int i = 1; i <= n; ++i) a[i] = (i << 1) - 1;
sort(a + 1, a + 1 + n, cmp);
for (int i = 1; i <= n; ++i) v[i].push_back(a[i]);
for (int i = 1; i < n; ++i) printf("%d %d\n", a[i], a[i + 1]);
for (int i = 1; i <= n; ++i) {
int pos = min(i + d[(a[i] + 1) >> 1] - 1, n);
printf("%d %d\n", a[i] + 1, v[pos][d[(a[i] + 1) >> 1] - (pos - i) - 1]);
if (v[pos].size() == d[(a[i] + 1) >> 1] - (pos - i))
v[pos].push_back(a[i] + 1);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <class T>
inline bool setmin(T &a, T b) {
if (a > b) return a = b, 1;
return 0;
}
template <class T>
inline bool setmax(T &a, T b) {
if (a < b) return a = b, 1;
return 0;
}
template <class T>
inline T fast(T a, T b, T mod) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
template <class T>
istream &operator>>(istream &os, vector<T> &container) {
for (auto &u : container) os >> u;
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &container) {
for (auto &u : container) os << u << " ";
return os;
}
template <class T>
inline T gcd(T a, T b) {
while (b) swap(a %= b, b);
return abs(a);
}
const int INF = 1e9 + 7;
const long long mod = 998244353;
const long long BIG_INF = 1e18 + 7;
const long long N = 1e6 + 7;
const unsigned int T = 1LL << 20;
const long double inf = 1e18;
const long double eps = 1e-14;
const int LOG = 20;
long long n, m, k;
vector<vector<int> > G(N);
vector<unordered_set<int> > siema(N);
int stopien[N];
set<pair<int, int> > wziete;
bool check_clique(int v) {
vector<int> teraz = {v};
for (auto &u : G[v])
if (wziete.count({stopien[u], u})) teraz.push_back(u);
assert((int)(teraz).size() == k);
shuffle((teraz).begin(), (teraz).end(), rng);
random_shuffle((teraz).begin(), (teraz).end());
for (int i = 0; i < k; i++)
for (int j = i + 1; j < k; j++)
if (!siema[teraz[i]].count(teraz[j])) return false;
cout << 2 << '\n';
for (auto &u : teraz) cout << u << ' ';
cout << '\n';
return true;
}
void solve() {
cin >> n >> m >> k;
srand(time(0));
for (int i = 1; i <= n; i++) G[i].clear();
for (int i = 1; i <= n; i++) siema[i].clear();
wziete = set<pair<int, int> >();
for (int i = 1; i <= n; i++) stopien[i] = 1;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
siema[a].insert(b);
siema[b].insert(a);
}
for (int i = 1; i <= n; i++) stopien[i] = (int)(G[i]).size();
for (int i = 1; i <= n; i++) wziete.insert({stopien[i], i});
while ((int)(wziete).size()) {
if ((*wziete.begin()).first == k - 1)
if (check_clique((*wziete.begin()).second)) {
return;
}
if ((*wziete.begin()).first >= k) break;
int pom = (*wziete.begin()).second;
wziete.erase(wziete.begin());
for (auto &u : G[pom]) {
if (wziete.count({stopien[u], u})) {
wziete.erase({stopien[u], u});
stopien[u]--;
wziete.insert(make_pair(stopien[u], u));
}
}
}
if ((int)(wziete).size() > k) {
cout << 1 << ' ' << (int)(wziete).size() << '\n';
for (auto &u : wziete) cout << u.second << ' ';
cout << '\n';
} else {
cout << -1 << '\n';
}
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t = 1;
cin >> t;
while (t--) solve();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, p[101];
int d[101];
int main() {
scanf("%d", &n);
for (int i = 0; i < n * 2; ++i) {
scanf("%d", &p[i]);
}
sort(p, p + (2 * n));
int l = n * 2;
int answer = 987654321;
for (int a = 0; a < l; ++a) {
for (int b = a + 1; b < l; ++b) {
int ans = 0;
bool sel = false;
int f = 0;
for (int i = 0; i < l; ++i) {
if (i == a | i == b) continue;
if (sel) {
ans += p[i] - f;
} else {
f = p[i];
}
sel = !sel;
}
answer = min(ans, answer);
}
}
printf("%d", answer);
}
| 3 |
//Bismillahir-Rahmanir-Rahim
//Atik Shahriar Anik
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define fast ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define endl '\n'
#define Endl '\n'
#define cont continue
#define gcd(a,b) __gcd(a,b)
#define lcm(a,b) a*b/__gcd(a,b)
#define pb push_back
#define mp make_pair
#define mem(x) memset(x, 0, sizeof(x))
#define YES cout<<"YES"<<endl;
#define NO cout<<"NO"<<endl;
const ll inf=1e18;
const int mod=1e9+7;
inline int bigmod(int B,int P){int R=1;while(P>0){if(P&1){R=(R*B)%mod;}P>>=1;B=(B*B)%mod;}return R;}
const int mxn = 2e3+10;
int Mod(int a) {
if(a < 0)
return (a+mod)%mod;
else return a % mod;
}
int Mul(int a, int b) {
return Mod(Mod(a) * Mod(b));
}
int Add(int a, int b) {
return Mod(Mod(a) + Mod(b));
}
/*
//sieve starts here
#define svMX 200005
bitset<svMX>siv;
vector<ll>prime;
void sieve () {
siv[0] = siv[1] = 1; // 0 and 1 are not prime
prime.push_back(2); // Only Even Prime
for ( int i = 4; i <= svMX; i += 2 ) siv[i] = 1; // Remove multiples of 2
int sqrtn = sqrt ( svMX );
for ( int i = 3; i <= sqrtn; i += 2 ) {
if ( siv[i] == 0 ) {
for ( int j = i * i; j <= svMX; j += 2 * i ) siv[j] = 1;
}
}
for ( int i = 3; i <= svMX; i += 2 ) if ( siv[i] == 0 ) prime.push_back(i);
}
//sieve ends here
*/
//ll fact[mxn];
//ll in_fact[mxn];
//fact[0] = 1;
//for(ll i = 1; i < mxn; i++) {
//fact[i] = (i*fact[i-1])%mod;
//}
//in_fact[mxn-1] = bigmod(fact[mxn-1],mod-2);
//for(ll i = mxn-2; i >= 0; i--) {
//in_fact[i] = (in_fact[i+1] * (i+1))%mod;
//}
//ll c(ll n,ll r) {
//ll ans = (fact[n] * (in_fact[r] * in_fact[n-r]%mod))%mod;
//return ans;
//}
int ip[mxn], memo[mxn][mxn];
int dp(int l, int r) {
if(memo[l][r] != -1) return memo[l][r];
if(l == r) return 0;
return memo[l][r] = ip[r]-ip[l] + min(dp(l,r-1),dp(l+1,r));
}
signed main(){
fast;
//freopen ("input.txt", "r", stdin);
//freopen ("output.txt", "w", stdout);
int tt = 1;
//cin>>tt;
for(int tc = 1; tc <= tt; tc++) {
int n;
cin>>n;
for(int i = 0; i < n; i++) cin>>ip[i];
sort(ip,ip+n);
memset(memo,-1, sizeof memo);
cout<<dp(0,n-1)<<endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int const N = 101;
long long const INF = 1 << 30;
double eps = 1.0e-8;
const double pai = acos(-1.0);
const double g = 9.87;
int a, b, c;
int i, j, k;
int n, s, l;
int ii, jj, kk;
int main() {
cin >> n >> s;
for (int m = 0; m < (n); m++) {
cin >> l;
if (l == 3) a++;
if (l == 4) b++;
if (l == 5) c++;
}
int ans = 0x3fffffff;
for (i = s / n; i >= 0; i--)
for (j = min((s - i * a) / (b + c), (ans + a * i) / b); j >= i; j--) {
if ((i * a - j * b) >= ans) break;
k = (s - i * a - j * b) / c;
if ((-j * b + k * c) >= ans) break;
if (i * a + j * b + k * c != s || k < j) continue;
if (abs(i * a - j * b) + abs(j * b - k * c) < ans) {
ans = abs(i * a - j * b) + abs(j * b - k * c);
ii = i, jj = j, kk = k;
}
}
if (ans == 0x3fffffff)
puts("-1\n");
else
cout << ii << ' ' << jj << ' ' << kk << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
const long long MOD = 1e9 + 7;
using namespace std;
long long fact(long long n) {
long long f = 1;
for (long long i = 2; i <= n; i++) f *= i;
return f;
}
long long ncr(long long n, long long r) {
return fact(n) / (fact(r) * fact(n - r));
}
long long isPrime(long long n) {
if (n <= 1) return 0;
if (n <= 3) return 1;
if (n % 2 == 0 || n % 3 == 0) return 0;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return 0;
return 1;
}
long long isVowel(char s) {
if (s == 'a' || s == 'e' || s == 'i' || s == 'o' || s == 'u')
return 1;
else
return 0;
}
long long fib(long long n) {
if (n < 2) return n;
return fib(n - 1) + fib(n - 2);
}
long long isEven(char a) {
if (a == '2' || a == '4' || a == '6' || a == '8' || a == '0')
return 1;
else
return 0;
}
long long is_distinct(long long n) {
long long c = 0;
set<long long> se;
while (n > 0) {
long long d = n % 10;
se.insert(d);
c++;
n /= 10;
}
if (se.size() == c)
return 1;
else
return 0;
}
long long lar_prime(long long n) {
for (long long i = n; i >= 2; i--) {
if (n % i == 0 && isPrime(i) == 1) return i;
}
}
long long isSub(string s, string t) {
for (long long i = 0; i < s.size(); i++) {
string z = s.substr(i, t.size());
if (z == t) return 1;
}
return 0;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
srand(time(NULL));
long long a, b, ans;
cin >> a >> b;
long long p = 1;
if (abs(a - b) >= 10) {
cout << 0;
return 0;
} else if (a == b) {
cout << 1;
return 0;
}
for (long long i = a + 1; i <= b; i++) {
p *= (i % 10);
ans = p % 10;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int w[300010];
int c[300010];
int sp[300010];
vector<pair<int, int>> adj[300010];
int visit[300010];
int ti[300010];
int tib[300010];
int at = 0;
int bridge[300010];
int root[300010];
vector<pair<int, int>> adj_big[300010];
long long c_big[300010];
int sp_big[300010];
long long child_dp[300010];
long long dp[300010];
int node_count;
int bridge_count;
void dfs1(int idx, int p) {
visit[idx] = 1;
ti[idx] = ++at;
tib[idx] = ti[idx];
for (auto it : adj[idx]) {
int y = it.first;
int i = it.second;
if (y == p) continue;
if (visit[y])
ti[idx] = min(ti[idx], tib[y]);
else {
dfs1(y, idx);
if (ti[y] > tib[idx]) {
bridge[i] = 1;
bridge_count++;
} else
ti[idx] = min(ti[idx], ti[y]);
}
}
return;
}
void dfs2(int idx, int p) {
visit[idx] = 1;
root[idx] = node_count;
c_big[node_count] += c[idx];
for (auto it : adj[idx]) {
int y = it.first;
int i = it.second;
if (y == p) continue;
if (!bridge[i] && !visit[y]) dfs2(y, idx);
}
return;
}
void dfs3(int idx, int p) {
child_dp[idx] = c_big[idx];
for (auto it : adj_big[idx]) {
int y = it.first;
int i = it.second;
if (y == p) continue;
dfs3(y, idx);
sp_big[idx] += sp_big[y];
if (sp_big[y] > 0 && sp_big[y] < k) {
child_dp[idx] += max(1ll * 0, child_dp[y] - w[i]);
} else
child_dp[idx] += child_dp[y];
}
return;
}
void dfs4(int idx, int p, long long val) {
long long all_val = child_dp[idx] + val;
dp[idx] = all_val;
for (auto it : adj_big[idx]) {
int y = it.first, i = it.second;
if (y == p) continue;
long long p_val;
int weight;
if (sp_big[y] > 0 && sp_big[y] < k)
weight = w[i];
else
weight = 0;
if (child_dp[y] - weight > 0)
p_val = max(1ll * 0, all_val - child_dp[y]);
else
p_val = max(1ll * 0, all_val - weight);
dfs4(y, idx, p_val);
}
return;
}
int main() {
int debug = 0, debug1 = 0;
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < k; i++) {
scanf("%d", &sp[i]);
sp[i]--;
}
for (int i = 0; i < n; i++) scanf("%d", &c[i]);
for (int i = 0; i < m; i++) scanf("%d", &w[i]);
for (int i = 0; i < m; i++) {
int t1, t2;
scanf("%d%d", &t1, &t2);
t1--;
t2--;
adj[t1].push_back(make_pair(t2, i));
adj[t2].push_back(make_pair(t1, i));
}
if (c[0] == 76096) debug1 = 0;
dfs1(0, -1);
if (debug) {
for (int i = 0; i < n; i++) cout << ti[i] << " ";
cout << endl;
cout << "at " << at << endl;
}
node_count = 0;
memset(visit, 0, sizeof(int) * n);
for (int i = 0; i < n; i++) {
if (!visit[i]) {
dfs2(i, -1);
node_count++;
}
}
if (debug) {
cout << "root ";
for (int i = 0; i < node_count; i++) cout << root[i] << " ";
cout << endl;
cout << "c_big ";
for (int i = 0; i < node_count; i++) cout << c_big[i] << " ";
cout << endl;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < adj[i].size(); j++) {
int v1 = i, v2 = adj[i][j].first;
int idx = adj[i][j].second;
if (bridge[idx]) adj_big[root[v1]].push_back(make_pair(root[v2], idx));
}
}
for (int i = 0; i < k; i++) sp_big[root[sp[i]]]++;
if (debug) {
cout << "sp_big ";
for (int i = 0; i < node_count; i++) cout << sp_big[i] << " ";
cout << endl;
}
dfs3(0, -1);
if (debug) {
cout << "child_dp ";
for (int i = 0; i < node_count; i++) cout << child_dp[i] << " ";
cout << endl;
}
dfs4(0, -1, 0);
if (debug) {
cout << "dp ";
for (int i = 0; i < n; i++) cout << dp[i] << " ";
cout << endl;
}
if (debug1) {
cout << "node_count " << node_count << endl;
cout << "bridge_count " << bridge_count << endl;
long long sum = 0, sum1 = 0;
for (int i = 0; i < n; i++) sum += c[i];
for (int i = 0; i < node_count; i++) sum1 += c_big[i];
cout << "sum " << sum << " " << sum1 << endl;
cout << "root " << root[0] << " " << root[1] << " " << root[2] << " "
<< root[80532] << endl;
cout << "c_big " << c_big[0] << " " << c_big[1] << " " << c_big[root[80532]]
<< endl;
cout << "child_dp " << child_dp[0] << endl;
}
for (int i = 0; i < n; i++) {
printf("%lld ", dp[root[i]]);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<vector<int>> graph;
set<int> visited;
queue<int> q;
void ReadInput() {
cin >> n >> m;
graph.resize(n + 1);
int x, y;
for (int i = 0; i < m; i++) {
cin >> x >> y;
graph[x].push_back(y);
graph[y].push_back(x);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ReadInput();
int start_index = -1;
int num_edges = 0;
for (size_t i = 1; i <= n; i++) {
if (graph[i].size() > num_edges) {
start_index = i;
num_edges = graph[i].size();
}
}
q.push(start_index);
while (!q.empty()) {
int current = q.front();
q.pop();
visited.insert(current);
for (size_t i = 0; i < graph[current].size(); i++) {
int dest = graph[current][i];
if (visited.count(dest)) continue;
visited.insert(dest);
cout << current << " " << dest << endl;
q.push(dest);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char inp[100005];
int fl[100005];
int main() {
int n;
cin >> n;
cout << "YES" << endl;
for (int i = 1; i <= n; i++) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
int nc = 0;
if (x1 % 2) nc += 2;
if (y1 % 2) nc++;
printf("%d\n", nc + 1);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, d[30][30];
char s[1000];
int main() {
scanf("%d", &n);
for (int i = 0; i < 26; ++i)
for (int j = 0; j < 26; ++j) d[i][j] = -1;
for (int i = 1; i <= n; ++i) {
scanf("%s", &s);
m = strlen(s);
for (int j = 0; j < 26; ++j)
if (d[j][int(s[0] - 'a')] > 0)
d[j][int(s[m - 1] - 'a')] =
max(d[j][int(s[m - 1] - 'a')], d[j][int(s[0] - 'a')] + m);
d[int(s[0] - 'a')][int(s[m - 1] - 'a')] =
max(d[int(s[0] - 'a')][int(s[m - 1] - 'a')], m);
}
for (int i = 0; i < 26; ++i) d[0][0] = max(d[0][0], d[i][i]);
printf("%d\n", max(0, d[0][0]));
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<string> save;
vector<vector<int> > AdjList;
int nodo_llegada;
int temp;
int cmp[101];
void dfs(int nodo) {
if (nodo == nodo_llegada) temp = 1;
cmp[nodo] = true;
for (int i = int(0); i < int(AdjList[nodo].size()); i++) {
int v = AdjList[nodo][i];
if (cmp[v] == false) dfs(v);
}
}
int main() {
int n, a, b, c;
scanf("%d", &n);
AdjList.assign(n + 2, vector<int>());
vector<pair<int, int> > save;
int cont = 0;
for (int i = int(0); i < int(n); i++) {
scanf("%d%d%d", &a, &b, &c);
if (a == 1) {
for (int j = int(0); j < int(save.size()); j++) {
if ((b < save[j].first && save[j].first < c) ||
(b < save[j].second && save[j].second < c)) {
AdjList[j].push_back(cont);
}
if ((save[j].first < b && b < save[j].second) ||
(save[j].first < c && c < save[j].second)) {
AdjList[cont].push_back(j);
}
}
save.push_back(pair<int, int>(b, c));
cont++;
} else {
temp = 0;
nodo_llegada = c - 1;
memset(cmp, 0, sizeof cmp);
dfs(b - 1);
if (temp == 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> adj[100010];
bool visited[100010];
void visit(int u) {
visited[u] = true;
for (int i = 0; i < adj[u].size(); i++)
if (!visited[adj[u][i]]) visit(adj[u][i]);
}
int main() {
int m, u, v;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
bool res = true;
memset(visited, false, sizeof(visited));
visit(1);
for (int i = 1; i <= n; i++)
if (!visited[i]) {
res = false;
break;
}
if (res && n == m)
puts("FHTAGN!");
else
puts("NO");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mt = 200000 + 5;
vector<int> g[mt];
int f[mt], deep[mt];
bool vis[mt];
int maxlen;
int b[mt], a[mt];
map<long long, long long> p, q;
int pcnt, qcnt;
inline int read() {
int num = 0, flag = 1;
char ch;
do {
ch = getchar();
if (ch == '-') flag = -1;
} while (ch < '0' || ch > '9');
do {
num = num * 10 + ch - '0';
ch = getchar();
} while (ch >= '0' && ch <= '9');
return num * flag;
}
void dfs(int u, int fa, int dep) {
vis[u] = 1, deep[u] = dep;
maxlen = max(dep, maxlen);
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (!vis[v]) dfs(v, u, dep + 1);
}
}
int main() {
int n = read();
for (int i = 1; i <= n; i++) b[i] = a[i] = read();
sort(b + 1, b + n + 1);
int last = 0;
for (int i = 1; i <= n; i++)
if (b[i] != b[i - 1]) b[++last] = b[i];
for (int i = 2; i <= n; i++) {
int x = read();
g[i].push_back(x);
g[x].push_back(i);
}
dfs(1, 0, 0);
int ans = 0;
for (int i = 1; i <= n; i++) {
if (deep[i] % 2 == maxlen % 2)
ans ^= a[i], p[a[i]]++, pcnt++;
else
q[a[i]]++, qcnt++;
}
long long res = 0;
if (ans == 0) {
res = 1ll * pcnt * (pcnt - 1) / 2 + 1ll * qcnt * (qcnt - 1) / 2;
for (int i = 1; i <= last; i++) res += 1ll * p[b[i]] * q[b[i]];
} else {
for (int i = 1; i <= n; i++) {
if (deep[i] % 2 == maxlen % 2) res += q[ans ^ a[i]];
}
}
printf("%lld\n", res);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
vector<int> a(n), b(n);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
sort(a.begin(), a.end());
sort(b.rbegin(), b.rend());
int f = 0;
for (int i = 0; i < n; i++) {
if (a[i] + b[i] > x) {
f = 1;
break;
}
}
if (f)
cout << "No" << endl;
else
cout << "Yes" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 155;
const int mo = 51123987;
inline void inc(int &a, const int b) { a = (a + b) % mo; }
int n, m, lim;
char s[N];
int nex[N][3];
int F;
int f[2][N][N][N];
int main() {
scanf("%d", &n);
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) s[i] -= 'a';
m = 0;
for (int i = 1, j = 1; i <= n; i = j) {
for (; j <= n && s[i] == s[j]; j++)
;
s[++m] = s[i];
}
for (int x = 0; x < 3; x++) nex[m + 1][x] = m + 1;
for (int i = m; i >= 0; i--) {
for (int x = 0; x < 3; x++) nex[i][x] = nex[i + 1][x];
if (i > 0) nex[i][s[i]] = i;
}
lim = (n + 2) / 3;
int ans = 0;
f[F][0][0][0] = 1;
for (int a = 0; a <= n && a <= lim; a++) {
for (int b = 0; a + b <= n && b <= lim; b++)
for (int c = 0; a + b + c <= n && c <= lim; c++)
for (int i = 0; i <= m; i++) {
if (a + b + c == n) {
if (abs(a - b) <= 1 && abs(b - c <= 1) && abs(a - c) <= 1)
inc(ans, f[F][b][c][i]);
continue;
}
inc(f[F ^ 1][b][c][nex[i][0]], f[F][b][c][i]);
inc(f[F][b + 1][c][nex[i][1]], f[F][b][c][i]);
inc(f[F][b][c + 1][nex[i][2]], f[F][b][c][i]);
f[F][b][c][i] = 0;
}
F ^= 1;
}
printf("%d\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int n;
long long int arr[100100];
long long int getInd(long long int x) {
for (long long int i = x; i <= n; i++) {
if (arr[x] != arr[i]) return i - 1;
}
return n;
}
long long int getVal(long long int x) { return (x * (x + 1)) / 2; }
long long int cal() {
long long int sum = 0;
for (long long int i = 1; i <= n; i++) {
long long int uu = getInd(i);
long long int vv = (uu - i) + 1;
sum = sum + getVal(vv);
i = uu;
}
return sum;
}
int main() {
cin >> n;
for (long long int i = 1; i <= n; i++) {
cin >> arr[i];
}
cout << cal() << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
inline int in() {
int x = 0;
char c = getchar();
bool f = false;
while (c < '0' || c > '9') f |= c == '-', c = getchar();
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return f ? -x : x;
}
const int N = 105;
int t[N], f[N * N][N], tot;
int main() {
int n = in(), res = 1;
for (int i = 1; i <= n; ++i) {
int a = in();
if (!t[a]) ++tot;
++t[a];
}
if (tot <= 2) {
printf("%d\n", n);
return 0;
}
f[0][0] = 1;
for (int i = 1; i <= 100; ++i)
if (t[i]) {
for (int j = 10000; j; --j)
for (int k = 1; k <= n; ++k)
for (int l = 1; l <= t[i] && l <= k && l * i <= j; ++l)
f[j][k] += f[j - l * i][k - l];
}
for (int i = 1; i <= 100; ++i)
if (t[i])
for (int j = 1; j <= t[i]; ++j)
if (f[i * j][j] == 1) res = std::max(res, j);
printf("%d\n", res);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const int MAXN = 1e5 + 7;
const long long NEUTRAL = -INF;
const long long MOD = 1e9 + 7;
void solve() {
long long p, q;
cin >> p >> q;
if (p < q) {
cout << p << '\n';
return;
}
long long res = 0;
for (long long i = 1; i * i <= q; ++i) {
if (q % i != 0) {
continue;
}
if (i != 1) {
long long tmp = p;
while (!(tmp % q)) {
tmp /= i;
}
res = max(res, tmp);
}
long long tmp = p;
while (!(tmp % q)) {
tmp /= (q / i);
}
res = max(res, tmp);
}
cout << res << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
cin >> t;
while (t--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long nmax = 500005;
long long n, m, i, j, cnt, mlc, r, c, R[nmax], S[nmax], solR[nmax], solS[nmax],
solA, solB, minr, mins;
long long tsort[nmax], where[nmax];
string s[nmax], t, u;
unordered_map<string, int> was;
vector<int> v[nmax], g[nmax], comp[nmax], V[nmax];
bitset<nmax> viz;
void dfs(long long x) {
viz[x] = 1;
for (auto it : v[x])
if (!viz[it]) dfs(it);
tsort[++c] = x;
}
void dfst(long long x) {
comp[c].push_back(x);
where[x] = c;
viz[x] = 1;
for (auto it : g[x])
if (!viz[it]) dfst(it);
}
void dfsc(long long x) {
viz[x] = 1;
for (auto it : V[x])
if (!viz[it]) dfsc(it);
tsort[++cnt] = x;
}
int main() {
cin.sync_with_stdio(false);
cin >> n;
for (i = 1; i <= n; i++) {
cin >> s[i];
mlc = s[i].size();
r = 0;
for (j = 0; j < mlc; j++) {
if (s[i][j] >= 'A' && s[i][j] <= 'Z') s[i][j] += 32;
if (s[i][j] == 'r') r++;
}
if (!was[s[i]]) {
was[s[i]] = ++cnt;
R[cnt] = r;
S[cnt] = mlc;
}
}
cin >> m;
for (i = 1; i <= m; i++) {
cin >> t >> u;
mlc = t.size();
r = 0;
for (j = 0; j < mlc; j++) {
if (t[j] >= 'A' && t[j] <= 'Z') t[j] += 32;
if (t[j] == 'r') r++;
}
if (!was[t]) {
was[t] = ++cnt;
R[cnt] = r;
S[cnt] = mlc;
}
mlc = u.size();
r = 0;
for (j = 0; j < mlc; j++) {
if (u[j] >= 'A' && u[j] <= 'Z') u[j] += 32;
if (u[j] == 'r') r++;
}
if (!was[u]) {
was[u] = ++cnt;
R[cnt] = r;
S[cnt] = mlc;
}
v[was[t]].push_back(was[u]);
g[was[u]].push_back(was[t]);
}
c = 0;
for (i = 1; i <= cnt; i++)
if (!viz[i]) dfs(i);
viz = 0;
c = 0;
for (i = cnt; i; i--)
if (!viz[tsort[i]]) {
c++;
dfst(tsort[i]);
}
for (i = 1; i <= c; i++) {
solR[i] = solS[i] = 1LL << 60;
for (auto it : comp[i]) {
if (R[it] < solR[i]) {
solR[i] = R[it];
solS[i] = S[it];
} else if (R[it] == solR[i]) {
if (S[it] < solS[i]) {
solR[i] = R[it];
solS[i] = S[it];
}
}
}
}
for (i = 1; i <= cnt; i++)
for (auto it : v[i]) V[where[i]].push_back(where[it]);
viz = 0;
cnt = 0;
for (i = 1; i <= c; i++)
if (!viz[i]) dfsc(i);
for (i = 1; i <= c; i++)
for (auto it : V[tsort[i]]) {
if (solR[it] < solR[tsort[i]]) {
solR[tsort[i]] = solR[it];
solS[tsort[i]] = solS[it];
} else if (solR[it] == solR[tsort[i]]) {
if (solS[it] < solS[tsort[i]]) {
solR[tsort[i]] = solR[it];
solS[tsort[i]] = solS[it];
}
}
}
for (i = 1; i <= n; i++) {
solA += solR[where[was[s[i]]]];
solB += solS[where[was[s[i]]]];
}
cout << solA << " " << solB;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double TOLL = 1e-9;
int N, M;
vector<string> tor[20];
map<string, int> mp;
int getInv(const vector<string>& v) {
int rv = 0;
for (int i = 0; i < (int((v).size())); i++)
for (int j = i + 1; j < (int((v).size())); j++) {
int oi = mp[v[i]], oj = mp[v[j]];
if (oi < oj) continue;
rv++;
}
return rv;
}
bool subseq(const vector<string>& v, const vector<string>& t) {
int i = 0, j = 0;
while (i < (int((t).size())) && j < (int((v).size()))) {
if (t[i] == v[j]) {
j++;
}
i++;
}
return (j == (int((v).size())));
}
int main() {
while (cin >> N) {
vector<string> v;
v.resize(N);
mp.clear();
for (int i = 0; i < N; i++) {
cin >> v[i];
mp[v[i]] = i;
}
cin >> M;
for (int i = 0; i < M; i++) {
int k;
cin >> k;
tor[i].resize(k);
for (int j = 0; j < k; j++) cin >> tor[i][j];
}
int bestInv = 100000, bestInd = -1;
sort((v).begin(), (v).end());
do {
for (int i = 0; i < M; i++)
if (subseq(v, tor[i])) {
int inv = getInv(v);
if (inv < bestInv) {
bestInv = inv;
bestInd = i + 1;
} else if (inv == bestInv)
bestInd = min(bestInd, i + 1);
}
} while (next_permutation((v).begin(), (v).end()));
if (bestInd == -1) {
cout << "Brand new problem!" << endl;
continue;
}
int simi = (N * (N - 1)) / 2 - bestInv + 1;
cout << bestInd << endl;
string rv = "[:" + string(simi, '|') + ":]";
cout << rv << endl;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int ans[17] = {0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0};
int main() {
int n;
scanf("%d", &n);
printf("%d\n", ans[n]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, tab[200006], maks;
string t;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> tab[i];
}
cin >> t;
for (int i = 0; i < n - 1; i++) {
if (t[i] == '1') {
maks = max(maks, tab[i]);
continue;
}
if (max(maks, tab[i]) != i + 1) {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.