solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long ans = 0;
long long mul = 0;
long long dec(long long tmp) {
tmp = tmp - 1;
tmp %= 1000000009;
tmp += 1000000009;
tmp %= 1000000009;
return tmp;
}
void fm(int mm) {
ans = 1;
while (mm--) {
ans = ans << 1;
if (ans >= 1000000009) ans %= 1000000009;
}
ans = dec(ans);
mul = dec(ans);
}
int main() {
scanf("%d %d", &n, &m);
fm(m);
for (int i = 2; i <= n; i++) {
ans *= mul;
ans %= 1000000009;
mul = dec(mul);
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
namespace IO {
char buf[500005], *p1 = buf, *p2 = buf, out[500005], *pout = out,
*eout = out + 500000;
inline char nc() {
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 500000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline void pc(char c) {
pout == eout && (fwrite(out, 1, 500000, stdout), pout = out);
(*pout++) = c;
}
inline void flush() { fwrite(out, 1, pout - out, stdout), pout = out; }
inline void put(int x) {
static char stk[40];
int top = 0;
while (x) stk[top++] = x % 10, x /= 10;
while (top--) pc(stk[top] + '0');
}
inline int read() {
char ch = nc();
int sum = 0;
for (; ch < '0' || ch > '9'; ch = nc())
;
while (ch >= '0' && ch <= '9')
sum = (sum << 3) + (sum << 1) + ch - 48, ch = nc();
return sum;
}
} // namespace IO
using IO::pc;
using IO::put;
int dx[] = {-1, 0, 0, 1}, dy[] = {0, -1, 1, 0};
char to[] = "ULRD";
struct edge {
int to, nxt, fl;
} e[100005 << 4];
int head[100005], cur[100005], cnte, d[100005], S, T, nod;
void ad(int u, int v, int fl) {
e[cnte] = (edge){v, head[u], fl};
head[u] = cnte++;
}
void adde(int u, int v, int fl) {
ad(u, v, fl);
ad(v, u, 0);
}
bool bfs() {
queue<int> q;
fill(d, d + 1 + nod, -1), q.push(S), d[S] = 0, memcpy(cur, head, sizeof(cur));
for (int u; q.size(); q.pop())
for (int i = cur[u = q.front()], v; ~i; i = e[i].nxt)
if (e[i].fl > 0 && d[v = e[i].to] == -1) d[v] = d[u] + 1, q.push(v);
return d[T] != -1;
}
int dfs(int u, int fl) {
if (u == T) return fl;
int ans = 0;
for (int &i = cur[u], v; ~i; i = e[i].nxt)
if (e[i].fl && d[u] + 1 == d[v = e[i].to]) {
int tmp = dfs(v, min(fl - ans, e[i].fl));
e[i].fl -= tmp;
e[i ^ 1].fl += tmp;
ans += tmp;
if (ans == fl) break;
}
return ans;
}
int n, m, sz;
int id(int i, int j) { return m * i + j; }
void work() {
n = IO::read();
m = IO::read();
sz = n * m;
vector<vector<int>> w(n, vector<int>(m)), co = w, dir = w;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) w[i][j] = IO::read();
int fs = sz, ft = sz + 1, cnt[2] = {0, 0};
S = sz + 2, T = S + 1, nod = T + 1, fill(head, head + 1 + nod, -1), cnte = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
bool F = 0;
for (int d = 0; d < 4; d++) {
int ni = i + dx[d], nj = j + dy[d];
if (ni < 0 || ni >= n || nj < 0 || nj >= m) continue;
F |= (w[i][j] > w[ni][nj]);
if (w[i][j] == w[ni][nj] && (i + j & 1)) adde(id(ni, nj), id(i, j), 1);
}
int u = id(i, j);
if (F) {
if (i + j & 1)
adde(u, ft, 1);
else
adde(fs, u, 1);
} else {
if (i + j & 1)
adde(u, T, 1), cnt[1]++;
else
adde(S, u, 1), cnt[0]++;
}
}
adde(fs, T, cnt[0]), adde(S, ft, cnt[1]), adde(ft, fs, 0x3f3f3f3f);
bool ans = 1;
while (bfs())
while (dfs(S, 0x3f3f3f3f))
;
for (int i = head[S]; ~i; i = e[i].nxt)
if (e[i].fl) ans = 0;
if (!ans)
return pc('N'), pc('O'), pc('\n');
else
pc('Y'), pc('E'), pc('S'), pc('\n');
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if ((i + j) % 2 == 0)
for (int u = id(i, j), x = head[u], v; ~x; x = e[x].nxt) {
if ((v = e[x].to) >= sz || e[x].fl) continue;
int ni = v / m, nj = v % m;
co[i][j] = 1, co[ni][nj] = w[i][j] - 1;
for (int d = 0; d < 4; d++)
if (ni == i + dx[d] && nj == j + dy[d])
dir[i][j] = to[d], dir[ni][nj] = to[d ^ 3];
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (!co[i][j])
for (int d = 0; d < 4; d++) {
int ni = i + dx[d], nj = j + dy[d];
if (ni < 0 || ni >= n || nj < 0 || nj >= m) continue;
if (w[i][j] > w[ni][nj])
dir[i][j] = to[d], co[i][j] = w[i][j] - w[ni][nj];
}
for (auto x : co) {
for (int y : x) put(y), pc(' ');
pc('\n');
}
for (auto x : dir) {
for (char y : x) pc(y), pc(' ');
pc('\n');
}
}
int main() {
for (int t = IO::read(); t--;) work();
IO::flush();
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 150003;
const long double eps = 1e-10L;
template <typename T>
inline void read(T &x) {
int ch = getchar();
x = 0;
for (; ch < '0' || ch > '9'; ch = getchar())
;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
}
template <typename T>
inline bool chkmin(T &a, const T &b) {
if (a > b) return a = b, 1;
return 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
if (a < b) return a = b, 1;
return 0;
}
int n;
long double ans = 1;
long long T, u;
struct Node {
int p, t;
long double x, l, r;
inline bool operator<(const Node &o) const { return x > o.x; }
} a[N];
inline int dcmp(long double x) { return x > eps ? 1 : (x < -eps ? -1 : 0); }
inline bool cmp(const Node &a, const Node &b) { return a.p < b.p; }
int main() {
read(n);
for (register int i = 1; i <= n; ++i) read(a[i].p);
for (register int i = 1; i <= n; ++i)
read(a[i].t), a[i].x = 1.0L * a[i].p / a[i].t, T += a[i].t;
sort(a + 1, a + n + 1);
for (register int i = 1, j = 1; i <= n; i = j) {
while (j <= n && !dcmp(a[i].x - a[j].x)) ++j;
for (register int k = i; k < j; ++k)
a[k].l = 1.0L * a[k].p * (u + a[k].t) / T;
for (register int k = i; k < j; ++k) u += a[k].t;
for (register int k = i; k < j; ++k) a[k].r = 1.0L * a[k].p * u / T;
}
sort(a + 1, a + n + 1, cmp);
for (register int i = 1, j; i < n; ++i)
if (a[i].p < a[i + 1].p) {
long double l = 1e8, r = 0;
for (j = i; j && a[i].p == a[j].p; --j) chkmin(l, a[j].l);
for (j = i + 1; j <= n && a[i + 1].p == a[j].p; ++j) chkmax(r, a[j].r);
if (dcmp(r - l) > 0) chkmin(ans, (a[i + 1].p - a[i].p) / (r - l));
}
printf("%.11Lf\n", ans);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 35;
const int MAXL = 100005;
const int CNT = 2;
int bas[CNT], mod[CNT];
bool isPrime(int x) {
for (int i = 2; i * i <= x; i++)
if (x % i == 0) return 0;
return 1;
}
void build() {
srand(time(NULL));
int la = 128;
for (int i = 0; i < CNT; i++) {
bas[i] = la + rand() % 64;
while (!isPrime(bas[i])) bas[i]++;
la = bas[i] + 1;
}
random_shuffle(bas, bas + CNT);
la = 1000000000;
for (int i = 0; i < CNT; i++) {
mod[i] = la + rand() % 32768;
while (!isPrime(mod[i])) mod[i]++;
la = mod[i] + 1;
}
random_shuffle(mod, mod + CNT);
}
char str[MAXL];
int p[MAXN], in[MAXL], h[CNT][MAXL], pw[CNT][MAXL];
void buildHash(int len) {
for (int _ = 0; _ < CNT; _++)
for (int i = (pw[_][0] = 1); i <= len; i++) {
h[_][i] = (1LL * h[_][i - 1] * bas[_] + str[i]) % mod[_];
pw[_][i] = 1LL * pw[_][i - 1] * bas[_] % mod[_];
}
}
long long getHash(int l, int r) {
long long now[2];
for (int _ = 0; _ < CNT; _++)
now[_] =
(h[_][r] - 1LL * h[_][l - 1] * pw[_][r - l + 1] % mod[_] + mod[_]) %
mod[_];
return now[0] * mod[1] + now[1];
}
vector<int> e[MAXL];
bool solve(int l, int r) {
for (int i = p[l]; i <= p[r + 1]; i++) e[i].clear(), in[i] = 0;
for (int i = l; i <= r; i++) {
e[p[r + 1]].push_back(p[i]);
for (int j = p[i]; j < p[i + 1]; j++)
for (int k = l; k <= r; k++) {
if (p[k + 1] - p[k] < p[i + 1] - j) {
if (getHash(j, j + p[k + 1] - p[k] - 1) ==
getHash(p[k], p[k + 1] - 1))
e[j].push_back(j + p[k + 1] - p[k]);
} else if (p[k + 1] - p[k] > p[i + 1] - j) {
if (getHash(j, p[i + 1] - 1) ==
getHash(p[k], p[k] + p[i + 1] - j - 1))
e[j].push_back(p[k] + p[i + 1] - j);
} else {
if (j == p[i]) continue;
if (getHash(j, p[i + 1] - 1) == getHash(p[k], p[k + 1] - 1))
e[j].push_back(p[r + 1]);
}
}
}
for (int i = p[l]; i <= p[r + 1]; i++)
for (int j = 0; j < (int)e[i].size(); j++) in[e[i][j]]++;
queue<int> q;
for (int i = p[l]; i <= p[r + 1]; i++)
if (!in[i]) q.push(i);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < (int)e[u].size(); i++)
if (--in[e[u][i]] == 0) q.push(e[u][i]);
}
for (int i = p[l]; i <= p[r + 1]; i++)
if (in[i]) return 0;
return 1;
}
int main() {
build();
int n;
scanf("%d", &n);
for (int i = (p[1] = 1); i <= n; i++) {
scanf("%s", str + p[i]);
p[i + 1] = p[i] + strlen(str + p[i]);
}
buildHash(p[n + 1] - 1);
int res = 0;
for (int l = 1, r = 1; l <= n; l++) {
while (r <= n && solve(l, r)) r++;
res += r - l;
}
return 0 * printf("%d", res);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> v;
long long int a[1000000];
long long int gu[2];
long long int vis[1000000];
long long int print[1000000];
void fail() {
cout << "NO";
exit(0);
}
void dfs(long long int p) {
v.push_back(p);
vis[p] = 1;
if (vis[a[p]] == 1)
return;
else
dfs(a[p]);
}
void process() {
long long int i, j, sum, k;
j = 0;
for (i = 0; i < v.size(); i++) {
print[v[i]] = gu[j];
j = (j + 1) % 2;
}
}
int main() {
long long int i, j, k, l, n, h, x, y, r, p, ans, sum, m, q;
cin >> n;
p = -1;
for (i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == i) p = i;
}
if (p != -1) {
cout << "YES" << endl;
for (i = 1; i <= n; i++) {
if (i != p) {
cout << i << " " << p << endl;
}
}
exit(0);
}
for (i = 1; i <= n; i++) {
x = i;
y = a[i];
if (a[y] == x) {
gu[0] = x;
gu[1] = y;
vis[x] = 1;
vis[y] = 1;
break;
}
}
if (i == n + 1) fail();
for (i = 1; i <= n; i++) {
if (vis[i] == 1) continue;
dfs(i);
p = v.size();
if ((p % 2) == 1) fail();
process();
v.clear();
}
cout << "YES" << endl;
for (i = 1; i <= n; i++) {
if (i == x || i == y) continue;
cout << i << " " << print[i] << endl;
}
cout << x << " " << y << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100003;
int n;
struct Edge {
int u, v, w, id;
} e[MaxN];
int dep[MaxN];
vector<int> g[MaxN];
void dfs(int x, int from) {
dep[x] = dep[from] + 1;
for (int i : g[x])
if (i != from) dfs(i, x);
}
inline bool cmp(const Edge& a, const Edge& b) {
return (a.w < b.w) || (a.w == b.w && dep[a.u] > dep[b.u]);
}
int fa[MaxN];
int getfa(int x) { return fa[x] == x ? x : fa[x] = getfa(fa[x]); }
long long ans[MaxN];
int block[MaxN], sz[MaxN];
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
g[u].push_back(v), g[v].push_back(u);
e[i].u = u, e[i].v = v, e[i].w = w, e[i].id = i;
}
dfs(1, 1);
for (int i = 1; i < n; ++i)
if (dep[e[i].u] > dep[e[i].v]) swap(e[i].u, e[i].v);
sort(e + 1, e + n, cmp);
for (int i = 1; i <= n; ++i) fa[i] = i, sz[i] = 1;
long long mx = 0;
int mxcnt = 0;
for (int i = 1, j; i < n; i = j) {
for (j = i; j < n && e[i].w == e[j].w; ++j) {
int &u = e[j].u, &v = e[j].v;
block[j] = sz[v];
fa[v] = getfa(u);
sz[getfa(u)] += sz[v];
}
for (int k = i; k < j; ++k) {
int &u = e[k].u, &v = e[k].v, &id = e[k].id;
int SZ = sz[getfa(u)];
ans[id] = 2LL * block[k] * (SZ - block[k]);
if (ans[id] > mx) {
mx = ans[id];
mxcnt = 1;
} else if (ans[id] == mx) {
mxcnt++;
}
}
}
printf("%lld %d\n", mx, mxcnt);
for (int i = 1; i < n; ++i)
if (ans[i] == mx) printf("%d ", i);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
float fast_exp(float n, int p) {
float ret = 1;
while (p) {
if (p & 1) ret *= n;
n *= n;
p >>= 1;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
int n, m;
scanf("%d %d", &m, &n);
float ans = 0;
for (float i = 1; i < m; i++) {
ans += fast_exp(i / m, n);
}
printf("%f", m - ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int i, j, f;
vector<pair<int, int> > po, ng;
for (i = 0; i < n; i++) {
int x, a;
cin >> x >> a;
if (x > 0) {
po.push_back(make_pair(x, a));
} else {
ng.push_back(make_pair((x * (-1)), a));
}
}
sort(po.begin(), po.end());
sort(ng.begin(), ng.end());
i = 0, j = 0, f = 0;
long long int sum1 = 0;
while (true) {
if (f == 0) {
if (i == po.size()) break;
sum1 += po[i].second;
i++;
f = 1;
} else {
if (j == ng.size()) break;
sum1 += ng[j].second;
j++;
f = 0;
}
}
i = 0, j = 0, f = 1;
long long int sum2 = 0;
while (true) {
if (f == 0) {
if (i == po.size()) break;
sum2 += po[i].second;
i++;
f = 1;
} else {
if (j == ng.size()) break;
sum2 += ng[j].second;
j++;
f = 0;
}
}
cout << max(sum1, sum2) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int n, type, fq[3];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &type);
fq[type]++;
}
if (fq[1] && fq[2]) {
fq[1]--;
fq[2]--;
printf("2 1 ");
}
while (fq[2]--) printf("2 ");
while (fq[1]--) printf("1 ");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int mxN = 1e6 + 1;
int main() {
int n, cb;
cin >> n >> cb;
int c[n];
for (int(i) = 0; (i) < (n); (i)++) cin >> c[i];
int usable[mxN];
int cnt[mxN] = {0};
fill_n(usable, mxN, 1);
usable[cb] = 0;
for (int(i) = 0; (i) < (n); (i)++) {
if (c[i] == cb) {
cnt[c[i]]++;
continue;
}
if (!usable[c[i]]) continue;
if (cnt[c[i]] < cnt[cb])
usable[c[i]] = 0;
else
cnt[c[i]]++;
}
for (int(i) = 0; (i) < (mxN); (i)++) {
if (cnt[i] >= cnt[cb] && usable[i] && i) {
cout << i;
return 0;
}
}
cout << -1;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s, t;
const int maxn = 5005;
const int mod = 1000000007;
int pre[maxn], now[maxn];
int main() {
while (cin >> s >> t) {
int i, j, k;
memset(pre, 0, sizeof(pre));
memset(now, 0, sizeof(now));
for (i = 0; i < t.size(); i++) {
for (j = 0; j < s.size(); j++) {
if (s[j] == t[i]) {
now[j + 1] = pre[j + 1] + pre[j] + 1;
now[j + 1] %= mod;
}
}
for (j = 0; j <= s.size(); j++) pre[j] = now[j];
}
int res = 0;
for (i = 1; i <= s.size(); i++) {
res += now[i];
res %= mod;
}
cout << res << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int mod = 1e9 + 7;
const long long inf = 1e17;
char a[maxn], b[maxn], s[maxn];
int v[200];
int main() {
int q;
scanf("%s%s", a, b);
int n = strlen(a);
for (int i = 0; i < n; ++i) v[a[i]] = 1;
n = strlen(b);
scanf("%d", &q);
while (q--) {
scanf("%s", s);
int len = strlen(s);
int o = len - n + 1;
if (o < 0) {
puts("NO");
continue;
}
int i = 0, j = 0, k;
while (i < n) {
if (b[i] == s[j]) {
i++;
j++;
} else if (b[i] == '?' && v[s[j]]) {
i++;
j++;
} else if (b[i] == '*') {
for (k = 0; k < o && j < len; ++k, ++j)
if (v[s[j]]) break;
if (k < o) break;
i++;
} else {
break;
}
}
if (i < n || j < len)
puts("NO");
else
puts("YES");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = INT_MAX, df = 1e5 + 7, mod = 1e9 + 7;
struct edge {
long long to, nxt;
} e[df << 2];
long long i, j, k, l, m, n, o = 1, p, q, r, s, t, u, v, w, x, y, z;
long long fa[df], dfn[df], pos[df], head[df], son[df], siz[df], top[df], cnt,
dp[df][305], a[df], ma[df], dep[df], f[df];
void upd(long long x, long long y) {
if (!x) return;
for (long long i = x; i <= n; i += (i & (-i))) ma[i] += y;
}
long long qry(long long x) {
long long ret = 0;
for (long long i = x; i; i -= (i & (-i))) ret += ma[i];
return ret;
}
bool cmp(long long st, long long ch) { return f[st] < f[ch]; }
long long query(long long x, long long y) {
long long ret = 0;
while (top[x] != top[y]) {
if (dep[top[x]] < dep[top[y]]) swap(x, y);
ret += qry(dfn[x]) - qry(dfn[top[x]] - 1);
x = fa[top[x]];
}
if (dfn[x] > dfn[y]) swap(x, y);
ret += qry(dfn[y]) - qry(dfn[x] - 1);
return ret;
}
inline void add(long long u, long long v) {
e[++o] = (edge){v, head[u]}, head[u] = o;
}
void dfs1(long long u) {
dep[u] = dep[fa[u]] + 1;
siz[u] = 1;
for (long long i = head[u], v; i; i = e[i].nxt) {
v = e[i].to;
if (v == fa[u]) continue;
fa[v] = u;
dfs1(v);
siz[u] += siz[v];
if (siz[v] > siz[son[u]]) son[u] = v;
}
return;
}
void dfs2(long long u, long long x) {
dfn[u] = ++cnt, pos[cnt] = u, top[u] = x;
if (son[u]) dfs2(son[u], x);
for (long long i = head[u], v; i; i = e[i].nxt) {
v = e[i].to;
if (v == fa[u] || v == son[u]) continue;
dfs2(v, v);
}
return;
}
inline long long read() {
long long x = 0, y = 1;
char ch = getchar();
while (ch > '9' || ch < '0') y = (ch == '-') ? -1 : 1, ch = getchar();
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
return x * y;
}
int main() {
n = read(), q = read();
for (long long i = (2); i <= (n); ++i) {
long long u = read(), v = read();
add(u, v), add(v, u);
}
dfs1(1), dfs2(1, 1);
while (q--) {
k = read(), m = read(), r = read();
for (long long i = (1); i <= (k); ++i) a[i] = read(), upd(dfn[a[i]], 1);
dp[1][1] = 1;
for (long long i = (1); i <= (k); ++i) f[a[i]] = query(a[i], r) - 1;
sort(a + 1, a + k + 1, cmp);
for (long long i = (2); i <= (k); ++i) {
for (long long j = (1); j <= (min(i, m)); ++j)
(dp[i][j] +=
max(0ll, j - f[a[i]]) * dp[i - 1][j] % mod + dp[i - 1][j - 1]) %= mod;
}
long long ans = 0;
for (long long i = (1); i <= (m); ++i) (ans += dp[k][i]) %= mod;
printf("%lld\n", ans);
for (long long i = (1); i <= (k); ++i) upd(dfn[a[i]], -1), f[a[i]] = 0;
for (long long i = (1); i <= (k); ++i)
for (long long j = (1); j <= (m); ++j) dp[i][j] = 0;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
int x = t / 2;
cout << x << endl;
if (t % 2 != 0) {
x--;
while (x--) cout << 2 << " ";
cout << 3 << endl;
} else {
while (x--) cout << 2 << " ";
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char** argv) {
unsigned long long p, k, q0, q1;
cin >> p >> k;
unsigned long long t = 0;
queue<unsigned long long> ansq;
q0 = p;
while (true) {
if (!t) {
q1 = q0 / k;
ansq.push(q0 - q1 * k);
} else {
q1 = q0 / k + (q0 % k == 0 ? 0 : 1);
ansq.push(q1 * k - q0);
}
t = 1 - t;
if (q1 == 0) break;
q0 = q1;
}
cout << ansq.size() << endl;
while (!ansq.empty()) {
cout << ansq.front() << ' ';
ansq.pop();
}
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct segt {
double value, lz;
};
segt tree[262192];
map<int, int> mp;
vector<int> disc;
void build(int l, int r, int index) {
if (l > r) return;
tree[index].value = 1.0 * (double)mp[disc[l]];
tree[index].lz = 1.0;
if (l == r) return;
int mid = l + (r - l) / 2;
build(l, mid, index * 2);
build(1 + mid, r, index * 2 + 1);
tree[index].value = tree[index * 2].value + tree[index * 2 + 1].value;
}
void pushdown(int l, int r, int index) {
if (l > r) return;
if (l < r) {
if (tree[index].lz != 1.0) {
tree[index * 2].lz *= tree[index].lz;
tree[index * 2 + 1].lz *= tree[index].lz;
tree[index * 2].value *= tree[index].lz;
tree[index * 2 + 1].value *= tree[index].lz;
}
}
tree[index].lz = 1.0;
}
void update(int start, int end, int l, int r, int index, double val) {
if (start > end || l > r) return;
pushdown(l, r, index);
if (start > r || l > end) return;
if (start <= l && r <= end) {
tree[index].value *= val;
tree[index].lz *= val;
return;
}
int mid = l + (r - l) / 2;
update(start, end, l, mid, index * 2, val);
update(start, end, 1 + mid, r, index * 2 + 1, val);
tree[index].value = tree[index * 2].value + tree[index * 2 + 1].value;
}
struct qrs {
int a, h, l, r;
};
qrs q[262192];
int n, m;
int tmp[262192];
int main() {
scanf("%d%d", &n, &m);
int i;
for (i = 1; i <= n; i++) {
scanf("%d%d%d%d", &q[i].a, &q[i].h, &q[i].l, &q[i].r);
}
for (i = 1; i <= m; i++) {
int v;
scanf("%d%d", &tmp[i], &v);
mp[tmp[i]] += v;
}
sort(tmp + 1, tmp + 1 + m);
for (i = 1; i <= m; i++) {
if (i == 1 || tmp[i] != tmp[i - 1]) disc.push_back(tmp[i]);
}
int tol = (int)disc.size();
build(0, tol - 1, 1);
for (i = 1; i <= n; i++) {
int l1 =
lower_bound(disc.begin(), disc.end(), q[i].a - q[i].h) - disc.begin();
int l2 = lower_bound(disc.begin(), disc.end(), q[i].a) - disc.begin() - 1;
update(l1, l2, 0, tol - 1, 1, 0.01 * (100 - q[i].l));
int r1 = upper_bound(disc.begin(), disc.end(), q[i].a) - disc.begin();
int r2 = upper_bound(disc.begin(), disc.end(), q[i].a + q[i].h) -
disc.begin() - 1;
update(r1, r2, 0, tol - 1, 1, 0.01 * (100 - q[i].r));
}
printf("%.10lf\n", tree[1].value);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using ii = pair<ll, ll>;
using vi = vector<ll>;
using vb = vector<bool>;
using vvi = vector<vi>;
using vii = vector<ii>;
using vvii = vector<vii>;
const int INF = 2000000000;
const ll LLINF = 9000000000000000000;
template <class T, const T &(*op)(const T &, const T &), T ident>
struct SegmentTree {
int n;
vector<T> tree;
SegmentTree(int _n) : n(_n), tree(2 * n, ident) {}
void update(int i, T val) {
for (tree[i + n] = val, i = (i + n) / 2; i > 0; i /= 2)
tree[i] = op(tree[2 * i], tree[2 * i + 1]);
}
T query(int l, int r) {
T lhs = T(ident), rhs = T(ident);
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) lhs = op(lhs, tree[l++]);
if (!(r & 1)) rhs = op(tree[r--], rhs);
}
return op(l == r ? op(lhs, tree[l]) : lhs, rhs);
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int N;
cin >> N;
vi T(N, 0LL);
for (ll &v : T) cin >> v;
SegmentTree<ll, min, LLINF> st(N);
st.update(0, 20);
cout << 20 << endl;
int l9 = 0, l1 = 0;
for (int i = 1; i < N; ++i) {
ll a = 20 + st.query(i - 1, i - 1);
while (T[l9] + 90 <= T[i]) ++l9;
while (T[l1] + 1440 <= T[i]) ++l1;
if (l9 > 0 && l9 < i)
a = min(a, 50LL + st.query(l9 - 1, i - 1));
else if (l9 == 0)
a = min(a, 50LL);
if (l1 > 0 && l1 < i)
a = min(a, 120LL + st.query(l1 - 1, i - 1));
else if (l1 == 0)
a = min(a, 120LL);
st.update(i, a);
cout << (a - st.query(i - 1, i - 1)) << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long int t, a, b;
cin >> t;
while (t--) {
cin >> a >> b;
long long int diff = abs(a - b);
for (long long int i = 0;; i++) {
long long int h = (i * (i + 1) / 2) - diff;
if (h >= 0 && !(h % 2)) {
cout << i << "\n";
break;
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 10;
const int inf = 2e9 + 10;
const int mod = 1e9 + 7;
const double eps = 1e-15;
int n, m, k;
pair<long long, long long> p[1111];
long long x[1111], y[1111], r[1111];
bitset<1001> po[1001];
int to[1001][1001];
bool incp(int a, int b) {
return (p[a].first - x[b]) * (p[a].first - x[b]) +
(p[a].second - y[b]) * (p[a].second - y[b]) <
r[b] * r[b];
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; ++i) {
cin >> p[i].first >> p[i].second;
}
for (int i = 0; i < m; ++i) {
cin >> r[i] >> x[i] >> y[i];
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
po[i][j] = incp(i, j);
}
}
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
to[i][j] = to[j][i] = (po[i] & po[j]).count();
}
}
int a, b;
for (int i = 1; i <= k; ++i) {
cin >> a >> b;
--a, --b;
cout << po[a].count() + po[b].count() - 2 * to[a][b] << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct pt {
long long x, y;
pt operator-(pt a) { return {x - a.x, y - a.y}; }
void read() { cin >> x >> y; }
};
long long cross(pt a, pt b) { return a.x * b.y - b.x * a.y; }
vector<pt> v;
bool sol(pt a, pt b) {
vector<pt> vv;
for (auto u : v) {
if (cross(b - a, u - a) != 0) {
vv.push_back(u);
}
}
if (vv.size() < 3) {
return true;
}
pt c = vv[0], d = vv[1];
for (auto u : vv) {
if (cross(d - c, u - c) != 0) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
pt a;
a.read();
v.push_back(a);
}
if (n < 5) {
cout << "YES" << endl;
return 0;
}
int ind = -1;
for (int i = 2; i < v.size(); i++) {
if (cross(v[i] - v[i - 1], v[i] - v[i - 2]) != 0) {
ind = i;
break;
}
}
if (ind == -1) {
cout << "YES\n";
return 0;
}
bool is = false;
is |= sol(v[ind], v[ind - 1]);
is |= sol(v[ind - 1], v[ind - 2]);
is |= sol(v[ind], v[ind - 2]);
if (is) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long a;
cin >> a;
unsigned long long m = a, t = 1;
int k = 1;
while (m) {
k++;
m /= 10;
t *= 10;
}
m = 45 * (k - 1);
k = k - 2;
while (k || m >= a) {
if (m >= a)
m -= a;
else {
k--;
m *= 10;
}
}
m = a - m;
cout << m << ' ' << t + m - 1 << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[1005], b[1005], n;
int main() {
int k = 0, v = 0;
std::cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
k += a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
v += b[i];
}
if (k >= v)
std::cout << "YES" << std::endl;
else
std::cout << "NO" << std::endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int cansel_sync = (ios::sync_with_stdio(0), cin.tie(0), 0);
const long long INF = 1ll << 60;
const int MAXN = 114514;
int n;
long long d;
long long a[MAXN];
void solve() {
cin >> n >> d;
for (int i = (1); i <= (n); i++) cin >> a[i];
a[0] = -INF;
a[n + 1] = INF;
int cnt = 0;
for (int i = (1); i <= (n + 1); i++) {
if (a[i] - a[i - 1] >= d * 2) cnt++;
if (i != 1 && i != n + 1 && a[i] - a[i - 1] > d * 2) cnt++;
}
cout << cnt << endl;
}
int main() { solve(); }
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, inf = 1e9 + 7;
int n, k;
const int MAXN = 2010;
int CINF = 1e9;
int INF = 1e9;
struct graph {
struct Edge {
int x, y;
int cap;
int cost;
int id;
};
int N, prev[MAXN];
int dist[MAXN], phi[MAXN];
vector<Edge> E;
vector<int> g[MAXN];
graph(int _N) : N(_N) {}
void add_edge(int x, int y, int cap, int cost, int opt = -1) {
Edge e1 = {x, y, cap, cost, opt}, e2 = {y, x, 0, -cost, -1};
g[x].emplace_back(E.size());
E.emplace_back(e1);
g[y].emplace_back(E.size());
E.emplace_back(e2);
}
bool augment(int s, int t) {
int x, y;
for (int i = 0; i <= N; i++) prev[i] = -1, dist[i] = INF;
dist[s] = prev[s] = 0;
set<pair<int, int> > q;
q.insert(make_pair(dist[s], s));
while (!q.empty()) {
x = q.begin()->second;
q.erase(q.begin());
for (auto it : g[x]) {
Edge &e = E[it];
if (e.cap <= 0) continue;
y = e.y;
int ncost = e.cost + phi[x] - phi[y];
if (dist[x] + ncost < dist[y]) {
q.erase(make_pair(dist[y], y));
dist[y] = dist[x] + ncost;
prev[y] = it;
q.insert(make_pair(dist[y], y));
}
}
}
if (prev[t] == -1)
return false;
else
return true;
}
pair<int, int> mcf(int s, int t, int nn = CINF) {
int flow = 0;
int cost = 0;
for (int i = 0; i <= N; i++) phi[i] = 0;
while (true) {
if (!augment(s, t) || flow == nn) break;
int z = nn - flow;
for (int i = t; i != s; i = E[prev[i]].x) z = min(z, E[prev[i]].cap);
for (int i = t; i != s; i = E[prev[i]].x)
E[prev[i]].cap -= z, E[prev[i] ^ 1].cap += z;
flow += z;
cost += z * (dist[t] - phi[s] + phi[t]);
for (int i = 0; i <= N; i++)
if (prev[i] != -1) phi[i] += dist[i];
}
return make_pair(flow, cost);
}
};
string s, t[N];
int c[N];
bool match(int i, int c) {
int j = 0;
while (i < s.size() && j < t[c].size()) {
if (s[i] != t[c][j]) break;
i++;
j++;
}
if (j == t[c].size()) return 1;
return 0;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int i, j, a, b, ans = 0, x;
cin >> n >> s >> k;
for (i = 0; i < k; i++) cin >> t[i] >> c[i];
cin >> x;
graph g(n + 2);
for (i = 0; i < n; i++) {
g.add_edge(i, i + 1, x, 0);
for (j = 0; j < k; j++) {
if (match(i, j)) g.add_edge(i + 1, i + 1 + t[j].size(), 1, -c[j]);
}
}
g.add_edge(i, i + 1, x, 0);
cout << -g.mcf(0, n + 1).second;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long arr[300000];
long long a[300000];
long long freq[300000];
long long up[200000][3];
long long q[200000][2];
int main() {
int n, m, k;
cin >> n >> m >> k;
int i;
for (i = 1; i <= n; i++) {
cin >> arr[i];
}
memset(freq, 0, sizeof(freq));
for (i = 1; i <= m; i++) {
cin >> up[i][0] >> up[i][1] >> up[i][2];
}
for (i = 1; i <= k; i++) {
cin >> q[i][0] >> q[i][1];
freq[q[i][0]]++;
freq[q[i][1] + 1]--;
}
for (i = 1; i <= m; i++) {
freq[i] += freq[i - 1];
}
memset(a, 0, sizeof(a));
for (i = 1; i <= m; i++) {
a[up[i][0]] += up[i][2] * freq[i];
a[up[i][1] + 1] -= up[i][2] * freq[i];
}
for (i = 1; i <= n; i++) {
a[i] += a[i - 1];
}
for (i = 1; i <= n; i++) {
cout << arr[i] + a[i] << " ";
}
cout << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 2e5 + 5;
template <typename T>
inline istream& operator>>(istream& is, vector<T>& v) {
for (int ii = 0; ii < (int)v.size(); ++ii) {
is >> v[ii];
}
return is;
}
template <typename T>
inline ostream& operator<<(ostream& os, vector<T>& v) {
for (int ii = 0; ii < (int)v.size(); ++ii) {
os << v[ii] << " ";
}
return os;
}
template <typename T1, typename T2>
inline istream& operator>>(istream& is, pair<T1, T2>& p) {
is >> p.first >> p.second;
return is;
}
template <typename T>
inline ostream& operator<<(ostream& os, vector<vector<T>>& mat) {
for (int ii = 0; ii < (int)mat.size(); ++ii) {
for (int jj = 0; jj < (int)mat[0].size(); ++jj) {
os << mat[ii][jj] << " ";
}
os << '\n';
}
return os;
}
template <typename it>
void compress(it start, it end) {
typedef typename remove_reference<decltype(*start)>::type T;
map<T, vector<it>> m;
for (it ii = start; ii != end; ii++) {
m[*ii].push_back(ii);
}
int t = 0;
for (auto& [x, v] : m) {
for (auto& i : v) {
*i = t;
}
++t;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
vector<string> grid(n);
for (auto& s : grid) cin >> s;
vector<vector<int>> dp(n, vector<int>(m, 0));
int sol = 0;
for (int ii = 0; ii < n; ++ii) {
for (int jj = 0; jj < m; ++jj) {
if (ii <= 1 || jj == 0 || jj == m - 1 ||
grid[ii][jj] != grid[ii - 1][jj] ||
grid[ii][jj] != grid[ii - 1][jj - 1] ||
grid[ii][jj] != grid[ii - 1][jj + 1] ||
grid[ii][jj] != grid[ii - 2][jj]) {
dp[ii][jj] = 1;
} else {
dp[ii][jj] = min({dp[ii - 1][jj], dp[ii - 1][jj - 1],
dp[ii - 1][jj + 1], dp[ii - 2][jj]}) +
1;
}
sol += dp[ii][jj];
}
}
cout << sol << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 10;
int n, q;
int a[maxN];
long long t[4 * maxN];
int mn[4 * maxN];
int cnt[4 * maxN];
int lazy[4 * maxN];
int mx[4 * maxN];
void merge(int v) {
mn[v] = min(mn[2 * v], mn[2 * v + 1]);
mx[v] = max(mx[2 * v], mx[2 * v + 1]);
t[v] = t[2 * v] + t[2 * v + 1];
}
void apply(int v, int x) {
lazy[v] = x;
mn[v] = x;
mx[v] = x;
t[v] = cnt[v] * 1ll * x;
}
void push(int v, int tl, int tr) {
if (tl != tr && lazy[v] != 0) {
apply(2 * v, lazy[v]);
apply(2 * v + 1, lazy[v]);
}
lazy[v] = 0;
}
void build(int v, int tl, int tr) {
if (tl == tr) {
mn[v] = a[tl];
mx[v] = a[tl];
t[v] = a[tl];
cnt[v] = 1;
return;
}
int tm = (tl + tr) / 2;
build(2 * v, tl, tm);
build(2 * v + 1, tm + 1, tr);
cnt[v] = tr - tl + 1;
merge(v);
}
void do_max(int v, int tl, int tr, int l, int r, int x) {
if (tr < l || r < tl) return;
if (mn[v] >= x) return;
if (l <= tl && tr <= r && mx[v] < x) {
apply(v, x);
return;
}
push(v, tl, tr);
int tm = (tl + tr) / 2;
do_max(2 * v, tl, tm, l, r, x);
do_max(2 * v + 1, tm + 1, tr, l, r, x);
merge(v);
}
int go(int v, int tl, int tr, int l, int r, int& y) {
if (tr < l || r < tl) return 0;
push(v, tl, tr);
if (l <= tl && tr <= r) {
if (y >= t[v]) {
y -= t[v];
return cnt[v];
}
if (mn[v] > y) {
return 0;
}
}
int tm = (tl + tr) / 2;
int d1 = go(2 * v, tl, tm, l, r, y);
int d2 = go(2 * v + 1, tm + 1, tr, l, r, y);
return d1 + d2;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> a[i];
build(1, 1, n);
while (q--) {
int tp, x, y;
cin >> tp >> x >> y;
if (tp == 1) {
do_max(1, 1, n, 1, x, y);
} else {
cout << go(1, 1, n, x, n, y) << '\n';
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class TT>
TT abs(TT a) {
if (a < 0) return -a;
return a;
}
template <class ZZ>
ZZ max(ZZ a, ZZ b, ZZ c) {
return max(a, max(b, c));
}
template <class ZZ>
ZZ min(ZZ a, ZZ b, ZZ c) {
return min(a, min(b, c));
}
typedef struct {
double x, y, z;
void scan() { scanf("%lf%lf%lf", &x, &y, &z); }
} PP;
PP p[100], P;
int main() {
int i, j, k, tks, ks = 1, n, m;
double a, dis, md;
while (cin >> n) {
P.x = P.y = P.z = 0.0;
for (i = 0; i < n; i++) {
p[i].scan();
P.x += p[i].x;
P.y += p[i].y;
P.z += p[i].z;
}
P.x /= n;
P.y /= n;
P.y /= n;
a = 0.1;
for (j = 0; j < 100000; j++) {
k = 0;
md = sqrt(((p[0].x - P.x) * (p[0].x - P.x)) +
((p[0].y - P.y) * (p[0].y - P.y)) +
((p[0].z - P.z) * (p[0].z - P.z)));
for (i = 1; i < n; i++) {
dis = sqrt(((p[i].x - P.x) * (p[i].x - P.x)) +
((p[i].y - P.y) * (p[i].y - P.y)) +
((p[i].z - P.z) * (p[i].z - P.z)));
if (dis > md) {
k = i;
md = dis;
}
}
P.x += (p[k].x - P.x) * a;
P.y += (p[k].y - P.y) * a;
P.z += (p[k].z - P.z) * a;
a *= 0.999;
}
printf("%lf %lf %lf\n", P.x, P.y, P.z);
}
return 0;
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i=0;i<(int)(n);++i)
#define rep1(i,n) for (int i=1;i<=(int)(n);++i)
typedef long long ll;
namespace internal { int ceil_pow2(int n) { int x = 0; while ((1U << x) < (unsigned int)(n)) x++; return x; } }
template <class S, S (*op)(S, S), S (*e)()> struct segtree {
public:
segtree() : segtree(0) {}
segtree(int n) : segtree(std::vector<S>(n, e())) {}
segtree(const std::vector<S>& v) : _n(int(v.size())) {
log = internal::ceil_pow2(_n), size = 1 << log, d = std::vector<S>(2 * size, e());
for (int i = 0; i < _n; i++) d[size + i] = v[i];
for (int i = size - 1; i >= 1; i--) update(i);
}
void set(int p, S x) {
assert(0 <= p && p < _n); p += size, d[p] = x;
for (int i = 1; i <= log; i++) update(p >> i);
}
S get(int p) { assert(0 <= p && p < _n); return d[p + size]; }
S prod(int l, int r) {
assert(0 <= l && l <= r && r <= _n); S sml = e(), smr = e(); l += size, r += size;
while (l < r) {
if (l & 1) sml = op(sml, d[l++]);
if (r & 1) smr = op(d[--r], smr);
l >>= 1, r >>= 1;
}
return op(sml, smr);
}
S all_prod() { return d[1]; }
template <bool (*f)(S)> int max_right(int l) { return max_right(l, [](S x) { return f(x); }); }
template <class F> int max_right(int l, F f) {
assert(0 <= l && l <= _n); assert(f(e()));
if (l == _n) return _n;
l += size; S sm = e();
do {
while (l % 2 == 0) l >>= 1;
if (!f(op(sm, d[l]))) {
while (l < size) { l = (2 * l); if (f(op(sm, d[l]))) sm = op(sm, d[l]), l++; }
return l - size;
}
sm = op(sm, d[l]), l++;
} while ((l & -l) != l);
return _n;
}
template <bool (*f)(S)> int min_left(int r) { return min_left(r, [](S x) { return f(x); }); }
template <class F> int min_left(int r, F f) {
assert(0 <= r && r <= _n); assert(f(e()));
if (r == 0) return 0;
r += size; S sm = e();
do {
r--;
while (r > 1 && (r % 2)) r >>= 1;
if (!f(op(d[r], sm))) {
while (r < size) { r = (2 * r + 1); if (f(op(d[r], sm))) sm = op(d[r], sm), r--; }
return r + 1 - size;
}
sm = op(d[r], sm);
} while ((r & -r) != r);
return 0;
}
private:
int _n, size, log;
std::vector<S> d;
void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
};
const int maxn=500007,maxm=1000007;
int n,m,k,q,t,a[maxn],b[maxn];
ll sum;
struct S{ int cnt; ll sum; };
S e(){ return {0,0}; }
S op(S l,S r){ return {l.cnt+r.cnt,l.sum+r.sum}; }
signed main(){
segtree<S,op,e> seg_a(maxm),seg_b(maxm);
auto fa=[&](int x){
if (x>m||x<=0) cerr<<x<<endl;
assert(x<=m&&x>0);
return seg_a.max_right(0,[&](S l){return l.cnt<x;});
};
auto fb=[&](int x){
assert(x<=n&&x>0);
return seg_b.max_right(0,[&](S l){return l.cnt<x;});
};
auto solve=[&](int start,int coef){
int mn=min(fa(1),fb(1));
if (start<=k+mn) return 1ll*(n-m)*start+sum;
auto ret=seg_b.prod(0,start-k);
return 1ll*coef*(start-k-mn)+1ll*(n-m)*start+sum+ret.sum-1ll*ret.cnt*(start-k);
};
cin>>m>>n>>q;
rep1(i,m) {cin>>a[i],sum+=a[i]; auto ret=seg_a.get(a[i]); ret.cnt++, ret.sum+=a[i], seg_a.set(a[i],ret);}
rep1(i,n) {cin>>b[i],sum-=b[i]; auto ret=seg_b.get(b[i]); ret.cnt++, ret.sum+=b[i], seg_b.set(b[i],ret);}
sum+=1ll*(m-n)*k;
auto res=[&](){
ll ans=-1e15;
ans=max(ans,solve(fb(1),m)), ans=max(ans,solve(fb(n),m)), ans=max(ans,solve(fa(1),m-1)), ans=max(ans,solve(fa(m),m-1));
int threshold=n>1?fb(n-1):0;
if (k+threshold<=1e6){
int pos=max(seg_a.prod(0,k+threshold).cnt,1); ans=max(ans,solve(fa(pos),m-1)); int nxt_pos=seg_a.max_right(0,[&](S l){return l.cnt<=pos;});
if (nxt_pos<maxm) ans=max(ans,solve(nxt_pos,m-1));
}
cout<<ans<<"\n";
};
while (q--){
int op,idx,x;
cin>>op;
if (op==1){
cin>>idx>>x;
auto ret=seg_a.get(a[idx]);
ret.cnt--, ret.sum-=a[idx];
seg_a.set(a[idx],ret);
sum-=a[idx], sum+=x, a[idx]=x; ret=seg_a.get(x); ret.cnt++, ret.sum+=x; seg_a.set(x,ret);
}
if (op==2){
cin>>idx>>x;
auto ret=seg_b.get(b[idx]);
ret.cnt--, ret.sum-=b[idx]; seg_b.set(b[idx],ret);
sum+=b[idx], sum-=x, b[idx]=x, ret=seg_b.get(x); ret.cnt++, ret.sum+=x; seg_b.set(x,ret);
}
if (op==3){ cin>>k; sum+=(m-n)*k; res(); sum-=(m-n)*k; }
}
return 0;
} | 12 |
#include <bits/stdc++.h>
using namespace std;
int it[1000001];
int dp[1000001][2];
pair<int, int> ba[1000001][2];
int ma[2];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int st = 1;
ma[0] = -1;
ma[1] = 1;
for (int i = 0; i < n; i++) {
cin >> it[i];
if (it[i] != (i + 1)) {
st = 0;
}
}
if (n <= 2 or st == 1) {
cout << "YES" << '\n';
for (int i = 0; i < n; i++) {
cout << it[i] << " ";
}
cout << '\n';
continue;
}
int xx = -(n + 1);
dp[0][0] = xx;
dp[0][1] = xx;
ba[0][0] = {-1, -1};
ba[0][1] = {-1, -1};
for (int i = 1; i < n; i++) {
dp[i][0] = n + 1;
dp[i][1] = n + 1;
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
if (dp[i - 1][j] == n + 1) {
continue;
}
if ((ma[k] * it[i]) > (ma[j] * it[i - 1])) {
if (dp[i - 1][j] < dp[i][k]) {
ba[i][k] = {i - 1, j};
}
dp[i][k] = min(dp[i][k], dp[i - 1][j]);
}
if ((it[i] * ma[k]) > dp[i - 1][j]) {
if ((ma[j] * (it[i - 1])) < dp[i][k]) {
ba[i][k] = {i - 1, j};
}
dp[i][k] = min(dp[i][k], (ma[j] * (it[i - 1])));
}
}
}
}
if (dp[n - 1][0] == -xx and dp[n - 1][1] == -xx) {
cout << "NO" << '\n';
} else {
pair<int, int> cur = {n - 1, 0};
if (dp[n - 1][1] != -xx) {
cur.second = 1;
}
cout << "YES" << '\n';
vector<int> ans;
while (cur.first >= 0) {
ans.push_back(it[cur.first] * ma[cur.second]);
cur = {ba[cur.first][cur.second].first,
ba[cur.first][cur.second].second};
}
for (int i = n - 1; i >= 0; i--) {
cout << ans[i] << " ";
}
cout << '\n';
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 252;
const int M = 26;
char s[N][N];
int pre[N][N][M];
bool isRowPalindrome(int l, int r, int row) {
int odd = 0;
for (int i = 0; i < M; ++i) {
int cc = pre[row][r][i] - pre[row][l - 1][i];
if (cc & 1) {
++odd;
}
if (odd > 1) {
return false;
}
}
return true;
}
pair<int, int> v[N * 2 + 5];
int A[N * 2];
bool isEqaul(int x, int y, int l, int r) {
if (v[l].first == 0 || v[r].first == 0) {
return false;
}
for (int i = 0; i < M; ++i) {
if (pre[v[l].second][y][i] - pre[v[l].second][x - 1][i] !=
pre[v[r].second][y][i] - pre[v[r].second][x - 1][i]) {
return false;
}
}
return true;
}
void solve() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%s", s[i] + 1);
for (int j = 1; j <= m; ++j) {
for (int k = 0; k < M; ++k) {
pre[i][j][k] = pre[i][j - 1][k];
}
pre[i][j][s[i][j] - 'a']++;
}
}
pair<int, int> emp = make_pair(1, 0);
long long ret = 0;
for (int x = 1; x <= m; ++x) {
for (int y = x; y <= m; ++y) {
int pos = 1;
v[pos++] = emp;
for (int i = 1; i <= n; ++i) {
v[pos++] = make_pair(isRowPalindrome(x, y, i), i);
v[pos++] = emp;
}
int L = pos - 1;
int r = 0, p = 0;
for (int i = 1; i <= L; ++i) {
if (i <= r) {
A[i] = min(A[2 * p - i], r - i);
} else {
A[i] = 0;
}
while (i - A[i] - 1 > 0 && i + A[i] + 1 <= L &&
isEqaul(x, y, i - A[i] - 1, i + A[i] + 1)) {
++A[i];
}
if (r < i + A[i]) r = i + A[i], p = i;
}
for (int i = 1; i <= L; ++i) {
if (v[i].first == 0) {
continue;
}
if (v[i] == emp) {
ret += (A[i] + 1) / 2;
} else {
ret += (A[i]) / 2 + 1;
}
}
}
}
cout << ret << endl;
}
int main() { solve(); }
| 8 |
#include <bits/stdc++.h>
using namespace std;
void showvector(vector<long long int> v) {
for (long long int x : v) cout << x << " ";
cout << endl;
}
bool comp(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return (a.first > b.first);
}
void fun() {
long long int n;
while (cin >> n) {
}
}
void vfun() {
long long int n, k;
while (cin >> n) {
vector<long long int> v(n);
for (long long int i = 0; i < n; i++) cin >> v[i];
cin >> k;
vector<long long int> v1(k);
for (long long int i = 0; i < k; i++) cin >> v1[i];
sort(v.begin(), v.end());
sort(v1.begin(), v1.end());
cout << v[n - 1] << " " << v1[k - 1] << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
long long int test = 1;
while (test--) {
vfun();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 50;
const int inf = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
int dfs(long long a, long long b) {
if (a > b) swap(a, b);
if (a == 0) return 0;
if (b % a == 0 || !dfs(b % a, a) || (b / a) % (a + 1) % 2 == 0) return 1;
return 0;
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
long long a, b;
scanf("%I64d%I64d", &a, &b);
if (dfs(a, b))
printf("First\n");
else
printf("Second\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n, a, b;
int chairs[100][100] = {0};
int count = 1;
cin >> n >> a >> b;
if (n > a * b) {
cout << -1;
} else {
for (i = 0; i < a; i++) {
if (b % 2 == 1 || i % 2 == 0)
for (j = 0; j < b; j++) {
chairs[i][j] = count;
count++;
if (count > n) break;
}
else
for (j = b - 1; j >= 0; j--) {
chairs[i][j] = count;
count++;
if (count > n) break;
}
if (count > n) break;
}
for (i = 0; i < a; i++) {
for (j = 0; j < b; j++) cout << chairs[i][j] << " ";
cout << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int P = 1000 * 1000 * 1000 + 7, N = 50 + 5;
long long n, dp[3 * N + 1][N][N], cnt[2], c[N][N], k, ans = 1;
void com() {
for (int i = 0; i < N; i++) c[i][0] = 1;
for (int i = 1; i < N; i++)
for (int j = 1; j <= i; j++) c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % P;
}
void updEve(int s, int x, int y) {
for (int i = 0; i <= cnt[0] - x; i++)
for (int j = 0; j <= cnt[1] - y; j++)
if (i + j != 0 && i * 50 + j * 100 <= k) {
dp[s + 1][x + i][y + j] +=
dp[s][x][y] * c[cnt[0] - x][i] % P * c[cnt[1] - y][j] % P;
dp[s + 1][x + i][y + j] %= P;
}
}
void updOdd(int s, int x, int y) {
for (int i = 0; i <= x; i++)
for (int j = 0; j <= y; j++)
if (i + j != 0 && i * 50 + j * 100 <= k) {
dp[s + 1][x - i][y - j] += dp[s][x][y] * c[x][i] % P * c[y][j] % P;
dp[s + 1][x - i][y - j] %= P;
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie();
cin >> n >> k;
for (int i = 0, a; i < n; i++) cin >> a, cnt[a / 50 - 1]++;
dp[0][cnt[0]][cnt[1]] = 1, com();
for (int i = 0; i < 3 * N; i++)
for (int j = 0; j <= cnt[0]; j++)
for (int l = 0; l <= cnt[1]; l++)
i & 1 ? updEve(i, j, l) : updOdd(i, j, l);
for (; ans < 3 * N && dp[ans][0][0] == 0; ans += 2)
;
ans < 3 * N ? cout << ans << endl << dp[ans][0][0] : cout << -1 << endl << 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void printvector(std::vector<long long> v) {
for (long long i = 0; i < v.size(); ++i) {
cout << v[i] << " ";
}
cout << "" << endl;
}
void printarray(long long a[], long long n) {
for (long long i = 0; i < n; ++i) {
cout << a[i] << " ";
}
cout << "" << endl;
}
long long f(long long n, long long x) {
if (n < x) return 0;
if (n == x) return 1;
if (x % 2 == 0) {
long long left = x, right = x;
long long sum = 0;
while (left <= n) {
sum += (right / 2 - left / 2 + 1);
left = left * 2;
right = right * 2 + 2;
right = min(right, n - n % 2);
}
left = x + 1, right = x + 1;
while (left <= n) {
sum += ((right - left) / 2 + 1);
left = left * 2 - 1;
right = right * 2 + 1;
right = min(right, n - 1 + n % 2);
}
return sum;
} else {
return 1 + f(n, 2 * x);
}
}
void solve() {
long long n, k;
cin >> n >> k;
if (k == n) {
cout << 1 << endl;
return;
}
long long ans1 = 1, ans2 = 0;
long long l = 2, r = n - n % 2;
while (l < r) {
long long mid = 2 * ((l / 2 + r / 2) / 2) + 2;
long long d = f(n, mid);
if (d >= k) {
l = mid;
} else {
r = mid - 2;
}
}
ans2 = l;
l = 1;
r = n - 1 + n % 2;
while (l < r) {
long long mid = 2 * ((l / 2 + r / 2) / 2) + 3;
long long d = f(n, mid);
if (d >= k) {
l = mid;
} else {
r = mid - 2;
}
}
ans1 = l;
cout << max(ans2, ans1) << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int ansL1, ansB1, ansL2, ansB2;
struct node {
long long int a, b, c, d;
int cnt;
node() {}
node(long long int A, long long int B, long long int C, long long int D,
int count) {
a = A, b = B, c = C, d = D, cnt = count;
}
};
map<pair<long long int,
pair<long long int, pair<long long int, long long int> > >,
bool>
vis;
int BFS(long long int& u1, long long int& u2, long long int& u3,
long long int& u4) {
queue<node> Q;
Q.push(node(u1, u2, u3, u4, 0));
vis[make_pair(u1, make_pair(u2, make_pair(u3, u4)))] = 1;
while (!Q.empty()) {
node z = Q.front();
Q.pop();
if ((z.a * z.b) == (z.c * z.d)) {
ansL1 = z.a, ansB1 = z.b, ansL2 = z.c, ansB2 = z.d;
return z.cnt;
}
if ((z.a * z.b) > (z.c * z.d)) {
if (z.a % 2 == 0) {
if (!vis[make_pair(z.a / 2, make_pair(z.b, make_pair(z.c, z.d)))]) {
Q.push(node(z.a / 2, z.b, z.c, z.d, z.cnt + 1));
vis[make_pair(z.a / 2, make_pair(z.b, make_pair(z.c, z.d)))] = 1;
}
} else if (z.b % 2 == 0) {
if (!vis[make_pair(z.a, make_pair(z.b / 2, make_pair(z.c, z.d)))]) {
Q.push(node(z.a, z.b / 2, z.c, z.d, z.cnt + 1));
vis[make_pair(z.a, make_pair(z.b / 2, make_pair(z.c, z.d)))] = 1;
}
}
if (z.a % 3 == 0) {
if (!vis[(make_pair((z.a / 3) * 2,
make_pair(z.b, make_pair(z.c, z.d))))]) {
Q.push(node((z.a / 3) * 2, z.b, z.c, z.d, z.cnt + 1));
vis[make_pair((z.a / 3) * 2, make_pair(z.b, make_pair(z.c, z.d)))] =
1;
}
} else if (z.b % 3 == 0) {
if (!vis[make_pair(z.a,
make_pair((z.b / 3) * 2, make_pair(z.c, z.d)))]) {
Q.push(node(z.a, (z.b / 3) * 2, z.c, z.d, z.cnt + 1));
vis[make_pair(z.a, make_pair((z.b / 3) * 2, make_pair(z.c, z.d)))] =
1;
}
}
} else {
if (z.c % 2 == 0) {
if (!vis[make_pair(z.a, make_pair(z.b, make_pair(z.c / 2, z.d)))]) {
Q.push(node(z.a, z.b, z.c / 2, z.d, z.cnt + 1));
vis[make_pair(z.a, make_pair(z.b, make_pair(z.c / 2, z.d)))] = 1;
}
} else if (z.d % 2 == 0) {
if (!vis[make_pair(z.a, make_pair(z.b, make_pair(z.c, z.d / 2)))]) {
Q.push(node(z.a, z.b, z.c, z.d / 2, z.cnt + 1));
vis[make_pair(z.a, make_pair(z.b, make_pair(z.c, z.d / 2)))] = 1;
}
}
if (z.c % 3 == 0) {
if (!vis[make_pair(z.a,
make_pair(z.b, make_pair((z.c / 3) * 2, z.d)))]) {
Q.push(node(z.a, z.b, (z.c / 3) * 2, z.d, z.cnt + 1));
vis[make_pair(z.a, make_pair(z.b, make_pair((z.c / 3) * 2, z.d)))] =
1;
}
} else if (z.d % 3 == 0) {
if (!vis[make_pair(z.a,
make_pair(z.b, make_pair(z.c, (z.d / 3) * 2)))]) {
Q.push(node(z.a, z.b, z.c, (z.d / 3) * 2, z.cnt + 1));
vis[make_pair(z.a, make_pair(z.b, make_pair(z.c, (z.d / 3) * 2)))] =
1;
}
}
}
}
}
bool notPossible(unsigned long long int a, unsigned long long int b,
unsigned long long int c, unsigned long long int d) {
a *= b, c *= d;
while (a % 2 == 0) a /= 2;
while (c % 2 == 0) c /= 2;
while (a % 3 == 0) a /= 3;
while (c % 3 == 0) c /= 3;
if (a == c) return false;
return true;
}
int main(void) {
long long int a, b, c, d;
cin >> a >> b >> c >> d;
if (notPossible(a, b, c, d)) {
cout << "-1";
return 0;
}
printf("%d\n", BFS(a, b, c, d));
printf("%lld %lld\n%lld %lld\n", ansL1, ansB1, ansL2, ansB2);
return (0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 25;
int ans_top, n, m, a[N][N];
vector<int> ans[100005];
pair<int, int> p[N * N];
void SWP(int x, int y) {
swap(p[x], p[y]);
swap(a[p[x].first][p[x].second], a[p[y].first][p[y].second]);
}
void insert(vector<int> v) {
ans[++ans_top] = v;
for (int i = (int)(v.size() - 2); i >= (int)(0); i--) SWP(v[i], v.back());
}
void ROL(int x, int y) {
insert(vector<int>{a[x][y], a[x + 1][y], a[x + 1][y + 1], a[x][y + 1]});
}
void ROR(int x, int y) {
insert(vector<int>{a[x][y], a[x][y + 1], a[x + 1][y + 1], a[x + 1][y]});
}
void GOL(int x, int y) { x == n ? ROR(x - 1, y - 1) : ROL(x, y - 1); }
void GOR(int x, int y) { x == n ? ROL(x - 1, y) : ROR(x, y); }
void GOU(int x, int y) { y == m ? ROL(x - 1, y - 1) : ROR(x - 1, y); }
void GOD(int x, int y) { y == m ? ROR(x, y - 1) : ROL(x, y); }
void move(int v, int tx, int ty) {
for (; p[v].second < ty; GOR(p[v].first, p[v].second))
;
for (; p[v].second > ty; GOL(p[v].first, p[v].second))
;
for (; p[v].first > tx; GOU(p[v].first, p[v].second))
;
for (; p[v].first < tx; GOD(p[v].first, p[v].second))
;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (int)(1); i <= (int)(n); i++)
for (int j = (int)(1); j <= (int)(m); j++) {
scanf("%d", &a[i][j]);
p[a[i][j]] = pair<int, int>(i, j);
}
for (int i = (int)(1); i <= (int)(n - 2); i++) {
for (int j = (int)(1); j <= (int)(m - 1); j++) move(i * m - m + j, i, j);
if (p[i * m] == pair<int, int>(i, m)) continue;
if (p[i * m].first == i + 1) GOD(p[i * m].first, p[i * m].second);
ROR(i, m - 1);
move(i * m, i + 1, m);
ROL(i, m - 1);
}
for (int j = (int)(1); j <= (int)(m - 2); j++) {
move((n - 2) * m + j, n - 1, j);
if (p[n * m - m + j] == pair<int, int>(n, j)) continue;
if (p[n * m - m + j].second == j + 1)
GOR(p[n * m - m + j].first, p[n * m - m + j].second);
ROL(n - 1, j);
move(n * m - m + j, n, j + 1);
ROR(n - 1, j);
}
srand(time(NULL));
for (;;) {
bool flg = 0;
for (int i = (int)(1); i <= (int)(n); i++)
for (int j = (int)(1); j <= (int)(m); j++)
if (a[i][j] != i * m - m + j) flg = 1;
if (!flg) break;
int tp = rand() % 3;
if (tp == 0) ROL(n - 1, m - 1);
if (tp == 1) ROL(n - 1, m - 2);
if (tp == 2)
insert(vector<int>{a[n - 1][m - 2], a[n - 1][m - 1], a[n - 1][m], a[n][m],
a[n][m - 1], a[n][m - 2]});
}
printf("%d\n", ans_top);
for (int i = (int)(1); i <= (int)(ans_top); i++) {
printf("%d ", ans[i].size());
for (auto j : ans[i]) printf("%d ", j);
puts("");
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int A[2][2] = {{0, 0}, {0, 0}};
vector<int> X[2][2];
vector<string> H;
set<string> G[2][2];
for (int i = 0; i < n; ++i) {
string S;
cin >> S;
int x = S[0] - '0', y = S.back() - '0';
A[x][y]++;
X[x][y].push_back(i);
H.push_back(S);
G[x][y].insert(S);
}
if (A[0][1] == 0 && A[1][0] == 0 && A[0][0] && A[1][1])
cout << -1 << '\n';
else {
int ans = abs(A[0][1] - A[1][0]) / 2;
vector<int> I;
bool x = A[0][1] < A[1][0];
int c = 0;
for (int i = 0; i < (int)X[x][!x].size() && c < ans; ++i) {
int index = X[x][!x][i];
reverse(H[index].begin(), H[index].end());
if (G[!x][x].count(H[index]) == 0) {
c++;
I.push_back(index);
}
}
if (c < ans)
cout << -1 << '\n' << '\n';
else {
cout << ans << '\n';
for (auto i : I) cout << i + 1 << " ";
cout << '\n';
}
}
}
exit(0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000003;
long double pi = 3.1415926536;
const int mx = 1000003;
long long gcd(long long x, long long y) {
if (y == 0) return x;
return gcd(y, x % y);
}
long long bp(long long a, long long b) {
long long ans = 1;
while (b > 0) {
if (b & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ans;
}
long long p(long long n) {
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
return n / i;
}
}
return 1;
}
vector<long long> z(string s) {
long long n = s.size();
vector<long long> z(n);
long long x = 0, y = 0, p = 0;
for (long long i = 1; i < n; i++) {
z[i] = max(p, min(z[i - x], y - i + 1));
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) {
x = i;
y = i + z[i];
z[i]++;
}
}
return z;
}
string f(string s) {
string p = "";
for (int i = 0; i < s.length(); i++)
if (isalpha(s[i])) p += toupper(s[i]);
return p;
}
int main() {
string s, p, A, B, C;
cin >> A >> B >> C;
A = f(A);
B = f(B);
C = f(C);
int n, i, j;
cin >> n;
while (n--) {
cin >> s;
s = f(s);
if (s == A + B + C || s == A + C + B || s == B + C + A || s == B + A + C ||
s == C + A + B || s == C + B + A)
cout << "ACC" << endl;
else
cout << "WA" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int N = 1005;
int v[N], w[N], dp[N] = {0};
int main() {
int i, j, V = 0, n;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d%d", &w[i], &v[i]);
V += w[i];
}
for (i = 1; i <= V; i++) dp[i] = V;
for (i = 0; i < n; i++)
for (j = V; j >= w[i]; j--)
dp[j] = (dp[j]) < (dp[j - w[i]] + v[i]) ? (dp[j]) : (dp[j - w[i]] + v[i]);
for (i = V; i >= 0; i--)
if (V - i >= dp[i]) break;
printf("%d\n", V - i);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, b, g, x, y;
bool women[100], man[100];
cin >> n >> m;
cin >> b;
for (int i = 0; i < n; i++) man[i] = 0;
for (int i = 0; i < m; i++) women[i] = 0;
for (int i = 0; i < b; i++) {
cin >> x;
man[x] = 1;
}
cin >> g;
for (int i = 0; i < g; i++) {
cin >> y;
women[y] = 1;
}
for (int i = 0; i <= (n * m) * (n * m); i++) {
if (man[i % n] == 1)
women[i % m] = 1;
else {
if (women[i % m] == 1) man[i % n] = 1;
}
}
bool flag1 = 1, flag2 = 1;
for (int i = 0; i < n; i++) flag1 *= man[i];
for (int i = 0; i < m; i++) flag2 *= women[i];
if (flag1 == 1 && flag2 == 1)
cout << "Yes";
else
cout << "No";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int MOD = 1000 * 1000 * 1000 + 7;
const int MAX = 100017;
int n, m, k;
int x, y;
long long gcd(long long a, long long b, long long& x, long long& y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long x1, frgrwegreg;
long long d = gcd(b % a, a, x1, frgrwegreg);
x = frgrwegreg - (b / a) * x1;
y = x1;
return d;
}
long long gcd(long long a, long long b) {
if (!a || !b) return a + b;
return gcd(b % a, a);
}
long long solve(long long a, long long b, long long c, long long val) {
int d = gcd(abs(a), abs(b));
if (abs(c) % d != 0) return 1e18;
a /= d;
b /= d;
c /= d;
long long x, y;
gcd(a, b, x, y);
if (a * x + b * y == -1) x *= -1, y *= -1;
x *= c;
y *= c;
if (val + 2 * y * m < 0) {
long long res = abs(val + 2 * y * m) / (2 * a * m);
y += a * res;
}
if (val + 2 * y * m > 0) {
long long res = abs(val + 2 * y * m) / (2 * a * m);
y -= a * res;
}
while (val + 2 * y * m - 2 * a * m > 0) y -= a;
while (val + 2 * y * m < 0) y += a;
return val + 2 * y * m;
}
int main() {
cin >> n >> m >> k;
for (int i = (0); i < (k); ++i) {
scanf("%d%d", &x, &y);
long long res = 1e18;
res = min(res, solve(2 * n, -2 * m, y - x, y));
res = min(res, solve(2 * n, -2 * m, y - (2 * n - x), y));
res = min(res, solve(2 * n, -2 * m, (2 * m - y) - x, 2 * m - y));
res = min(res, solve(2 * n, -2 * m, (2 * m - y) - (2 * n - x), 2 * m - y));
if (res == 1e18)
cout << "-1\n";
else
cout << res << "\n";
long long x0 = 0, y0 = 0, dx = 1, dy = 1;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using namespace std;
struct nodes {
int mx[103], mn[103], cnt;
} node[20002];
const int INF = 1e9 + 9;
int p, m, t = 0;
string E;
bool flag = 1;
stack<int> pos;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> E >> p >> m;
if (m <= 100) flag = 0;
for (char c : E) {
if ('1' <= c && c <= '9') {
t++;
node[t].cnt = 0;
node[t].mx[0] = node[t].mn[0] = c - '0';
pos.push(t);
} else if (c == ')') {
int r = pos.top();
pos.pop();
int l = pos.top();
pos.pop();
pos.push(++t);
node[t].cnt = node[l].cnt + node[r].cnt + 1;
int ilim = min(node[t].cnt, 100);
for (int i = (0); i <= (ilim); ++i) {
node[t].mx[i] = -INF;
node[t].mn[i] = INF;
int jlim = min(node[l].cnt, i);
for (int j = (0); j <= (jlim); ++j)
if (flag) {
if (i - j - 1 <= node[r].cnt && i != j)
node[t].mx[i] =
max(node[t].mx[i], node[l].mx[j] + node[r].mx[i - j - 1]),
node[t].mn[i] =
min(node[t].mn[i], node[l].mn[j] + node[r].mn[i - j - 1]);
if (i - j <= node[r].cnt)
node[t].mx[i] =
max(node[t].mx[i], node[l].mx[j] - node[r].mn[i - j]),
node[t].mn[i] =
min(node[t].mn[i], node[l].mn[j] - node[r].mx[i - j]);
} else {
if (i - j <= node[r].cnt)
node[t].mx[i] =
max(node[t].mx[i], node[l].mx[j] + node[r].mx[i - j]),
node[t].mn[i] =
min(node[t].mn[i], node[l].mn[j] + node[r].mn[i - j]);
if (i - j - 1 <= node[r].cnt && i != j)
node[t].mx[i] =
max(node[t].mx[i], node[l].mx[j] - node[r].mn[i - j - 1]),
node[t].mn[i] =
min(node[t].mn[i], node[l].mn[j] - node[r].mx[i - j - 1]);
}
}
}
}
int id = p;
if (!flag) id = m;
cout << node[t].mx[id];
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
bool check = false;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] == arr[j]) {
arr[j] = 0;
}
}
}
sort(arr, arr + n);
for (int i = 0; i < n; i++) {
if (i + 1 >= n || i + 2 >= n) {
break;
}
if ((arr[i] == arr[i + 1] - 1) && (arr[i + 1] == arr[i + 2] - 1) &&
arr[i] != 0) {
cout << "YES" << endl;
check = true;
break;
}
}
if (check == false) {
cout << "NO" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
const int N = 203600;
vector<int> g[N];
set<int> brg[N];
bool vis[N], ap[N];
int low[N], bt[N], lv;
void dfs(int u, int fr) {
vis[u] = 1;
bt[u] = low[u] = lv++;
int nChild = 0;
for (int j = (0); j < (int)(g[u].size()); j++) {
int i = g[u][j];
if (!vis[i]) {
nChild++;
dfs(i, u);
low[u] = min(low[u], low[i]);
} else if (i != fr)
low[u] = min(low[u], bt[i]);
if (bt[u] < low[i]) {
brg[u].insert(i);
brg[i].insert(u);
}
}
if (fr == 0)
ap[u] = fr == 0 && nChild > 1;
else if (fr != 0 && low[u] >= bt[fr])
ap[fr] = 1;
}
int ans;
int mrk[N];
void go(int u, int p, int dst, int cur, int id) {
if (mrk[u] == id) return;
mrk[u] = id;
if (u == dst) {
ans = cur;
return;
}
for (__typeof((g[u]).begin()) it = (g[u]).begin(); it != (g[u]).end(); it++) {
int second = *it;
if (brg[u].find(second) != brg[u].end()) {
go(second, u, dst, cur + 1, id);
} else {
go(second, u, dst, cur, id);
}
}
}
int main() {
scanf("%d%d", &n, &m);
while (m--) {
int first, second;
scanf("%d%d", &first, &second);
g[first].push_back(second);
g[second].push_back(first);
}
memset(bt, 0, sizeof(bt));
memset(low, 0, sizeof(low));
lv = 0;
dfs(1, -1);
for (int i = (1); i <= (int)(n); i++) {
for (__typeof((brg[i]).begin()) it = (brg[i]).begin(); it != (brg[i]).end();
it++) {
}
}
int k;
scanf("%d", &k);
int nn = 0;
memset(mrk, -1, sizeof(mrk));
while (k--) {
int first, second;
scanf("%d%d", &first, &second);
go(first, -1, second, 0, nn);
nn++;
printf("%d\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n, s;
cin >> n >> s;
s--;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
int mx = 0;
int ans = 0;
if (v[s] != 0) {
v[s] = 0;
ans++;
}
if (n == 1) {
cout << ans << endl;
return 0;
}
vector<int> cnt(n + 1, 0);
for (int i = 0; i < n; i++)
if (i != s) cnt[v[i]]++;
int bad = n - 1;
int wow = 0;
int ff = 2e9;
for (int i = 1; i <= n - 1; i++) {
if (cnt[i] == 0) wow++;
bad -= cnt[i];
if (bad >= wow)
ff = min(ff, bad);
else
ff = min(ff, wow);
}
ans += ff;
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 2241;
char a[MaxN][MaxN];
int n, display[MaxN][MaxN];
bool propagetDown[MaxN][MaxN], propagateLeft[MaxN][MaxN];
bool propagateUp[MaxN][MaxN], propagateRight[MaxN][MaxN];
int main() {
cin.sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) cin >> a[i][j];
int diff = n - 1, ans = 0;
for (int i = 0; i < n - 1; i++) {
for (int j = 1; j + diff <= n; j++) {
display[j][j + diff] %= 2;
if (propagetDown[j][j + diff]) {
display[j + 1][j + diff]++;
propagetDown[j + 1][j + diff] ^= 1;
}
if (propagateLeft[j][j + diff]) {
display[j][j + diff - 1]++;
propagateLeft[j][j + diff - 1] ^= 1;
}
if (display[j][j + diff] != a[j][j + diff] - '0') {
display[j + 1][j + diff]++;
display[j][j + diff - 1]++;
propagetDown[j + 1][j + diff] ^= 1;
propagateLeft[j][j + diff - 1] ^= 1;
++ans;
}
display[j + diff][j] %= 2;
if (propagateUp[j + diff][j]) {
display[j + diff - 1][j]++;
propagateUp[j + diff - 1][j] ^= 1;
}
if (propagateRight[j + diff][j]) {
display[j + diff][j + 1]++;
propagateRight[j + diff][j + 1] ^= 1;
}
if (display[j + diff][j] != a[j + diff][j] - '0') {
display[j + diff - 1][j]++;
display[j + diff][j + 1]++;
propagateUp[j + diff - 1][j] ^= 1;
propagateRight[j + diff][j + 1] ^= 1;
ans++;
}
}
diff--;
}
for (int i = 1; i <= n; i++)
if (display[i][i] % 2 != a[i][i] - '0') ans++;
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using ll = long long;
using llu = long long unsigned;
using ld = long double;
const ld EPS = 1e-9;
inline int cmp(ld first, ld second = 0, ld tol = EPS) {
return (first <= second + tol) ? (first + tol < second) ? -1 : 0 : 1;
}
const int MOD = 1;
inline int mod(ll first, int m = MOD) { return (int)(((first % m) + m) % m); }
int n;
ll gcd(ll a, ll b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int main() {
scanf("%d", &n);
ll big = -1;
while (n--) {
ll first;
scanf("%lld", &first);
if (big == -1) big = first;
big = gcd(big, first);
}
if (big == 1) {
printf("1\n");
exit(0);
}
int ans = 0;
for (ll i = 1; i * i <= big; i++) {
if (i * i == big) {
++ans;
} else {
ans += 2 * (big % i == 0);
}
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct P {
int x;
int y;
};
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
bool visit[1005][1005];
bool grid[1005][1005];
int n, m;
int sx, sy;
int allarea = 0;
vector<P> l, r;
void bfs(int sx, int sy) {
int countt = 0;
P sp;
sp.x = sx, sp.y = sy;
queue<P> q;
q.push(sp);
while (!q.empty()) {
P p;
p = q.front();
q.pop();
for (int i = 0; i < 4; i += 1) {
int x = p.x + dx[i], y = p.y + dy[i];
if (x >= 0 && x < n && y >= 0 && y < m && grid[x][y] && !visit[x][y]) {
allarea += 1;
visit[x][y] = true;
P tmpp;
tmpp.x = x, tmpp.y = y;
q.push(tmpp);
}
}
}
}
bool check1() {
int flag = -1;
for (int i = 0; i < n; i += 1) {
for (int j = 0; j < m; j += 1) {
if (grid[i][j] && !visit[i][j]) {
if (flag == -1) {
allarea += 1;
sx = i, sy = j;
flag = 0;
visit[i][j] = true;
bfs(i, j);
continue;
} else
return false;
}
}
}
return true;
}
bool check2(int dx, int dy) {
int countt = 0;
for (int i = sx; i < sx + dx; i += 1) {
for (int j = sy; j < sy + dy; j += 1) {
if (!grid[i][j]) return false;
}
}
countt = dx * dy;
int tmpx = sx, tmpy = sy;
while (1) {
bool flag1 = true;
for (int i = tmpy; i < tmpy + dy; i += 1) {
if (!grid[tmpx + dx][i]) flag1 = false;
}
if (flag1) tmpx += 1, countt += dy;
bool flag2 = true;
for (int i = tmpx; i < tmpx + dx; i += 1) {
if (!grid[i][tmpy + dy]) flag2 = false;
}
if (flag2) tmpy += 1, countt += dx;
if (!flag1 && !flag2) break;
}
if (countt == allarea)
return true;
else
return false;
}
int solve() {
int flag = 0;
int ansx = 99999999, ansy = 99999999;
for (int i = 0; i < n; i += 1) {
int countt = 0;
for (int j = 0; j < m; j += 1) {
if (grid[i][j]) countt += 1;
}
if (countt) {
ansy = min(ansy, countt);
}
}
for (int i = 0; i < m; i += 1) {
int countt = 0;
for (int j = 0; j < n; j += 1) {
if (grid[j][i]) countt += 1;
}
if (countt) {
ansx = min(ansx, countt);
}
}
int ans = 999999999;
for (int i = 1; i <= ansy; i += 1) {
if (check2(ansx, i)) ans = min(ans, ansx * i), flag = 1;
}
for (int i = 1; i <= ansx; i += 1) {
if (check2(i, ansy)) ans = min(ans, ansy * i), flag = 1;
}
if (flag)
return ans;
else
return -1;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i += 1) {
for (int j = 0; j < m; j += 1) {
char c;
cin >> c;
if (c == '.')
grid[i][j] = false;
else
grid[i][j] = true;
}
}
memset(visit, false, sizeof(visit));
if (check1()) {
printf("%d\n", solve());
} else {
printf("-1\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void task();
int main() {
srand(time(0));
task();
return 0;
}
const int N = 1e5 + 10;
char buf[N];
string s, rs;
string t;
vector<int> z_func(string s) {
int n = s.length();
vector<int> z(n, 0);
int l = 0, r = 0;
for (int i = 1; i < n; ++i) {
if (r >= i) z[i] = min(z[i - l], r - i + 1);
while (z[i] + i < n && s[z[i]] == s[z[i] + i]) ++z[i];
if (z[i] + i - 1 > r) l = i, r = z[i] + i - 1;
}
return z;
}
void task() {
scanf("%s", buf);
s = buf;
rs = s;
reverse((rs.begin()), (rs.end()));
int q;
scanf("%d", &q);
int ans = 0;
while (q--) {
scanf("%s", buf);
t = buf;
if (t.length() < 2) continue;
vector<int> z1 = z_func(t + "!" + s + "!");
reverse((t.begin()), (t.end()));
vector<int> z2 = z_func(t + "!" + rs + "!");
vector<int> z(((int)((z1).size())), 0);
for (int i = ((int)((z1).size())) - 1; i > t.length(); --i)
if (z1[i]) z[i + z1[i] - 1] = max(z1[i], z[i + z1[i] - 1]);
z1 = z;
for (int i = ((int)((z1).size())) - 2; i > t.length(); --i)
z1[i] = max(z1[i], z1[i + 1] - 1);
for (int i = t.length() + 1; i < ((int)((z1).size())); ++i)
z1[i] = max(z1[i], z1[i - 1]);
z.assign(((int)((z2).size())), 0);
for (int i = ((int)((z2).size())) - 1; i > t.length(); --i)
if (z2[i]) z[i + z2[i] - 1] = max(z2[i], z[i + z2[i] - 1]);
z2 = z;
for (int i = ((int)((z2).size())) - 2; i > t.length(); --i)
z2[i] = max(z2[i], z2[i + 1] - 1);
for (int i = t.length() + 1; i < ((int)((z2).size())); ++i)
z2[i] = max(z2[i], z2[i - 1]);
int ok = 0;
for (int i = 0; i < s.length() - 1; ++i) {
if (z1[i + t.length() + 1] + z2[t.length() + s.length() - i - 1] >=
t.length())
ok = 1;
}
ans += ok;
}
printf("%d", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int num[10005];
int w, m;
int main() {
while (scanf("%d%d", &w, &m) != EOF) {
int cnt = 0;
bool flag = false;
memset(num, 0, sizeof(num));
while (m) {
num[cnt++] = m % w;
m /= w;
}
for (int i = 0; i < cnt; i++) {
if (num[i] == 0 || num[i] == 1) continue;
if (num[i] - w == -1) {
int pos = i + 1;
num[pos]++;
while (num[pos] >= w) {
num[pos] -= w;
num[pos + 1]++;
pos++;
cnt = max(cnt, pos);
}
continue;
}
flag = true;
break;
}
if (flag)
puts("NO");
else
puts("YES");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 10;
int n;
vector<pair<int, int> > q;
int ans[N];
vector<int> pool[N], mem[N];
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int t[2 * N];
inline int pos(int l, int r) { return (l + r) | (l != r); }
void apply(int l, int r, int v) {
int id = pos(l, r);
t[id] = min(t[id], v);
}
void release(int l, int r) {
int id = pos(l, r), mid = (l + r) >> 1;
apply(l, mid, t[id]);
apply(mid + 1, r, t[id]);
}
void update(int l, int r) {
int id = pos(l, r), mid = (l + r) >> 1;
t[id] = max(t[pos(l, mid)], t[pos(mid + 1, r)]);
}
void modify(int l, int r, int p, int q, int v) {
if (p <= l && r <= q) {
apply(l, r, v);
return;
}
release(l, r);
int mid = (l + r) >> 1;
if (p <= mid) modify(l, mid, p, q, v);
if (q > mid) modify(mid + 1, r, p, q, v);
update(l, r);
}
int res;
bool flag;
void query(int l, int r, int p, int q) {
if (!flag) return;
if (l < r) release(l, r);
int mid = (l + r) >> 1;
if (p <= l && r <= q) {
int id = pos(l, r);
if (t[id] <= q + 1)
res = r + 1;
else {
if (l < r) query(l, mid, p, q), query(mid + 1, r, p, q);
flag = false;
}
} else {
if (p <= mid) query(l, mid, p, q);
if (q > mid) query(mid + 1, r, p, q);
}
if (l < r) update(l, r);
}
int main() {
int m;
n = read();
m = read();
while (m--) {
int l, r;
l = read();
r = read();
if (l < r) pool[l].push_back(r);
}
int tot;
tot = read();
q.resize(tot);
for (int i = 0; i < tot; i++) {
scanf("%d%d", &q[i].first, &q[i].second);
if (q[i].first < q[i].second)
mem[q[i].first].push_back(i);
else
ans[i] = q[i].first;
}
memset(t, 0x3f, sizeof t);
for (int i = n; i > 0; i--) {
for (int j = 0; j < pool[i].size(); j++) {
int k = pool[i][j];
modify(1, n, i, k - 1, k);
}
for (int j = 0; j < mem[i].size(); j++) {
int k = mem[i][j];
res = i, flag = true;
query(1, n, i, q[k].second - 1);
ans[k] = res;
}
}
for (int i = 0; i < q.size(); i++) printf("%d\n", ans[i]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int a[100010];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
if (a[n] >= a[n - 1] + a[n - 2])
printf("NO");
else {
printf("YES\n");
for (int i = 1; i < n - 1; i++) printf("%d ", a[i]);
printf("%d %d", a[n], a[n - 1]);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int kMaxn = 1010, kMaxw = 1010;
int n, m, w, id, a[kMaxn], b[kMaxn], v[kMaxn], dp[2][kMaxw], ans, aa, bb;
class Edge {
public:
int v;
Edge *next;
Edge(int V, Edge *ne) : v(V), next(ne) {}
} * g[kMaxn];
void add(int x, int y) {
g[x] = new Edge(y, g[x]);
g[y] = new Edge(x, g[y]);
}
void dfs(int x, int id) {
v[x] = 1;
aa += a[x];
bb += b[x];
for (int j = a[x]; j <= w; ++j)
dp[1 - id][j] = std::max(dp[1 - id][j], dp[id][j - a[x]] + b[x]);
for (Edge *e = g[x]; e; e = e->next)
if (!v[e->v]) dfs(e->v, id);
}
int main() {
static int i, j, x, y;
scanf("%d%d%d", &n, &m, &w);
for (i = 1; i <= n; ++i) scanf("%d", a + i);
for (i = 1; i <= n; ++i) scanf("%d", b + i);
for (i = 1; i <= n; ++i) g[i] = 0;
for (i = 1; i <= m; ++i) {
scanf("%d%d", &x, &y);
add(x, y);
}
memset(v, 0, sizeof(v));
memset(dp, 0, sizeof(dp));
id = 0;
for (i = 1; i <= n; ++i) {
if (v[i]) continue;
aa = bb = 0;
memcpy(dp[1 - id], dp[id], sizeof(dp[1 - id]));
dfs(i, id);
for (j = aa; j <= w; ++j)
dp[1 - id][j] = std::max(dp[1 - id][j], dp[id][j - aa] + bb);
id = 1 - id;
}
ans = 0;
for (j = 0; j <= w; ++j) ans = std::max(ans, dp[id][j]);
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e5 + 5;
const int offset = (int)1e5 + 1;
unordered_map<string, int> m;
int parent[N];
int find_parent(int v) {
if (v != parent[v]) {
parent[v] = find_parent(parent[v]);
}
return parent[v];
}
void disjoint_set_union(int u, int v) {
parent[find_parent(u)] = find_parent(v);
}
int main() {
int n, M, q;
cin >> n >> M >> q;
int z = 1;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
m[s] = z++;
}
for (int i = 1; i < z; i++) {
parent[i] = i;
parent[i + offset] = i + offset;
}
for (int i = 0; i < M; i++) {
int t;
string X, Y;
cin >> t >> X >> Y;
int x = m[X];
int y = m[Y];
bool ok = false;
if (t == 1) {
if (find_parent(x) != find_parent(y + offset) &&
find_parent(y) != find_parent(x + offset)) {
disjoint_set_union(x, y);
disjoint_set_union(x + offset, y + offset);
ok = true;
}
} else {
if (find_parent(x) != find_parent(y) &&
find_parent(x + offset) != find_parent(y + offset)) {
disjoint_set_union(x, y + offset);
disjoint_set_union(y, x + offset);
ok = true;
}
}
if (ok)
puts("YES");
else
puts("NO");
}
for (int i = 0; i < q; i++) {
string X, Y;
cin >> X >> Y;
int x = m[X];
int y = m[Y];
if (find_parent(x) == find_parent(y))
puts("1");
else if (find_parent(x) == find_parent(y + offset))
puts("2");
else
puts("3");
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2e9;
const long long INF = 8e18;
const int maxn = 3e3 + 5;
int n, m;
int a[maxn], sz[maxn];
pair<int, long long> dp[maxn][maxn], dpp[maxn][maxn];
vector<int> e[maxn];
inline void init() {
for (int i = 0; i < n + 5; ++i) e[i].clear();
}
inline void dfs(int u, int pre) {
sz[u] = 1;
dp[u][1] = {0, a[u]};
for (auto v : e[u]) {
if (v == pre) continue;
dfs(v, u);
for (int i = 1; i <= sz[u] + sz[v]; ++i) dpp[u][i] = {0, -INF};
for (int i = 1; i <= sz[u]; ++i) {
for (int j = 1; j <= sz[v]; ++j) {
dpp[u][i + j] = max(dpp[u][i + j], {dp[u][i].first + dp[v][j].first +
(dp[v][j].second > 0),
dp[u][i].second});
dpp[u][i + j - 1] =
max(dpp[u][i + j - 1], {dp[u][i].first + dp[v][j].first,
dp[v][j].second + dp[u][i].second});
}
}
for (int i = 1; i <= sz[u] + sz[v]; ++i) dp[u][i] = dpp[u][i];
sz[u] += sz[v];
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
cin >> n >> m;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
a[i] = x - a[i];
}
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
e[u].push_back(v);
e[v].push_back(u);
}
dfs(1, 1);
cout << dp[1][m].first + (dp[1][m].second > 0) << '\n';
init();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int lft = 0;
int a;
for (int i = 1; i <= n; ++i) {
cin >> a;
lft += a;
if (lft >= 8) {
k -= 8;
lft -= 8;
} else {
k -= lft;
lft = 0;
}
if (k <= 0) {
cout << i << endl;
return 0;
}
}
puts("-1");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, line[35], column[35], var, count;
cin >> n;
for (i = 1; i <= n; ++i) line[i] = column[i] = 0;
for (i = 1; i <= n; ++i)
for (j = 1; j <= n; ++j) {
cin >> var;
line[i] += var;
column[j] += var;
}
count = 0;
for (i = 1; i <= n; ++i)
for (j = 1; j <= n; ++j) {
if (column[i] > line[j]) count++;
}
cout << count;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool sortbysec(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.second < b.second);
}
int main() {
vector<pair<long long, long long>> v;
int n, f[26] = {}, i, t;
cin >> n;
char h1 = 'n', h2 = 'z';
string s;
cin >> s;
for (i = 0; i < n; i++) {
f[s[i] - 'a']++;
}
for (i = 0; i < f[13]; i++) cout << 1 << " ";
for (i = 0; i < f[25]; i++) cout << 0 << " ";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long f(int a, int b) {
while (a != 0 && b != 0) {
if (a > b)
a %= b;
else
b %= a;
}
return a + b;
}
long long a, b, k;
int main() {
cin >> a >> b;
k = 7 - max(a, b);
cout << k / f(k, 6) << "/" << 6 / f(k, 6);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int arr[1024 * 1024];
int main() {
int n, maxv = 0, pos;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
if (arr[i] > maxv) {
maxv = arr[i];
pos = i;
}
}
bool flag = true;
for (int i = pos + 1; i <= n; i++) {
if (arr[i] >= arr[i - 1]) flag = false;
}
for (int i = pos - 1; i > 0; i--)
if (arr[i] >= arr[i + 1]) flag = false;
sort(arr + 1, arr + 1 + n);
for (int i = 2; i <= n; i++)
if (arr[i] == arr[i - 1]) flag = false;
printf("%s", flag ? "YES" : "NO");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t;
cin >> t;
while (t--) {
int n, x, num;
cin >> n >> x;
vector<int> cnt(1000, 0);
for (__typeof(0) i = (0); i < (n); i++) {
cin >> num;
cnt[num]++;
}
int i = 1;
for (; i < 1000; i++) {
if (cnt[i] == 0) {
if (x == 0) {
i--;
break;
}
x--;
}
}
cout << i << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s, p;
cin >> s >> p;
long l = s.size();
s += "#";
p += "#";
long x = 0, y = 0;
for (long i = 0; i < l; i++) {
if (s[i] != p[i]) {
if (s[i] == '4')
x++;
else
y++;
}
}
cout << max(x, y);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 51;
mt19937 mt(20050103);
int n, st, x, v, nxt, c, vx, nxtx;
inline int read() {
register int num = 0, neg = 1;
register char ch = getchar();
while (!isdigit(ch) && ch != '-') {
ch = getchar();
}
if (ch == '-') {
neg = -1;
ch = getchar();
}
while (isdigit(ch)) {
num = (num << 3) + (num << 1) + (ch - '0');
ch = getchar();
}
return num * neg;
}
int main() {
n = read(), nxt = st = read(), x = read(), v = -1;
for (register int i = 1; i <= min(n, 1000); i++) {
c = mt() % n + 1, cout << "? " << c << endl, vx = read(), nxtx = read();
vx > v &&vx <= x ? v = vx, nxt = nxtx : 1;
}
if (v == x) {
return cout << "! " << v << endl, 0;
}
for (register int i = 1; i <= 1000; i++) {
if (nxt == -1) {
return cout << "! -1" << endl, 0;
}
cout << "? " << nxt << endl, vx = read(), nxtx = read();
if (vx >= x) {
return cout << "! " << vx << endl, 0;
}
v = vx, nxt = nxtx;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200100, mod = 998244353;
inline int ksm(int a, int b) {
int res = 1;
for (; b; b >>= 1, a = 1ll * a * a % mod)
if (b & 1) res = 1ll * res * a % mod;
return res;
}
int f[maxn], g[maxn], n, k;
vector<int> v[2];
inline int check(const vector<int> &v) {
for (int i = 0; i < (int)v.size(); i++)
if (v[i] != -1) return 0;
return 1;
}
inline int getans(const vector<int> &v) {
if (check(v)) return 1ll * k * ksm(k - 1, v.size() - 1) % mod;
int L = 0, R = v.size() - 1, cnt = 0;
while (v[L] == -1) L++, cnt++;
while (v[R] == -1) R--, cnt++;
int cur = L;
int ans = ksm(k - 1, cnt);
for (;;) {
int l = cur, r = cur;
if (r >= R) break;
while (v[r + 1] == -1) r++;
r++;
if (v[l] == v[r])
ans = 1ll * ans * f[r - l - 1] % mod;
else
ans = 1ll * ans * g[r - l - 1] % mod;
cur = r;
}
return ans;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (i & 1)
v[0].push_back(x);
else
v[1].push_back(x);
}
f[0] = 0;
g[0] = 1;
for (int i = 1; i <= n; i++) {
if (i & 1) {
f[i] = (1ll * f[i >> 1] * f[i >> 1] % mod +
1ll * (k - 1) * g[i >> 1] % mod * g[i >> 1] % mod) %
mod;
g[i] = (2ll * f[i >> 1] * g[i >> 1] % mod +
1ll * (k - 2) * g[i >> 1] % mod * g[i >> 1] % mod) %
mod;
} else {
f[i] = 1ll * (k - 1) * g[i - 1] % mod;
g[i] = (f[i - 1] + 1ll * (k - 2) * g[i - 1] % mod) % mod;
}
}
int ans = 1ll * getans(v[0]) * getans(v[1]) % mod;
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX_N = 1e5 + 5;
long long n, k, ans;
long long Arr[MAX_N];
long long Brr[MAX_N];
long long fenL[MAX_N], fenR[MAX_N];
long long getL(long long tmp) {
long long res = 0;
for (; tmp; tmp -= tmp & -tmp) res += fenL[tmp];
return res;
}
long long getR(long long tmp) {
long long res = 0;
for (; tmp; tmp -= tmp & -tmp) res += fenR[tmp];
return res;
}
void updL(long long val, long long tmp) {
for (; tmp < MAX_N; tmp += tmp & -tmp) fenL[tmp] += val;
}
void updR(long long val, long long tmp) {
for (; tmp < MAX_N; tmp += tmp & -tmp) fenR[tmp] += val;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n >> k;
for (long long i = 0; i < n; i++) {
cin >> Arr[i];
Brr[i] = Arr[i];
}
sort(Brr, Brr + n);
long long len = unique(Brr, Brr + n) - Brr;
for (long long i = 0; i < n; i++)
Arr[i] = 1 + lower_bound(Brr, Brr + len, Arr[i]) - Brr;
long long l = 0, r = n - 1, sum = 0;
updR(+1, Arr[n - 1]);
while (r && sum + getR(Arr[r - 1] - 1) <= k) {
sum += getR(Arr[r - 1] - 1);
updR(+1, Arr[r - 1]);
r--;
}
for (long long i = 0; i < n; i++) {
sum += getR(Arr[i] - 1);
sum += getL(MAX_N - 1) - getL(Arr[i]);
updL(+1, Arr[i]);
if (r == i) {
sum -= getR(Arr[i] - 1);
sum -= getL(MAX_N - 1) - getL(Arr[i]);
updR(-1, Arr[i]);
r++;
}
while (r < n && k < sum) {
sum -= getR(Arr[r] - 1);
sum -= getL(MAX_N - 1) - getL(Arr[r]);
updR(-1, Arr[r]);
r++;
}
ans += n - r;
}
cout << ans << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
bool a[51][51];
int r, c;
cin >> r >> c;
getchar();
for (int i = (0); i < (r); i++) {
for (int j = (0); j < (c); j++) {
char a1 = getchar();
if (a1 == 'W')
a[i][j] = 1;
else
a[i][j] = 0;
}
getchar();
}
vector<pair<int, int> > r1(51);
vector<pair<int, int> > r2(51);
vector<pair<int, int> > c1(51);
vector<pair<int, int> > c2(51);
for (int i = (0); i < (r); i++) {
for (int j = (0); j < (c); j++) {
if (a[i][j] == 0) {
int val = j;
while (j < c && !a[i][j]) j++;
r1[i] = (make_pair(val, j - 1));
r2[i] = (make_pair(j - 1, val));
while (j < c)
if (!a[i][j]) {
cout << "NO\n";
return 0;
} else
j++;
}
}
}
for (int i = (0); i < (c); i++) {
for (int j = (0); j < (r); j++) {
if (a[j][i] == 0) {
int val = j;
while (j < r && !a[j][i]) j++;
c1[i] = make_pair(val, j - 1);
c2[i] = (make_pair(j - 1, val));
while (j < r)
if (!a[j][i]) {
cout << "NO\n";
return 0;
} else
j++;
}
}
}
for (int i = (0); i < (r); i++) {
for (int j = (0); j < (c); j++) {
for (int k = (0); k < (r); k++) {
for (int l = (0); l < (c); l++) {
if (i == k && j == l) continue;
if (a[i][j] || a[k][l]) continue;
if (i <= k && j <= l) {
if ((r1[i].second >= l && c2[l].second <= i) ||
(c1[j].second >= k && r2[k].second <= j))
;
else {
cout << "NO\n";
return 0;
}
} else if (i >= k && j >= l) {
if ((r1[k].second >= j && c2[j].second <= k) ||
(c1[l].second >= i && r2[i].second <= l))
;
else {
cout << "NO\n";
return 0;
}
} else if (i <= k && j >= l) {
if ((r1[k].second >= j && c1[j].second >= k) ||
(c2[l].second <= i && r2[i].second <= l))
;
else {
cout << "NO\n";
return 0;
}
} else if (i >= k && j <= l) {
if ((r1[i].second >= l && c1[l].second >= i) ||
(c2[j].second <= k && r2[k].second <= j))
;
else {
cout << "NO\n";
return 0;
}
}
}
}
}
}
cout << "YES\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, x;
cin >> n;
bool down = true;
for (long long i = 0; i < n; i++) {
cin >> x;
if (x % 2 == 0) {
cout << x / 2 << '\n';
} else {
if (down) {
if (x < 0)
cout << (x - 1) / 2 << '\n';
else
cout << x / 2 << '\n';
} else {
if (x > 0)
cout << (x + 1) / 2 << '\n';
else
cout << x / 2 << '\n';
}
down = !down;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int fa[200010], ch[200010][26], len[200010], cnt = 1, las = 1;
int ls[200010 * 40], rs[200010 * 40], ntot, n;
int nxt[200010 << 1], to[200010 << 1], head[200010], rcnt;
int root[200010];
void insert(int &u, int l, int r, int p) {
if (!u) u = ++ntot;
if (l == r) return;
int mid = (l + r) >> 1;
if (p <= mid)
insert(ls[u], l, mid, p);
else
insert(rs[u], mid + 1, r, p);
}
void insert(int c) {
int p = las, q = las = ++cnt;
len[q] = len[p] + 1;
insert(root[q], 1, n, len[q]);
for (; p && !ch[p][c]; p = fa[p]) ch[p][c] = q;
if (!p)
fa[q] = 1;
else {
int np = ch[p][c];
if (len[np] == len[p] + 1)
fa[q] = np;
else {
int nq = ++cnt;
memcpy(ch[nq], ch[np], sizeof(ch[nq]));
fa[nq] = fa[np];
fa[np] = fa[q] = nq;
len[nq] = len[p] + 1;
for (; p && ch[p][c] == np; p = fa[p]) ch[p][c] = nq;
}
}
}
int answer(int u, int l, int r, int L, int R) {
if (!u || L > R || l > R || L > r) return false;
if (L <= l && r <= R) return true;
int mid = (l + r) >> 1;
return answer(ls[u], l, mid, L, R) || answer(rs[u], mid + 1, r, L, R);
}
int merge(int x, int y) {
if (!x || !y) return x + y;
int u = ++ntot;
ls[u] = merge(ls[x], ls[y]);
rs[u] = merge(rs[x], rs[y]);
return u;
}
void add(int u, int v) {
nxt[++rcnt] = head[u];
to[rcnt] = v;
head[u] = rcnt;
}
void dfs(int u) {
for (int i = head[u]; i; i = nxt[i]) {
int v = to[i];
dfs(v);
root[u] = merge(root[u], root[v]);
}
}
char s[200010];
int zy[200010];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) insert(s[i] - 'a');
for (int i = 2; i <= cnt; i++) add(fa[i], i);
dfs(1);
int m;
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int l, r;
scanf("%d%d", &l, &r);
scanf("%s", s + 1);
int len = strlen(s + 1), u = 1, p;
for (p = 1;; p++) {
zy[p] = -1;
for (int c = p > len ? 0 : s[p] - 'a' + 1; c < 26; c++) {
int v = ch[u][c];
if (v && answer(root[v], 1, n, l + p - 1, r)) {
zy[p] = c;
break;
}
}
int v = p > len ? 0 : ch[u][s[p] - 'a'];
if (!v || p == n + 1 || !answer(root[v], 1, n, l + p - 1, r)) break;
u = v;
}
for (; p && zy[p] == -1; p--)
;
if (!p) {
puts("-1");
continue;
} else {
for (int j = 1; j < p; j++) putchar(s[j]);
putchar('a' + zy[p]);
puts("");
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
string s;
int n, i, kol, ans;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
getline(cin, s);
getline(cin, s);
for (i = 0; i < n; i++) {
if (isupper(s[i]))
kol++;
else if (s[i] == ' ')
kol = 0;
ans = max(ans, kol);
}
cout << ans << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
int N, M;
string s;
int main(void) {
cin >> N >> M >> s;
int cnt = 0;
for (int i = 0; i < (int)(N - 1); ++i)
if (s[i] == '.' and s[i + 1] == '.') cnt++;
for (int mmm = 0; mmm < (int)(M); ++mmm) {
int i;
char c;
cin >> i >> c;
i--;
if (c == '.' and s[i] != '.') {
if (i > 0 and s[i - 1] == '.') cnt++;
if (i < N - 1 and s[i + 1] == '.') cnt++;
}
if (c != '.' and s[i] == '.') {
if (i > 0 and s[i - 1] == '.') cnt--;
if (i < N - 1 and s[i + 1] == '.') cnt--;
}
s[i] = c;
cout << cnt << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> num;
set<int> score;
int main() {
int tc, n, g, s, b, solve[400005];
cin >> tc;
while (tc--) {
cin >> n;
g = s = b = 0;
for (int i = 1; i <= n; i++)
cin >> solve[i], num[solve[i]]++, score.insert(-1 * solve[i]);
for (auto i = score.begin(); i != score.end(); i++) {
if (g == 0) {
g += num[-1 * *i];
} else if (s <= g) {
s += num[-1 * *i];
} else if (b <= g || 2 * (g + s + b) <= n) {
b += num[-1 * *i];
if ((g + s + b) > (n / 2)) {
b -= num[-1 * *i];
break;
}
}
}
if (g + s + b > n / 2)
cout << "0 0 0" << endl;
else if (g >= s || g >= b)
cout << "0 0 0" << endl;
else
cout << g << " " << s << " " << b << endl;
score.clear();
num.clear();
}
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize "O3"
using namespace std;
const char E = '\n';
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
int n;
cin >> n;
string s;
cin >> s;
int mx = 1;
for (int i = 1; i < n; i += 2) {
string s1 = "";
string s2 = "";
for (int j = 0; j <= i / 2; j++) s1 += s[j];
for (int j = i / 2 + 1; j <= i; j++) s2 += s[j];
int q = s1.length();
if (s1 == s2) mx = max(mx, q);
}
cout << n - mx + 1 << E;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int Set(int N, int pos) { return N = N | (1 << pos); }
int reset(int N, int pos) { return N = N & ~(1 << pos); }
bool check(int N, int pos) { return (bool)(N & (1 << pos)); }
int main() {
map<pair<int, int>, pair<int, int> > ob;
int n;
scanf("%d", &n);
double r1 = -1, r2 = -1;
int idx1, idx21, idx22;
for (int i = 1; i <= n; i++) {
int arr[3];
scanf("%d%d%d", &arr[0], &arr[1], &arr[2]);
sort(arr, arr + 3);
double m = arr[0];
m /= 2.0;
if (r1 < m) {
idx1 = i;
r1 = m;
}
long long int sum = 0;
for (int k = 0; k < 3; k++) sum += arr[k];
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j == k) continue;
int A = min(arr[j], arr[k]);
int B = max(arr[j], arr[k]);
int C = sum - (A + B);
if (ob.find(pair<int, int>(A, B)) != ob.end()) {
pair<int, int> p = ob[pair<int, int>(A, B)];
m = min(A, min(B, p.first + C));
m /= 2.0;
if (r2 < m) {
r2 = m;
idx21 = i;
idx22 = p.second;
}
}
}
}
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j == k) continue;
int A = min(arr[j], arr[k]);
int B = max(arr[j], arr[k]);
int C = sum - (A + B);
if (ob.find(pair<int, int>(A, B)) == ob.end()) {
ob[pair<int, int>(A, B)] = pair<int, int>(C, i);
} else if (C > ob[pair<int, int>(A, B)].first) {
ob[pair<int, int>(A, B)] = pair<int, int>(C, i);
}
}
}
}
if (r1 >= r2) {
cout << "1\n" << idx1;
} else {
cout << "2\n" << idx21 << " " << idx22;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1);
int d1[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
int d2[8][2] = {{1, 0}, {0, 1}, {0, -1}, {-1, 0},
{1, 1}, {-1, 1}, {1, -1}, {-1, -1}};
long long cnt(long long a, long long b, long long c) {
long long mx = max((a), max((b), (c)));
return mx - a + mx - b + mx - c;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long b, d, s;
cin >> b >> d >> s;
long long ans = std::numeric_limits<long long>::max();
ans = min(ans, cnt(b + 2, d + 2, s + 2));
ans = min(ans, cnt(b + 1, d + 2, s + 2));
ans = min(ans, cnt(b + 1, d + 1, s + 2));
ans = min(ans, cnt(b + 1, d + 1, s + 1));
ans = min(ans, cnt(b + 2, d + 2, s + 1));
ans = min(ans, cnt(b + 1, d + 2, s + 1));
ans = min(ans, cnt(b + 1, d + 1, s + 1));
ans = min(ans, cnt(b + 1, d + 1, s));
ans = min(ans, cnt(b + 2, d + 1, s + 1));
ans = min(ans, cnt(b + 1, d + 1, s + 1));
ans = min(ans, cnt(b + 1, d, s + 1));
ans = min(ans, cnt(b + 1, d, s));
ans = min(ans, cnt(b, d + 1, s + 1));
ans = min(ans, cnt(b, d, s + 1));
ans = min(ans, cnt(b, d, s));
cout << ans << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void show(T a, int n) {
for (int i = 0; i < n; ++i) cout << a[i] << ' ';
cout << endl;
}
template <class T>
void show(T a, int r, int l) {
for (int i = 0; i < r; ++i) show(a[i], l);
cout << endl;
}
const int N = 120000;
const int M = 120000;
const int oo = 10000 * 10000 * 10;
const double g = 9.8;
double ang[N];
double wx[M], wy[M];
double ax[N], ay[N];
int pd[N];
int wd[M];
int n, m;
double v;
bool pcmp(int i, int j) { return ang[i] < ang[j]; }
bool wcmp(int i, int j) { return wx[i] < wx[j]; }
void solve() {
int i, j, k;
for (i = 0; i < n; ++i) pd[i] = i;
for (j = 0; j < m; ++j) wd[j] = j;
sort(pd, pd + n, pcmp);
sort(wd, wd + m, wcmp);
j = 0;
for (i = 0; i < n; ++i) {
int id = pd[i];
double vx = v * cos(ang[id]);
double vy = v * sin(ang[id]);
double t = 2.0 * vy / g;
double sx = vx * t;
while (j < m) {
int jd = wd[j];
if (wx[jd] <= sx) {
double tt = wx[jd] / vx;
double ty = vy * tt - 0.5 * g * tt * tt;
if (ty <= wy[jd]) {
ax[id] = wx[jd];
ay[id] = ty;
break;
} else
++j;
} else {
ax[id] = sx;
ay[id] = 0;
break;
}
}
if (j == m) {
ax[id] = sx;
ay[id] = 0;
}
}
for (i = 0; i < n; ++i) {
printf("%.10f %.10f\n", ax[i], ay[i]);
}
}
int main() {
int i, j, cas = 0;
scanf("%d", &n);
scanf("%lf", &v);
for (i = 0; i < n; ++i) scanf("%lf", &ang[i]);
scanf("%d", &m);
for (i = 0; i < m; ++i) {
scanf("%lf %lf", &wx[i], &wy[i]);
}
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 6;
int t, n;
vector<int> v(MAX);
vector<bool> check(MAX);
void file_io(char *input, char *output) {
freopen(input, "r", stdin);
freopen(output, "w", stdout);
}
void fast_io() {
ios::sync_with_stdio(false);
cin.tie(0);
}
void input() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> v[i];
}
void solve() {
cout << "YES\n";
int p = 1;
for (int i = 1; i <= n; ++i) {
cout << p << ((i == n) ? " \n" : " ");
for (int j = 1; j <= n; ++j) {
for (int k = 1; k <= n; ++k) {
int l = p + v[j] - v[k];
if (1 <= l and l <= 1000000) check[l] = true;
}
}
while (check[p]) p++;
}
for (int i = 1; i <= 1000000; ++i) check[i] = false;
}
int main() {
fast_io();
cin >> t;
while (t--) {
input();
solve();
}
return 0;
}
| 4 |
#pragma GCC optimize ("O3")
#pragma GCC target ("sse4")
#include <bits/stdc++.h>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/rope>
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
typedef long long ll;
typedef long double ld;
typedef complex<ld> cd;
typedef pair<int, int> pi;
typedef pair<ll,ll> pl;
typedef pair<ld,ld> pd;
typedef vector<int> vi;
typedef vector<ld> vd;
typedef vector<ll> vl;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<cd> vcd;
template <class T> using Tree = tree<T, null_type, less<T>, rb_tree_tag,tree_order_statistics_node_update>;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define F0R(i, a) for (int i = 0; i < (a); i++)
#define FORd(i,a,b) for (int i = (b)-1; i >= (a); i--)
#define F0Rd(i,a) for (int i = (a)-1; i >= 0; i--)
#define trav(a, x) for (auto& a : x)
#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define sz(x) (int)x.size()
#define all(x) begin(x), end(x)
#define rsz resize
const int MOD = 1000000007; // 998244353
const ll INF = 1e18;
const int MX = 200005;
const ld PI = 4*atan((ld)1);
template<class T> void ckmin(T &a, T b) { a = min(a, b); }
template<class T> void ckmax(T &a, T b) { a = max(a, b); }
namespace input {
template<class T> void re(complex<T>& x);
template<class T1, class T2> void re(pair<T1,T2>& p);
template<class T> void re(vector<T>& a);
template<class T, size_t SZ> void re(array<T,SZ>& a);
template<class T> void re(T& x) { cin >> x; }
void re(double& x) { string t; re(t); x = stod(t); }
void re(ld& x) { string t; re(t); x = stold(t); }
template<class Arg, class... Args> void re(Arg& first, Args&... rest) {
re(first); re(rest...);
}
template<class T> void re(complex<T>& x) { T a,b; re(a,b); x = cd(a,b); }
template<class T1, class T2> void re(pair<T1,T2>& p) { re(p.f,p.s); }
template<class T> void re(vector<T>& a) { F0R(i,sz(a)) re(a[i]); }
template<class T, size_t SZ> void re(array<T,SZ>& a) { F0R(i,SZ) re(a[i]); }
}
using namespace input;
namespace output {
template<class T1, class T2> void pr(const pair<T1,T2>& x);
template<class T, size_t SZ> void pr(const array<T,SZ>& x);
template<class T> void pr(const vector<T>& x);
template<class T> void pr(const set<T>& x);
template<class T1, class T2> void pr(const map<T1,T2>& x);
template<class T> void pr(const T& x) { cout << x; }
template<class Arg, class... Args> void pr(const Arg& first, const Args&... rest) {
pr(first); pr(rest...);
}
template<class T1, class T2> void pr(const pair<T1,T2>& x) {
pr("{",x.f,", ",x.s,"}");
}
template<class T> void prContain(const T& x) {
pr("{");
bool fst = 1; for (const auto& a: x) pr(!fst?", ":"",a), fst = 0; // const needed for vector<bool>
pr("}");
}
template<class T, size_t SZ> void pr(const array<T,SZ>& x) { prContain(x); }
template<class T> void pr(const vector<T>& x) { prContain(x); }
template<class T> void pr(const set<T>& x) { prContain(x); }
template<class T1, class T2> void pr(const map<T1,T2>& x) { prContain(x); }
void ps() { pr("\n"); }
template<class Arg> void ps(const Arg& first) {
pr(first); ps(); // no space at end of line
}
template<class Arg, class... Args> void ps(const Arg& first, const Args&... rest) {
pr(first," "); ps(rest...); // print w/ spaces
}
}
using namespace output;
namespace io {
void setIn(string s) { freopen(s.c_str(),"r",stdin); }
void setOut(string s) { freopen(s.c_str(),"w",stdout); }
void setIO(string s = "") {
ios_base::sync_with_stdio(0); cin.tie(0); // fast I/O
if (sz(s)) { setIn(s+".in"), setOut(s+".out"); } // for USACO
}
}
using namespace io;
template<class T> T invGeneral(T a, T b) {
a %= b; if (a == 0) return b == 1 ? 0 : -1;
T x = invGeneral(b,a);
return x == -1 ? -1 : ((1-(ll)b*x)/a+b)%b;
}
template<class T> struct modular {
T val;
explicit operator T() const { return val; }
modular() { val = 0; }
template<class U> modular(const U& v) {
val = (-MOD <= v && v <= MOD) ? v : v % MOD;
if (val < 0) val += MOD;
}
friend ostream& operator<<(ostream& os, const modular& a) { return os << a.val; }
friend bool operator==(const modular& a, const modular& b) { return a.val == b.val; }
friend bool operator!=(const modular& a, const modular& b) { return !(a == b); }
modular operator-() const { return modular(-val); }
modular& operator+=(const modular& m) { if ((val += m.val) >= MOD) val -= MOD; return *this; }
modular& operator-=(const modular& m) { if ((val -= m.val) < 0) val += MOD; return *this; }
modular& operator*=(const modular& m) { val = (ll)val*m.val%MOD; return *this; }
friend modular exp(modular a, ll p) {
modular ans = 1; for (; p; p /= 2, a *= a) if (p&1) ans *= a;
return ans;
}
friend modular inv(const modular& a) {
auto i = invGeneral(a.val,MOD); assert(i != -1);
return i;
} // equivalent to return exp(b,MOD-2) if MOD is prime
modular& operator/=(const modular& m) { return (*this) *= inv(m); }
friend modular operator+(modular a, const modular& b) { return a += b; }
friend modular operator-(modular a, const modular& b) { return a -= b; }
friend modular operator*(modular a, const modular& b) { return a *= b; }
friend modular operator/(modular a, const modular& b) { return a /= b; }
};
typedef modular<int> mi;
typedef pair<mi,mi> pmi;
typedef vector<mi> vmi;
typedef vector<pmi> vpmi;
typedef double T;
namespace Point {
typedef pair<T,T> P;
typedef vector<P> vP;
/*P dir(T ang) {
cd c = exp(ang*cd(0,1));
return P(c.real(),c.imag());
}*/
T norm(P x) { return x.f*x.f+x.s*x.s; }
T abs(P x) { return sqrt(norm(x)); }
T angle(P x) { return atan2(x.s,x.f); }
P conj(P x) { return P(x.f,-x.s); }
P operator+(const P& l, const P& r) { return P(l.f+r.f,l.s+r.s); }
P operator-(const P& l, const P& r) { return P(l.f-r.f,l.s-r.s); }
P operator*(const P& l, const T& r) { return P(l.f*r,l.s*r); }
P operator*(const T& l, const P& r) { return r*l; }
P operator/(const P& l, const T& r) { return P(l.f/r,l.s/r); }
P operator*(const P& l, const P& r) { return P(l.f*r.f-l.s*r.s,l.s*r.f+l.f*r.s); }
P operator/(const P& l, const P& r) { return l*conj(r)/norm(r); }
P& operator+=(P& l, const P& r) { return l = l+r; }
P& operator-=(P& l, const P& r) { return l = l-r; }
P& operator*=(P& l, const T& r) { return l = l*r; }
P& operator/=(P& l, const T& r) { return l = l/r; }
P& operator*=(P& l, const P& r) { return l = l*r; }
P& operator/=(P& l, const P& r) { return l = l/r; }
P unit(P x) { return x/abs(x); }
T dot(P a, P b) { return (conj(a)*b).f; }
T cross(P a, P b) { return (conj(a)*b).s; }
T cross(P p, P a, P b) { return cross(a-p,b-p); }
T dist(P p, P a, P b) { return std::abs(cross(p,a,b))/abs(a-b); }
P rotate(P a, T b) { return a*P(cos(b),sin(b)); }
P reflect(P p, P a, P b) { return a+conj((p-a)/(b-a))*(b-a); }
P foot(P p, P a, P b) { return (p+reflect(p,a,b))/(T)2; }
P extension(P a, P b, P c, P d) {
T x = cross(a,b,c), y = cross(a,b,d);
return (d*x-c*y)/(x-y);
}
// computes the intersection of line segments AB, CD
// verification: https://open.kattis.com/problems/segmentintersection
vP segIntersect(P a, P b, P c, P d) {
if (a > b) swap(a,b);
if (c > d) swap(c,d);
auto a1 = cross(a,b,c), a2 = cross(a,b,d);
if (a1 > a2) swap(a1,a2);
if (!(a1 <= 0 && a2 >= 0)) return {};
if (a1 == 0 && a2 == 0) {
if (cross(a,c,d) != 0) return {};
auto x1 = max(a,c), x2 = min(b,d);
if (x1 > x2) return {};
if (x1 == x2) return {x1};
return {x1,x2};
}
auto z = extension(a,b,c,d);
if (a <= z && z <= b) return {z};
return {};
}
// sorts points according to atan2
// verification: ?
template<class T> int half(pair<T,T> x) { return mp(x.s,x.f) > mp((T)0,(T)0); }
bool cmp(P a, P b) {
int A = half(a), B = half(b);
if (A != B) return A < B;
return cross(a,b) > 0;
}
// computes the center of mass of a polygon with constant mass per unit area
// verification: kattis polygonarea, VT HSPC 2018 Holiday Stars
T area(const vP& v) {
T area = 0;
F0R(i,sz(v)) {
int j = (i+1)%sz(v); T a = cross(v[i],v[j]);
area += a;
}
return std::abs(area)/2;
}
P centroid(const vP& v) {
P cen(0,0); T area = 0; // 2*signed area
F0R(i,sz(v)) {
int j = (i+1)%sz(v); T a = cross(v[i],v[j]);
cen += a*(v[i]+v[j]); area += a;
}
return cen/area/(T)3;
}
// tests whether a point is inside, on, or outside the perimeter of any polygon
// verification: https://open.kattis.com/problems/pointinpolygon
string inPoly(const vP& p, P z) {
int n = sz(p), ans = 0;
F0R(i,n) {
P x = p[i], y = p[(i+1)%n];
if (cross(x,y,z) == 0 && min(x,y) <= z && z <= max(x,y)) return "on";
if (x.s > y.s) swap(x,y);
if (x.s <= z.s && y.s > z.s && cross(z,x,y) > 0) ans ^= 1;
}
return ans ? "in" : "out";
}
pair<P,double> ccCenter(P a, P b, P c) { // circumcenter
b -= a; c -= a;
P res = b*c*(conj(c)-conj(b))/(b*conj(c)-conj(b)*c);
return {a+res,abs(res)};
}
pair<P, double> mec(vP ps) { // minimum enclosing circle, ex. USACO Camp 2019 Contest 2 #4
shuffle(all(ps), mt19937(time(0)));
P o = ps[0]; double r = 0, EPS = 1 + 1e-8;
F0R(i,sz(ps)) if (abs(o-ps[i]) > r*EPS) {
o = ps[i], r = 0;
F0R(j,i) if (abs(o-ps[j]) > r*EPS) {
o = (ps[i]+ps[j])/2, r = abs(o-ps[i]);
F0R(k,j) if (abs(o-ps[k]) > r*EPS)
tie(o,r) = ccCenter(ps[i],ps[j],ps[k]);
}
}
return {o,r};
}
};
using namespace Point;
int k,n;
vP v;
vP group[4], lef;
pair<P,T> circ[4];
pair<P,T> approx(vP v) {
int num = 0;
P sum = {0,0};
F0R(i,50) {
P x = v[rand()%sz(v)], y = v[rand()%sz(v)], z = v[rand()%sz(v)];
if (cross(x,y,z) == 0 || ccCenter(x,y,z).s > 1000000) continue;
sum += ccCenter(x,y,z).f; num ++;
}
sum /= (double)num;
double dist = 0;
trav(t,v) dist += abs(sum-t);
dist /= sz(v);
return {sum,dist};
}
void fin() {
cout << fixed << setprecision(8);
F0R(i,k) ps(circ[i].f.f,circ[i].f.s,circ[i].s);
exit(0);
}
double val(pair<P,T> c, P t) {
double x = abs(c.f-t);
if (x < 0.8*c.s || x > 1.2*c.s) return MOD;
return abs(x-c.s);
}
void test() {
F0R(i,k) group[i].clear();
lef.clear();
F0R(i,n) group[rand()%k].pb(v[i]);
F0R(i,200) {
F0R(j,k) if (sz(group[j]) <= 5) return;
if (i > 0 && sz(lef) == 0) fin();
F0R(j,k) {
circ[j] = approx(group[j]);
group[j].clear();
}
lef.clear();
trav(t,v) {
pair<double,int> bes = {MOD,MOD};
F0R(j,k) ckmin(bes,{val(circ[j],t),j});
if (bes.f == MOD) lef.pb(t);
else group[bes.s].pb(t);
}
}
}
int main() {
setIO(); re(k,n); v.rsz(n*k); re(v);
// ps(v);
while (1) test();
}
/* stuff you should look for
* int overflow, array bounds
* special cases (n=1?), set tle
* do smth instead of nothing and stay organized
*/ | 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long int n;
unsigned long long int ar;
cin >> n >> ar;
ar % n == 0 ? cout << ar / n : cout << ar / n + 1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = long double;
using str = string;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using pd = pair<db, db>;
template <class T>
using V = vector<T>;
template <class T, size_t SZ>
using AR = array<T, SZ>;
template <class T>
using PR = pair<T, T>;
template <class T>
using pqg = priority_queue<T, V<T>, greater<T>>;
using vi = V<int>;
using vb = V<bool>;
using vl = V<ll>;
using vd = V<db>;
using vs = V<str>;
using vpi = V<pi>;
using vpl = V<pl>;
using vpd = V<pd>;
const int MOD = 1e9 + 7;
const int MX = 1010;
const ll INF = 1e18;
const db PI = acos((db)-1);
const vi dx{0, 1, 0, -1}, dy{1, 0, -1, 0};
constexpr int pct(int x) { return __builtin_popcount(x); }
constexpr int bits(int x) { return x == 0 ? 0 : 31 - __builtin_clz(x); }
template <class T, class... U>
void pr(T&& a, U&&... b) {
cout << forward<T>(a);
(int[]){(cout << " " << forward<U>(b), 0)...};
cout << "\n";
}
template <class T, class... U>
void re(T&& a, U&&... b) {
cin >> forward<T>(a);
(int[]){(cin >> forward<U>(b), 0)...};
}
void DBG() { cerr << "]" << endl; }
template <class H, class... T>
void DBG(H h, T... t) {
cerr << to_string(h);
if (sizeof...(t)) cerr << ", ";
DBG(t...);
}
void setIO(str S = "") {
cin.tie(0)->sync_with_stdio(0);
if ((int)(S).size()) {
freopen((S + ".in").c_str(), "r", stdin);
freopen((S + ".out").c_str(), "w", stdout);
}
}
void solve(int tc) {
ll n, m;
re(n, m);
vi cnt(61);
ll sum = 0;
for (int i = (0); i < (m); ++i) {
int a;
re(a);
sum += a;
++cnt[bits(a)];
}
if (sum < n) {
pr(-1);
return;
}
int ans = 0;
for (int i = (0); i < (bits(n) + 1); ++i) {
if (n >> i & 1) {
if (cnt[i] == 0) {
int j = i + 1;
while (cnt[j] == 0) ++j;
--cnt[j];
while (--j >= i) {
++cnt[j], ++ans;
}
}
--cnt[i];
}
cnt[i + 1] += cnt[i] / 2;
}
pr(ans);
}
int main() {
setIO();
int TC;
re(TC);
for (int i = (1); i < (TC + 1); ++i) solve(i);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool isprime(int n) {
if (n < 2) return false;
if (n == 2) return true;
for (int i = 2; i <= sqrt(n); i++)
if (n % i == 0) return false;
return true;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
double d, l, v1, v2;
cin >> d >> l >> v1 >> v2;
l -= d;
l /= 2;
cout << setprecision(20) << fixed << l / ((v1 + v2) / 2) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long m, w;
int bi[1000];
int pos = 0;
int main() {
cin >> w >> m;
while (m) {
bi[++pos] = m % w;
m /= w;
}
for (int i = 1; i <= pos; i++) {
if (bi[i] != 1 && bi[i] != w && bi[i] != w - 1 && bi[i] != 0) {
cout << "NO";
return 0;
}
if (bi[i] == w || bi[i] == w - 1) {
++bi[i + 1];
}
}
cout << "YES";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
vector<long long> v;
v.push_back(2);
for (int i = 2;; ++i) {
long long ans = v.back() + 3 * (i - 1) + 2;
v.push_back(ans);
if (ans > 1e9) break;
}
while (t--) {
long long n;
cin >> n;
long long ans = 0;
while (n >= 2) {
auto x = upper_bound(v.begin(), v.end(), n);
x--;
ans += (n / *x);
n = (n % *x);
}
cout << ans << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int N;
cin >> N;
vector<int> T(N), H(N);
for (int i = 0; i < N; i++) {
cin >> T[i];
}
for (int i = 0; i < N; i++) {
cin >> H[i];
}
long long ans = 0;
vector<vector<int>> adj(N);
vector<int> in(N), out(N);
for (int i = 0; i < N - 1; i++) {
int u, v;
cin >> u >> v;
u--, v--;
ans += T[u] + T[v];
if (H[u] == H[v]) {
adj[u].push_back(v);
adj[v].push_back(u);
} else {
if (H[u] > H[v]) swap(u, v);
out[u]++, in[v]++;
}
}
vector<long long> up(N), down(N);
vector<bool> vis(N);
function<void(int, int)> dfs = [&](int cur, int fa) {
vis[cur] = 1;
vector<long long> vals{0};
long long sum = 0;
for (int nxt : adj[cur]) {
if (nxt != fa) {
dfs(nxt, cur);
sum += down[nxt];
vals.push_back(up[nxt] - down[nxt]);
}
}
int child = (int)vals.size() - 1;
sort(vals.begin() + 1, vals.end(), greater<long long>());
for (int i = 0; i < (int)vals.size(); i++) {
sum += vals[i];
if (~fa) {
down[cur] = max(
down[cur],
1LL * min(in[cur] + 1 + i, out[cur] + child - i) * T[cur] + sum);
up[cur] = max(
up[cur],
1LL * min(in[cur] + i, out[cur] + 1 + child - i) * T[cur] + sum);
} else {
down[cur] =
max(down[cur],
1LL * min(in[cur] + i, out[cur] + child - i) * T[cur] + sum);
}
}
};
for (int i = 0; i < N; i++) {
if (!vis[i]) {
dfs(i, -1);
ans -= down[i];
}
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int l, r;
} sl[100005], sr[100005];
bool cmpl(node x, node y) { return x.l < y.l; }
bool cmpr(node x, node y) { return x.r < y.r; }
int n, m, a[100005], nowl, nowr, d[100005], lzy[600005];
bool mark[600005];
void doit(int ind, int l, int r) {
mark[ind] ^= 1;
lzy[ind] = r - l + 1 - lzy[ind];
}
void pushdown(int ind, int l, int r) {
if (!mark[ind]) return;
doit(ind << 1, l, l + r >> 1);
doit(ind << 1 ^ 1, (l + r >> 1) + 1, r);
mark[ind] = false;
}
void modify(int ind, int l, int r, int left, int right) {
if (l >= left && r <= right) {
doit(ind, l, r);
return;
}
if (l > right || r < left) return;
pushdown(ind, l, r);
modify(ind << 1, l, l + r >> 1, left, right);
modify(ind << 1 ^ 1, (l + r >> 1) + 1, r, left, right);
lzy[ind] = lzy[ind << 1] + lzy[ind << 1 ^ 1];
}
int ask(int ind, int l, int r, int left, int right) {
if (l >= left && r <= right) return lzy[ind];
if (l > right || r < left) return 0;
pushdown(ind, l, r);
return ask(ind << 1, l, l + r >> 1, left, right) +
ask(ind << 1 ^ 1, (l + r >> 1) + 1, r, left, right);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &sl[i].l, &sl[i].r);
sl[i].l = lower_bound(a + 1, a + n + 1, sl[i].l) - a;
sl[i].r = upper_bound(a + 1, a + n + 1, sl[i].r) - a - 1;
if (sl[i].l > sl[i].r) --m, --i;
sr[i] = sl[i];
}
sort(sl + 1, sl + m + 1, cmpl);
sort(sr + 1, sr + m + 1, cmpr);
long long ans = 1ll * n * (n - 1) * (n - 2) / 6;
for (int i = 1; i <= n; i++) {
while (nowl < m && sl[nowl + 1].l == i) {
nowl++;
modify(1, 1, n, sl[nowl].l, sl[nowl].r);
}
d[i] = ask(1, 1, n, i + 1, n) + (i - 1 - ask(1, 1, n, 1, i - 1));
ans -= 1ll * d[i] * (d[i] - 1) / 2;
while (nowr < m && sr[nowr + 1].r == i) {
nowr++;
modify(1, 1, n, sr[nowr].l, sr[nowr].r);
}
}
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2 * 100005;
bool vis[maxn], par[maxn];
vector<int> edge[maxn];
pair<int, int> seg[maxn];
int n;
void add(int a, int b) { edge[a].push_back(b), edge[b].push_back(a); }
void dfs(int x, int cur) {
if (vis[x]) return;
vis[x] = true;
par[x] = cur;
for (int i = 0; i < edge[x].size(); i++) dfs(edge[x][i], cur ^ 1);
}
int main() {
scanf("%d", &n);
for (int i = 0, l, r; i < n; i++) {
scanf("%d%d", &l, &r);
add(i * 2, i * 2 + 1);
seg[i * 2] = make_pair(l, i * 2);
seg[i * 2 + 1] = make_pair(r + 1, i * 2 + 1);
}
sort(seg, seg + 2 * n);
for (int i = 0; i < n; i++) {
add(seg[i * 2].second, seg[i * 2 + 1].second);
}
memset(vis, false, sizeof(vis));
memset(par, 0, sizeof(par));
for (int i = 0; i < 2 * n; i++)
if (!vis[i]) dfs(i, 0);
for (int i = 0; i < n; i++) printf("%d ", par[i * 2]);
printf("\n");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 7;
const int inf = 1e9 + 7;
const long double eps = 1e-6;
int gcd(int a, int b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
signed main() {
int m;
cin >> m;
vector<int> s(m);
for (auto(i) = (0); (i) < (m); ++i) cin >> s[i];
int mn = s[0];
int k = mn;
for (auto(i) = (1); (i) < (m); ++i) {
k = gcd(k, s[i]);
}
if (k != mn) {
cout << -1;
return 0;
}
int n = 2 * (m - 1) + 1;
cout << n << endl;
cout << mn << ' ';
for (auto(i) = (1); (i) < (m); ++i) {
cout << s[i] << ' ' << mn << ' ';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using ll = long long;
const ll MOD = 998244353;
const int INF = (ll)1e9 + 7;
const ll INFLL = (ll)1e18;
using namespace std;
template <class t>
using vvector = vector<vector<t>>;
template <class t>
using vvvector = vector<vector<vector<t>>>;
template <class t>
using priority_queuer = priority_queue<t, vector<t>, greater<t>>;
template <class t, class u>
bool chmax(t &a, u b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class t, class u>
bool chmin(t &a, u b) {
if (a > b) {
a = b;
return true;
}
return false;
}
namespace templates {
ll modpow(ll x, ll b) {
ll res = 1;
while (b) {
if (b & 1) res = res * x % MOD;
x = x * x % MOD;
b >>= 1;
}
return res;
}
ll modinv(ll x) { return modpow(x, MOD - 2); }
bool was_output = false;
template <class t>
void output(t a) {
if (was_output) cout << " ";
cout << a;
was_output = true;
}
void outendl() {
was_output = false;
cout << endl;
}
ll in() {
ll res;
scanf("%lld", &res);
return res;
}
template <class t>
istream &operator>>(istream &is, vector<t> &x) {
for (auto &i : x) is >> i;
return is;
}
template <class t, class u>
istream &operator>>(istream &is, pair<t, u> &x) {
is >> x.first >> x.second;
return is;
}
template <class t>
void in(t &x) {
cin >> x;
}
template <class t>
t in() {
t res;
cin >> res;
return res;
}
template <class t>
void out(t x) {
cout << x;
}
template <class t>
vector<t> sorted(
vector<t> line,
function<bool(t, t)> comp = [](t a, t b) { return a < b; }) {
sort(line.begin(), line.end(), comp);
return line;
}
template <class t>
vector<t> reversed(vector<t> line) {
reverse(line.begin(), line.end());
return line;
}
} // namespace templates
using namespace templates;
void func() {
int n = in();
int m = in();
vvector<int> edges(n);
for (int i = (m) * (strlen("") != 0); i < (int)(strlen("") ?: (m)); ++i) {
int a = in() - 1;
int b = in() - 1;
edges[a].emplace_back(b);
}
vector<int> ans;
vector<int> cnt(n, 0);
for (int i = (n) * (strlen("") != 0); i < (int)(strlen("") ?: (n)); ++i) {
if (cnt[i] == 2) {
ans.emplace_back(i);
continue;
}
for (auto &edge : (edges[i])) {
chmax(cnt[edge], cnt[i] + 1);
}
}
cout << ans.size() << endl;
for (auto &i : (ans)) {
output(i + 1);
}
outendl();
}
int main() {
int n = in();
for (int i = (n) * (strlen("") != 0); i < (int)(strlen("") ?: (n)); ++i) {
func();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0, k = 0;
cin >> n >> k;
vector<int> p(n);
for (int i = 0; i < n; i++) {
cin >> p[i];
}
vector<int> c(256);
vector<bool> used(256, false);
for (int i = 0; i < 256; i++) {
c[i] = i;
}
vector<int> ans(n, 0);
for (int i = 0; i < n; i++) {
if (used[p[i]]) {
continue;
} else {
int t = p[i];
used[t] = true;
while (t - 1 >= 0 && p[i] - t + 1 < k && !used[t - 1]) {
used[t] = true;
t--;
used[t] = true;
}
if (p[i] - t == k - 1) {
for (int j = t; j <= p[i]; j++) {
c[j] = t;
}
} else if (t == 0) {
for (int j = t; j <= p[i]; j++) {
c[j] = 0;
}
} else if (used[t - 1]) {
if (p[i] - c[t - 1] < k) {
for (int j = t; j <= p[i]; j++) {
c[j] = c[t - 1];
}
} else {
for (int j = t; j <= p[i]; j++) {
c[j] = t;
}
}
}
}
}
for (int i = 0; i < n; i++) {
cout << c[p[i]] << ' ';
}
cout << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5005;
const int maxl = 105;
double dp[maxn][maxn];
int n, tot;
int t[maxn];
int p[maxn];
double ans;
int main() {
cin >> n >> tot;
for (int i = 1; i <= n; i++) {
cin >> p[i] >> t[i];
}
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
double now = 0;
double pp = 0.01 * p[i];
double r = pow(1 - pp, t[i] - 1);
for (int j = 1; j <= tot; j++) {
now *= 1 - pp;
now += pp * dp[i - 1][j - 1];
if (j >= t[i]) {
now -= pp * r * dp[i - 1][j - t[i]];
now += r * dp[i - 1][j - t[i]];
if (j - t[i] - 1 >= 0) now -= (1 - pp) * r * dp[i - 1][j - t[i] - 1];
}
dp[i][j] = now;
}
for (int j = 1; j <= tot; j++) ans += dp[i][j];
}
printf("%.9lf", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void splitstr(const string &s, vector<T> &out) {
istringstream in(s);
out.clear();
copy(istream_iterator<T>(in), istream_iterator<T>(), back_inserter(out));
}
template <class T>
T read_value(string s) {
T result;
istringstream sin(s);
sin >> result;
return result;
}
string read_line() {
string ret_val;
getline(std::cin, ret_val);
return ret_val;
}
template <class T>
void init_array(T *arr, int size, T value) {
for (int i = 0; i < size; i++) arr[i] = value;
}
template <class T>
inline T gcd(T a, T b) {
return (!a) ? b : gcd(b % a, a);
}
template <class T>
inline T mod(T a, T p) {
a %= p;
return (a < 0) ? a + p : a;
}
template <class T>
inline int numbits(T n) {
return (!n) ? 0 : 1 + numbits(n & (n - 1));
}
template <class T>
inline T inverse(T a, T m) {
a = mod<T>(a, m);
return (a == 1) ? 1 : mod((1 - m * inverse(m % a, a)) / a, m);
}
template <class T>
inline bool is_prime(T a) {
T lim = (T)sqrt((double)a);
for (T i = 2; i <= T(lim + 1E-9); i++)
if (a % i == 0) return false;
return true;
}
template <class T>
inline T power(T a, T p, T mod) {
if (!p) return 1;
T temp = power(a, p >> 1, mod);
temp = (temp * temp) % mod;
if (p & 1) temp = (temp * a) % mod;
return temp;
}
void get_primes(int start, int end, vector<int> &vi) {
bool *p = new bool[end + 1];
init_array<bool>(p, end + 1, 0);
p[1] = 1;
for (int i = 2; i <= end; i++) {
if (!p[i]) {
if (i >= start) vi.push_back(i);
for (int j = 2 * i; j <= end; j += i) p[j] = 1;
}
}
delete[] p;
}
bool dfs(int current, int final, int total, vector<int> &visited,
vector<vector<bool> > &edges, bool flow) {
if (current == final) return true;
if (visited[current]) return false;
visited[current] = true;
for (int i = 0; i < total; i++)
if (edges[current][i] && dfs(i, final, total, visited, edges, flow)) {
if (flow) {
edges[current][i] = false;
edges[i][current] = true;
}
return true;
}
return false;
}
int flow(int in, int out, int total, vector<vector<bool> > &edges) {
int result = 0;
for (vector<int> visited(total, 0); dfs(in, out, total, visited, edges, true);
++result)
visited = vector<int>(total, 0);
return result;
}
void create_set(int x, int *P, int *rank) {
P[x] = x;
rank[x] = 0;
}
int find_set(int x, int *P) {
if (x != P[x]) P[x] = find_set(P[x], P);
return P[x];
}
bool merge_sets(int x, int y, int *P, int *rank) {
int Px = find_set(x, P);
int Py = find_set(y, P);
if (Px == Py) return false;
if (rank[Px] > rank[Py])
P[Py] = Px;
else
P[Px] = Py;
if (rank[Px] == rank[Py]) rank[Py]++;
return true;
}
template <typename T>
int read_cum_freq(int index, T *tree) {
int sum = 0;
while (index) {
sum += tree[index];
index -= (index & -index);
}
return sum;
}
template <typename T>
void upd_freq(int index, int mxIndex, int value, T *tree) {
while (index <= mxIndex) {
tree[index] += value;
index += (index & -index);
}
}
template <typename T>
int read_freq(int index, T *tree) {
return read_cum_freq(index, tree) - read_cum_freq(index - 1, tree);
}
void build_failure_function(const string &str, int *temp_arr) {
temp_arr[0] = temp_arr[1] = 0;
for (int i = 2; i <= ((int)(str).size()); i++) {
temp_arr[i] = -1;
for (int ind = temp_arr[i - 1]; temp_arr[i] == -1; ind = temp_arr[ind]) {
if (str[ind] == str[i - 1]) {
temp_arr[i] = ind + 1;
} else if (ind == 0) {
temp_arr[i] = 0;
}
}
}
}
void KMP(const string &text, const string &pattern, int *res) {
int *temp_arr = new int[((int)(pattern).size()) + 1];
build_failure_function(pattern, temp_arr);
int i = 0;
int ind = 0;
while (i < ((int)(text).size())) {
if (text[i] == pattern[ind]) {
res[i] = ++ind;
if (res[i] == ((int)(pattern).size())) {
ind = temp_arr[ind];
}
i++;
} else if (ind == 0) {
res[i++] = 0;
} else {
ind = temp_arr[ind];
}
}
delete[] temp_arr;
}
template <typename T, int N>
struct matrix {
T m[N][N];
T md;
matrix(T md, bool unary = false) {
this->md = md;
memset(m, 0, sizeof(m));
if (unary) {
for (int i = 0; i < N; i++) {
m[i][i] = 1;
}
}
}
matrix operator*(const matrix &that) const {
matrix ret_val(md, false);
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
for (int k = 0; k < N; k++) {
ret_val.m[i][j] += this->m[i][k] * that.m[k][j];
ret_val.m[i][j] %= md;
}
}
}
return ret_val;
}
vector<T> operator*(const vector<T> &vec) const {
vector<T> ret_val(vec.size(), 0);
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
ret_val[i] += m[i][j] * vec[j];
ret_val[i] %= md;
}
}
return ret_val;
}
matrix power(int pw) const {
if (!pw) return matrix(md, true);
if (pw == 1) return *this;
matrix ret_val = power(pw >> 1);
ret_val = ret_val * ret_val;
if (pw & 1) ret_val = ret_val * (*this);
return ret_val;
}
};
void setup(int value, string name) {
string name_in = name + ".in";
string name_out = name + ".out";
freopen(name_in.c_str(), "r", stdin);
if (value) freopen(name_out.c_str(), "w", stdout);
}
long long go(long long from, long long step, long long num, long long f,
long long l, long long u, long long v, long long mod) {
long long last = from + step * num - step;
if (last < u || from > v) return 0;
if (num == l - f + 1) {
u = ((u - from + step - 1) / step * step) + from;
v = ((v - from) / step * step) + from;
u = max(u, from);
v = min(v, last);
num = (v - u) / step + 1;
long long sum = u + v;
if (sum & 1)
num >>= 1;
else
sum >>= 1;
return ((sum % mod) * (num % mod)) % mod;
}
long long odd = (num >> 1) + (num & 1);
long long even = (num >> 1);
if (f > odd)
return go(from + step, step << 1, even, f - odd, l - odd, u, v, mod);
if (l <= odd) return go(from, step << 1, odd, f, l, u, v, mod);
return (go(from, step << 1, odd, f, odd, u, v, mod) +
go(from + step, step << 1, even, 1, l - odd, u, v, mod)) %
mod;
}
int main() {
long long n, m, mod, f, l, u, v;
std::cin >> n >> m >> mod;
for (int i = 0; i < m; ++i) {
scanf("%I64d %I64d %I64d %I64d", &f, &l, &u, &v);
printf("%I64d\n", go(1, 1, n, f, l, u, v, mod));
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
string str;
int main() {
int N;
cin >> N;
cin >> str;
int ans = 0;
for (int i = 0; i < N; ++i)
if (str[i] == '<')
++ans;
else
break;
for (int i = N - 1; i >= 0; --i)
if (str[i] == '>')
++ans;
else
break;
cout << ans << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool debug = false;
int n, m, k;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
long long ln, lk, lm;
int a[10];
bool v[9], vv[9];
bool walk(int x) {
v[x] = 1;
if (a[x] == 1 || vv[a[x]]) return vv[x] = 1;
if (v[a[x]]) return 0;
return vv[x] = walk(a[x]);
}
bool ck() {
for (int i = 2; i <= k; i++) {
v[i] = 0;
vv[i] = 0;
}
for (int i = 2; i <= k; i++)
if (!v[i]) {
if (!walk(i)) {
return 0;
}
}
return 1;
}
long long tmp;
void dfs(int x) {
if (x == k + 1) {
if (ck()) tmp++;
return;
}
for (int(i) = 1; (i) <= (int)(k); (i)++)
if (i != x) {
a[x] = i;
dfs(x + 1);
}
}
int main() {
scanf("%d%d", &n, &k);
long long ans = k;
dfs(2);
(ans *= tmp) %= 1000000007;
m = n - k;
for (int i = k + 1; i <= n; i++) {
(ans *= m) %= 1000000007;
}
printf("%lld\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
std::vector<double> q(n);
for (int i = 0; i < n; ++i) {
int p;
scanf("%d", &p);
q[i] = 1. - p / 100.;
}
if (n == 1) {
puts("1");
} else {
std::vector<double> pw(n);
for (int i = 0; i < n; ++i) {
pw[i] = q[i];
}
std::priority_queue<std::pair<double, int>> h;
for (int i = 0; i < n; ++i) {
h.push({(1. - pw[i] * q[i]) / (1 - pw[i]), i});
}
double pd = 1.;
for (int i = 0; i < n; ++i) {
pd *= 1 - pw[i];
}
double result = n + 1 - pd;
while (1 - pd > 1e-12) {
std::pair<double, int> t = h.top();
h.pop();
pd *= t.first;
result += 1 - pd;
int i = t.second;
pw[i] *= q[i];
h.push({(1. - pw[i] * q[i]) / (1 - pw[i]), i});
}
printf("%.10f\n", result);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long int a[1000009];
int main() {
long long int n, d, j = 1, num = 0;
scanf("%I64d %I64d", &n, &d);
for (int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
}
for (int i = 1; i <= n; i++) {
while (a[i] - a[j] > d && j <= n) {
j++;
}
num += (i - j) * (i - j - 1) / 2;
}
printf("%I64d", num);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void P1(int n, char A[]) {
for (int i = 0; i < n; i++) {
int x = A[i] - '0' + 1;
if (x == 10)
A[i] = '0';
else
A[i] = x + '0';
}
return;
}
void P2(int n, char A[]) {
char aux[1001] = {};
aux[0] = A[0];
strcpy(A, A + 1);
A[n - 1] = aux[0];
return;
}
void compara(int n, char A[], char mini[]) {
if (strcmp(A, mini) < 0) strcpy(mini, A);
return;
}
int main() {
int n;
cin >> n;
char A[1001], mini[1001] = {};
cin >> A;
strcpy(mini, A);
for (int i = 0; i < n; i++) {
P2(n, A);
for (int j = 1; j <= 10; j++) {
P1(n, A);
compara(n, A, mini);
}
}
cout << mini;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 500010;
long long n, k;
long long dp[N][2];
vector<pair<long long, long long>> g[N];
void dfs(long long v, long long p) {
vector<pair<long long, long long>> s;
for (auto [w, u] : g[v]) {
if (u != p) {
dfs(u, v);
s.emplace_back(dp[u][1] + w, dp[u][0]);
}
}
sort(s.begin(), s.end(),
[&](const pair<long long, long long> &p1,
const pair<long long, long long> &p2) {
return p1.first - p1.second > p2.first - p2.second;
});
dp[v][0] = 0;
dp[v][1] = 0;
for (long long i = 0; i < (long long)s.size(); i++) {
if (i < k && s[i].first > s[i].second) {
dp[v][0] += s[i].first;
} else {
dp[v][0] += s[i].second;
}
if (i < k - 1 && s[i].first > s[i].second) {
dp[v][1] += s[i].first;
} else {
dp[v][1] += s[i].second;
}
}
}
void solve() {
cin >> n >> k;
for (long long i = 0; i < n - 1; i++) {
long long v, u, w;
cin >> v >> u >> w;
v--;
u--;
g[v].emplace_back(w, u);
g[u].emplace_back(w, v);
}
dfs(0, -1);
cout << dp[0][0] << '\n';
for (long long i = 0; i < n; i++) {
g[i].clear();
g[i].shrink_to_fit();
}
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long q;
cin >> q;
while (q--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n, par[maxn], fen[maxn];
map<char, int> vowel;
int get(int val, int idx) {
int now = 0;
for (int i = 20; i >= 0; i--) {
if (now + (1 << i) > n + 1) continue;
if (val < fen[now + (1 << i)]) now += (1 << i);
}
return idx - now;
}
void add(int idx, int val) {
idx++;
for (; idx <= n + 1; idx += idx & -idx) fen[idx] = min(fen[idx], val);
}
int main() {
ios_base::sync_with_stdio(false);
memset(fen, 63, sizeof fen);
string s;
cin >> s;
n = s.size();
vowel['A'] = vowel['a'] = vowel['O'] = vowel['o'] = vowel['E'] = vowel['e'] =
vowel['U'] = vowel['u'] = vowel['I'] = vowel['i'] = 1;
for (int i = 1; i <= n; i++) {
if (vowel[s[i - 1]] == 1)
par[i] = -1;
else
par[i] = 2;
par[i] += par[i - 1];
}
int mx = -1;
add(0, 0);
for (int i = 1; i <= n; i++) {
if (par[i] >= 0)
mx = i;
else
mx = max(mx, get(par[i], i));
add(i, par[i]);
}
if (mx == -1) return cout << "No solution\n", 0;
cout << mx << " ";
int cnt = 0;
for (int i = mx; i <= n; i++)
if (par[i] - par[i - mx] >= 0) cnt++;
cout << cnt << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int s[1000005];
int n, m;
int main() {
int i, j, k, t1, t2, t3;
long long l1, l2, l3;
while (scanf("%d%d", &n, &m) != EOF) {
memset(s, 0, sizeof(s));
for (i = 0; i != m; ++i) {
scanf("%d%d", &t1, &t2);
++s[t1];
++s[t2];
}
l1 = 0;
for (i = 1; i != n + 1; ++i) {
l1 += s[i] * (n - 1 - s[i]);
}
l1 /= 2;
l2 = (long long)(n) * (n - 1) * (n - 2) / 6;
printf("%I64d\n", l2 - l1);
}
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.