solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
struct ww {
int l, ll, a, cov, s, key, sum, k;
} a[400010];
int i, j, k, n, m, s, an, t, F;
int g[400010], fa[400010], f[400010], huan[400010], se[400010], id[400010],
ans[400010];
vector<int> b[400010];
void Dfs(int x) {
if (s) return;
int i;
g[++*g] = x;
f[x] = 1;
for (i = 0; i < b[x].size(); i++) {
int A = b[x][i];
if (fa[x] == A) continue;
if (s) return;
if (f[A]) {
huan[s = 1] = A;
se[A] = 1;
for (; (i = g[*g]) != A; (*g)--) {
huan[++s] = i;
se[i] = s;
}
return;
}
fa[A] = x;
Dfs(A);
}
(*g)--;
f[x] = 0;
}
void dfs(int x) {
int i;
id[x] = k;
ans[k]++;
for (i = 0; i < b[x].size(); i++) {
int A = b[x][i];
if (A == fa[x] || se[A]) continue;
fa[A] = x;
a[++t].a = x;
a[t].k = 1;
a[A].a = t;
dfs(A);
}
}
inline bool isroot(int x) {
return !a[x].a || a[a[x].a].l != x && a[a[x].a].ll != x;
}
inline void update(int x) {
if (!x) return;
int y = a[x].l, z = a[x].ll;
a[x].s = a[y].s + a[z].s + a[x].k;
a[x].sum = a[y].sum + a[z].sum + a[x].key;
}
inline void right(int x) {
int y = a[x].a, z = a[y].a;
if (a[z].l == y) a[z].l = x;
if (a[z].ll == y) a[z].ll = x;
a[x].a = z, a[y].a = x;
a[y].l = a[x].ll;
a[x].ll = a[a[y].l].a = y;
update(y);
}
inline void left(int x) {
int y = a[x].a, z = a[y].a;
if (a[z].l == y) a[z].l = x;
if (a[z].ll == y) a[z].ll = x;
a[x].a = z, a[y].a = x;
a[y].ll = a[x].l;
a[x].l = a[a[y].ll].a = y;
update(y);
}
inline void Cov(int x) {
if (!x) return;
if (a[x].k) a[x].key ^= 1;
a[x].sum = a[x].s - a[x].sum;
a[x].cov ^= 1;
}
inline void renew(int x) {
if (!x) return;
if (a[x].cov) Cov(a[x].l), Cov(a[x].ll);
a[x].cov = 0;
}
inline void splay(int x) {
int y, z;
for (g[y = 1] = z = x; !isroot(z); g[++y] = a[z].a, z = a[z].a)
;
for (; y; y--) renew(g[y]);
for (; !isroot(x);) {
y = a[x].a, z = a[y].a;
if (isroot(y))
if (a[y].l == x)
right(x);
else
left(x);
else if (a[z].l == y)
if (a[y].l == x)
right(y), right(x);
else
left(x), right(x);
else if (a[y].l == x)
right(x), left(x);
else
left(y), left(x);
}
update(x);
}
inline int access(int x) {
int y = 0;
for (; x; y = x, x = a[x].a) {
splay(x);
a[x].ll = y;
update(x);
}
return y;
}
inline void gao(int x, int y) {
int I = id[x];
access(x);
int A = access(y);
splay(A);
splay(x);
int B = a[A].ll;
ans[I] -= a[B].s - 2 * a[B].sum;
if (x != A) ans[I] -= a[x].s - 2 * a[x].sum;
Cov(B);
if (x != A) Cov(x);
}
inline int get(int x, int y, int _) {
if (_ == 1) {
if (x < y)
return y - x;
else
return s - x + y;
} else {
if (x > y)
return x - y;
else
return x + s - y;
}
}
inline void Gao(int x, int y) {
if (get(x, y, 1) < get(x, y, -1) ||
get(x, y, 1) == get(x, y, -1) && huan[x + 1] < huan[x - 1]) {
if (x < y)
gao(huan[x] + n, huan[y] + n);
else
gao(huan[1] + n, huan[y] + n), gao(huan[x] + n, huan[s] + n), F ^= 1;
} else {
if (x > y)
gao(huan[x] + n, huan[y] + n);
else
gao(huan[1] + n, huan[x] + n), gao(huan[y] + n, huan[s] + n), F ^= 1;
}
}
inline int pan() {
int A = huan[s] + n;
access(A);
splay(A);
if (a[A].sum == s - 1) return 0;
return F ? -1 : 0;
}
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
b[x].push_back(y);
b[y].push_back(x);
}
Dfs(1);
t = n + n;
for (i = 1; i <= s; i++) {
int A = huan[i];
fa[A] = 0;
k = i;
dfs(A);
if (i > 1) {
a[++t].a = huan[i - 1] + n;
a[t].k = 1;
a[A + n].a = t;
}
}
for (i = n + 1; i <= n + n; i++) id[i] = s + 1;
for (i = 1; i <= t; i++) update(i);
huan[0] = huan[s];
huan[s + 1] = huan[1];
an = n;
for (i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
int A = id[x], B = id[y];
if (A == B) {
an -= ans[A];
gao(x, y);
an += ans[A];
} else {
an -= ans[A] + ans[B] + ans[s + 1];
gao(x, huan[A]);
gao(y, huan[B]);
Gao(A, B);
an += ans[A] + ans[B] + ans[s + 1];
}
printf("%d\n", an + pan());
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int bigp = 10000007;
int H, Q, N, V, E, p, xc, yc, dg;
int hash1[15000005], hash2[15000005];
char st[10];
double ans;
void mplus(int S, int E) {
int e = S % bigp;
while ((hash1[e] != 0) && (hash1[e] != S)) ++e;
hash1[e] = S;
hash2[e] += E;
}
int getsize(int S) {
int e = S % bigp;
while ((hash1[e] != 0) && (hash1[e] != S)) ++e;
if (hash1[e] == 0)
return 0;
else
return hash2[e];
}
int main() {
scanf("%d %d", &H, &Q);
N = 1 << H;
memset(hash1, 0, sizeof(hash1));
memset(hash2, 0, sizeof(hash2));
for (int sc = 1; sc <= Q; sc++) {
scanf("%s", st);
if (st[0] == 'd') {
p = 1;
ans = 0;
dg = 0;
double t = 0.5;
for (int i = 1; i <= H; i++) {
xc = getsize(p * 2);
yc = getsize(p * 2 + 1);
if (xc >= yc) {
ans += double(max(getsize(p) - yc, dg)) * t;
dg = max(dg, getsize(p) - xc);
p = p * 2;
} else {
ans += double(max(getsize(p) - xc, dg)) * t;
dg = max(dg, getsize(p) - yc);
p = p * 2 + 1;
}
t *= 0.5;
}
t *= 2;
ans += double(max(getsize(p), dg)) * t;
printf("%.10lf\n", ans);
} else {
scanf("%d %d", &V, &E);
while (V > 0) {
mplus(V, E);
V /= 2;
}
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int n, m, suc;
vector<int> e[N];
int a[N], b[N], fr[N];
long long ATK;
int vis[N];
void dfs(int x, int fa, long long ATK) {
if (suc) return;
for (auto i : e[x])
if (i != fa && a[i] < ATK) {
if (vis[i] && vis[x]) continue;
if (vis[i]) {
suc = 1;
for (int j = x; j; j = fr[j]) vis[j] = 1;
} else if (fr[i]) {
suc = 1;
for (int j = i; j; j = fr[j]) vis[j] = 1;
for (int j = x; j; j = fr[j]) vis[j] = 1;
} else {
fr[i] = x;
dfs(i, x, ATK + b[i]);
}
if (suc) return;
}
}
bool check(int v) {
int rem = n - 1;
memset(vis, 0, sizeof(vis));
vis[1] = 1;
for (;;) {
bool flg = 0;
suc = 0;
long long ATK = v;
memset(fr, 0, sizeof(fr));
for (int i = 1; i <= n; i++)
if (vis[i])
ATK += b[i];
else
flg = 1;
if (!flg) return 1;
for (int i = 1; i <= n && !suc; i++)
if (vis[i]) dfs(i, 0, ATK);
if (!suc) return 0;
}
}
void solve() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) e[i].resize(0);
for (int i = 2; i <= n; i++) scanf("%d", &a[i]);
for (int i = 2; i <= n; i++) scanf("%d", &b[i]);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
e[x].push_back(y);
e[y].push_back(x);
}
int l = 1, r = 1e9 + 5, ans = -1;
while (l <= r) {
int mid = (l + r) / 2;
if (check(mid))
ans = mid, r = mid - 1;
else
l = mid + 1;
}
cout << ans << endl;
}
int main() {
int T;
scanf("%d", &T);
while (T--) solve();
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long t;
cin >> t;
while (t--) {
long long n, i, j, ans = 0;
cin >> n;
vector<long long> v(n);
for (i = 0; i < n; i++) cin >> v[i];
for (i = 0, j = n - 1; i < j;) {
if (v[i] >= 0) {
v[i + 1] -= v[i];
i++;
continue;
}
if (v[j] <= 0) {
v[j - 1] += v[j];
j--;
continue;
}
v[i] = abs(v[i]);
ans += min(v[i], v[j]);
if (v[i] == v[j]) {
i++;
j--;
} else if (v[i] < v[j]) {
v[j] -= v[i];
i++;
} else {
v[i] -= v[j];
v[i] = -v[i];
j--;
}
}
cout << ans << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
long long c = 0, x = 0, y = 0, yd = 0, xd = 0, ans = 0;
map<int, vector<int> > oc;
vector<int> a;
scanf("%d %d", &n, &m);
scanf("%d", &x);
a.push_back(x);
for (int i = 1; i < m; ++i) {
scanf("%d", &x);
a.push_back(x);
c += abs(a[i] - a[i - 1]);
if (a[i] != a[i - 1]) {
oc[a[i]].push_back(a[i - 1]);
oc[a[i - 1]].push_back(a[i]);
}
}
ans = c;
map<int, vector<int> >::iterator it;
for (it = oc.begin(); it != oc.end(); it++) {
x = it->first;
sort(it->second.begin(), it->second.end());
if (it->second.size() & 1)
y = it->second.at(it->second.size() / 2);
else if (it->second.empty())
y = 0;
else
y = it->second.at(it->second.size() / 2 - 1);
xd = yd = 0;
for (int j = 0; j < it->second.size(); ++j) {
xd += abs(it->second.at(j) - x);
yd += abs(it->second.at(j) - y);
}
long long tmp = (c - xd + yd);
ans = min(ans, tmp);
}
printf("%I64d", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 333;
const int MO = 1e9 + 7;
int n, m, a[N], b[N], c[1111][1111], d[1111];
long long f[N][N];
map<int, int> M;
map<int, int>::iterator it;
int C(int x, int y) {
if (x < 0 || y < 0 || x < y) return 0;
return c[x][y];
}
int fpow(int x, int y = MO - 2) {
if (!y) return 1;
long long z = fpow(x, y >> 1);
z = z * z % MO;
if (y & 1) z = z * x % MO;
return z;
}
int main() {
int i, j, k, l, x;
long long t, ans = 1;
n = 1000;
for (i = 0; i <= n; i = i + 1) {
c[i][0] = 1;
for (j = 1; j <= i; j = j + 1)
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % MO;
}
d[0] = 1;
for (i = 1; i <= n; i = i + 1) d[i] = (long long)d[i - 1] * i % MO;
cin >> n;
for (i = 1; i <= n; i = i + 1) {
cin >> x;
for (j = 2; j * j <= x; j = j + 1)
if (x % (j * j) == 0) x /= j * j, j--;
M[x]++;
}
for (it = M.begin(); it != M.end(); it++)
a[++m] = (*it).second, ans *= d[a[m]], ans %= MO;
b[0] = 1;
for (i = 1; i <= m; i = i + 1) b[i] = b[i - 1] + a[i];
f[0][0] = 1;
for (i = 0; i < m; i = i + 1) {
for (j = 0; j <= n; j = j + 1) {
f[i][j] %= MO;
x = a[i + 1];
for (k = 0; k <= x; k = k + 1) {
for (l = 0; k + l <= x; l = l + 1) {
t = f[i][j] * C(j, k) % MO * C(b[i] - j, l) % MO *
C(x - 1, k + l - 1) % MO;
if (t) f[i + 1][j - k + x - l - k] += t;
}
}
}
}
cout << f[m][0] % MO * ans % MO;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int maxn = 2e5 + 5;
int n, x, y;
vector<int> adj[maxn];
int deg[maxn];
int dp1[maxn], dp2[maxn];
void dfs(int i, int p) {
int sum_dp2 = 0;
vector<int> diffs;
for (int j : adj[i]) {
if (j == p) continue;
dfs(j, i);
sum_dp2 += dp2[j];
diffs.push_back(dp1[j] - dp2[j]);
}
sort(diffs.begin(), diffs.end());
int mindiff_dp1 = 1;
if (diffs.size() >= 1) mindiff_dp1 = min(mindiff_dp1, diffs[0]);
dp1[i] = mindiff_dp1 + sum_dp2;
dp2[i] = dp1[i];
if (diffs.size() >= 2) {
dp2[i] = min(dp2[i], sum_dp2 + diffs[0] + diffs[1] - 1);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> x >> y;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
deg[a]++;
deg[b]++;
}
if (x == y) {
cout << (1LL * (n - 1) * x) << endl;
} else if (x > y) {
int maxDeg = 0;
for (int i = 1; i <= n; i++) {
maxDeg = max(maxDeg, deg[i]);
}
if (maxDeg == n - 1) {
cout << (1LL * (n - 2) * y + x) << endl;
} else {
cout << (1LL * (n - 1) * y) << endl;
}
} else {
dfs(1, 1);
int paths = dp2[1];
cout << (1LL * (paths - 1) * y + 1LL * (n - paths) * x) << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline char nc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int read() {
register int x = 0, f = 1;
register char ch = nc();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = nc();
}
while (ch >= '0' && ch <= '9') x = (x << 3) + (x << 1) + ch - '0', ch = nc();
return x * f;
}
inline void write(register int x) {
if (!x) putchar('0');
if (x < 0) x = -x, putchar('-');
static int sta[20];
register int tot = 0;
while (x) sta[tot++] = x % 10, x /= 10;
while (tot) putchar(sta[--tot] + 48);
}
int n, m;
int s[505], t[505], nxt[505], trans[505][2];
int f[2][505][505], ans[505];
void upd(int &x, int y) {
if (x == -1) x = y;
x = min(x, y);
}
int main() {
n = read(), m = read();
for (int i = 1; i <= n; ++i) {
char ch = nc();
while (ch != '0' && ch != '1') ch = nc();
s[i] = ch - '0';
}
for (int i = 1; i <= m; ++i) {
char ch = nc();
while (ch != '0' && ch != '1') ch = nc();
t[i] = ch - '0';
}
for (int i = 2, p = 0; i <= m; ++i) {
while (p && t[p + 1] != t[i]) p = nxt[p];
if (t[p + 1] == t[i]) ++p;
nxt[i] = p;
}
for (int i = 0; i < m; ++i) {
if (i < m - 1) trans[i][t[i + 1]] = i + 1;
for (int j = 0; j <= 1; ++j)
trans[i][j] = max(trans[i][j], trans[nxt[i]][j]);
}
int las = 0, cur = 1;
memset(f[las], -1, sizeof(f[las]));
f[las][0][0] = 0;
for (int i = 1; i <= n; ++i) {
memset(f[cur], -1, sizeof(f[cur]));
for (int j = 0; j < m; ++j)
for (int k = 0; k <= n - m + 1; ++k)
if (f[las][j][k] != -1) {
for (int l = 0; l <= 1; ++l) {
if (j == m - 1 && l == t[m])
upd(f[cur][trans[j][l]][k + 1], f[las][j][k] + (s[i] != l));
else
upd(f[cur][trans[j][l]][k], f[las][j][k] + (s[i] != l));
}
}
cur ^= 1, las ^= 1;
}
memset(ans, -1, sizeof(ans));
for (int i = 0; i < m; ++i)
for (int j = 0; j <= n - m + 1; ++j)
if (f[las][i][j] != -1) upd(ans[j], f[las][i][j]);
for (int i = 0; i <= n - m + 1; ++i) printf("%d ", ans[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
char sym[] = {'A', 'O', 'M', 'H', 'I', 'o', 'T', 'V',
'W', 'U', 'X', 'Y', 'x', 'w', 'v'};
map<char, char> mp;
mp['b'] = 'd';
mp['d'] = 'b';
mp['p'] = 'q';
mp['q'] = 'p';
string s;
cin >> s;
int n = s.length();
int a = n / 2 - 1, b;
if (n & 1)
b = n / 2 + 1;
else
b = n / 2;
if (n & 1 && count(sym, sym + 16, s[n / 2]) == 0) {
cout << "NIE";
return 0;
}
for (int i = 0, j = n - 1; i <= a && j >= b; i++, j--) {
if (s[i] == s[j] && count(sym, sym + 16, s[i]) == 1) {
continue;
}
if (mp[s[i]] == s[j] && mp[s[j]] == s[i]) {
continue;
}
cout << "NIE";
return 0;
}
cout << "TAK";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if (k > n || (n > 1 && k == 1))
cout << -1;
else {
if (n == 1)
cout << 'a';
else {
int a = 1;
for (int i = 0; i < n - k + 2; i++)
if (a) {
cout << 'a';
a = 0;
} else {
cout << 'b';
a = 1;
}
for (int i = 2; i < k; i++) printf("%c", 'a' + i);
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int testcases = 1;
cin >> testcases;
while (testcases--) {
int x, y, z;
cin >> x >> y >> z;
bool can = true;
vector<int> v;
v.push_back(x);
v.push_back(y);
v.push_back(z);
sort((v).begin(), (v).end());
if ((x != y && y != z && z != x) || (v[0] == v[1] && v[1] != v[2])) {
can = false;
}
if (can) {
cout << "Yes";
cout << "\n";
cout << v[0] << " " << v[1] << " " << v[0];
} else
cout << "NO";
cout << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 105, MOD = 1e9 + 7;
long long n, k;
struct mat {
long long arr[N][N];
mat operator*(mat b) {
mat c = mat();
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < n; j++) {
for (long long k = 0; k < n; k++) {
c.arr[i][j] = (c.arr[i][j] + arr[i][k] * b.arr[k][j] % MOD) % MOD;
}
}
}
return c;
}
mat() { memset(arr, 0, sizeof arr); }
};
mat fastpow(mat m, long long p) {
mat ans = mat();
for (long long i = 0; i < n; i++) ans.arr[i][i] = 1;
while (p) {
if (p & 1) ans = ans * m;
m = m * m;
p >>= 1;
}
return ans;
}
long long cnt(long long num) {
long long ans = 0;
while (num) {
ans++;
num &= num - 1;
}
return ans;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
long long arr[n];
for (auto &x : arr) cin >> x;
mat m = mat();
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < n; j++) {
if (cnt(arr[i] ^ arr[j]) % 3 == 0) m.arr[i][j] = 1;
}
m.arr[i][n] = 1;
}
mat tmp = fastpow(m, k - 1);
long long ans = 0;
for (long long i = 0; i <= n; i++) {
for (long long j = 0; j <= n; j++) {
ans = (ans + tmp.arr[i][j]) % MOD;
}
}
cout << ans << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
static int prefix[200000];
static int prefix_len;
struct Segment {
long long base;
Segment(long long base) : base(base) {}
virtual int value(long long index) const = 0;
};
struct RawValue : public Segment {
RawValue(long long base, int val) : Segment(base), val(val) {}
int value(long long index) const { return val; }
private:
int val;
};
struct RepValue : public Segment {
RepValue(long long base, int l) : Segment(base), l(l) {}
int value(long long index) const { return prefix[(index - base) % l]; }
private:
int l;
};
static vector<Segment*> custom;
static long long N;
void append(int val) {
if (N < 100000) {
prefix[prefix_len++] = val;
} else {
custom.push_back(new RawValue(N, val));
}
N++;
}
void repeat(int l, int c) {
while (N < 100000 && c > 0) {
memcpy(&prefix[N], &prefix[0], l * sizeof(prefix[0]));
N += l;
prefix_len += l;
c--;
}
if (c > 0) {
custom.push_back(new RepValue(N, l));
N += c * l;
}
}
const Segment* bin_search(long long index) {
int left = 0;
int right = (int)custom.size();
while (right - left > 1) {
int mid = (left + right) / 2;
if (custom[mid]->base <= index)
left = mid;
else
right = mid;
}
return custom[left];
}
int main(int argc, const char* argv[]) {
int M;
cin >> M;
for (int i = 0; i < M; i++) {
int type;
cin >> type;
if (type == 1) {
int val;
cin >> val;
append(val);
} else {
int l, c;
cin >> l >> c;
repeat(l, c);
}
}
int n;
cin >> n;
for (int i = 0; i < n; i++) {
long long index;
cin >> index;
index--;
if (index < prefix_len) {
cout << prefix[index] << ' ';
} else {
const Segment* it = bin_search(index);
cout << it->value(index) << ' ';
}
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void *malloc(size_t size);
int main() {
long long int y, x, min_x, min_y, max_x, max_y, s;
int n, i;
cin >> n;
for (i = 0; i < n; i++) {
cin >> x >> y;
if (i == 0) {
max_x = min_x = x;
max_y = min_y = y;
} else {
if (x > max_x) {
max_x = x;
}
if (x < min_x) {
min_x = x;
}
if (y > max_y) {
max_y = y;
}
if (y < min_y) {
min_y = y;
}
}
}
s = max(abs(max_y - min_y), abs(max_x - min_x));
cout << s * s << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int L = 22, MAXN = (1 << L);
int dp[MAXN], n, a[MAXN];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
dp[a[i]] = a[i];
}
for (int mask = 0; mask < MAXN; mask++) {
for (int i = 0; i < L; i++) {
if ((mask >> i) & 1) {
dp[mask] = max(dp[mask], dp[mask - (1 << i)]);
}
}
}
for (int i = 0; i < MAXN; i++)
if (dp[i] == 0) dp[i] = -1;
for (int i = 0; i < n; i++) cout << dp[a[i] ^ ((1 << L) - 1)] << ' ';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int size = 50 + 10;
int n, k, aim[size], num[size], ans = -1;
int main() {
cin >> n >> k;
if (k > n) {
cout << -1 << endl;
return 0;
}
for (int i = 1; i <= n; i++) cin >> aim[i];
sort(aim + 1, aim + n + 1);
num[1] = 0;
for (int i = 2; i <= n; i++)
if (aim[i] > aim[i - 1])
num[i] = i - 1;
else
num[i] = num[i - 1];
for (int i = 1; i <= n; i++)
if (aim[i] != aim[i + 1] && n - num[i] == k) ans = aim[i];
if (ans < 0) {
cout << ans << endl;
return 0;
}
cout << ans << " " << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
template <class T>
T gcd(T a, T b) {
return ((b == 0) ? a : gcd(b, a % b));
}
vector<int> g[10];
int deg[10];
int ed[10][10];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < (int)(m); i++) {
int a, b;
cin >> a >> b;
a--, b--;
deg[a]++, deg[b]++;
ed[a][b] = ed[b][a] = 1;
}
int mn = 1e9;
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(n); j++)
if (i != j) {
int cur = 0;
for (int k = 0; k < (int)(n); k++)
if (k != i && k != j) {
if (ed[i][k] && ed[j][k]) cur++;
}
mn = min(mn, cur);
}
if (n < 7)
cout << m << endl;
else
cout << m - mn << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> arr[100000 + 10];
int n, ans[100000 + 10], opt[100000 + 10];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &opt[i]);
for (int i = 0; i <= n; ++i)
if (!opt[i]) {
int nex = i + 1;
for (; nex <= n + 1; ++nex)
if (!opt[nex]) break;
int cnt = 0;
for (int j = i + 1; j < nex; ++j) arr[++cnt] = make_pair(opt[j], j);
sort(arr + 1, arr + cnt + 1, greater<pair<int, int> >());
if (!cnt)
ans[nex] = 4;
else if (cnt == 1)
ans[arr[1].second] = 0, ans[nex] = 5;
else if (cnt == 2)
ans[arr[1].second] = 0, ans[arr[2].second] = 1, ans[nex] = 6;
else {
ans[arr[1].second] = 0;
ans[arr[2].second] = 1;
ans[arr[3].second] = 2;
for (int j = 4; j <= n; ++j) ans[arr[j].second] = 3;
ans[nex] = 7;
}
}
for (int i = 1; i <= n; ++i) switch (ans[i]) {
case 0:
puts("pushStack");
break;
case 1:
puts("pushQueue");
break;
case 2:
puts("pushFront");
break;
case 3:
puts("pushBack");
break;
case 4:
puts("0");
break;
case 5:
puts("1 popStack");
break;
case 6:
puts("2 popStack popQueue");
break;
case 7:
puts("3 popStack popQueue popFront");
break;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long fix(long long cur, long long m) { return ((cur % m) + m) % m; }
long long fast_power(long long x, long long y, long long m) {
if (y == 0) return 1;
long long temp = fast_power(x, y / 2, m);
temp = (temp * temp) % m;
if (y % 2 != 0) temp = (temp * x) % m;
return temp;
}
int main() {
cin.tie(0);
std::ios::sync_with_stdio(false);
cout.tie(0);
int n;
cin >> n;
int arr[n];
map<int, int> mp;
for (int i = 0; i < n; i++) {
cin >> arr[i];
mp[arr[i]]++;
}
vector<int> ans;
for (int i = 0; i < 6000; i++) {
if (mp[i]) {
ans.push_back(i);
mp[i]--;
}
}
for (int i = 6000; i >= 0; i--) {
if (mp[i] && (ans[ans.size() - 1] != i)) {
ans.push_back(i);
mp[i]--;
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
const int maxL = 1e6 + 100;
struct Flight {
int fr, to, cost;
Flight(int a = 0, int b = 0, int c = 0) { fr = a, to = b, cost = c; }
};
int N, M, K, L;
int used[maxn];
long long pre[maxL], suf[maxL];
vector<Flight> ope[maxL];
void Prepare() {
long long ret = 0;
memset(used, 255, sizeof(used[0]) * (N + 2));
int g = 0;
for (int i = (1), _i = (L); i <= _i; i++) {
for (int j = (0), _j = (ope[i].size() - 1); j <= _j; j++) {
int fr = ope[i][j].fr, to = ope[i][j].to, cost = ope[i][j].cost;
if (to != 0) continue;
if (used[fr] == -1) {
++g;
ret += cost;
used[fr] = cost;
} else if (cost < used[fr]) {
ret -= used[fr] - cost;
used[fr] = cost;
}
}
pre[i] = (g == N ? ret : -1);
}
ret = 0;
memset(used, 255, sizeof(used[0]) * (N + 2));
g = 0;
for (int i = (L), _i = (1); i >= _i; i--) {
for (int j = (0), _j = (ope[i].size() - 1); j <= _j; j++) {
int fr = ope[i][j].fr, to = ope[i][j].to, cost = ope[i][j].cost;
if (fr != 0) continue;
if (used[to] == -1) {
++g;
ret += cost;
used[to] = cost;
} else if (cost < used[to]) {
ret -= used[to] - cost;
used[to] = cost;
}
}
suf[i] = (g == N ? ret : -1);
}
}
int main() {
for (; scanf("%d%d%d", &N, &M, &K) != EOF;) {
for (int i = (0), _i = (maxL - 1); i <= _i; i++) ope[i].clear();
L = 0;
for (int i = (1), _i = (M); i <= _i; i++) {
int d, f, t, c;
scanf("%d%d%d%d", &d, &f, &t, &c);
ope[d].push_back(Flight(f, t, c));
L = max(L, d);
}
Prepare();
long long ans = -1;
for (int i = (1), _i = (L - K - 1); i <= _i; i++) {
int j = i + K + 1;
if (pre[i] == -1 || suf[j] == -1) continue;
if (ans == -1 || pre[i] + suf[j] < ans) ans = pre[i] + suf[j];
}
printf("%I64d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int g[1000][1000];
void solve() {
m = 3;
while (n * 2 >= m * (m + 1)) m++;
for (int i = 0; i < m; i++) g[i][0] = 0;
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
g[i][++g[i][0]] = n;
g[j][++g[j][0]] = n;
n--;
}
}
printf("%d\n", m);
while (m--) {
for (int i = 1; i <= g[m][0]; i++)
printf("%d%c", g[m][i], i < g[m][0] ? ' ' : '\n');
}
}
int main() {
while (cin >> n) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 5;
bool u[maxn][maxn];
int main() {
vector<pair<int, int>> v(3);
for (int i = 0; i < 3; ++i) scanf("%d%d", &v[i].first, &v[i].second);
vector<int> o(3);
for (int i = 0; i < 3; ++i) o[i] = i;
vector<pair<int, int>> ans;
do {
for (int s = 0; s < 4; ++s) {
memset(u, false, sizeof(u));
for (int i = 0; i < 3; ++i) u[v[i].first][v[i].second] = true;
for (int i = 0; i < 2; ++i) {
int x = v[o[i]].first, y = v[o[i]].second;
if (s >> i & 1) {
while (x > v[o[i + 1]].first) u[x][y] = true, --x;
while (x < v[o[i + 1]].first) u[x][y] = true, ++x;
while (y > v[o[i + 1]].second) u[x][y] = true, --y;
while (y < v[o[i + 1]].second) u[x][y] = true, ++y;
} else {
while (y > v[o[i + 1]].second) u[x][y] = true, --y;
while (y < v[o[i + 1]].second) u[x][y] = true, ++y;
while (x > v[o[i + 1]].first) u[x][y] = true, --x;
while (x < v[o[i + 1]].first) u[x][y] = true, ++x;
}
}
vector<pair<int, int>> res;
for (int i = 0; i < maxn; ++i) {
for (int j = 0; j < maxn; ++j)
if (u[i][j]) res.emplace_back(i, j);
}
if ((int)ans.size() == 0 || (int)res.size() < (int)ans.size()) ans = res;
}
} while (next_permutation(o.begin(), o.end()));
printf("%d\n", (int)ans.size());
for (int i = 0; i < (int)ans.size(); ++i) {
printf("%d %d\n", ans[i].first, ans[i].second);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return {i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
using ll = long long;
constexpr int mod = 1000 * 1000 * 1000 + 7;
void DodajDo(int& a, int b) {
a += b;
if (a >= mod) a -= mod;
}
int Dodaj(int a, int b) {
DodajDo(a, b);
return a;
}
int Mnoz(int a, int b) { return (ll)a * b % mod; }
void MnozDo(int& a, int b) { a = Mnoz(a, b); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
set<pair<int, int>> z[2];
int roz[2];
for (int i = 0; i < 2; i++) cin >> roz[i];
for (int i = 0; i < 2; i++) {
while (roz[i]--) {
int a, b;
cin >> a >> b;
z[i].insert(make_pair(a, b));
z[i].insert(make_pair(b, a));
}
}
set<int> dobre;
bool zle = false;
for (int h = 0; h < 2; h++) {
for (auto& it : z[h]) {
vector<int> jed = {it.first, it.second};
set<int> jdob;
for (auto& it2 : z[h ^ 1]) {
vector<int> dwa = {it2.first, it2.second};
set<int> to_samo;
for (int j : jed)
for (int d : dwa)
if (j == d) to_samo.insert(d);
if ((int)to_samo.size() == 1) {
const int x = *to_samo.begin();
dobre.insert(x);
jdob.insert(x);
}
}
if ((int)jdob.size() > 1) {
zle = true;
}
}
}
if ((int)dobre.size() == 1)
cout << *dobre.begin() << endl;
else if (zle)
cout << -1 << endl;
else
cout << 0 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool visited[1010];
vector<int> g[1010];
pair<int, int> v[2010];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int i, j, n, k, l, m;
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> v[i].first;
v[i].second = i + 1;
}
for (i = 0; i < m; i++) {
cin >> j >> k;
g[j].emplace_back(k);
g[k].emplace_back(j);
}
sort(v, v + n);
long long ans = 0;
for (i = 0; i < n; i++) {
j = g[v[i].second].size();
visited[v[i].second] = 1;
for (k = 0; k < j; k++)
if (!visited[g[v[i].second][k]]) ans += (long long)v[i].first;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline void add(int &x, int y) {
x += y;
if (x >= 1000000007) x -= 1000000007;
}
int u[260], v[260];
map<int, int> mp;
int sz;
inline int get_id(int x) {
if (!mp[x]) mp[x] = (int)mp.size();
return mp[x];
}
vector<int> e[260];
void addedge(int u, int v) {
e[u].push_back(v);
e[v].push_back(u);
}
inline int cal_size(int u, int n, int d) {
int t = u, c = 0, res;
while (t) c++, t >>= 1;
res = (1 << (d - c + 1)) - 1, t = c;
while (t < d) t++, u = u << 1 | 1;
return res - max(min(u - n, 1 << (d - c)), 0);
}
int num[260];
void pre_dp(int u, int f) {
for (auto &v : e[u]) {
if (v == f) continue;
num[u] -= num[v];
pre_dp(v, u);
}
}
int vis[260];
void dfs(int u, int &tot) {
add(tot, num[u]);
vis[u] = 1;
for (auto &v : e[u])
if (!vis[v]) dfs(v, tot);
vis[u] = 0;
}
int main() {
int n, m, d = 0;
scanf("%d%d", &n, &m);
while ((1 << d) <= n) d++;
get_id(1);
for (int i = 0; i < m; ++i) {
scanf("%d%d", &u[i], &v[i]);
int t = u[i];
while (t) get_id(t), t >>= 1;
t = v[i];
while (t) get_id(t), t >>= 1;
}
for (auto &t : mp) {
int u = t.first, id = t.second;
if (u > 1) addedge(get_id(u), get_id(u >> 1));
num[id] = cal_size(u, n, d);
}
pre_dp(1, 0);
for (int i = 0; i < m; ++i) addedge(get_id(u[i]), get_id(v[i]));
int res = 0;
for (int i = 1; i <= (int)mp.size(); ++i) {
int tot = 0;
dfs(i, tot);
add(res, 1LL * tot * num[i] % 1000000007);
}
printf("%d\n", res);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
char c, str[1148576], temp[1148576];
int main() {
int i, j, k, cnt = 0, flag;
while (gets(temp) != NULL) {
flag = 0;
for (i = 0; temp[i]; ++i) {
if (temp[i] != ' ' && temp[i] != '#') break;
if (temp[i] == '#') flag = 1;
}
if (flag == 1 && cnt == 0)
printf("%s\n", temp);
else if (flag == 1 && cnt != 0) {
for (i = 0; i < cnt; ++i)
if (str[i] != ' ' && str[i] != '\n') printf("%c", str[i]);
printf("\n");
printf("%s\n", temp);
cnt = 0;
} else {
if (temp[0] == '\0') str[cnt++] = '\n';
for (i = 0; temp[i]; ++i) str[cnt++] = temp[i];
}
}
if (cnt != 0) {
for (i = 0; i < cnt; ++i)
if (str[i] != ' ' && str[i] != '\n') printf("%c", str[i]);
printf("\n");
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int n;
cin >> n;
long long a[n], xr = 0;
map<long long, long long> m1, m2;
for (int i = 0; i < n; i++) {
cin >> a[i];
xr = xr ^ a[i];
if (i % 2 == 0)
m1[xr]++;
else
m2[xr]++;
}
long long ans = 0, nxr = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
ans += m2[nxr];
else
ans += m1[nxr];
nxr = nxr ^ a[i];
if (i % 2 == 0)
m1[nxr]--;
else
m2[nxr]--;
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, cs, cd, mij;
string s;
int main() {
std::srand(std::time(nullptr));
cin >> n >> k;
while (1) {
cs = 1;
cd = n;
while (1) {
cs = max(1LL, cs - 2 * k);
cd = min(n, cd + 2 * k);
mij = (cs + cd) / 2LL;
if (cd - cs <= 100) {
int numar = rand() % 100;
cout << min(cs + numar, n) << " " << min(cs + numar, n) << endl;
cin >> s;
if (s == "Yes") return 0;
}
cout << cs << " " << mij << endl;
cout << flush;
cin >> s;
if (s == "Yes")
cd = mij;
else
cs = mij;
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int f, s;
cin >> n;
string arr[] = {"zero", "one", "two", "three", "four",
"five", "six", "seven", "eight", "nine",
"ten", "eleven", "twelve", "thirteen", "fourteen",
"fifteen", "sixteen", "seventeen", "eighteen", "nineteen",
"twenty"};
string arr1[] = {"", "", "twenty", "thirty", "forty",
"fifty", "sixty", "seventy", "eighty", "ninety"};
if (n <= 20) {
cout << arr[n] << "\n";
} else {
s = n / 10;
f = n % 10;
if (f == 0)
cout << arr1[s] << "\n";
else
cout << arr1[s] << "-" << arr[f] << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
double fib(double x, double z);
string bn(long long x);
string kok(long long x);
long long kok(string x);
long long bn(string x);
long long po(long long x, long long y, long long mod);
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
vector<int> x, zz;
map<int, bool> z;
int y, n, i, j, a;
long long s = 0;
long long ans = 0;
cin >> n >> y;
for (i = 0; i < n; i++) {
cin >> a;
s += a;
x.push_back(a);
}
for (i = 0; i < y; i++) {
cin >> a;
zz.push_back(a - 1);
z[a - 1] = 1;
}
if (z[0] != 1 && z[n - 1] != 1) ans += (x[0] * x[n - 1]);
for (i = 1; i < n; i++) {
if (z[i] != 1 && z[i - 1] != 1) {
ans += (x[i] * x[i - 1]);
}
}
for (i = 0; i < zz.size(); i++) {
s -= x[zz[i]];
ans += (s * x[zz[i]]);
}
cout << ans << endl;
return 0;
}
double fib(double x, double z) {
int i = 0;
double f = x, r = x, t;
for (i = 2; i < z; i++) {
t = f;
f += r;
r = t;
}
return f;
}
string bn(long long x) {
string z;
while (1) {
if (x % 2 == 0)
z += '0';
else
z += '1';
x /= 2;
if (x == 0) break;
}
reverse(z.begin(), z.end());
return z;
}
long long bn(string x) {
long long i;
unsigned long long z = 1, a = 0;
for (i = x.size() - 1; i >= 0; i--) {
if (x[i] == '1') a += z;
z *= 2;
}
return a;
}
long long kok(string x) {
long long z = 0, i;
for (i = 0; i < x.size(); i++) {
z *= 10;
z += (x[i] - '0');
}
return z;
}
string kok(long long x) {
string z;
while (x != 0) {
z += (x % 10 + '0');
x /= 10;
}
reverse(z.begin(), z.end());
return z;
}
long long po(long long x, long long y, long long mod) {
long long z = 1, d = y, q;
y = x;
for (int i = 0; i < 30; i++) {
q = (1 << i);
if ((d & q) != 0) {
z *= y;
z = z % mod;
}
y *= y;
y = y % mod;
}
return z;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int const N = 5e5 + 20, INF = 1e9;
int n, m, a[N], val[N << 2], mn[N << 2], ans[N];
pair<int, int> q[N];
vector<int> v[N];
map<int, int> last;
void build(int v = 1, int b = 0, int e = n) {
if (b == e - 1) {
val[v] = INF;
mn[v] = INF;
return;
}
int mid = b + e >> 1, lc = v << 1, rc = lc | 1;
build(lc, b, mid);
build(rc, mid, e);
val[v] = INF;
mn[v] = min(mn[lc], mn[rc]);
return;
}
int get(int l, int r, int v = 1, int b = 0, int e = n) {
mn[v] = min(mn[v], val[v]);
if (l >= e || r <= b) return INF;
if (l <= b && e <= r) return mn[v];
int mid = b + e >> 1, lc = v << 1, rc = lc | 1;
val[lc] = min(val[lc], val[v]), val[rc] = min(val[rc], val[v]);
int ret = min(get(l, r, lc, b, mid), get(l, r, rc, mid, e));
return ret;
}
void update(int l, int r, int x, int v = 1, int b = 0, int e = n) {
mn[v] = min(mn[v], val[v]);
if (l >= e || r <= b) return;
mn[v] = min(mn[v], x);
if (l <= b && e <= r) {
val[v] = min(val[v], x);
return;
}
int mid = b + e >> 1, lc = v << 1, rc = lc | 1;
val[lc] = min(val[lc], val[v]), val[rc] = min(val[rc], val[v]);
update(l, r, x, lc, b, mid);
update(l, r, x, rc, mid, e);
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) {
cin >> q[i].first >> q[i].second;
q[i].first--, q[i].second--;
v[q[i].second].push_back(i);
}
build();
for (int i = 0; i < n; i++) {
if (last.count(a[i])) update(last[a[i]], last[a[i]] + 1, i - last[a[i]]);
last[a[i]] = i;
for (auto ind : v[i]) ans[ind] = get(q[ind].first, i);
}
for (int i = 0; i < m; i++) cout << (ans[i] == INF ? -1 : ans[i]) << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string sy;
int com(string s1, string s2) {
if (s1.size() != s2.size()) return 0;
for (int i = 0; i < s1.size(); i++) {
if (s1[i] != s2[i]) return 0;
}
return 1;
}
int pr(int st, int en, string s1) {
int st1 = 0, en1 = 0;
for (int i = 0; i < s1.size(); i++) {
if (s1[i] == '0') {
break;
}
st1++;
}
for (int i = s1.size() - 1; i >= 0; i--) {
if (s1[i] == '0') {
break;
}
en1++;
}
if (en == 0 && st1 != st) return 0;
while (en1 < en) {
s1 += '1';
en1++;
}
reverse(s1.begin(), s1.end());
while (st1 < st) {
s1 += '1';
st1++;
}
reverse(s1.begin(), s1.end());
return com(s1, sy);
}
int main() {
long long x, y;
cin >> x >> y;
string s1, s2, s3, s4;
for (int i = 0; y || x; i++) {
char c1 = (y % 2) + '0';
char c2 = (x % 2) + '0';
if (y) sy += c1;
if (x) s1 += c2;
y /= 2;
x /= 2;
}
reverse(sy.begin(), sy.end());
reverse(s1.begin(), s1.end());
int id = s1.size() - 1;
while (s1[id] == '0' && id >= 0) {
id--;
}
for (id; id >= 0; id--) {
s2 += s1[id];
}
s3 = s1;
s3 += '1';
s4 = s3;
int st = 0, en = 0;
string temp;
reverse(s4.begin(), s4.end());
for (int i = 0; i < sy.size(); i++) {
if (sy[i] == '0') {
break;
}
st++;
}
for (int i = sy.size() - 1; i >= 0; i--) {
if (sy[i] == '0') {
break;
}
en++;
}
if (st == sy.size()) st = 0;
string s5 = s2;
reverse(s5.begin(), s5.end());
if (pr(st, en, s5) || pr(st, en, s1) || pr(st, en, s2) || pr(st, en, s3) ||
pr(st, en, s4))
cout << "YES";
else
cout << "NO";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0)
return b;
else {
return gcd(b % a, a);
}
}
int main() {
long long t;
cin >> t;
for (long long i = 0; i < t; ++i) {
long long n;
cin >> n;
cout << (4 * n) / gcd(n + 1, 4 * n) + 1 << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool isPal(string);
int main() {
string str;
cin >> str;
string ans = "";
vector<char> ma(str.size(), 'a');
char maxi = 'a';
for (int i = str.size() - 1; i >= 0; i--) {
maxi = max(maxi, str[i]);
ma[i] = maxi;
}
for (int i = 0; i < str.size(); i++) {
if (str[i] == ma[i]) ans += str[i];
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T x, T y) {
if (x < y) swap(x, y);
while (y > 0) {
T f = x % y;
x = y;
y = f;
}
return x;
}
const int maxn = 100007;
int BLOCKSIZE = 350;
set<int> s[maxn];
int a[maxn];
int nxt[maxn];
int prv[maxn];
int n, m;
long long b[maxn];
int d[maxn];
int lst[maxn];
long long query(int block, int R) {
int iBlockStart = block * BLOCKSIZE;
int iBlockEnd = min((block + 1) * BLOCKSIZE, n);
int idx = upper_bound(d + iBlockStart, d + iBlockEnd, R,
[](int i, int j) { return i < nxt[j]; }) -
d;
if (idx == iBlockStart) return 0;
return b[idx - 1];
}
void updateBlock(int block) {
int iBlockStart = block * BLOCKSIZE;
int iBlockEnd = min((block + 1) * BLOCKSIZE, n);
sort(d + iBlockStart, d + iBlockEnd,
[](int i, int j) { return nxt[i] < nxt[j]; });
b[iBlockStart] = nxt[d[iBlockStart]] - d[iBlockStart];
for (int i = iBlockStart + 1; i < iBlockEnd; i++)
b[i] = b[i - 1] + nxt[d[i]] - d[i];
}
int main(int argc, char *argv[]) {
std::cin.sync_with_stdio(false);
std::cin.tie(nullptr);
cin >> n >> m;
{
BLOCKSIZE = 1;
while (BLOCKSIZE * BLOCKSIZE < n) BLOCKSIZE++;
BLOCKSIZE = max(BLOCKSIZE, 10);
for (int i = 0; i < n; i++) nxt[i] = n, prv[i] = -1, d[i] = i;
memset(lst, -1, sizeof(lst));
for (int i = 0; i < n; i++) {
cin >> a[i];
int pr = lst[a[i]];
if (pr != -1) {
nxt[pr] = i;
prv[i] = pr;
}
lst[a[i]] = i;
s[a[i]].insert(i);
}
for (int i = 0; i * BLOCKSIZE < n; i++) updateBlock(i);
for (int i = 0; i < m; i++) {
int op;
cin >> op;
if (op == 1) {
int p, x;
cin >> p >> x;
p--;
if (a[p] == x) continue;
if (nxt[p] != n) prv[nxt[p]] = prv[p];
if (prv[p] != -1) {
nxt[prv[p]] = nxt[p];
if (prv[p] / BLOCKSIZE != p / BLOCKSIZE)
updateBlock(prv[p] / BLOCKSIZE);
}
s[a[p]].erase(p);
a[p] = x;
nxt[p] = n;
prv[p] = -1;
auto it = s[x].emplace(p).first;
bool updatedNext = false;
if (it != s[x].begin()) {
int pr = *prev(it);
int nx = nxt[pr];
nxt[pr] = p;
prv[p] = pr;
if (pr / BLOCKSIZE != p / BLOCKSIZE) updateBlock(pr / BLOCKSIZE);
if (nx != n) {
prv[nx] = p;
nxt[p] = nx;
updatedNext = true;
}
}
if (!updatedNext) {
auto nxiter = next(it);
if (nxiter != s[x].end()) {
int nx = *nxiter;
prv[nx] = p;
nxt[p] = nx;
}
}
updateBlock(p / BLOCKSIZE);
} else {
int l, r, R;
cin >> l >> r;
l--;
r--;
R = r;
long long res = 0;
for (; l <= r && l % BLOCKSIZE; l++)
if (nxt[l] <= R) res += nxt[l] - l;
for (; l <= r && (r + 1) % BLOCKSIZE; r--)
if (nxt[r] <= R) res += nxt[r] - r;
if (l <= r) {
for (int i = l / BLOCKSIZE, j = r / BLOCKSIZE; i <= j; i++) {
res += query(i, R);
}
}
cout << res << endl;
}
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long fx[] = {+1, -1, +0, +0};
const long long fy[] = {+0, +0, +1, -1};
const long long N = 1e6 + 5, K = 20, mod = 1000000007, MOD = 1000000007,
INF = LLONG_MAX / 2;
long long CeilIndex(std::vector<long long>& v, long long l, long long r,
long long key) {
while (r - l > 1) {
long long m = l + (r - l) / 2;
if (v[m] >= key)
r = m;
else
l = m;
}
return r;
}
long long LongestIncreasingSubsequenceLength(std::vector<long long>& v) {
if (v.size() == 0) return 0;
std::vector<long long> tail(v.size(), 0);
long long length = 1;
tail[0] = v[0];
for (size_t i = 1; i < v.size(); i++) {
if (v[i] < tail[0])
tail[0] = v[i];
else if (v[i] > tail[length - 1])
tail[length++] = v[i];
else
tail[CeilIndex(tail, -1, length - 1, v[i])] = v[i];
}
return length;
}
void solve() {
long long n;
cin >> n;
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
cout << LongestIncreasingSubsequenceLength(v) << endl;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long TESTS = 1;
while (TESTS--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1e6 + 5, mod = 998244353, bit = 60;
long long int solve(long long int n) {
set<long long int> ms;
for (int i = 0; i <= n; i++) {
for (int j = 0; j + i <= n; j++) {
for (int k = 0; k + j + i <= n; k++) {
int l = n - (k + j + i);
ms.insert(i * 1 + j * 5 + k * 10 + l * 50);
}
}
}
return ms.size();
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int pro = 1, temp, t, i, j, l, r, n, m, mid, z, k, x, y, rem,
carry = 0, ind, ans = 0, mx = -LONG_LONG_MAX,
mn = LONG_LONG_MAX, cnt = 0, curr = 0, prev, next, sum = 0,
flag = 1, i1 = -1, i2 = -1;
cin >> n;
temp = max(0ll, n - 11);
n = min(11ll, n);
ans = 49 * temp + solve(n);
cout << ans << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
string a[1000], b[1000];
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
for (int i = 0; i < m; i++) {
string cmd, ip, tip;
cin >> cmd >> ip;
for (int i = 0; i < ip.size() - 1; i++) tip += ip[i];
for (int i = 0; i < n; i++) {
if (tip.compare(b[i]) == 0)
cout << cmd << " " << ip << " #" << a[i] << '\n';
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6;
long long a[N];
signed main() {
long long T;
cin >> T;
while (T--) {
long long n;
cin >> n;
string stl, str;
cin >> stl >> str;
bool f = 0;
for (long long i = 0; i < n; i++) {
if (stl[i] == '1' && str[i] == '1') f = 1;
}
if (f)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const int maxn = 1e4, max_num = 1e5;
int fpm(long long b, long long e, const int &m) {
long long t = 1;
for (; e; e >>= 1, (b *= b) %= m)
if (e & 1) (t *= b) %= m;
return t;
}
int gcd(int first, int second) {
while (second) second ^= first ^= second ^= first %= second;
return first;
}
int n, m, p;
int a[maxn + 5];
int ans = 0;
int main() {
scanf("%d%d%d", &n, &m, &p);
vector<int> all;
for (int i = 1; i * i <= p - 1; ++i)
if (!((p - 1) % i)) {
all.push_back(i);
if (i * i != p - 1) all.push_back((p - 1) / i);
}
sort((all).begin(), (all).end());
for (int i = (0), _end_ = (n); i != _end_; ++i) scanf("%d", a + i);
int yyt = p - 1;
for (int i = (0), _end_ = (m); i != _end_; ++i) {
static int first;
scanf("%d", &first);
yyt = gcd(yyt, first);
}
for (int i = (0), _end_ = (n); i != _end_; ++i)
for (int j = (0), _end_ = ((int((all).size()))); j != _end_; ++j)
if (fpm(a[i], (long long)all[j] * yyt, p) == 1) {
a[i] = (p - 1) / all[j];
break;
}
sort(a, a + n), n = unique(a, a + n) - a, reverse(a, a + n);
static int dp[max_num + 5];
for (int i = (0), _end_ = (n); i != _end_; ++i) {
dp[i] = (p - 1) / a[i];
for (int j = (0), _end_ = (i); j != _end_; ++j)
if (!(a[j] % a[i])) dp[i] -= dp[j];
ans += dp[i];
}
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int can[1010][1010], f[1010][1010][2], a[1010];
inline int read() {
char c = getchar();
int x = 0, flag = 1;
while (!isdigit(c)) {
if (c == '-') flag = -1;
c = getchar();
}
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
return x * flag;
}
int gg(int a, int b) {
if (b == 0) return a;
return gg(b, a % b);
}
int main() {
int n = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (gg(a[i], a[j]) > 1) can[i][j] = 1;
}
}
for (int i = 1; i <= n; i++) {
f[i][i][0] = f[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;
for (int k = i + 1; k <= j; k++) {
if (can[k][i] && f[i + 1][k][1] && f[k][j][0]) {
f[i][j][0] = 1;
break;
}
}
for (int k = i; k < j; k++) {
if (can[k][j] && f[i][k][1] && f[k][j - 1][0]) {
f[i][j][1] = 1;
break;
}
}
}
}
for (int i = 1; i <= n; i++) {
if (f[1][i][1] && f[i][n][0]) {
puts("Yes");
return 0;
}
}
puts("No");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int mp[8000010];
vector<int> vec;
int iCnt = 1;
void compress() {
sort(vec.begin(), vec.end());
iCnt = 1;
for (int i = 0; i < vec.size(); i++) {
mp[vec[i]] = iCnt;
iCnt += 3;
}
}
pair<int, int> pArr[8000010];
bool nisi[8000010];
int lineSweepArr[8000010];
void onKoro(int i, int j) {
for (int ii = i; ii <= j; ii++) lineSweepArr[ii]++;
}
void offKoro(int i, int j) {
for (int ii = i; ii <= j; ii++) lineSweepArr[ii]--;
}
bool overLapAse() {
for (int ii = 0; ii < iCnt + 2; ii++) {
if (lineSweepArr[ii] > 1) return true;
}
return false;
}
int main() {
int n;
scanf("%d", &n);
memset(nisi, false, sizeof(nisi));
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d", &x);
scanf("%d", &y);
pArr[i] = make_pair(x, y);
if (!nisi[x]) vec.push_back(x), nisi[x] = true;
if (!nisi[y]) vec.push_back(y), nisi[y] = true;
}
compress();
for (int i = 0; i < n; i++) {
int x, y;
x = pArr[i].first;
y = pArr[i].second;
x = mp[x];
y = mp[y];
lineSweepArr[x + 1]++;
lineSweepArr[y - 1]--;
}
for (int i = 1; i < iCnt + 2; i++) {
lineSweepArr[i] += lineSweepArr[i - 1];
}
vector<int> ans;
int ansCnt;
for (int i = 0; i < n; i++) {
int x, y;
x = pArr[i].first;
y = pArr[i].second;
x = mp[x];
y = mp[y];
offKoro(x, y);
if (!overLapAse()) ans.push_back(i + 1);
onKoro(x, y);
}
cout << ans.size() << "\n";
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100009;
int sol, qs[N], qe[N], sorted[N], ans[N], a[N], s, e;
unordered_map<int, int> freq;
void add(int el) {
sol -= !(freq[el] ^ el);
freq[el]++;
sol += !(freq[el] ^ el);
}
void remove(int el) {
sol -= !(freq[el] ^ el);
freq[el]--;
sol += !(freq[el] ^ el);
}
void mo(int idx) {
while (s > qs[idx]) add(a[--s]);
while (e <= qe[idx]) add(a[e++]);
while (s < qs[idx]) remove(a[s++]);
while (e > qe[idx] + 1) remove(a[--e]);
ans[idx] = sol;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) {
cin >> qs[i] >> qe[i];
qs[i]--, qe[i]--;
sorted[i] = i;
}
int sq = sqrt(n);
sort(sorted, sorted + m, [sq](int i, int j) {
return make_pair(qs[i] / sq, qe[i]) < make_pair(qs[j] / sq, qe[j]);
});
for (int i = 0; i < m; i++) mo(sorted[i]);
for (int i = 0; i < m; i++) cout << ans[i] << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, n, m, cs;
cin >> n >> m;
if (n & 1) {
cs = (n + 1) / 2;
if (m >= cs)
a = m - 1;
else
a = m + 1;
} else {
cs = n / 2;
if (m > cs)
a = m - 1;
else
a = m + 1;
}
if (n == 1) a = 1;
cout << a;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const long long inf = 2147383647;
const double pi = 2 * acos(0.0);
const double eps = 1e-9;
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
inline long long gcd(long long a, long long b) {
a = ((a) < 0 ? -(a) : (a));
b = ((b) < 0 ? -(b) : (b));
while (b) {
a = a % b;
swap(a, b);
}
return a;
}
long long ext_gcd(long long A, long long B, long long* X, long long* Y) {
long long x2, y2, x1, y1, x, y, r2, r1, q, r;
x2 = 1;
y2 = 0;
x1 = 0;
y1 = 1;
for (r2 = A, r1 = B; r1 != 0;
r2 = r1, r1 = r, x2 = x1, y2 = y1, x1 = x, y1 = y) {
q = r2 / r1;
r = r2 % r1;
x = x2 - (q * x1);
y = y2 - (q * y1);
}
*X = x2;
*Y = y2;
return r2;
}
inline long long modInv(long long a, long long m) {
long long x, y;
ext_gcd(a, m, &x, &y);
if (x < 0) x += m;
return x;
}
inline long long power(long long a, long long p) {
long long res = 1, x = a;
while (p) {
if (p & 1) res = (res * x);
x = (x * x);
p >>= 1;
}
return res;
}
inline long long bigmod(long long a, long long p, long long m) {
long long res = 1 % m, x = a % m;
while (p) {
if (p & 1) res = (res * x) % m;
x = (x * x) % m;
p >>= 1;
}
return res;
}
using namespace std;
template <typename T>
ostream& operator<<(ostream& out, vector<T> v) {
out << "[ ";
for (int i = 0; i < (((int)(v).size())); i++) {
if (i) out << ", ";
out << v[i];
}
out << " ]";
return out;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2> p) {
out << "( " << p.first << ", " << p.second << ")";
return out;
}
template <typename T>
ostream& operator,(ostream& out, T x) {
out << x << " ";
return out;
}
int main() {
int kases, kaseno = 0;
scanf("%d", &kases);
while (kases--) {
int n, x;
int cntOdd = 0, cntEven = 0;
cin >> n >> x;
for (int i = 0; i < (n); i++) {
int num;
cin >> num;
if ((num & 1) == 0) {
cntEven++;
} else {
cntOdd++;
}
}
bool possible = false;
for (int i = 1; i <= cntOdd && i <= x; i += 2) {
if ((x - i) <= cntEven) {
possible = true;
break;
}
}
if (possible)
printf("Yes\n");
else
printf("No\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-9;
const int mod = 1e9 + 7;
const long long INF = 1e12 + 1;
const int N = 2e5 + 9;
int n, mx;
int a[N];
bool b[N];
vector<int> v;
int main() {
ios_base ::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
mx = max(mx, a[i]);
if ((long long)(v.size()) > 0 && v[(long long)(v.size()) - 1] == a[i]) {
if ((long long)(v.size()) > 1 &&
v[(long long)(v.size()) - 2] > v[(long long)(v.size()) - 1]) {
v.pop_back();
} else if ((long long)(v.size()) <= 1)
v.pop_back();
} else
v.push_back(a[i]);
}
if ((long long)(v.size()) == 0) {
cout << "YES" << endl;
exit(0);
}
if ((long long)(v.size()) == 1 && v[0] >= mx)
cout << "YES" << endl;
else
cout << "NO" << endl;
exit(0);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int n, k, v, m, ans, sum, sum1, l, r,
mx = -1111111111, mn = 9999999999, mnn = 9, mxx = -1, c, z, x, y, a[555555],
d[1555555], t[1111111];
long double w;
string s, sos, ss, str;
char ch[111][111], chel, cha;
bool used[1111111];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
if (n == 1) {
cout << a[n];
return 0;
}
int j = n;
for (int i = 1; i <= n / 2; i++) {
z++;
t[z] = a[i];
if (z > 1 && z % 2 == 1 && t[z] > t[z - 1]) {
cout << "impossible";
return 0;
}
z++;
t[z] = a[j];
if (z % 2 == 0 && t[z] < t[z - 1]) {
cout << "impossible";
return 0;
}
j--;
if (n % 2 == 1 && i == n / 2) {
z++;
t[z] = a[i + 1];
if (z > 1 && z % 2 == 1 && t[z] > t[z - 1]) {
cout << "impossible";
return 0;
}
if (z % 2 == 0 && t[z] < t[z - 1]) {
cout << "impossible";
return 0;
}
}
}
for (int i = 1; i <= z; i++) {
cout << t[i] << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double PI =
3.141592653589793238462643383279502884197169399375105820974944;
int startwithone(char str[][105], int n) {
int ans = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if ((i + j) % 2 && str[i][j] == '1')
ans++;
else if ((i + j) % 2 == 0 && str[i][j] == '0')
ans++;
return ans;
}
int startwithzero(char str[][105], int n) {
int ans = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if ((i + j) % 2 && str[i][j] == '0')
ans++;
else if ((i + j) % 2 == 0 && str[i][j] == '1')
ans++;
return ans;
}
int main() {
int n;
cin >> n;
char str[105][105];
int a[4] = {0}, b[4] = {0};
for (int i = 0; i < n; i++) cin >> str[i];
a[0] = startwithone(str, n);
b[0] = startwithzero(str, n);
for (int i = 0; i < n; i++) cin >> str[i];
a[1] = startwithone(str, n);
b[1] = startwithzero(str, n);
for (int i = 0; i < n; i++) cin >> str[i];
a[2] = startwithone(str, n);
b[2] = startwithzero(str, n);
for (int i = 0; i < n; i++) cin >> str[i];
a[3] = startwithone(str, n);
b[3] = startwithzero(str, n);
unsigned long long ans = 10000000;
for (int i = 0; i < 16; i++) {
unsigned long long temp = 0;
int bitcount = 0, bits = i;
for (int j = 0; j < 4; j++) {
bitcount += bits % 2;
bits /= 2;
}
if (bitcount == 2) {
bits = i;
for (int j = 0; j < 4; j++) {
if (bits % 2)
temp += a[j];
else
temp += b[j];
bits /= 2;
}
ans = min(ans, temp);
}
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int in() {
int x;
cin >> x;
return x;
}
long long lin() {
long long x;
cin >> x;
return x;
}
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline void print(pair<T, T> p) {
cout << "(" << p.first << "," << p.second << ") ";
}
template <typename T>
istream& operator>>(istream& is, vector<T>& vec) {
for (T& x : vec) is >> x;
return is;
}
const long long INF = 1e9 + 7;
int main() {
long long t;
cin >> t;
while (t--) {
string s;
cin >> s;
long long n = s.length();
long long m = -1;
long long cnt = 0;
for (long long i = 0; i < n; i++) {
if (s[i] == 'L') {
cnt++;
} else {
m = max(m, cnt);
cnt = 0;
}
}
m = max(m, cnt);
cout << m + 1 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string s;
cin >> s;
long long sum = 0;
unordered_map<long long, long long> mp;
mp[0] = 1;
long long ans = 0;
int k = 0;
for (int i = 0; i < n; i++) {
sum += (s[i] - '0') - 1;
if (mp[sum] > 0) ans += mp[sum];
mp[sum]++;
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int ar[3000], Max[3000][2], Min;
int b, n, c = 0;
cin >> n >> b;
int ans = b;
Max[0][0] = -1;
for (int i = 0; i < n; i++) {
cin >> ar[i];
if (ar[i] >= Max[c][0]) {
if (i == 0)
Max[c][0] = ar[i];
else
Max[++c][0] = ar[i];
Max[c][1] = i;
} else {
c++;
Max[c][0] = Max[c - 1][0];
Max[c][1] = Max[c - 1][1];
Max[c - 1][0] = ar[i];
Max[c - 1][1] = i;
}
}
int Tr = c + 1;
while (Tr--) {
int Min = Max[c][0];
for (int i = 0; i < Max[c][1]; i++) {
if (ar[i] < Min) {
Min = ar[i];
}
}
if (Min != Max[c][0]) {
ans = max((((b / Min) * Max[c][0]) + (b % Min)), ans);
}
c--;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cout << "2000\n";
for (int i = 1; i <= 1000; ++i)
cout << i << " 1"
<< " " << i << " 2" << '\n';
for (int i = 1000; i > 0; --i)
cout << i << " 1"
<< " " << i << " 2" << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct st {
int wei, zhi;
};
long long p = 3332227, q = 10000007, p1 = 2, q1 = 1000000007, p2 = 7766332,
q2 = 99999997, now1 = 1, now2 = 1, now3 = 1;
string s, t;
int sum2, j, len, m, ha[30], ha1[30], ha2[30], i, sum, sum1, ke[20000][4],
fangan[30], e, hj[20000], tou[13000001], bian[20000][3];
st sz[200];
void insert(int i) {
sum += ha[i];
if (sum >= q) sum -= q;
sum1 += ha1[i];
if (sum1 >= q1) sum1 -= q1;
sum2 += ha2[i];
if (sum2 >= q2) sum2 -= q2;
}
int find(int i, int j, int k) {
int now = tou[i];
while (now != 0) {
if (bian[now][1] == j && bian[now][3] == k) return now;
now = hj[now];
}
return -1;
}
void insert1(int i, int j, int k) {
int now = find(i, j, k);
if (now != -1) {
return;
}
e++;
bian[e][1] = j;
bian[e][3] = k;
hj[e] = tou[i];
tou[i] = e;
}
bool cmp(st a, st b) {
if (a.zhi < b.zhi) return 1;
return 0;
}
int main() {
cin >> s;
len = s.length();
cin >> m;
for (i = 1; i <= 26; i++) {
now1 = (now1 * p) % q;
now2 = (now2 * p1) % q1;
now3 = (now3 * p2) % q2;
ha[i] = int(now1);
ha1[i] = int(now2);
ha2[i] = int(now3);
}
for (i = 1; i <= m; i++) {
cin >> t;
sum = 0;
sum1 = 0;
sum2 = 0;
for (j = 0; j < t.length(); j++) insert(t[j] - 'a' + 1);
insert1(sum, sum1, sum2);
ke[i][1] = sum;
ke[i][2] = sum1;
ke[i][3] = sum2;
}
for (i = 1; i <= 26; i++) fangan[i] = len;
for (j = 1; j <= 26; j++) sz[j].wei = j;
for (i = len - 1; i >= 0; i--) {
int tmp, lim;
sum = 0;
sum1 = 0;
sum2 = 0;
insert(s[i] - 'a' + 1);
tmp = find(sum, sum1, sum2);
if (tmp != -1)
if (i == len - 1 || s[i + 1] != s[i]) bian[tmp][2]++;
lim = fangan[s[i] - 'a' + 1];
for (j = 1; j <= 26; j++) {
sz[j].wei = j;
sz[j].zhi = fangan[j];
}
sort(sz + 1, sz + 1 + 26, cmp);
for (j = 1; j <= 26; j++) {
if (lim != len && sz[j + 1].zhi >= lim) break;
if (sz[j].zhi >= lim) break;
insert(sz[j].wei);
tmp = find(sum, sum1, sum2);
if (tmp != -1) bian[tmp][2]++;
}
fangan[s[i] - 'a' + 1] = i;
}
for (i = 1; i <= m; i++)
cout << bian[find(ke[i][1], ke[i][2], ke[i][3])][2] << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
const int nINF = 1 << 31;
const int MAXN = 2010;
const int INF = 1000000000;
class node {
public:
int v, f, couple;
pair<int, int> w;
node(int V, pair<int, int> W, int F, int CC) {
v = V;
w = W;
f = F;
couple = CC;
};
};
int fa[MAXN], ff[MAXN];
vector<node> g[MAXN];
void newnode(int a, int b, int c, pair<int, int> d) {
node p(b, d, c, g[b].size());
node q(a, {-d.first, -d.second}, 0, g[a].size());
g[a].push_back(p);
g[b].push_back(q);
}
pair<int, int> SPFA(int s, int t, int n) {
vector<pair<int, int> > d(n + 1, {INF, INF});
vector<bool> z(n + 1, false);
d[s] = {0, 0};
queue<int> q;
q.push(s);
z[s] = true;
while (!q.empty()) {
int i = q.front();
q.pop();
for (auto p = g[i].begin(); p != g[i].end(); ++p) {
pair<int, int> dc = {d[i].first + p->w.first, d[i].second + p->w.second};
if (p->f > 0 && d[p->v] > dc) {
d[p->v] = dc;
fa[p->v] = i;
ff[p->v] = p - g[i].begin();
if (!z[p->v]) {
z[p->v] = true;
q.push(p->v);
}
}
}
z[i] = false;
}
return d[t];
}
pair<int, int> min_cost(int s, int t, int n) {
int flow = 0;
pair<int, int> cost = {0, 0};
while (SPFA(s, t, n) < (pair<int, int>){0, 0}) {
int i = t, now = INF;
while (i != s) {
node &p = g[fa[i]][ff[i]];
i = fa[i];
if (p.f < now) now = p.f;
}
flow += now;
i = t;
while (i != s) {
g[fa[i]][ff[i]].f -= now;
cost = {cost.first + now * g[fa[i]][ff[i]].w.first,
cost.second + now * g[fa[i]][ff[i]].w.second};
g[i][g[fa[i]][ff[i]].couple].f += now;
i = fa[i];
}
}
return cost;
}
const int N = 510;
int n, x, y, a[N], q1, q2, r1[N], r2[N], src, tgt, wts = 0;
vector<int> g1[N], g2[N];
void dfs1(int s, int p = 0, int pre = src) {
if (r1[s]) {
newnode(pre, n + s, r1[s], {-1, 0});
newnode(n + s, s, 1, {0, -a[s]});
} else {
newnode(pre, s, 1, {0, -a[s]});
}
for (int v : g1[s])
if (v != p) dfs1(v, s, r1[s] ? n + s : pre);
}
void dfs2(int s, int p = 0, int pre = tgt) {
if (r2[s]) {
newnode(n + n + s, pre, r2[s], {-1, 0});
newnode(s, n + n + s, 1, {0, 0});
} else {
newnode(s, pre, 1, {0, 0});
}
for (int v : g2[s])
if (v != p) dfs2(v, s, r2[s] ? n + n + s : pre);
}
signed main() {
ios::sync_with_stdio(false);
cin >> n >> x >> y;
for (int i = (1); i <= (n); i++) cin >> a[i];
for (int _ = 0; _ < (n - 1); _++) {
int u, v;
cin >> u >> v;
g1[u].push_back(v);
g1[v].push_back(u);
}
for (int _ = 0; _ < (n - 1); _++) {
int u, v;
cin >> u >> v;
g2[u].push_back(v);
g2[v].push_back(u);
}
cin >> q1;
for (int _ = 0; _ < (q1); _++) {
int k, num;
cin >> k >> num;
r1[k] = num;
wts += num;
}
cin >> q2;
for (int _ = 0; _ < (q2); _++) {
int k, num;
cin >> k >> num;
r2[k] = num;
wts += num;
}
src = n + n + n + 1;
tgt = n + n + n + 1 + 1;
dfs1(x);
dfs2(y);
pair<int, int> ans = min_cost(src, tgt, tgt);
cout << (ans.first != -wts ? -1 : -ans.second) << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7, INF = 0x3f3f3f3f;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long qpow(long long a, long long n) {
long long r = 1 % P;
for (a %= P; n; a = a * a % P, n >>= 1)
if (n & 1) r = r * a % P;
return r;
}
long long inv(long long first) {
return first <= 1 ? 1 : inv(P % first) * (P - P / first) % P;
}
inline int rd() {
int first = 0;
char p = getchar();
while (p < '0' || p > '9') p = getchar();
while (p >= '0' && p <= '9') first = first * 10 + p - '0', p = getchar();
return first;
}
const int N = 1e3 + 10;
int n, m, vis[N], a[N][N], b[N];
char s[N][N];
map<long long, int> f;
int main() {
scanf("%d%d", &m, &n);
for (int i = 1; i <= n; ++i) scanf("%s", s[i] + 1);
for (int i = 1; i <= m; ++i) {
long long first = 0;
for (int j = 1; j <= n; ++j) first = first << 1 ^ (s[j][i] == '1');
++f[first];
}
a[0][0] = 1;
for (int i = 1; i <= m; ++i)
for (int j = 1; j <= i; ++j) {
a[i][j] = (a[i - 1][j - 1] + (long long)j * a[i - 1][j]) % P;
b[i] = (b[i] + a[i][j]) % P;
}
long long ans = 1;
for (auto t : f) ans = ans * b[t.second] % P;
printf("%lld\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, f[100001], nast[100001];
int find(int i) { return f[i] == i ? i : f[i] = find(f[i]); }
void uni(int a, int b) { f[find(a)] = find(b); }
int main() {
scanf("%d", &n);
if (n & 1) {
printf("-1\n");
return 0;
}
for (int i = 0; i < n; i++) f[i] = i;
for (int i = 0; i < n / 2; i++) {
nast[i] = i * 2 % n;
uni(i, i * 2 % n);
nast[n / 2 + i] = (i * 2 + 1) % n;
uni(n / 2 + i, (i * 2 + 1) % n);
}
for (int i = 0; i < n / 2; i++) {
if (find(i) != find(n / 2 + i)) {
nast[i] = (i * 2 + 1) % n;
nast[n / 2 + i] = i * 2 % n;
uni(i, n / 2 + i);
}
}
printf("0 ");
int ak = 0;
do {
ak = nast[ak];
printf("%d ", ak);
} while (ak != 0);
printf("\n");
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long f1, v, sum, d[2][2005], c[2], to[2005][2005], g[2005][2005][2],
P[2005][2005], val[2005][2005], r[2005];
struct lsh {
int pos;
long long x;
} l[2005];
bool vst[2005][2005][2];
inline bool cmp(lsh aa, lsh bb) { return aa.x < bb.x; }
int s, t, i, j, cnt, n, m, nxt[2005][2005][2], p[2005];
void solve(long long* f, int fm) {
int i, j, now;
bool vst[2005];
memset(vst, 0, sizeof(vst));
for (i = 0; i <= n; ++i) {
f[i] = 1e15;
}
f[fm] = 0;
for (i = 1; i <= n; ++i) {
now = 0;
for (j = 1; j <= n; ++j)
if (!vst[j] && f[j] < f[now]) now = j;
vst[now] = 1;
for (j = 1; j <= n; ++j)
if (!vst[j]) f[j] = min(f[j], f[now] + to[now][j]);
}
for (i = 1; i <= n; ++i) l[i].pos = i, l[i].x = f[i];
sort(l + 1, l + n + 1, cmp);
cnt = 0;
l[0].x = -1;
for (i = 1; i <= n; ++i) f[l[i].pos] = (cnt += (l[i].x != l[i - 1].x));
}
long long dfs(int x, int y, int p) {
if (x == c[0] || y == c[1]) return 0;
if (vst[x][y][p]) return g[x][y][p];
vst[x][y][p] = 1;
if (p) {
return g[x][y][p] =
min(dfs(x, nxt[x][y][p], p), dfs(x, nxt[x][y][p], p ^ 1));
} else {
return g[x][y][p] =
max(dfs(nxt[x][y][p], y, p), dfs(nxt[x][y][p], y, p ^ 1)) +
val[x][y];
}
}
int x, y;
int main() {
cin >> n >> m >> s >> t;
for (i = 1; i <= n; ++i) cin >> p[i], sum += p[i];
memset(to, 0x3f, sizeof(to));
for (i = 1; i <= m; ++i) {
cin >> x >> y >> v;
to[x][y] = to[y][x] = min(to[x][y], v);
}
solve(d[0], s);
c[0] = cnt;
solve(d[1], t);
c[1] = cnt;
for (i = 1; i <= n; ++i) P[d[0][i]][d[1][i]] += p[i] + 1000000005;
for (i = 0; i <= c[1]; ++i) r[i] = c[1];
for (i = c[0] - 1; ~i; --i) {
for (j = 0; j < c[1]; ++j)
if (P[i + 1][j + 1]) r[j] = j + 1;
for (j = c[1] - 1; ~j; --j) r[j] = min(r[j], r[j + 1]), nxt[i][j][1] = r[j];
}
for (i = 0; i <= c[0]; ++i) r[i] = c[0];
for (i = c[1] - 1; ~i; --i) {
for (j = 0; j < c[0]; ++j)
if (P[j + 1][i + 1]) r[j] = j + 1;
for (j = c[0] - 1; ~j; --j) r[j] = min(r[j], r[j + 1]), nxt[j][i][0] = r[j];
}
for (i = 1; i <= n; ++i) P[d[0][i]][d[1][i]] -= 1000000005;
for (i = c[0]; i; --i)
for (j = c[1]; j; --j)
P[i][j] += P[i + 1][j] + P[i][j + 1] - P[i + 1][j + 1];
for (i = 0; i < c[0]; ++i)
for (j = 0; j < c[1]; ++j)
val[i][j] = P[i + 1][j + 1] - P[nxt[i][j][0] + 1][j + 1];
f1 = dfs(0, 0, 0);
if (f1 > sum - f1)
cout << "Break a heart";
else if (f1 == sum - f1)
cout << "Flowers";
else
cout << "Cry";
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1000 * 1000 * 1000;
struct rib {
long long b, u, c, f;
size_t back;
};
void add_rib(vector<vector<rib> >& g, long long a, long long b, long long u,
long long c) {
rib r1 = {b, u, c, 0, g[b].size()};
rib r2 = {a, 0, -c, 0, g[a].size()};
g[a].push_back(r1);
g[b].push_back(r2);
}
namespace k {
long long n, m, k, c, d;
}
vector<long long> vr[55];
long long lr[50];
int main() {
long long n = 6001, m, k = INF;
vector<vector<rib> > g(n);
long long s, t;
cin >> k::n >> k::m >> k::k >> k::c >> (k::d);
long long tim = 100;
for (int i = 1; i < k::k + 1; i++) {
cin >> lr[i];
add_rib(g, 0, lr[i], 1, 0);
}
for (int j = 0; j < tim - 1; j++) {
for (int i = 2; i < k::n + 1; i++)
add_rib(g, j * 50 + i, (j + 1) * 50 + i, 50, k::c);
}
for (int j = 1; j < tim; j++) {
add_rib(g, j * 50 + 1, 1, 50, 0);
}
for (int i = 0; i < k::m; i++) {
long long x, y;
cin >> x >> y;
vr[x].push_back(y);
vr[y].push_back(x);
for (int j = 0; j < tim - 1; j++) {
for (int l = 0; l < 50; l++) {
add_rib(g, j * 50 + x, (j + 1) * 50 + y, 1,
(k::c) + (k::d) * ((l + 1) * (l + 1) - (l * l)));
add_rib(g, j * 50 + y, (j + 1) * 50 + x, 1,
(k::c) + (k::d) * ((l + 1) * (l + 1) - (l * l)));
}
}
}
s = 0, t = 1;
long long flow = 0, cost = 0;
while (flow < k) {
vector<long long> id(n, 0);
vector<long long> d(n, INF);
vector<long long> q(n);
vector<long long> p(n);
vector<size_t> p_rib(n);
long long qh = 0, qt = 0;
q[qt++] = s;
d[s] = 0;
while (qh != qt) {
long long v = q[qh++];
id[v] = 2;
if (qh == n) qh = 0;
for (size_t i = 0; i < g[v].size(); ++i) {
rib& r = g[v][i];
if (r.f < r.u && d[v] + r.c < d[r.b]) {
d[r.b] = d[v] + r.c;
if (id[r.b] == 0) {
q[qt++] = r.b;
if (qt == n) qt = 0;
} else if (id[r.b] == 2) {
if (--qh == -1) qh = n - 1;
q[qh] = r.b;
}
id[r.b] = 1;
p[r.b] = v;
p_rib[r.b] = i;
}
}
}
if (d[t] == INF) break;
long long addflow = k - flow;
for (long long v = t; v != s; v = p[v]) {
long long pv = p[v];
size_t pr = p_rib[v];
addflow = min(addflow, g[pv][pr].u - g[pv][pr].f);
}
for (long long v = t; v != s; v = p[v]) {
long long pv = p[v];
size_t pr = p_rib[v], r = g[pv][pr].back;
g[pv][pr].f += addflow;
g[v][r].f -= addflow;
cost += g[pv][pr].c * addflow;
}
flow += addflow;
}
cout << cost << "\n";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
vector<int> arr;
scanf("%d%d", &n, &k);
int x;
map<int, int> mymap;
for (int i = 0; i < n; i++) {
scanf("%d", &x);
if (mymap.find(x) != mymap.end() && mymap[x] == 1) continue;
if (arr.size() < k) {
arr.push_back(x);
mymap[x] = 1;
} else {
mymap[arr[0]] = 0;
for (int j = 0; j < k; j++) {
arr[j] = arr[j + 1];
}
arr[k - 1] = x;
mymap[x] = 1;
}
}
printf("%ld\n", arr.size());
reverse(arr.begin(), arr.end());
for (vector<int>::iterator it = arr.begin(); it != arr.end(); it++) {
printf("%d ", *it);
}
printf("\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
int n, m, q, c = 0;
double x;
cin >> n >> m >> x;
string t, a[n];
map<char, int> v;
vector<pair<int, int> > si;
vector<double> all(26, INT_MAX);
bool f = false;
for (int i = 0; i < n; i++) cin >> a[i];
cin >> q >> t;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
v[a[i][j]]++;
if (a[i][j] == 'S') si.push_back(make_pair(i, j));
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (a[i][j] == 'S') continue;
for (unsigned int k = 0; k < si.size(); k++) {
double dis = sqrt(pow(si[k].first - i, 2) + pow(si[k].second - j, 2));
if (all[a[i][j] - 'a'] > dis) all[a[i][j] - 'a'] = dis;
}
}
for (int i = 0; i < q; i++) {
if (t[i] < 'a') f = true;
if ((v['S'] < 1 && f) || (t[i] >= 'a' && v[t[i]] < 1) ||
(t[i] < 'a' && v[t[i] + 32] < 1)) {
cout << "-1\n";
return 0;
}
if (t[i] >= 'a') continue;
if (all[t[i] + 32 - 'a'] > x) c++;
}
cout << c << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, b = 0, i, j, m, ans = 0;
scanf("%d %d", &n, &k);
bool prime[n + 1];
int primes[n];
memset(prime, true, sizeof(prime));
for (i = 2; i <= n; i++) {
if (prime[i] == true) {
primes[b] = i;
b++;
for (int j = i * 2; j <= n; j += i) prime[j] = false;
}
}
for (j = 0; j < b; j++)
for (m = 0; m < b - 1; m++)
if (primes[j] - 1 == primes[m] + primes[m + 1]) {
ans++;
if (ans == k) break;
}
if (ans >= k)
printf("YES");
else
printf("NO");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[200008], sign[200008];
int b[200008];
int main() {
int n;
scanf("%d", &n);
int t;
memset(a, 0, sizeof(a));
memset(sign, 0, sizeof(sign));
for (int i = 0; i < n; i++) {
scanf("%d", &t);
int k = t;
int time = 0;
b[i] = t;
while (k) {
a[k] += time;
sign[k]++;
if (k & 1 && k > 1) {
int kk = k / 2 * 2, tim = time + 2;
while (kk < 200008) {
a[kk] += tim;
sign[kk]++;
kk <<= 1;
tim++;
}
}
k >>= 1;
time++;
}
k = t, time = 0;
while (k < 200008) {
a[k] += time;
sign[k]++;
k <<= 1;
time++;
}
sign[t]--;
}
int res = 0x3f3f3f3f;
for (int i = 1; i < 200008; i++) {
if (sign[i] == n) {
res = min(res, a[i]);
}
}
printf("%d\n", res);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int d1[4][2] = {{0, 1}, {-1, 0}, {0, -1}, {1, 0}};
const int d2[4][2] = {{1, 1}, {-1, 1}, {-1, -1}, {1, -1}};
const int d3[4][2] = {{0, 0}, {-1, 0}, {-1, -1}, {0, -1}};
const int N = 200005;
int n, m, top, ok[4];
map<int, int> mn, mx;
struct P {
int x, y;
P() {}
P(int _x, int _y) {
x = _x;
y = _y;
}
P operator+(const P &a) const { return P(x + a.x, y + a.y); }
P operator-(const P &a) const { return P(x - a.x, y - a.y); }
long long operator*(const P &a) const {
return 1ll * x * a.y - 1ll * y * a.x;
}
bool operator<(const P &a) const { return x == a.x ? y < a.y : x < a.x; }
bool operator==(const P &a) const { return x == a.x && y == a.y; }
long long dis() { return 1ll * x * x + 1ll * y * y; }
} a[N], q[N * 4];
bool cmp(P x, P y) {
if (x * y) return x * y > 0;
return x.dis() < y.dis();
}
void Convex_hull() {
sort(q + 1, q + top + 1);
top = unique(q + 1, q + top + 1) - q - 1;
P bas = a[1];
for (int i = (int)(1); i <= (int)(top); i++) q[i] = q[i] - bas;
sort(q + 2, q + top + 1, cmp);
n = top;
top = 1;
for (int i = (int)(2); i <= (int)(n); i++) {
for (; top >= 2 && (q[top] - q[top - 1]) * (q[i] - q[top]) <= 0; top--)
;
q[++top] = q[i];
}
for (int i = (int)(1); i <= (int)(top); i++) q[i] = q[i] + bas;
}
bool chk(int x, int y) {
if (mn.find(x) == mn.end()) return 0;
return mn[x] <= y && mx[x] >= y;
}
void solve() {
top = 0;
scanf("%d%d", &n, &m);
if (!(n + m)) exit(0);
mn.clear();
mx.clear();
for (int i = (int)(1); i <= (int)(m); i++) scanf("%d%d", &a[i].x, &a[i].y);
for (int i = (int)(1); i <= (int)(m); i++) mn[a[i].x] = n + 1, mx[a[i].x] = 0;
for (int i = (int)(1); i <= (int)(m); i++) {
mn[a[i].x] = min(mn[a[i].x], a[i].y);
mx[a[i].x] = max(mx[a[i].x], a[i].y);
}
for (int i = (int)(1); i <= (int)(m); i++) {
ok[0] = ok[1] = ok[2] = ok[3] = 1;
for (int j = (int)(0); j <= (int)(3); j++)
if (!chk(a[i].x + d1[j][0], a[i].y + d1[j][1]))
ok[j] = ok[(j + 1) % 4] = 0;
for (int j = (int)(0); j <= (int)(3); j++)
if (!chk(a[i].x + d2[j][0], a[i].y + d2[j][1])) ok[j] = 0;
for (int j = (int)(0); j <= (int)(3); j++)
if (ok[j]) q[++top] = P(a[i].x + d3[j][0], a[i].y + d3[j][1]);
}
Convex_hull();
reverse(q + 2, q + top + 1);
printf("%d\n", top);
for (int i = (int)(1); i <= (int)(top); i++)
printf("%d %d\n", q[i].x, q[i].y);
}
int main() {
for (;;) solve();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a;
int ara[a];
for (int i = 0; i < a; i++) {
cin >> ara[i];
}
sort(ara, ara + a);
for (int i = 0; i < a / 2; i++) {
cout << ara[i] << " " << ara[a - i - 1] << " ";
}
if (a % 2 == 1) {
cout << ara[a / 2] << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline double MTD(const double minutes) { return minutes / 60; }
inline double rad(const double deg) {
return (deg * (long double)acos(-1.0) / 180.0);
}
inline double deg(double rad) {
if (rad < 0) rad += 2 * (long double)acos(-1.0);
return (rad * 180) / (long double)acos(-1.0);
}
FILE *fptr = fopen("output.txt", "r");
long long k, n, a, b, q;
class solver {
public:
long long getSum(long long v) {
long long ans = 0;
while (v) {
ans += v;
v /= k;
}
return ans;
}
int getans() {
long long lo = 1, hi = 1000000000;
while (lo <= hi) {
long long v = lo + (hi - lo) / 2;
if (getSum(v) >= n) hi = v - 1;
if (getSum(v) >= n)
hi = v - 1;
else
lo = v + 1;
}
return lo;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
q = 1;
while (q--) {
cin >> n >> k;
solver ob;
cout << ob.getans() << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double INF = 1000000000;
const double EPS = 0.0000000001;
int Nr(vector<double>& st, double a) {
int n = st.size();
double il = (double)n * a - 10.0 * st[n - 1];
int odp = st[n - 1];
while (il >= 10.0) {
il -= 10.0;
++odp;
}
return odp;
}
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<double> a(n + 1);
a[0] = 0;
for (int i = 1; i < n + 1; ++i) cin >> a[i];
double L = -INF, P = INF;
for (int i = 0; i < n; ++i) {
L = max(L, (10.0 * (a[i + 1] - a[i]) + 10.0 * a[i]) / ((double)i + 1));
P = min(P, (10.0 * (a[i + 1] - a[i] + 1) + 10.0 * a[i]) / ((double)i + 1));
}
L = max(10.0, L);
P = max(10.0, P);
P -= EPS;
if (Nr(a, L) == Nr(a, P))
cout << "unique" << endl << Nr(a, L);
else
cout << "not unique";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int arr[1005][1005];
int main() {
int n;
cin >> n;
if (n == 4) {
printf("-1\n");
return 0;
}
int m = n;
if (!(n & 1)) n--;
for (int i = 2; i <= n; i += 2) {
arr[1][i] = 1;
if (i + 1 <= n) {
arr[i][i + 1] = 1;
arr[i + 1][1] = 1;
}
for (int j = i + 2; j <= n; j += 2) {
arr[i][j] = 1;
if (j + 1 <= n) arr[i + 1][j + 1] = 1;
}
for (int j = 2; j < i; j += 2) {
arr[i][j + 1] = 1;
if (i + 1 <= n) arr[i + 1][j] = 1;
}
}
if (n != m) {
arr[m][m - 1] = arr[1][m] = 1;
for (int i = 2; i < m; i += 2) {
arr[m][i] = 1;
if (i + 1 < m - 1) arr[i + 1][m] = 1;
}
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= m; j++) {
if ((i == j && arr[i][j] + arr[j][i] != 0) ||
(i != j && arr[i][j] + arr[j][i] != 1))
return -1;
}
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= m; j++) cout << arr[i][j] << " ";
cout << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 2;
vector<pair<int, int>> v[N];
int in_deg[N], maxi = 0, cnt = 0, n, first = 0;
queue<pair<int, int>> q;
void toplogical() {
while (!q.empty()) {
int x = q.front().first, lvl = q.front().second;
if (lvl == n - 1) {
first = 1;
break;
}
q.pop();
for (auto i : v[x]) {
if (--in_deg[i.first] == 0) {
q.push({i.first, lvl + 1});
maxi = max(maxi, i.second);
}
}
}
}
int main() {
int m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, e;
cin >> u >> e;
v[u].push_back({e, i + 1});
in_deg[e]++;
}
for (int i = 1; i <= n; i++) {
if (!in_deg[i]) q.push({i, 0});
}
toplogical();
if (first)
cout << maxi;
else
cout << -1;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void cnm() {
while (1) printf("cnm!!n");
}
const int N = 100 + 5;
char a[N][N];
const char (*s)[N];
const char S5[][N] = {">...v", "v.<..", "..^..", ">....", "..^.<"};
const char S3[][N] = {">vv", "^<.", "^.<"};
void gen() {
int i, j;
for (i = 0; i < (100); ++i)
for (j = 0; j < (100); ++j) a[i][j] = '.';
for (i = 0; i < (100); ++i) {
if (i % 2 == 0) {
for (j = 6; j < (56); ++j) a[i][j] = '>';
for (j = 0; j < (20); ++j) a[i][61 + j * 2] = '>';
a[i][99] = 'v';
} else {
for (j = 0; j < (20); ++j) a[i][6 + 2 * j] = '<';
for (j = 50; j <= (99); ++j) a[i][j] = '<';
a[i][6] = 'v';
}
}
for (i = 51; i < (100); ++i) a[i][5] = '^';
a[0][5] = '>';
a[0][55] = '.';
a[99][6] = '.';
a[99][8] = '.';
a[99][1] = '<';
}
int main() {
int TT = 1;
for (int tt = 1; tt <= TT; ++tt) {
int i;
int n, x;
cin >> n >> x;
pair<int, int> p;
switch (n) {
case 3:
s = S3;
p = make_pair(1, 3);
break;
case 5:
s = S5;
p = make_pair(1, 1);
break;
case 100:
gen();
s = a;
p = make_pair(1, 6);
break;
default:
cnm();
}
for (i = 0; i < (n); ++i) printf("%s\n", s[i]);
cout << p.first << ' ' << p.second << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10, N = 2e5;
int a[maxn], b[maxn], val[maxn];
struct bit {
int c[maxn];
void up(int x, int v) {
for (; x <= N; x += x & -x) c[x] += v;
}
int qu(int x) {
int cat = 0;
for (; x; x -= x & -x) cat += c[x];
return cat;
}
} T1, T2;
int gao(int x) {
int l = 1, r = N;
while (l < r) {
int mid = (l + r) / 2;
if (T1.qu(mid) < x)
l = mid + 1;
else
r = mid;
}
T1.up(l, -1);
return l - 1;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
a[i]++;
T1.up(a[i], 1);
}
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
b[i]++;
T2.up(b[i], 1);
}
for (int i = 1; i <= n; i++) {
val[i] += T1.qu(a[i] - 1);
val[i] += T2.qu(b[i] - 1);
T1.up(a[i], -1);
T2.up(b[i], -1);
}
reverse(val + 1, val + 1 + n);
for (int i = 1; i <= n; i++) {
if (val[i] >= i) val[i] -= i, val[i + 1]++;
T1.up(i, 1);
}
for (int i = n; i; i--) printf("%d ", gao(val[i] + 1));
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:136777216")
using namespace std;
int bits(int x) { return x == 0 ? 0 : 1 + bits(x & (x - 1)); }
const double PI = acos(-1.0);
const double eps = 1e-9;
const int INF = 1000000000;
string nextString() {
char buf[1000000];
scanf("%s", buf);
return buf;
}
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
int n, m, k;
scanf("%d %d %d\n", &n, &m, &k);
int min_dist = INF;
int x, y;
for (int(i) = 0; (i) < (k); (i)++) {
scanf("%d %d\n", &x, &y);
int cur_dist = min(min(x - 1, y - 1), min(n - x, m - y));
min_dist = min(cur_dist, min_dist);
}
puts(min_dist < 5 ? "YES" : "NO");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
for (int i = 0; i <= n / 1234567; i++) {
for (int j = 0; j <= n / 123456; j++) {
if (1234567 * i + 123456 * j <= n) {
long long x = n - (1234567 * i + 123456 * j);
if (x % 1234 == 0) {
cout << "YES";
return 0;
}
}
}
}
cout << "NO";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10;
vector<int> ld[N * N + 10];
double f[N * N + 10][2];
int id(int x, int y) {
if (x & 1)
return 10 * x + 10 - y;
else
return 10 * x + y + 1;
}
int main() {
f[1][0] = f[1][1] = 0;
for (int i = 2; i <= 7; ++i) f[i][0] = f[i][1] = 6;
for (int i = 0; i < 10; ++i)
for (int j = 0; j < 10; ++j) {
int h;
scanf("%d", &h);
if (!h) continue;
ld[id(i, j)].push_back(id(i - h, j));
};
for (int i = 8; i <= 100; ++i) {
double s = 0;
for (int j = 1; j <= 6; ++j) s += f[i - j][1];
f[i][1] = f[i][0] = s / 6 + 1;
for (int j = 0; j < ld[i].size(); ++j)
f[i][1] = min(f[i][1], f[ld[i][j]][0]);
};
printf("%.10f\n", f[100][1]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long i, j, x, y, z, ans, c, d, n, k;
bool fun(long long v) {
z = 0;
y = 1;
while (v) {
z += v;
v /= k;
if (z >= n) return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
long long low, high, mid;
low = 1;
high = n;
while (low < high) {
mid = (low + high) / 2;
if (fun(mid))
high = mid;
else
low = mid + 1;
}
cout << high;
return 0;
}
| 3 |
#include <bits/stdc++.h>
double p[23], mat[485][485], ans[485];
int l[23][23], pos[485], t[23][23];
int main() {
int i, j, k, n, m, a, b, x, y, o = 0;
double tmp;
scanf("%d%d%d%d", &n, &m, &a, &b);
for (i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
l[x][++l[x][0]] = y;
l[y][++l[y][0]] = x;
}
for (i = 1; i <= n; i++)
for (j = i; j <= n; j++) {
t[i][j] = t[j][i] = ++o;
pos[o] = o;
}
for (i = 1; i <= n; i++) scanf("%lf", &p[i]);
for (i = 1; i <= n; i++)
for (j = i; j <= n; j++) {
mat[t[i][j]][t[i][j]]--;
if (i < j) {
mat[t[i][j]][t[i][j]] += p[i] * p[j];
for (x = 1; x <= l[i][0]; x++)
mat[t[l[i][x]][j]][t[i][j]] += p[j] * (1 - p[i]) / l[i][0];
for (x = 1; x <= l[j][0]; x++)
mat[t[l[j][x]][i]][t[i][j]] += p[i] * (1 - p[j]) / l[j][0];
for (x = 1; x <= l[i][0]; x++)
for (y = 1; y <= l[j][0]; y++)
mat[t[l[i][x]][l[j][y]]][t[i][j]] +=
(1 - p[i]) * (1 - p[j]) / l[i][0] / l[j][0];
}
}
mat[t[a][b]][o + 1]--;
for (i = 1; i <= o; i++) {
for (a = i; a <= o; a++)
for (b = i; b <= o; b++)
if (!(((mat[a][b]) > 0 ? (mat[a][b]) : (-(mat[a][b]))) < 1e-8))
goto out;
break;
out:
if (a > i)
for (j = 1; j <= o + 1; j++) {
tmp = mat[i][j];
mat[i][j] = mat[a][j];
mat[a][j] = tmp;
}
if (b > i) {
for (j = 1; j <= o; j++) {
tmp = mat[j][i];
mat[j][i] = mat[j][b];
mat[j][b] = tmp;
}
pos[i] ^= pos[b];
pos[b] ^= pos[i];
pos[i] ^= pos[b];
}
for (j = i + 1; j <= o; j++)
for (k = o + 1; k >= i; k--)
mat[j][k] = mat[j][i] / mat[i][i] * mat[i][k] - mat[j][k];
}
for (i--; i; i--) {
ans[pos[i]] = mat[i][o + 1];
for (j = i + 1; j <= o; j++) ans[pos[i]] -= mat[i][j] * ans[pos[j]];
ans[pos[i]] /= mat[i][i];
}
for (i = 1; i <= n; i++)
printf("%.10lf%c", ans[t[i][i]], (i == n) ? '\n' : ' ');
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 5;
int s[N];
int main() {
int n, k, a;
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> a;
s[i % k] += a;
}
int st = 0;
for (int i = 0; i < k; ++i) {
if (s[st] > s[i]) st = i;
}
cout << st + 1;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10010;
int n;
pair<int, int> tab[N];
int main() {
int t;
scanf("%d %d", &n, &t);
for (int i = 0; i < (n); ++i) {
scanf("%d %d", &tab[i].first, &tab[i].second);
}
sort(tab, tab + n);
int res = 2;
for (int i = 0; i < (n - 1); ++i) {
double a1 = tab[i].second, a2 = tab[i + 1].second;
double pos = tab[i + 1].first - tab[i].first - a1 / 2.0 - a2 / 2.0;
if (pos == t)
res++;
else if (pos > t)
res += 2;
}
printf("%d\n", res);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int n, k, cnt, a[2010], f[2010][(1 << 11) + 5];
int main() {
scanf("%d%d", &n, &k);
cnt = 1 << k;
f[0][0] = 1;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
for (int j = 0; j <= cnt; j += 2) {
if (a[i] == 2 || a[i] == 0) {
f[i][min(j + 2, cnt)] += f[i - 1][j];
f[i][min(j + 2, cnt)] %= MOD;
}
if (a[i] == 4 || a[i] == 0) {
if (j % 4) {
f[i][4] += f[i - 1][j];
f[i][4] %= MOD;
} else {
f[i][min(j + 4, cnt)] += f[i - 1][j];
f[i][min(j + 4, cnt)] %= MOD;
}
}
}
}
printf("%d\n", f[n][cnt]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << 6 * n * (n - 1) + 1;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000 + 86;
vector<int> f[MAXN];
double dfs(int d, int r, int p) {
double tot = 1.0 / d;
for (int i = 0; i < (int)f[r].size(); ++i) {
if (f[r][i] == p) continue;
tot += dfs(d + 1, f[r][i], r);
}
return tot;
}
int main() {
int n;
int a, b;
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
scanf("%d%d", &a, &b), --a, --b;
f[a].push_back(b);
f[b].push_back(a);
}
printf("%.16lf\n", dfs(1, 0, -1));
return 0;
}
| 7 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int v;
cin>>v;
while (v--){
int n;
cin>>n;
int dem1[1000],dem2[1000],hoa[1000];
for (int i=1; i<=n; i++) {
dem1[i]=(n-1)/2;
dem2[i]=dem1[i];
hoa[i]=n-1-dem1[i]-dem2[i];
}
for (int i=1; i<n; i++) {
int t=1;
for (int j=1; j<=dem1[i]; j++) {
cout<<"1 ";
dem2[i+t]--;
t++;
}
for (int j=1; j<=hoa[i]; j++) {
cout<<"0 ";
hoa[i+t]--;
t++;
}
for (int j=1; j<=dem2[i]; j++) {
cout<<"-1 ";
dem1[i+t]--;
t++;
}
}
cout<<endl;
}
} | 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (1 << 6);
int cmp[MAXN][MAXN];
int tab[MAXN];
int n;
void read() {
for (int i = 0; i < MAXN; i++)
for (int j = 0; j < MAXN; j++) cmp[i][j] = 0;
scanf("%d", &n);
for (int i = 0; i < n * (n - 1) / 2 - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--, y--;
cmp[x][y] = 1;
cmp[y][x] = -1;
}
}
bool check() {
for (int i = 0; i < n; i++) tab[i] = i;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
if (cmp[tab[i]][tab[j]] == -1) swap(tab[i], tab[j]);
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
if (cmp[tab[i]][tab[j]] == -1) return false;
return true;
}
void compute() {
int mx, my;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (i != j and cmp[i][j] == cmp[j][i]) {
mx = i;
my = j;
}
cmp[mx][my] = 1;
cmp[my][mx] = -1;
if (check())
printf("%d %d\n", mx + 1, my + 1);
else
printf("%d %d\n", my + 1, mx + 1);
}
int main() {
read();
compute();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int a[N];
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
int res = 0;
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]), res ^= a[i];
if (res == 0) {
puts("DRAW");
} else {
int s = 0, pos = 30;
for (int i = 30; i >= 0; --i) {
if ((res >> i) & 1) {
pos = i;
break;
}
}
int cnt = 0;
for (int i = 1; i <= n; ++i) {
if ((a[i] >> pos) & 1) ++cnt;
}
int x = cnt;
int y = n - x;
if (x % 4 == 3 && y % 2 == 0)
puts("LOSE");
else
puts("WIN");
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long t, a, b, c, d;
signed main() {
scanf("%lld", &t);
while (t--) {
scanf("%lld%lld%lld%lld", &a, &b, &c, &d);
long long qwq = (a & 1) + (b & 1) + (c & 1) + (d & 1);
if ((qwq > 1 && !min(a, min(b, c))) || qwq == 2)
puts("No");
else
puts("Yes");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int id[20] = {0, 1, 2};
int neg[20], n2[20];
double a[20], b[20], ans[20];
int cnt = 0;
string fuck[] = {"x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x",
"z^x^y", "z^y^x", "(z^x)^y", "(z^y)^x"};
struct data {
int x, id;
double y;
bool operator<(const data &b) const {
if (x != b.x) return x < b.x;
if (x) {
return y < b.y || (y == b.y && id < b.id);
}
return y > b.y || (y == b.y && id < b.id);
}
} hehe[20];
void f() {
double temp = log(b[0]);
if (temp < 0) ++neg[cnt], temp *= -1;
ans[cnt++] = log(temp) + b[2] * log(b[1]);
if (cnt % 2 == 0) cnt += 2;
}
void g() {
double temp = b[2] * b[1] * log(b[0]);
if (temp < 0) ++neg[cnt], temp *= -1;
ans[cnt++] = log(temp);
if (cnt % 2 == 0) cnt += 2;
}
int main() {
for (int i = 0; i < 3; ++i) cin >> a[i];
do {
for (int i = 0; i < 3; ++i) b[i] = a[id[i]];
f();
} while (next_permutation(id, id + 3));
cnt = 2;
for (int i = 0; i < 3; ++i) id[i] = i;
do {
for (int i = 0; i < 3; ++i) b[i] = a[id[i]];
g();
} while (next_permutation(id, id + 3));
for (int i = 0; i < 12; ++i)
hehe[i].x = neg[i], hehe[i].y = ans[i], hehe[i].id = i;
sort(hehe, hehe + 12);
cout << fuck[hehe[0].id] << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
int parent_digit(int arr[][7], int i) {
int j1, j2, counter, c;
counter = 0;
for (j1 = 0; j1 < 10; j1++) {
c = 0;
for (j2 = 0; j2 < 7; j2++) {
if (arr[j1][j2] - arr[i][j2] == -1) {
c = -1;
break;
}
}
if (c != -1) {
counter += 1;
}
}
return counter;
}
int main() {
int digitstick[10][7] = {{1, 1, 1, 1, 1, 1, 0}, {0, 0, 1, 1, 0, 0, 0},
{0, 1, 1, 0, 1, 1, 1}, {0, 1, 1, 1, 1, 0, 1},
{1, 0, 1, 1, 0, 0, 1}, {1, 1, 0, 1, 1, 0, 1},
{1, 1, 0, 1, 1, 1, 1}, {0, 1, 1, 1, 0, 0, 0},
{1, 1, 1, 1, 1, 1, 1}, {1, 1, 1, 1, 1, 0, 1}};
int n, n1, n2;
scanf("%d", &n);
n1 = n / 10;
n2 = n % 10;
printf("%d", parent_digit(digitstick, n1) * parent_digit(digitstick, n2));
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 998244353;
const long double error = 2e-6;
const long double PI = acosl(-1);
mt19937 rng((unsigned)chrono::system_clock::now().time_since_epoch().count());
inline long long int MOD(long long int x, long long int m = mod) {
long long int y = x % m;
return (y >= 0) ? y : y + m;
}
const int inf = 1e9;
const long long int infl = 1061109567;
const int nmax = 2e5 + 10;
int input[nmax];
int used[nmax];
set<int> st{-2};
bool comp1(int i, int j) {
if (i == -1) return true;
return input[i] <= input[j];
}
bool comp2(int i, int j) {
if (i == -1) return true;
return input[i] >= input[j];
}
struct crstk {
vector<int> stk;
vector<int> prv;
set<int> ownst;
bool (*f)(int, int);
crstk(bool (*_f)(int, int)) {
f = _f;
ownst.insert(-2);
stk.push_back(-1);
prv.push_back(-1);
}
void add(int x) {
while (!f(stk.back(), x)) {
int y = stk.back();
ownst.insert(y);
used[y]--;
if (used[y] == 0) st.insert(y);
stk.pop_back();
prv.pop_back();
}
prv.push_back(stk.back());
stk.push_back(x);
if (stk.end()[-2] != -1 && input[stk.end()[-2]] == input[stk.end()[-1]])
prv.back() = prv.end()[-2];
used[x]++;
}
};
int ans3[nmax][3];
int ans4[nmax][4];
vector<int> Qans[nmax][5];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n, q;
cin >> n >> q;
crstk mn(comp1), mx(comp2);
for (int i = 0; i < n; i++) cin >> input[i];
for (int i = 0; i < n; i++) {
mn.add(i);
mx.add(i);
int a = mn.prv.back();
int b = mx.prv.back();
int tmp = a;
auto it = mn.ownst.lower_bound(tmp);
it--;
ans3[i][0] = *it;
ans3[i][1] = *lower_bound(mn.stk.begin(), mn.stk.end(), *it);
tmp = b;
it = mx.ownst.lower_bound(tmp);
it--;
if (ans3[i][0] < *it) {
ans3[i][0] = *it;
ans3[i][1] = *lower_bound(mx.stk.begin(), mx.stk.end(), *it);
}
tmp = min(a, b);
it = st.lower_bound(tmp);
it--;
ans4[i][0] = *it;
ans4[i][1] = *lower_bound(mn.stk.begin(), mn.stk.end(), *it);
ans4[i][2] = *lower_bound(mx.stk.begin(), mx.stk.end(), *it);
if (ans4[i][1] > ans4[i][2]) swap(ans4[i][1], ans4[i][2]);
ans3[i][2] = ans4[i][3] = i;
}
int best3 = 0, best4 = 0;
for (int i = 0; i < n; i++) {
if (ans3[i][0] > ans3[best3][0]) best3 = i;
Qans[i][3] = vector<int>(ans3[best3], ans3[best3] + 3);
if (ans4[i][0] > ans4[best4][0]) best4 = i;
Qans[i][4] = vector<int>(ans4[best4], ans4[best4] + 4);
}
for (int i = 0; i < q; i++) {
int l, r;
cin >> l >> r;
l--, r--;
vector<int> v;
if (Qans[r][4][0] >= l)
v = Qans[r][4];
else if (Qans[r][3][0] >= l)
v = Qans[r][3];
cout << v.size() << "\n";
for (int x : v) {
cout << x + 1 << " ";
}
cout << "\n";
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
#include <unordered_map>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<ll> vll;
typedef pair<int, int> ii;
typedef pair<int, ii> iii;
typedef vector<ii> vii;
typedef set<int> si;
typedef map<string, int> msi;
typedef map<string, string> mss;
#define re return
#define clr(x, v) memset(x, v, sizeof(x))
#define mp make_pair
#define pb push_back
#define mt make_tuple
#define eb emplace_back
#define bn begin()
#define nd end()
#define X first
#define Y second
#define all(v) v.begin(), v.end()
#define allr(v) v.rbegin(), v.rend()
#define UNIQUE(c) (c).resize(unique(ALL(c)) - (c).begin())
#define NumofDigits(n) ((int)log10(n) + 1)
#define sc1(x) scanf("%d", &x)
#define sc2(x, y) scanf("%d%d", &x, &y)
#define sc3(x, y, z) scanf("%d%d%d", &x, &y, &z)
#define sz size()
#define rep(i, v) for (int i = 0; i < (int)v.sz; i++)
#define lp(i, a, b) for (int i = int(a); i < int(b); i++)
#define lpi(i, b, a) for (int i = int(b); i >= a; i--)
#define watch(x) cout << (#x) << " is " << (x) << endl
#define print(ans) cout << ans << endl
#define print2(a, b) cout << a << ' ' << b << endl
#define EPS 1e-10
#define MAX 1000005
#define INF 1e18
ll MOD = 1e9 + 7;
const double PI = acos(-1.0);
#define print_prec(ans, num) cout << fixed << setprecision(num) << (ans) << endl
#define IO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
const int dx[] = {1, -1, 0, 0, 0, 0};
const int dy[] = {0, 0, 1, -1, 0, 0};
const int dz[] = {0, 0, 0, 0, 1, -1};
const int N = 2e5 + 5;
int main()
{
//freopen("read.txt", "r", stdin);
//freopen("write.txt", "w", stdout);
IO;
int t;
cin >> t;
while (t--)
{
int n;
cin >> n;
n += 2;
vll a(n);
ll sm = 0;
lp(i, 0, n) cin >> a[i], sm += a[i];
sort(all(a));
int x = -1, e = -1;
lp(i, 0, n)
{
if (i != n - 1)
{
if (sm - a[i] - a[n - 1] == a[n - 1])
{
x = i;
e = n - 1;
break;
}
}
else
{
if (sm - a[i] - a[n - 2] == a[n - 2])
{
x = i;
e = n - 2;
break;
}
}
}
if (x == -1)
{
cout << -1 << endl;
}
else
{
lp(i, 0, n) if (i != x && i != e) cout << a[i] << " ";
cout << endl;
}
}
} | 2 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long a = 0, b = getchar(), c = 1;
while (!isdigit(b)) c = b == '-' ? -1 : 1, b = getchar();
while (isdigit(b)) a = a * 10 + b - '0', b = getchar();
return a * c;
}
const int N = 1e6 + 5;
long long n, r1, r2, r3, d, a[N], p1[N], p2[N], dp[N];
int main() {
n = read(), r1 = read(), r2 = read();
r3 = read(), d = read();
for (int i = 0; i < n; i++) {
a[i] = read();
p1[i] = r1 * a[i] + r3;
p2[i] = min(r1 + r2, r1 * (a[i] + 2));
}
dp[0] = p1[0];
dp[1] = min(p1[0] + p1[1] + d, p2[0] + p2[1] + d * 3);
for (int i = 2; i < n - 1; i++)
dp[i] = min(dp[i - 1] + p1[i] + d, dp[i - 2] + p2[i - 1] + p2[i] + d * 4);
if (n > 2) {
dp[n - 1] = min(dp[n - 2] + p1[n - 1] + d,
dp[n - 3] + p2[n - 2] + p1[n - 1] + d * 3);
dp[n - 1] = min(dp[n - 1], dp[n - 3] + p2[n - 2] + p2[n - 1] + d * 4);
dp[n - 1] = min(dp[n - 1], dp[n - 2] + p2[n - 1] + d * 3);
}
cout << dp[n - 1];
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
double ans = 0;
double len = 0;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
double p;
scanf("%lf", &p);
ans += p * (2 * len + 1);
len = (len + 1) * p;
}
printf("%.10lf\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long m0 = 0, m1 = 0;
vector<long long> v0, v1, v2;
int main() {
long long q, n, i, j, cnt = 0, l, r, one = 0, zero = 0, even = 0, odd = 0,
total = 0;
string s;
cin >> n >> q;
cin >> s;
v0.push_back(0);
v1.push_back(0);
long long p = 1;
for (i = 0; i <= 100005; i++) {
v2.push_back(p);
p = (p * 2) % 1000000007;
}
for (i = 0; i < n; i++) {
if (s[i] == '0')
m0++;
else
m1++;
v0.push_back(m0);
v1.push_back(m1);
}
while (q--) {
cin >> l >> r;
one = v1[r] - v1[l - 1];
zero = v0[r] - v0[l - 1];
even = (v2[one] - 1) % 1000000007;
long long qq = (v2[zero] - 1) % 1000000007;
odd = (even * qq) % 1000000007;
total = (even + odd) % 1000000007;
cout << total << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int num[5010];
vector<int> ve;
int main() {
int n;
while (cin >> n) {
int maxvar = 0;
memset(num, 0, sizeof(num));
ve.clear();
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
++num[x];
maxvar = max(maxvar, x);
}
for (int i = 1; i <= maxvar; ++i) {
if (num[i] > 0) {
ve.push_back(i);
--num[i];
}
}
for (int i = maxvar - 1; i >= 1; --i) {
if (num[i] > 0) {
ve.push_back(i);
--num[i];
}
}
int len = ve.size();
cout << len << endl;
for (int i = 0; i < len; ++i) {
cout << ve[i] << (i == len - 1 ? "\n" : " ");
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int dx[] = {-1, -1, -1, 0, 1, 1, 1, 0};
int dy[] = {-1, 0, 1, 1, 1, 0, -1, -1};
using namespace std;
long long power(long long a, long long p, long long M) {
long long r = 1;
a = a % M;
while (p > 0) {
if (p % 2) r = (r * a) % M;
a = (a * a) % M;
p /= 2;
}
return r;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void solve() {
int n;
cin >> n;
string ans = "z";
int x = 0;
while (n) {
int j;
for (int i = 1; i < 1000; i++) {
if (n < i * (i - 1) / 2) {
j = i;
break;
}
}
j--;
n -= j * (j - 1) / 2;
for (int i = 0; i < j; i++) {
ans += (x + 'a');
}
x++;
}
cout << ans << endl;
}
int main() {
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct SNM {
vector<SNM*> trgs;
vector<SNM*> rv_trgs;
int stype;
bool asgn;
bool used;
void asgnN() {
if (asgn) return;
asgn = true;
for (vector<SNM*>::iterator i = trgs.begin(); i != trgs.end(); i++) {
(*i)->asgnN();
}
}
void usedN() {
if (used) return;
used = true;
if (stype == 1) return;
for (vector<SNM*>::iterator i = rv_trgs.begin(); i != rv_trgs.end(); i++) {
(*i)->usedN();
}
}
SNM() {
used = false;
asgn = false;
}
};
SNM nodes[100000];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &nodes[i].stype);
}
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
nodes[a].trgs.push_back(&nodes[b]);
nodes[b].rv_trgs.push_back(&nodes[a]);
}
for (int i = 0; i < n; i++) {
if (nodes[i].stype == 1) {
nodes[i].asgnN();
}
}
for (int i = 0; i < n; i++) {
if (nodes[i].stype == 2) {
nodes[i].usedN();
}
}
for (int i = 0; i < n; i++) {
if (nodes[i].asgn && nodes[i].used) {
printf("1\n");
} else {
printf("0\n");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
char s[1000], a[1000];
int l, k = 0, x, cnt = 0;
scanf("%[^\n]s", &s[0]);
l = strlen(s);
for (int i = 0; i < l; i++) {
if (s[i] >= 97 && s[i] <= 122) {
a[k] = s[i];
k++;
}
}
for (int i = 0; i < k; i++) {
x = 0;
for (int j = i + 1; j < k; j++) {
if (a[i] == a[j]) {
x++;
}
}
if (x == 0) {
cnt++;
}
}
cout << cnt;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
bool can[30][30];
int sx, sy;
struct state {
int x, y, st;
};
int x[10], y[10], w[10], mp[10];
int tot = 0;
int bx[10], by[10];
int btot = 0;
int dp[30][30][256];
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
int sum[256];
int main() {
scanf("%d %d\n", &n, &m);
char ch;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
scanf("%c", &ch);
switch (ch) {
case '.':
case 'S':
can[i][j] = 1;
break;
default:
can[i][j] = 0;
}
switch (ch) {
case '#':
case '.':
break;
case 'S':
sx = i;
sy = j;
break;
case 'B':
bx[++btot] = i;
by[btot] = j;
break;
default:
x[++tot] = i;
y[tot] = j;
mp[ch - '1' + 1] = tot;
break;
}
}
scanf("\n");
}
for (int i = 1; i <= tot; ++i) {
scanf("%d", &w[mp[i]]);
}
for (int i = 1; i <= btot; ++i) {
x[++tot] = bx[i];
y[tot] = by[i];
w[tot] = -3000;
}
for (int i = 1; i < (1 << tot); ++i) {
for (int j = 0; j < tot; ++j) {
if (i & (1 << j)) sum[i] += w[j + 1];
}
}
memset(dp, 0xff, sizeof dp);
dp[sx][sy][0] = 0;
queue<state> q;
q.push({sx, sy, 0});
int ans = 0;
while (q.size()) {
state u = q.front();
q.pop();
if (u.x == sx && u.y == sy) {
ans = max(ans, sum[u.st] - dp[u.x][u.y][u.st]);
}
for (int i = 0; i < 4; ++i) {
int tx = u.x + dx[i], ty = u.y + dy[i];
if (tx < 1 || tx > n || ty < 1 || ty > m) continue;
if (!can[tx][ty]) continue;
int nst = u.st;
for (int j = 1; j <= tot; ++j) {
if ((x[j] == tx && u.x < tx && y[j] > ty) ||
(x[j] == u.x && u.x > tx && y[j] > u.y))
nst ^= 1 << (j - 1);
}
if (!(~dp[tx][ty][nst])) {
dp[tx][ty][nst] = dp[u.x][u.y][u.st] + 1;
q.push({tx, ty, nst});
}
}
}
printf("%d", ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a;
cin >> a;
if (a % 2 == 0) {
cout << "0" << endl;
return 0;
}
cout << "1" << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int i, n, flag = 0;
cin >> n;
vector<int> a(n);
for (i = 0; i < n; i++) {
cin >> a[i];
if (i && a[i] >= a[i - 1]) flag = 1;
}
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000000,100000000000")
using namespace std;
const double eps = 1E-9;
const double Exp = 2.718281828459045;
const double Pi = 3.1415926535897932;
const int NMAX = 100000 + 5;
const int MMAX = 300 + 5;
const int INF = 1000000000;
const int BASE = 1000000007;
template <typename T>
inline T abs(const T a) {
if (a < 0) return -a;
return a;
}
template <typename T>
inline T sqr(const T& a) {
return a * a;
}
static int b[NMAX];
static int a[NMAX];
vector<int> t[4 * NMAX];
void make(int v, int tl, int tr) {
if (tl == tr) {
t[v].push_back(a[tl]);
return;
}
int tm = (tl + tr) / 2;
make(2 * v, tl, tm);
make(2 * v + 1, tm + 1, tr);
t[v].resize(int((t[2 * v]).size()) + int((t[2 * v + 1]).size()));
merge(t[2 * v].begin(), t[2 * v].end(), t[2 * v + 1].begin(),
t[2 * v + 1].end(), t[v].begin());
}
int query(int v, int tl, int tr, int l, int r, int x) {
if (tl == tr) {
}
}
int main() {
ios::sync_with_stdio(false);
int n, m, s, e;
int i, j, k;
static int dp[MMAX][NMAX];
static vector<int> next[NMAX];
cin >> n >> m >> s >> e;
for (i = 1; i <= n; i++) {
cin >> a[i];
next[a[i]].push_back(i);
}
for (i = 0; i < NMAX; i++) {
next[i].push_back(n + 1);
}
for (i = 1; i <= m; i++) cin >> b[i];
for (i = 0; i <= s / e + 1; i++)
for (j = 0; j <= m; j++) dp[i][j] = INF;
for (j = 0; j <= m; j++) {
dp[0][j] = 0;
}
make(1, 1, n);
int mn = INF;
for (i = 1; i <= s / e; i++) {
mn = INF;
for (j = 1; j <= m; j++) {
mn = min(mn, dp[i - 1][j - 1]);
if (mn == INF)
dp[i][j] = INF;
else
dp[i][j] = *lower_bound(next[b[j]].begin(), next[b[j]].end(), mn + 1);
if (dp[i][j] == n + 1) dp[i][j] = INF;
}
}
int ok = 0;
for (i = 1; i <= s / e; i++) {
for (j = 1; j <= m; j++) {
if ((j + dp[i][j] + i * e) <= s) {
ok = i;
break;
}
}
}
cout << ok << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int i, j, m, n, p, k, l, ans[300005];
struct Node {
int a[5];
void read() {
int i;
for (i = 0; i < 5; ++i) scanf("%d", &a[i]);
}
} A[300005];
int main() {
scanf("%d", &n);
for (i = 1; i <= n; ++i) A[i].read();
if (n >= 100)
printf("%d\n", 0);
else {
for (i = 1; i <= n; ++i) {
int flag = 0;
for (j = 1; j <= n; ++j)
for (k = 1; k <= n; ++k)
if (i != j && i != k && j != k) {
int s = 0;
for (l = 0; l < 5; ++l)
s += (A[j].a[l] - A[i].a[l]) * (A[k].a[l] - A[i].a[l]);
if (s > 0) flag = 1;
}
if (!flag) ans[++ans[0]] = i;
}
printf("%d\n", ans[0]);
for (i = 1; i <= ans[0]; ++i) printf("%d\n", ans[i]);
}
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.