solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long int xx1, yy1, xx2, yy2, xx3, yy3, xx4, yy4, n, m, xx5, yy5, xx6, yy6;
void input() {
long long int i, j;
scanf("%lld %lld", &n, &m);
scanf("%lld %lld", &xx1, &yy1);
scanf("%lld %lld", &xx2, &yy2);
scanf("%lld %lld", &xx3, &yy3);
scanf("%lld %lld", &xx4, &yy4);
xx5 = max(xx1, xx3);
yy5 = max(yy1, yy3);
xx6 = min(xx2, xx4);
yy6 = min(yy2, yy4);
}
long long int getwhite(long long int xxx1, long long int yyy1,
long long int xxx2, long long int yyy2) {
if (xxx1 > xxx2 || yyy1 > yyy2) {
return 0;
}
long long int ret;
if ((xxx1 + yyy1) % 2 == 0) {
ret = ((xxx2 - xxx1 + 1 + 1) / 2) * ((yyy2 - yyy1 + 1 + 1) / 2) +
((xxx2 - xxx1 + 1) / 2) * ((yyy2 - yyy1 + 1) / 2);
} else {
ret = ((xxx2 - xxx1 + 1) / 2) * ((yyy2 - yyy1 + 1 + 1) / 2) +
((xxx2 - xxx1 + 1 + 1) / 2) * ((yyy2 - yyy1 + 1) / 2);
}
return ret;
}
long long int getblack(long long int xxx1, long long int yyy1,
long long int xxx2, long long int yyy2) {
long long int ret;
if (xxx1 > xxx2 || yyy1 > yyy2) {
return 0;
}
if ((xxx1 + yyy1) % 2 == 1) {
ret = ((xxx2 - xxx1 + 1 + 1) / 2) * ((yyy2 - yyy1 + 1 + 1) / 2) +
((xxx2 - xxx1 + 1) / 2) * ((yyy2 - yyy1 + 1) / 2);
} else {
ret = ((xxx2 - xxx1 + 1) / 2) * ((yyy2 - yyy1 + 1 + 1) / 2) +
((xxx2 - xxx1 + 1 + 1) / 2) * ((yyy2 - yyy1 + 1) / 2);
}
return ret;
}
void solve() {
long long int w1, b1, w2, b2, wi, bi, wu, bu, wt, bt, ws, bs;
wt = getwhite(1, 1, m, n);
bt = getblack(1, 1, m, n);
w1 = getwhite(xx1, yy1, xx2, yy2);
b1 = getblack(xx1, yy1, xx2, yy2);
w2 = getwhite(xx3, yy3, xx4, yy4);
b2 = getblack(xx3, yy3, xx4, yy4);
wi = getwhite(xx5, yy5, xx6, yy6);
bi = getblack(xx5, yy5, xx6, yy6);
wu = w1 + w2 - wi;
bu = b1 + b2 - bi;
wt -= wu;
bt -= bu;
ws = wu + bu - w2 - b2;
bs = w2 + b2;
wt += ws;
bt += bs;
printf("%lld %lld", wt, bt);
puts("");
}
int main() {
long long int cs, ts;
scanf("%lld", &ts);
for (cs = 0; cs < ts; cs++) {
input();
solve();
}
}
| 3 |
#include <bits/stdc++.h>
const int MAXN = 100010;
const int mod1 = 1234577, mod2 = 1004535809;
const int bse1 = 12243, bse2 = 31873;
std::mt19937 rd(time(0));
struct hash {
int x, y;
hash() { x = y = 0; }
hash(int a, int b) { x = a, y = b; }
void front(const hash& a) {
x = ((long long)x * bse1 + a.x) % mod1,
y = ((long long)y * bse2 + a.y) % mod2;
}
void back(const hash& a, const hash& b) {
x = ((long long)a.x * b.x + x) % mod1;
y = ((long long)a.y * b.y + y) % mod2;
}
} ch[256], pw[MAXN];
void init() {
for (int i = 0; i < 256; ++i) ch[i].x = rd() % mod1, ch[i].y = rd() % mod2;
pw[0].x = pw[0].y = 1;
for (int i = 1; i != MAXN; ++i) {
pw[i].x = (long long)pw[i - 1].x * bse1 % mod1;
pw[i].y = (long long)pw[i - 1].y * bse2 % mod2;
}
}
int head[MAXN], nxt[MAXN], fa[MAXN], fae[MAXN];
int n, Q;
int up[17][MAXN], dep[MAXN];
namespace graph {
struct _ {
int to, nxt, v;
} es[MAXN << 1];
int tot, head[MAXN];
void dfs(int u) {
up[0][u] = fa[u];
for (int i = 1; i != 17; ++i) up[i][u] = up[i - 1][up[i - 1][u]];
for (int i = head[u]; i; i = es[i].nxt) {
const int v = es[i].to;
if (v != fa[u]) {
dep[v] = dep[u] + 1;
fa[v] = u;
fae[v] = es[i].v;
nxt[v] = ::head[u];
::head[u] = v;
dfs(v);
}
}
}
void init() {
for (int i = 1, b, e; i < n; ++i) {
static char buf[10];
std::cin >> b >> e >> buf;
es[++tot] = (_){e, head[b], *buf};
head[b] = tot;
es[++tot] = (_){b, head[e], *buf};
head[e] = tot;
}
dfs(1);
}
} // namespace graph
inline int jump(int x, int y) {
for (int i = 16, t = dep[x] - y; ~i; --i)
if (t >> i & 1) x = up[i][x];
return x;
}
inline int LCA(int x, int y) {
if (dep[x] < dep[y]) std::swap(x, y);
if ((x = jump(x, dep[y])) == y) return x;
for (int i = 16; ~i; --i)
if (up[i][x] != up[i][y]) x = up[i][x], y = up[i][y];
return up[0][x];
}
hash qstr[MAXN], up1[MAXN], up2[MAXN];
int pcur[MAXN];
int ansl[MAXN];
struct QR {
int x, y, id, c;
};
std::vector<QR> qs[MAXN];
QR th[MAXN << 1], tq[MAXN << 1];
int buc[MAXN];
struct hashtable {
int head[mod1], tot;
struct _ {
int nxt, key;
} es[MAXN << 1];
int getid(const hash& x, bool nx = true) {
for (int i = head[x.x]; i; i = es[i].nxt)
if (es[i].key == x.y) return i;
if (nx) {
es[++tot] = (_){head[x.x], x.y};
return head[x.x] = tot;
}
return 0;
}
} ha0, ha1;
int hav0[MAXN], hav1[MAXN];
void dfs2(int u) {
int h0 = ha0.getid(up1[u]), h1 = ha1.getid(up2[u]);
++hav0[h0], ++hav1[h1];
for (int i = buc[u] + 1; i <= buc[u + 1]; ++i) {
int hx = (tq[i].y == 1 ? ha0 : ha1).getid(qstr[tq[i].id], false);
ansl[tq[i].id] += (tq[i].y == 1 ? hav0[hx] : hav1[hx]) * tq[i].c;
}
for (int i = head[u]; i; i = nxt[i]) dfs2(i);
--hav0[h0], --hav1[h1];
}
int main() {
std::ios_base::sync_with_stdio(false), std::cin.tie(0);
init();
std::cin >> n;
graph::init();
std::cin >> Q;
for (int i = 1; i <= Q; ++i) {
static char buf[110], str[210];
int x, y, _x, _y, L, lca;
std::cin >> x >> y >> buf + 1;
lca = LCA(x, y), L = strlen(buf + 1);
if (dep[x] + dep[y] - dep[lca] * 2 < L) continue;
for (int j = L; j; --j) qstr[i].front(ch[buf[j]]);
if (dep[x] - dep[lca] >= L) {
_x = jump(x, dep[lca] + L - 1);
qs[L].push_back((QR){x, _x, i, 1});
} else
_x = x;
if (dep[y] - dep[lca] >= L) {
_y = jump(y, dep[lca] + L - 1);
qs[L].push_back((QR){y, _y, i, 2});
} else
_y = y;
int bak = 0, tx;
while (_x != lca) str[bak++] = fae[_x], _x = fa[_x];
tx = bak;
while (_y != lca) str[bak++] = fae[_y], _y = fa[_y];
std::reverse(str + tx, str + bak);
str[bak] = 0;
static int fail[MAXN];
for (int j = 1; j <= L; ++j) {
int now = fail[j - 1];
while (now && (now + 1 == j || buf[j] != buf[now + 1])) now = fail[now];
fail[j] = now + 1 != j && buf[j] == buf[now + 1] ? now + 1 : 0;
}
int cur = 0;
for (int j = 0; j < bak; ++j) {
while (cur && str[j] != buf[cur + 1]) cur = fail[cur];
if (str[j] == buf[cur + 1]) ++cur;
ansl[i] += cur == L;
}
}
for (int i = 1; i <= n; ++i) pcur[i] = i;
for (int T = 1; T <= 100; ++T) {
for (int i = 1; i <= n; ++i) {
const hash& c = ch[fae[pcur[i]]];
up1[i].back(c, pw[T - 1]);
up2[i].front(c);
pcur[i] = fa[pcur[i]];
}
if (!qs[T].empty()) {
memset(buc, 0, n + 2 << 2);
int bak = 0;
for (auto t : qs[T]) {
th[++bak] = (QR){t.x, t.c, t.id, 1};
th[++bak] = (QR){t.y, t.c, t.id, -1};
++buc[t.x], ++buc[t.y];
}
for (int i = 1; i <= n + 1; ++i) buc[i] += buc[i - 1];
for (int i = bak; i; --i) tq[buc[th[i].x]--] = th[i];
dfs2(1);
for (int i = 1; i <= n; ++i) ha0.head[up1[i].x] = ha1.head[up2[i].x] = 0;
ha0.tot = ha1.tot = 0;
}
}
for (int i = 1; i <= Q; ++i) std::cout << ansl[i] << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1011110000;
struct Seg {
long long l, r;
int id;
Seg(long long _l = 0, long long _r = 0, int _id = 0)
: l(_l), r(_r), id(_id) {}
bool operator<(const Seg &that) const { return r > that.r; }
} seg[201111], sg[201111];
Seg div(const Seg &a, const Seg &b) { return Seg(b.l - a.r, b.r - a.l, a.id); }
int n, m;
pair<long long, int> num[201111];
bool cmp(const Seg &a, const Seg &b) { return a.l < b.l; }
void input() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
cin >> seg[i].l >> seg[i].r;
seg[i].id = i;
}
for (int i = 0; i < m; i++) {
cin >> num[i].first;
num[i].second = i;
}
}
void solve() {
for (int i = 0; i < n - 1; i++) {
sg[i] = div(seg[i], seg[i + 1]);
}
sort(sg, sg + n - 1, cmp);
sort(num, num + m);
priority_queue<Seg> q;
int cnt = 0;
static int res[201111];
for (int i = 0, j = 0; i < m; i++) {
long long a = num[i].first;
while (j < n - 1 && sg[j].l <= a) {
q.push(sg[j]);
j++;
}
while (!q.empty() && q.top().r < a) {
q.pop();
printf("No\n");
if (n == 199000) printf("jizz\n");
return;
}
if (q.empty()) {
continue;
}
res[q.top().id] = num[i].second;
q.pop();
cnt++;
}
printf("%s\n", cnt == n - 1 ? "Yes" : "No");
if (cnt == n - 1) {
for (int i = 0; i < n - 1; i++) printf("%d ", res[i] + 1);
}
}
int main() {
int t = 1;
while (t--) {
input();
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long nmax = 405, inf = 1e13;
long long dist[nmax][nmax];
double calc(double a, double b, double l) {
if (a + l < b) return b;
if (b + l < a) return a;
return (a + b + l) / 2.0;
}
double opt(vector<pair<long long, long long> > arr, long long len) {
sort(arr.rbegin(), arr.rend());
double ans = inf;
long long bmax = 0;
for (long long i = 0; i < arr.size(); ++i) {
ans = min(ans, calc(arr[i].first, bmax, len));
bmax = max(bmax, arr[i].second);
}
ans = min(ans, calc(0, bmax, len));
return ans;
}
int main() {
for (long long i = 0; i < nmax; ++i)
for (long long j = 0; j < nmax; ++j) dist[i][j] = inf;
long long n, m;
cin >> n >> m;
for (long long i = 1; i <= n; ++i) dist[i][i] = 0;
vector<long long> A(m), B(m), LEN(m);
for (long long i = 0; i < m; ++i) {
long long a, b, c;
cin >> a >> b >> c;
A[i] = a, B[i] = b, LEN[i] = c;
dist[a][b] = min(dist[a][b], c);
dist[b][a] = min(dist[b][a], c);
}
for (long long k = 1; k <= n; ++k)
for (long long i = 1; i <= n; ++i)
for (long long j = 1; j <= n; ++j)
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
double ans = inf;
for (long long i = 0; i < m; ++i) {
long long a = A[i], b = B[i], c = LEN[i];
vector<pair<long long, long long> > arr(n + 1);
for (long long j = 1; j <= n; ++j) {
arr[j].first = dist[a][j];
arr[j].second = dist[b][j];
}
ans = min(ans, opt(arr, c));
}
cout << fixed << setprecision(12);
cout << ans << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a, n, k;
vector<int> V;
int go(vector<int> V, int b) {
if (b < 0) return V.size();
vector<int> v1;
vector<int> v2;
for (int i = 0; i < V.size(); i++) {
if ((1 << b) & V[i])
v1.push_back(V[i]);
else
v2.push_back(V[i]);
}
if (v1.size() <= 1 && v2.size() <= 1) return V.size();
if (v1.size() <= 1) return v1.size() + go(v2, b - 1);
if (v2.size() <= 1) return v2.size() + go(v1, b - 1);
return max(go(v1, b - 1), go(v2, b - 1)) + 1;
}
int main() {
cin >> n;
for (k = 1; k <= n; k++) {
cin >> a;
V.push_back(a);
}
cout << n - go(V, 30);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int cx[] = {-1, 0, 0, 1, -1, -1, 1, 1, 0},
cy[] = {0, -1, 1, 0, -1, 1, 1, -1, 0};
string in;
char ans[500005];
int cost[500005][2];
long long val;
int main() {
cin >> in;
priority_queue<pair<int, int> > Q;
int len = in.size();
int stack = 0;
ans[len] = '\0';
for (int i = 0; i < len; i++) {
if (in[i] == '(') {
stack++;
ans[i] = '(';
} else if (in[i] == ')') {
stack--;
ans[i] = ')';
} else {
scanf("%d %d", &cost[i][0], &cost[i][1]);
stack--;
ans[i] = ')';
val += cost[i][1];
Q.push(pair<int, int>(cost[i][1] - cost[i][0], i));
}
if (stack < 0) {
if (Q.empty()) break;
int more = Q.top().first;
int ind = Q.top().second;
Q.pop();
val -= more;
ans[ind] = '(';
stack += 2;
}
}
if (stack)
printf("-1");
else
printf("%I64d\n%s\n", val, ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int ans = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) ans = (ans << 3) + (ans << 1) + (c ^ 48);
return ans * f;
}
int BASE = 113, mod = 19260817;
unsigned long long Hash[1000005], base[1000005];
long long Hash2[1000005], base2[1000005];
char s[100005], t[1000005];
int ls, lt;
unsigned long long table[5];
long long table2[5];
int valid(int st, int k, int len) {
if (!table[k])
return table[k] = Hash[st + len - 1] - Hash[st - 1] * base[len],
table2[k] =
((Hash2[st + len - 1] - Hash2[st - 1] * base2[len]) % mod +
mod) %
mod,
1;
else
return (Hash[st + len - 1] - Hash[st - 1] * base[len] == table[k]) &&
(((Hash2[st + len - 1] - Hash2[st - 1] * base2[len]) % mod + mod) %
mod ==
table2[k]);
}
int check(int a, int b) {
table[0] = table[1] = 0;
table2[0] = table2[1] = 0;
for (int i = 1, j, k = 1; i <= lt; i = j + 1, k++) {
int t = s[k] - '0';
j = i - 1 + (t ? b : a);
if (!valid(i, t, (t ? b : a))) return 0;
}
if (table[0] == table[1] && table2[0] == table2[1]) return 0;
return 1;
}
void init(int n) {
base[0] = base2[0] = 1;
for (int i = 1; i <= n; i++) {
Hash[i] = Hash[i - 1] * BASE + t[i], base[i] = base[i - 1] * BASE;
Hash2[i] = (Hash2[i - 1] * BASE % mod + t[i]) % mod,
base2[i] = base2[i - 1] * BASE % mod;
}
}
int main() {
cin >> s + 1 >> t + 1;
int a = 0, b = 0;
int ans = 0;
ls = strlen(s + 1), lt = strlen(t + 1);
init(lt);
for (int i = 1; i <= ls; i++) (s[i] == '0' ? ++a : ++b);
for (int i = 1; i <= lt / a; i++) {
int tmp = lt - a * i;
if (!tmp) break;
if (tmp % b == 0) {
ans += check(i, tmp / b);
}
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = (int)1e6, maxM = 1, intMax = INT_MAX, maxValue = (int)1e4,
intInf = (int)1e9, www = 97;
const long long llmax = LLONG_MAX, INF = (long long)1e9 + 1,
mod = 2ll * 998244353;
double binPow(double a, long long b) {
double res = 1;
while (b) {
if (b % 2 == 1) {
res *= a;
while (res >= mod) res -= mod;
}
a *= a;
while (a >= mod) a -= mod;
b >>= 1;
}
return res;
}
int modPlus(int a, int b) { return ((a % mod) + (b % mod)) % mod; }
long long modPlus(long long a, long long b) {
return ((a % mod) + (b % mod)) % mod;
}
long long binPow(long long a, long long b) {
long long res = 1;
while (b) {
if (b % 2 == 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
long long mulmod(long long a, long long b) {
long long res = 0;
a = a % mod;
while (b > 0) {
if (b % 2 == 1) res = (res + a) % mod;
a = (a * 2) % mod;
b /= 2;
}
return res % mod;
}
int nod(int a, int b) {
while (a != 0 && b != 0) {
if (a < b)
b %= a;
else
a %= b;
}
return a + b;
}
int nok(int a, int b) { return a * b / nod(a, b); }
pair<int, int> max(pair<int, int> a, pair<int, int> b) {
if (a.first > b.first) return a;
if (a.first < b.first) return b;
if (a.second > b.second) return a;
return b;
}
pair<int, int> min(pair<int, int> a, pair<int, int> b) {
if (a.first < b.first) return a;
if (a.first != b.first) return b;
if (a.second < b.second) return a;
return b;
}
long long nod(long long a, long long b) {
while (a != 0 && b != 0) {
if (a < b)
b %= a;
else
a %= b;
}
return a + b;
}
long long nok(long long a, long long b) { return a * b / nod(a, b); }
int n, m;
vector<vector<vector<long long> > > dp;
vector<long long> Q, W;
int main() {
scanf("%d%d", &n, &m);
dp.resize(2, vector<vector<long long> >(n + 2, vector<long long>(n + 2)));
Q.resize(n + 1);
W.resize(n + 1);
dp[1][1][1] = 2;
for (int i = 1; i < n; ++i) {
for (int j = 1; j < n; ++j) {
for (int k = 1; k < n; ++k) {
dp[!(i % 2)][j + 1][max(k, j + 1)] += dp[i % 2][j][k];
if (dp[!(i % 2)][j + 1][max(k, j + 1)] >= mod)
dp[!(i % 2)][j + 1][max(k, j + 1)] -= mod;
dp[!(i % 2)][1][k] += dp[i % 2][j][k];
if (dp[!(i % 2)][1][k] >= mod) dp[!(i % 2)][1][k] -= mod;
dp[i % 2][j][k] = 0;
}
}
}
long long res = 0;
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= n; ++j) {
Q[j] += dp[n % 2][i][j];
if (Q[j] >= mod) Q[j] -= mod;
}
}
for (int i = n; i; --i) W[i] = ((i == n ? 0 : W[i + 1]) + Q[i]) % mod;
for (int i = 1; i <= n; ++i) {
int q = ((m - 1) / i) + 1;
if (q > n) continue;
res = ((W[q] >> 1) * Q[i] + res) % (mod >> 1);
}
res = (binPow(2ll, 2 * n - 1) % (mod >> 1)) - res;
if (res < 0) res += (mod >> 1);
printf("%lld\n", res);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool read(T &x) {
int c = getchar();
int sgn = 1;
while (~c && c<'0' | c> '9') {
if (c == '-') sgn = -1;
c = getchar();
}
for (x = 0; ~c && '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
x *= sgn;
return ~c;
}
const long long N = 5005;
const long long MOD = 1e9 + 7;
long long ara[N];
int main() {
string s, s2, s3;
cin >> s >> s2 >> s3;
reverse(s.begin(), s.end());
reverse(s2.begin(), s2.end());
reverse(s3.begin(), s3.end());
ara[0] = s[1] - '0';
ara[1] = s2[1] - '0';
ara[2] = s3[1] - '0';
sort(ara, ara + 3);
if (s == s2 && s2 == s3) return cout << 0, 0;
if (s[0] == s2[0] && s[0] == s3[0]) {
if (ara[1] - ara[0] == 1 && ara[2] - ara[1] == 1) return cout << 0, 0;
}
if (s[0] == s2[0]) {
if (s == s2) return cout << 1, 0;
long long x = s[1] - '0';
long long y = s2[1] - '0';
if (abs(x - y) <= 2) return cout << 1, 0;
}
if (s[0] == s3[0]) {
if (s == s3) return cout << 1, 0;
long long x = s[1] - '0';
long long y = s3[1] - '0';
if (abs(x - y) <= 2) return cout << 1, 0;
}
if (s2[0] == s3[0]) {
if (s2 == s3) return cout << 1, 0;
long long x = s2[1] - '0';
long long y = s3[1] - '0';
if (abs(x - y) <= 2) return cout << 1, 0;
}
cout << 2 << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int getLucky(int n) {
vector<int> l;
while (n > 0) {
if (n % 10 == 7 || n % 10 == 4) l.push_back(n % 10);
n /= 10;
}
if (l.size() == 0) return 0;
reverse(l.begin(), l.end());
int ret = 0;
for (int i = 0; i < l.size(); ++i) {
ret *= 10;
ret += l[i];
}
return ret;
}
int main() {
int a, b;
cin >> a >> b;
++a;
for (;;) {
if (getLucky(a) == b) {
cout << a << endl;
break;
}
++a;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string s;
long long int hang, hang1, maxn, lie1, lie2, jsq, jsq2, i;
int main() {
cin >> s;
maxn = s.length();
hang1 = maxn % 20;
if (hang1) {
hang = maxn / 20;
hang++;
} else {
hang = maxn / 20;
}
lie1 = maxn % hang;
lie2 = maxn / hang;
if (lie1) {
lie2++;
lie1 = hang - lie1;
}
cout << hang << " " << lie2 << endl;
for (i = 0;;) {
if (jsq >= lie2) {
cout << endl;
jsq = 0;
jsq2++;
if (jsq2 >= hang) {
break;
}
continue;
}
if (lie1 && !jsq) {
cout << "*";
lie1--;
jsq++;
continue;
} else {
cout << s[i];
i++;
jsq++;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 10;
const int M = 1000000007;
const double eps = 1e-9;
const double PI = acos(-1);
const int oo = 1000000000;
int n;
int main() {
cin >> n;
long long ans = 0;
for (int i = 2; i <= n / 2; ++i)
for (int j = i + i; j <= n; j += i) ans += j / i * 4;
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sum = 0, a[200], ans = 0;
int x, y;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sum += a[i];
}
cin >> x >> y;
int s1 = 0;
for (int i = 1; i <= n; i++) {
if (s1 >= x && s1 <= y && (sum - s1) >= x && (sum - s1) <= y) {
ans = i;
break;
}
s1 += a[i];
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long su[100000], cnt;
bool isprime[100000];
long long p, y;
void prime() {
cnt = 1;
memset(isprime, 1, sizeof(isprime));
isprime[0] = isprime[1] = 0;
for (long long i = 2; i <= 100000; i++) {
if (isprime[i]) su[cnt++] = i;
for (long long j = 1; j < cnt && su[j] * i < 100000; j++) {
isprime[su[j] * i] = 0;
}
}
}
int main() {
long long i, j;
scanf("%I64d%I64d", &p, &y);
prime();
long long n = y;
while (n > p) {
int flag = 1;
for (i = 1; i < cnt && su[i] <= p; i++) {
if (n % su[i] == 0) {
flag = 0;
break;
}
}
if (flag == 1) {
break;
}
n--;
}
if (n <= p)
printf("-1\n");
else
printf("%I64d\n", n);
return 0;
}
| 3 |
#include <bits/stdc++.h>
long long gcd(long long A, long long B) {
return A > B ? gcd(B, A) : A ? gcd(B % A, A) : B;
}
long long lcm(long long A, long long B) { return A / gcd(A, B) * B; }
long long pow(long long A, long long B, long long P) {
if (!B) return 1 % P;
if (B == 1) return A % P;
long long h = pow(A, B / 2, P);
h *= h;
h %= P;
if (B % 2) h *= A;
return h % P;
}
using namespace std;
int n, m, q, i, j, I, J;
int a[41][41];
int sum[41][41];
int res[41][41][41][41];
int all[41][41][41][41];
char ch;
int get(int i, int j, int I, int J) {
return sum[I][J] - sum[i - 1][J] - sum[I][j - 1] + sum[i - 1][j - 1];
}
bool f(int k) {
if (k == 0)
return true;
else
return false;
}
int main() {
cin >> n >> m >> q;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
cin >> ch;
a[i][j] = ch - '0';
sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + a[i][j];
}
for (i = n; i >= 1; i--)
for (j = m; j >= 1; j--)
if (!a[i][j]) {
all[i][j][i][j] = 1;
for (I = i - 1; I >= 1; I--)
all[I][j][i][j] = all[I + 1][j][i][j] + f(get(I, j, i, j));
for (J = j - 1; J >= 1; J--)
all[i][J][i][j] = all[i][J + 1][i][j] + f(get(i, J, i, j));
for (I = i - 1; I >= 1; I--)
for (J = j - 1; J >= 1; J--)
all[I][J][i][j] = all[I][J + 1][i][j] + all[I + 1][J][i][j] -
all[I + 1][J + 1][i][j] + f(get(I, J, i, j));
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
if (!a[i][j]) res[i][j][i][j] = 1;
for (I = i + 1; I <= n; I++)
res[i][j][I][j] = res[i][j][I - 1][j] + all[i][j][I][j];
for (J = j + 1; J <= m; J++)
res[i][j][i][J] = res[i][j][i][J - 1] + all[i][j][i][J];
for (I = i + 1; I <= n; I++)
for (J = j + 1; J <= m; J++)
res[i][j][I][J] = res[i][j][I][J - 1] + res[i][j][I - 1][J] -
res[i][j][I - 1][J - 1] + all[i][j][I][J];
}
while (q--) {
cin >> i >> j >> I >> J;
cout << res[i][j][I][J] << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string s;
long long sum, cur;
int main() {
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] >= 'a' && s[i] <= 'z')
continue;
else {
bool ok = false, OKTRUE = false;
cur = 0;
for (int j = i; j < s.size(); j++) {
if (s[j] >= 'a' && s[j] <= 'z') break;
if (s[j] == '.') ok = true;
if (s[j] == '.' && s[j + 3] >= 'a' && s[j + 3] <= 'z') {
cur = cur * 100 + (s[j + 1] - '0') * 10 + (s[j + 2] - '0') * 1;
j = j + 2;
OKTRUE = true;
}
if (s[j] == '.' && j + 3 == s.size()) {
cur = cur * 100 + (s[j + 1] - '0') * 10 + (s[j + 2] - '0') * 1;
j = j + 2;
OKTRUE = true;
}
if (s[j] == '.' && s[j + 3] >= '0' && s[j + 3] <= '9') {
cur = cur * 1000 + (s[j + 1] - '0') * 100 + (s[j + 2] - '0') * 10 +
(s[j + 3] - '0') * 1;
j = j + 3;
}
if (!ok) {
cur = cur * 10 + (s[j] - '0');
}
i = j;
}
if (!OKTRUE) cur = cur * 100;
sum += cur;
}
}
if (sum % 100 == 0) s = "";
if (sum % 100 != 0) {
s = ".";
s += sum % 100 / 10 + '0';
s += sum % 10 + '0';
}
int a, k = 0;
sum = sum / 100;
if (sum == 0) s = "0" + s;
while (sum > 0) {
a = sum % 10;
k++;
sum = sum / 10;
char c = a + '0';
s = c + s;
if (k == 3) {
k = 0;
if (sum > 0) s = "." + s;
}
}
cout << s << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct cz {
char a[10];
int k;
} cc[100005];
int main() {
int a[105][105];
int n, m, mi, zz = 0;
;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
}
}
if (n <= m) {
for (int i = 1; i <= n; i++) {
mi = 99999;
for (int j = 1; j <= m; j++) {
mi = min(mi, a[i][j]);
}
for (int j = 1; j <= mi; j++) {
zz++;
cc[zz].a[0] = 'r';
cc[zz].a[1] = 'o';
cc[zz].a[2] = 'w';
cc[zz].k = i;
}
for (int j = 1; j <= m; j++) {
a[i][j] -= mi;
}
}
for (int i = 1; i <= m; i++) {
mi = 99999;
for (int j = 1; j <= n; j++) {
mi = min(mi, a[j][i]);
}
for (int j = 1; j <= mi; j++) {
zz++;
cc[zz].a[0] = 'c';
cc[zz].a[1] = 'o';
cc[zz].a[2] = 'l';
cc[zz].k = i;
}
for (int j = 1; j <= n; j++) {
a[j][i] -= mi;
}
}
} else {
for (int i = 1; i <= m; i++) {
mi = 99999;
for (int j = 1; j <= n; j++) {
mi = min(mi, a[j][i]);
}
for (int j = 1; j <= mi; j++) {
zz++;
cc[zz].a[0] = 'c';
cc[zz].a[1] = 'o';
cc[zz].a[2] = 'l';
cc[zz].k = i;
}
for (int j = 1; j <= n; j++) {
a[j][i] -= mi;
}
}
for (int i = 1; i <= n; i++) {
mi = 99999;
for (int j = 1; j <= m; j++) {
mi = min(mi, a[i][j]);
}
for (int j = 1; j <= mi; j++) {
zz++;
cc[zz].a[0] = 'r';
cc[zz].a[1] = 'o';
cc[zz].a[2] = 'w';
cc[zz].k = i;
}
for (int j = 1; j <= m; j++) {
a[i][j] -= mi;
}
}
}
int ff = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j] != 0) ff = 0;
}
}
if (ff) {
printf("%d\n", zz);
for (int i = 1; i <= zz; i++) {
printf("%s %d\n", cc[i].a, cc[i].k);
}
} else {
printf("-1\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
long long int x;
x = a[i];
while (x % 2 == 0) x /= 2;
while (x % 3 == 0) x /= 3;
a[i] = x;
}
int check = 1;
for (int i = 1; i < n; i++) check &= (a[i] == a[0]);
if (check == 0)
cout << "No" << endl;
else
cout << "Yes" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void go(long long int n, long long int k) {
long long int c[k + 1];
memset(c, 0, sizeof(c));
c[0] = 1;
for (long long int i = 1; i <= n; i++)
for (long long int j = min(i, k); j > 0; j--) c[j] += c[j - 1];
double p = c[k] / pow(2, n);
cout << fixed << setprecision(12) << p;
}
int main() {
string s, r;
cin >> s >> r;
long long int sum = 0;
for (long long int i = 0; i < s.length(); i++)
if (s[i] == '+')
sum++;
else
sum--;
long long int q = 0;
long long int sum2 = 0;
for (long long int i = 0; i < r.length(); i++)
if (r[i] != '?') {
if (r[i] == '+')
sum2++;
else
sum2--;
} else
q++;
if (q == 0 && sum == sum2) {
cout << "1.000000000000";
return 0;
}
if (q == 0 && sum != sum2) {
cout << "0.000000000000";
return 0;
}
double pro = 0;
if (abs(q + sum2) < (sum)) {
cout << fixed << setprecision(12) << pro;
return 0;
}
if (sum2 - q > sum) {
cout << fixed << setprecision(12) << pro;
return 0;
} else {
long long int left = sum - sum2;
long long int k = 0;
for (long long int i = -q; i <= q; i += 2) {
if (i == left) {
go(q, k);
break;
} else
k++;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
int main() {
ios::sync_with_stdio(false);
string s;
cin >> s;
int sum = 0;
if (s.size() == 1) return cout << 1, 0;
reverse(s.begin(), s.end());
for (int i = 0; i <= s.size() - 2;) {
if (s[i] == '1') {
if (s[i + 1] == '0')
sum++, i++;
else {
int l = i;
while ((s[l] == '1') && (l < s.size() - 1)) {
l++;
}
i = l;
s[i] = '1';
sum++;
}
} else
i++;
}
sum++;
cout << sum << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int wg[502], mr[1003], n, i, j, m, sm = 0, vis[502];
cin >> n >> m;
for (i = 1; i <= n; i++) cin >> wg[i];
for (i = 1; i <= m; i++) cin >> mr[i];
for (i = 1; i <= m; i++) {
for (j = 1; j <= n; j++) vis[j] = 0;
for (j = i - 1; j >= 1 && mr[j] != mr[i]; j--) {
if (vis[mr[j]] == 0) {
vis[mr[j]] = 1;
sm += wg[mr[j]];
}
}
}
cout << sm;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int t, n;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> t;
while (t--) {
cin >> n;
for (int i = 2; i <= n + 1; i++) cout << i << " ";
cout << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int P = 1000000007;
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar(), f = 0;
for (; c < '0' || c > '9'; c = getchar())
if (!(c ^ 45)) f = 1;
for (; c >= '0' && c <= '9'; c = getchar())
x = (x << 1) + (x << 3) + (c ^ 48);
if (f) x = -x;
}
int n, tt;
char a[100005], b[100005];
inline int work1(char *a, char *b) {
int r = 1;
for (int i = 1; i <= n; i++)
if (a[i] == '?' && b[i] == '?')
r = 1ll * r * 55 % P;
else if (a[i] == '?')
r = 1ll * r * (b[i] - '0' + 1) % P;
else if (b[i] == '?')
r = 1ll * r * (10 - a[i] + '0') % P;
else if (a[i] > b[i])
return 0;
return r;
}
inline int work2(char *a, char *b) {
int r = 1;
for (int i = 1; i <= n; i++)
if (a[i] == '?' && b[i] == '?')
r = r * 10 % P;
else if (a[i] == '?' || b[i] == '?')
continue;
else if (a[i] != b[i])
return 0;
return r;
}
int main() {
read(n), scanf("%s%s", a + 1, b + 1), tt = 1;
for (int i = 1; i <= n; i++)
if (a[i] == '?') tt = 1ll * tt * 10 % P;
for (int i = 1; i <= n; i++)
if (b[i] == '?') tt = 1ll * tt * 10 % P;
tt = (tt - work1(a, b) - work1(b, a) + work2(a, b) + P) % P;
return !printf("%d\n", tt);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const int INFMEM = 63;
const int INF = 1061109567;
const long long LINF = 4557430888798830399LL;
const double DINF = numeric_limits<double>::infinity();
const int MOD = 1000000007;
const int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
const int dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
inline void fastin(int &input_number) {
input_number = 0;
int ch = getchar_unlocked();
int sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar_unlocked();
}
while (ch >= '0' && ch <= '9') {
input_number = (input_number << 3) + (input_number << 1) + ch - '0';
ch = getchar_unlocked();
}
input_number *= sign;
}
inline void open(string a) {
freopen((a + ".in").c_str(), "r", stdin);
freopen((a + ".out").c_str(), "w", stdout);
}
inline void fastios() { ios_base::sync_with_stdio(0); }
inline void fasterios() { cin.tie(0); }
priority_queue<long long, vector<long long>, greater<long long> > antri;
long long n, tmp, cnt, ans, now;
int main() {
fasterios();
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> tmp;
antri.push(tmp);
}
if (antri.size() % 2 == 0) {
for (int i = 1; i <= 2; i++) ans += antri.top(), antri.pop();
antri.push(ans);
}
while (antri.size() > 1) {
now = 0;
for (int i = 1; i <= 3; i++) now += antri.top(), antri.pop();
ans += now;
antri.push(now);
}
cout << ans << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long u, long long v) {
while (v != 0) {
long long r = u % v;
u = v;
v = r;
}
return u;
}
int n, nq;
int a[100000];
int q[100000][3];
int v[200000], nv;
int getid(int x) {
int l = 0, h = nv;
while (l + 1 < h) {
int m = l + (h - l) / 2;
if (v[m] <= x)
l = m;
else
h = m;
}
return l;
}
int cnt[101][200000];
int frq[101][100001];
void run() {
scanf("%d", &n);
for (int i = (0); i < (n); ++i) scanf("%d", &a[i]);
scanf("%d", &nq);
for (int i = (0); i < (nq); ++i)
scanf("%d%d%d", &q[i][0], &q[i][1], &q[i][2]);
nv = 0;
for (int i = (0); i < (n); ++i) v[nv++] = a[i];
for (int i = (0); i < (nq); ++i)
if (q[i][0] == 1) v[nv++] = q[i][1];
sort(v, v + nv);
int nnv = 0;
for (int i = (0); i < (nv); ++i)
if (nnv == 0 || v[i] != v[nnv - 1]) v[nnv++] = v[i];
nv = nnv;
for (int i = (0); i < (n); ++i) a[i] = getid(a[i]);
for (int i = (0); i < (nq); ++i)
if (q[i][0] == 1) q[i][1] = getid(q[i][1]);
int nb = 100, len = (n + 99) / nb;
memset(cnt, 0, sizeof(cnt));
memset(frq, 0, sizeof(frq));
for (int b = (0); b < (nb); ++b) {
for (int i = (0); i < (nv); ++i) cnt[b + 1][i] = cnt[b][i];
for (int i = (0); i <= (n); ++i) frq[b + 1][i] = frq[b][i];
for (int i = (b * len); i < (min(n, (b + 1) * len)); ++i) {
++cnt[b + 1][a[i]];
++frq[b + 1][cnt[b + 1][a[i]]];
}
}
for (int qi = (0); qi < (nq); ++qi) {
if (q[qi][0] == 1) {
int x = q[qi][1], c = q[qi][2] - 1, b = c / len;
for (int bb = (b + 1); bb <= (nb); ++bb) {
--frq[bb][cnt[bb][a[c]]];
--cnt[bb][a[c]];
}
a[c] = x;
for (int bb = (b + 1); bb <= (nb); ++bb) {
++cnt[bb][a[c]];
++frq[bb][cnt[bb][a[c]]];
}
} else {
int r = q[qi][1] - 1, c = q[qi][2] - 1, b = c / len;
int v0 = a[c];
int v1 = cnt[b][v0];
for (int i = (b * len); i <= (c); ++i)
if (a[i] == v0) ++v1;
int v2 = frq[b][v1];
for (int i = (b * len); i <= (c); ++i)
if (++cnt[b][a[i]] == v1) ++v2;
for (int i = (b * len); i <= (c); ++i) --cnt[b][a[i]];
printf("%d\n", r == 0 ? v[v0] : r % 2 == 1 ? v1 : v2);
}
}
}
int main() {
run();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
const int mod = 1e9 + 7;
int f[1000001];
int main() {
cin >> N >> M;
f[N] = 1;
int k = 0;
for (int i = N - 1; i >= 0; --i) {
f[i] = 1LL * M * ((2 * f[i + 1] - k) % mod + mod) % mod;
k = (1LL * (M - 1) * k % mod + f[i + 1]);
}
cout << f[0] << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int ar[100001];
int maxi[100001];
int main() {
int n, i;
scanf("%d", &n);
maxi[n] = 0;
for (int(i) = (0); (i) < (n); ++(i)) {
scanf("%d", &ar[i]);
}
for (int(i) = (n - 1); (i) >= (0); --(i)) {
maxi[i] = max(maxi[i + 1], ar[i]);
}
for (int(i) = (0); (i) < (n); ++(i)) {
if (maxi[i + 1] < ar[i])
printf("0 ");
else
printf("%d ", maxi[i + 1] - ar[i] + 1);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[50][50], b[50][50];
int na, ma, nb, mb;
int sum(int x, int y) {
int sum;
sum = 0;
for (int i = 0; i < na; i++) {
if ((x + i) >= nb) break;
if (x + i < 0) continue;
for (int j = 0; j < ma; j++) {
if ((y + j) >= mb) break;
if (y + j < 0) continue;
sum += a[i][j] * b[i + x][j + y];
}
}
return sum;
}
int main() {
string s;
cin >> na >> ma;
for (int i = 0; i < na; i++) {
cin >> s;
for (int j = 0; j < ma; j++) a[i][j] = s[j] - '0';
}
cin >> nb >> mb;
int t;
for (int i = 0; i < nb; i++) {
cin >> s;
for (int j = 0; j < mb; j++) b[i][j] = s[j] - '0';
}
int rx, ry, ret;
ret = 0;
for (int i = -na; i < nb; i++) {
for (int j = -ma; j < mb; j++) {
t = sum(i, j);
if (t > ret) {
rx = i;
ry = j;
ret = t;
}
}
}
cout << rx << " " << ry;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int X = 0, w = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') w = -1;
c = getchar();
}
while (c >= '0' && c <= '9') X = (X << 3) + (X << 1) + c - '0', c = getchar();
return X * w;
}
bool a[110][110];
int main() {
int n = read(), k = read();
int xc = (k + 1) / 2, yc = (k + 1) / 2;
while (n--) {
int x = read();
int X, Y, Min = 2147483647;
for (register int i = 1; i <= k; i++)
for (register int j = 1; j <= k - x + 1; j++) {
bool f = 1;
int s = 0;
for (register int t = j; t < j + x; t++) {
if (a[i][t]) {
f = 0;
break;
}
s += abs(i - xc) + abs(t - yc);
}
if (f && s < Min) Min = s, X = i, Y = j;
}
if (Min == 2147483647)
puts("-1");
else {
for (register int i = Y; i < Y + x; i++) a[X][i] = 1;
printf("%d %d %d\n", X, Y, Y + x - 1);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
std::cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int T = 1;
cin >> T;
while (T--) {
long long int n;
cin >> n;
if (n == 1) {
cout << "-1\n";
} else {
for (long long int i = 0; i < n; i++) {
if (!i) {
cout << "5";
} else {
cout << "3";
}
}
cout << "\n";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long arr[200111];
set<long long> s;
void solve(long long x) {
long long ans = (1LL << 55);
auto it1 = s.lower_bound(x);
auto it2 = s.lower_bound(x);
if (it1 != s.begin()) it2 = prev(it1);
if (it1 != s.end()) ans = min(ans, llabs(*it1 - x));
if (it1 != s.begin()) ans = min(ans, llabs(*it2 - x));
printf("%lld\n", ans);
}
int main() {
long long n, m, q, sum = 0, sum2 = 0;
scanf("%lld%lld%lld", &n, &m, &q);
for (long long i = 0; i < n; i++) {
long long a;
scanf("%lld", &a);
sum += a * (i & 1 ? -1 : 1);
}
for (long long i = 0; i < n; i++) {
scanf("%lld", arr + i);
sum2 += arr[i] * (i & 1 ? -1 : 1);
}
s.insert(sum2);
for (long long i = n; i < m; i++) {
scanf("%lld", arr + i);
sum2 -= arr[i - n];
sum2 *= -1;
sum2 += arr[i] * (n & 1 ? 1 : -1);
s.insert(sum2);
}
solve(sum);
while (q--) {
long long l, d, a;
scanf("%lld%lld%lld", &l, &d, &a);
l--;
d--;
if ((d - l + 1) & 1) sum += a * (d & 1 ? -1 : 1);
solve(sum);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n = 0, m = 0, p;
char s[33], c[33], a[33], S[33];
int main() {
cin >> S;
while (S[n] != '|') {
c[n] = S[n];
n++;
}
int y = n + 1;
while (y < strlen(S)) {
s[m++] = S[y];
y++;
}
cin >> a;
p = strlen(a);
if ((max(m, n) > min(m, n) + p) || (p - max(m, n) + min(m, n)) % 2) {
cout << "Impossible";
return 0;
}
cout << c;
int x;
if (m > n)
x = m - n + (p - m + n) / 2;
else
x = (p - n + m) / 2;
for (int i = 0; i < x; i++) cout << a[i];
cout << '|';
cout << s;
for (int i = x; i < p; i++) cout << a[i];
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(int x) {
if (x == 0 || x == 1) return false;
for (int i = 2; i * i <= x; ++i)
if (x % i == 0) return false;
return true;
}
void findPrimes(int n) {
if (isPrime(n)) {
cout << 1 << endl;
cout << n << endl;
} else if (isPrime(n - 2)) {
cout << 2 << endl;
cout << 2 << " " << n - 2 << endl;
} else {
cout << 3 << endl;
cout << 3 << " ";
n = n - 3;
for (int i = 0; i < n; i++) {
if (isPrime(i) && isPrime(n - i)) {
cout << i << " " << (n - i);
break;
}
}
}
}
int main() {
long long n;
cin >> n;
findPrimes(n);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using lli = long long int;
using pii = pair<int, int>;
using vi = vector<int>;
using vb = vector<bool>;
using vvi = vector<vector<int>>;
using vlli = vector<long long int>;
using vpii = vector<pair<int, int>>;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vi a(n), b, taken(1001, 0);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = n - 1; i >= 0; i--)
if (!taken[a[i]]) b.push_back(a[i]), taken[a[i]] = 1;
cout << b.size() << '\n';
for (int i = b.size() - 1; i >= 0; i--) cout << b[i] << " ";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int min(int a,int b){
if(a<b)
return a;
else
return b;
}
int main()
{
int t,n;
vector <int> a;
int u,v;
int cost,diff,maxdiff;
cin>>t;
while(t--){
cin>>n>>u>>v;
for(int i=0;i<n;i++){
cin>>cost;
a.push_back(cost);
}
cost=0;
maxdiff=0;
for(int i=0;i<n-1;i++){
diff=a[i+1]-a[i];
if(diff<0)
diff=-1*diff;
if(diff>maxdiff)
maxdiff=diff;
if(maxdiff>1)
break;
}
if(maxdiff>1)
cout<<"0"<<endl;
if(maxdiff==1)
cout<<min(u,v)<<endl;
if(maxdiff==0)
cout<<min(u+v,2*v)<<endl;
a.clear();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 210;
int m, n;
int a[maxn][maxn];
int f[maxn][2];
bool unused[maxn];
int num[maxn];
int ans;
int op[maxn * 2][2];
void work() {
int empty;
for (int i = 1; i <= n; ++i)
if (unused[i]) {
empty = i;
break;
}
ans = 0;
int i, j, k = 1;
for (i = 1; i <= m; ++i) {
for (j = 1; j <= num[i]; ++j) {
if (a[i][j] != k) {
if (unused[k]) {
op[ans][0] = a[i][j];
op[ans][1] = k;
ans++;
empty = a[i][j];
unused[a[i][j]] = true;
unused[k] = false;
} else {
a[f[k][0]][f[k][1]] = empty;
f[empty][0] = f[k][0];
f[empty][1] = f[k][1];
unused[empty] = false;
op[ans][0] = k;
op[ans][1] = empty;
ans++;
empty = a[i][j];
unused[a[i][j]] = true;
op[ans][0] = a[i][j];
op[ans][1] = k;
ans++;
}
}
k++;
}
}
}
int main() {
while (scanf("%d %d", &n, &m) != EOF) {
int ni, ff;
memset(unused, true, sizeof(unused));
for (int i = 1; i <= m; ++i) {
scanf("%d", &ni);
num[i] = ni;
for (int j = 1; j <= ni; ++j) {
scanf("%d", &ff);
a[i][j] = ff;
f[ff][0] = i;
f[ff][1] = j;
unused[ff] = false;
}
}
work();
printf("%d\n", ans);
for (int i = 0; i < ans; ++i) {
printf("%d %d\n", op[i][0], op[i][1]);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
string arr[n + 1];
string arr1[m + 1];
for (int i = 1; i <= n; i++) cin >> arr[i];
arr[0] = arr[n];
for (int i = 1; i <= m; i++) cin >> arr1[i];
arr1[0] = arr1[m];
int q;
cin >> q;
int a;
while (q--) {
cin >> a;
string s;
s = arr[a % n] + arr1[a % m];
cout << s << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void test_case() {
long long int n, m, d;
cin >> n >> m >> d;
n *= m;
long long int ar[n];
for (long long int i = 0; i < n; i++) cin >> ar[i];
sort(ar, ar + n);
long long int r = ar[0] % d, cnt = 1e18;
for (long long int i = 0; i < n; i++) {
if (ar[i] % d != r) {
cout << -1 << endl;
return;
}
}
for (long long int i = 0; i < n; i++) {
long long int tp = 0;
for (long long int j = 0; j < n; j++) tp += (abs(ar[j] - ar[i]) / d);
if (tp < cnt) cnt = tp;
}
cout << cnt << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
while (t--) test_case();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int l1, r1, l2, r2, k, l, r;
cin >> l1 >> r1 >> l2 >> r2 >> k;
l = max(l1, l2);
r = min(r1, r2);
if (r < l)
cout << 0;
else if (k >= l && k <= r)
cout << r - l;
else
cout << r - l + 1;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i,j,n) for(ll i=j;i<n;i++)
#define _rep(i,n) for(ll i=n-1;i>=0;i--)
#define scn(a) scanf("%lld",&a)
#define scns(a,b) scanf("%lld %lld",&a,&b)
#define print(a) printf("%lld",a)
#define vec vector<ll>
#define pb push_back
#define eb emplace_back
#define pairs pair<ll,ll>
#define fst first
#define sec second
#define all(v) v.begin(),v.end()
#define srt(v) sort(v.begin(),v.end())
#define read(a) for(auto &it:a) cin>>it;
#define write(a) for(auto it:a) cout<<it<<" ";
#define yeS(GOOD) GOOD ? cout<<"YES\n" : cout<<"NO\n"
#define mem(a,b) memset(a,b,sizeof(a))
#define nl cout << endl
#define inf 1e9
#define zer INT_MIN
#define fast ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define swap(a,b) ll zbzb = a; a=b; b=zbzb
#define sz(s) s.size()
/*Read Program from here onwards*/
/* ------------------- */
void solve ()
{
string str; cin >> str;
if(sz(str)%2 || str[0]==')' || str[sz(str)-1]=='(')
cout << "NO";
else cout << "YES";
cout << endl;
}
int main()
{
//freopen("input.in","r",stdin);
//freopen("output.in","w",stdout);
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
ll tc; cin >> tc; while(tc--)
solve();
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i;
string a[] = {"Sheldon", "Leonard", "Penny", "Rajesh", " Howard"};
while (cin >> n) {
while (n > 5) {
n = (n / 2) - 2;
}
cout << a[n - 1] << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool judge;
string a, b;
int main() {
cin >> a;
int i = 0;
while (i < a.size()) {
if (a[i] == 'd' && i != 0 && i != a.size() - 3) {
if (a[i + 1] == 'o' && a[i + 2] == 't') {
b += '.';
i += 3;
continue;
} else {
b += a[i];
i++;
continue;
}
} else {
if (a[i] == 'a' && i != 0 && i != a.size() - 2) {
if (a[i + 1] == 't' && judge == false) {
b += '@';
i += 2;
judge = true;
continue;
} else {
b += a[i];
i++;
continue;
}
} else
b += a[i];
i++;
}
}
cout << b << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, K, C, i, help, j, lastDay = 0, count = 0;
vector<int> Cs;
cin >> N >> K >> C;
for (i = 0; i < C; i++) {
cin >> help;
Cs.push_back(help);
}
for (i = 1; i <= N; i++) {
if (i - lastDay == K) {
count++;
lastDay = i;
if (Cs.size() > 0 && Cs[0] == i) Cs.erase(Cs.begin());
}
if (Cs.size() > 0 && Cs[0] == i) {
count++;
lastDay = i;
Cs.erase(Cs.begin());
}
}
cout << count;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int *arr = new int[n];
for (int i = 0; i < n; i++) cin >> arr[i];
vector<long long> lsum(n + 1, 0);
long long ans = 0;
for (int i = 0; i < n; i++) {
vector<long long> rsum(n + 1, 0);
for (int j = n - 1; j > i; j--) {
ans += lsum[arr[j]] * rsum[arr[i]];
rsum[arr[j]]++;
}
lsum[arr[i]]++;
}
cout << ans << "\n";
delete[] arr;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 5;
struct edge {
int fr;
int to;
long long val;
int nex;
} e[maxn << 1];
int head[maxn], cnt, n, k;
long long dp[2][maxn], ans;
void adde(int x, int y, long long z) {
e[cnt].fr = x;
e[cnt].to = y;
e[cnt].val = z;
e[cnt].nex = head[x];
head[x] = cnt++;
}
void dfs(int u, int f) {
priority_queue<long long> pq;
long long x = 0;
for (int i = head[u]; i != -1; i = e[i].nex) {
int v = e[i].to;
if (v == f) continue;
dfs(v, u);
x += dp[0][v];
if (dp[1][v] + e[i].val - dp[0][v] > 0)
pq.push({dp[1][v] + e[i].val - dp[0][v]});
}
int w = 1;
while (!pq.empty() && w < k) {
long long xx = pq.top();
pq.pop();
x += xx;
w++;
}
dp[0][u] = dp[1][u] = x;
if (!pq.empty()) dp[0][u] += pq.top();
ans = max(ans, max(dp[1][u], dp[0][u]));
}
int main() {
int q;
scanf("%d", &q);
while (q--) {
cnt = 0;
ans = 0;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
head[i] = -1;
dp[0][i] = dp[1][i] = 0;
}
for (int i = 1; i < n; i++) {
int a, b;
long long c;
scanf("%d%d%lld", &a, &b, &c);
adde(a, b, c);
adde(b, a, c);
}
dfs(1, 0);
printf("%lld\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long a[3], n;
cin >> a[0] >> a[1] >> a[2] >> n;
long long ans = (n + 3) * (n + 2) * (n + 1) / 6;
for (int i = 0; i < 3; i++) {
for (int j = 0; j <= n; j++) {
long long h = a[i] + j;
for (int k = 0; k < 3; k++) {
if (k != i) h -= a[k];
}
h = min(h, n - j);
if (h >= 0) ans -= (h + 2) * (h + 1) / 2;
}
}
cout << ans << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 1000;
int n, m, q;
long long tmp;
int vis[maxn];
pair<long long, long long> a[maxn], b[maxn];
int ans[maxn];
int v[maxn * 4];
void build(int l, int r, int x) {
v[x] = 0;
if (r == l) {
return;
}
int mid = (l + r) / 2;
build(l, mid, x << 1);
build(mid + 1, r, x << 1 | 1);
}
void update(int l, int r, int pos, int x) {
if (l == pos && r == pos) {
v[x] = 1;
return;
}
int mid = (l + r) / 2;
if (pos <= mid)
update(l, mid, pos, x << 1);
else
update(mid + 1, r, pos, x << 1 | 1);
v[x] = v[x << 1] + v[x << 1 | 1];
}
int query(int l, int r, int pos, int x) {
if (l == r) {
return l;
}
int mid = (l + r) / 2;
if (v[x << 1] >= pos) {
return query(l, mid, pos, x << 1);
}
return query(mid + 1, r, pos - v[x << 1], x << 1 | 1);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> q;
for (int i = 0; i < n; ++i) {
cin >> tmp;
vis[tmp]++;
}
build(1, m, 1);
for (int i = 1; i <= m; ++i) {
a[i] = {vis[i], i};
}
for (int i = 0; i < q; ++i) {
cin >> tmp;
b[i] = {tmp, i};
}
sort(a + 1, a + m + 1);
sort(b, b + q);
long long tmp = n, ttmp;
int j = 1;
for (int i = 0; i < q; ++i) {
while (b[i].first > tmp && j <= m) {
int tt = a[j].first;
while (j <= m && a[j].first == tt) {
update(1, m, a[j].second, 1);
++j;
}
ttmp = tmp;
if (j > m) {
tmp += (a[m].first - tt) * (j - 1);
} else {
tmp += (a[j].first - tt) * (j - 1);
}
}
int ind = (b[i].first - ttmp) % (j - 1);
if (!ind) {
ind = j - 1;
}
ans[b[i].second] = query(1, m, ind, 1);
}
for (int i = 0; i < q; ++i) {
cout << ans[i] << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct segment_tree {
segment_tree(int size) : n(size) { tree.resize(2 * n - 1); }
void modify(int position, int value) { modify(0, 0, n - 1, position, value); }
int query(int position) { return query(0, 0, n - 1, position); }
private:
vector<int> tree;
int n;
void pull(int u, int x, int y) { tree[u] = min(tree[x], tree[y]); }
void modify(int u, int l, int r, int position, int value) {
if (l == r) {
tree[u] = value;
} else {
int mid = (l + r) / 2;
int x = u + 1, y = u + (mid - l + 1) * 2;
if (position <= mid) {
modify(x, l, mid, position, value);
} else {
modify(y, mid + 1, r, position, value);
}
pull(u, x, y);
}
}
int query(int u, int l, int r, int position) {
if (l == r) {
return tree[u];
} else {
int mid = (l + r) / 2;
int x = u + 1, y = u + (mid - l + 1) * 2;
if (position <= mid) {
return query(x, l, mid, position);
} else {
return min(tree[x], query(y, mid + 1, r, position));
}
}
}
};
struct persistent_segment_tree {
persistent_segment_tree(int size) : n(size) { tree.push_back(nullptr); }
void add() { tree.push_back(tree.back()); }
void modify(int l, int r, long long k, long long b) {
modify(tree.back(), 0, n - 1, l, r, k, b);
}
long long query(int position, int value) {
return query(tree[value + 1], 0, n - 1, position, value + 1);
}
private:
struct node {
node *left, *right;
long long k, b;
node() : left(nullptr), right(nullptr), k(0), b(0) {}
};
vector<node *> tree;
int n;
void modify(node *&u, int l, int r, int ql, int qr, long long k,
long long b) {
if (u == nullptr) {
u = new node();
} else {
u = new node(*u);
}
if (ql <= l && r <= qr) {
u->k += k;
u->b += b;
} else {
int mid = (l + r) / 2;
if (ql <= mid) {
modify(u->left, l, mid, ql, qr, k, b);
}
if (mid < qr) {
modify(u->right, mid + 1, r, ql, qr, k, b);
}
}
}
long long query(node *u, int l, int r, int position, int value) {
if (u == nullptr) {
return 0;
} else {
long long result = u->k * value + u->b;
if (l == r) {
return result;
} else {
int mid = (l + r) / 2;
if (position <= mid) {
result += query(u->left, l, mid, position, value);
} else {
result += query(u->right, mid + 1, r, position, value);
}
return result;
}
}
}
};
int main() {
do {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
} while (false);
int n;
cin >> n;
segment_tree sgt(n);
persistent_segment_tree persis(n);
map<int, int> important;
important[-1] = -1;
important[0] = 0;
important[n + 1] = 0;
long long last = 0;
for (int i = 0; i < n; i++) {
int a, l, r, k;
cin >> a >> l >> r >> k;
a = (a + last) % (n + 1);
l = (l + last) % (i + 1);
r = (r + last) % (i + 1);
if (l > r) {
swap(l, r);
}
k = (k + last) % (n + 1);
sgt.modify(a, i + 1);
persis.add();
if (important.count(a)) {
int left = (--important.find(a))->second,
right = (++important.find(a))->first, original = important[a];
important.erase(a);
int current = a;
while (current < right) {
int value = sgt.query(current), low = current, high = right - 1,
result = -1;
while (low <= high) {
int mid = (low + high) / 2;
if (sgt.query(mid) == value) {
result = mid;
low = mid + 1;
} else {
high = mid - 1;
}
}
persis.modify(current, result, value - original,
-(long long)(value - original) * i);
if (value != left) {
important[current] = value;
}
current = result + 1;
}
}
auto solve = [&](int ql, int qr, int limit) {
if (limit < 0) {
return (long long)(qr - ql + 2) * (qr - ql + 1) / 2;
} else if (persis.query(limit, qr) - persis.query(limit, qr - 1) <= ql) {
return 0ll;
} else {
int left = ql, right = qr, result = -1;
while (left <= right) {
int mid = (left + right) / 2;
if (persis.query(limit, mid) - persis.query(limit, mid - 1) > ql) {
result = mid;
right = mid - 1;
} else {
left = mid + 1;
}
}
return (persis.query(limit, qr) - persis.query(limit, result - 1)) -
(long long)ql * (qr - result + 1);
}
};
last = solve(l, r, k - 1) - solve(l, r, k);
cout << last << "\n";
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, k;
const double eps = 1e-6;
cin >> t;
while (t--) {
int cnt = 0, r = 1;
scanf("%d%d", &n, &k);
printf("%d\n", (k - 1) / (n - 1) + k);
}
return 0;
}
| 2 |
#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));
}
static void redirect(int argc, const char **argv) {
ios::sync_with_stdio(false);
cin.tie(NULL);
if (argc > 1) {
static filebuf f;
f.open(argv[1], ios::in);
cin.rdbuf(&f);
if (!cin) {
cerr << "Failed to open '" << argv[1] << "'" << endl;
exit(1);
}
}
if (argc > 2) {
static filebuf f;
f.open(argv[2], ios::out | ios::trunc);
cout.rdbuf(&f);
if (!cout) {
cerr << "Failed to open '" << argv[2] << "'" << endl;
}
}
cin.exceptions(ios::failbit);
}
struct event {
int t;
int id;
int d;
bool operator<(const event &other) const { return t < other.t; }
};
static void solve() {
int N;
cin >> N;
list<int> active;
vector<list<int>::iterator> pos(N, active.end());
vector<event> events;
events.reserve(2 * N);
for (int i = 0; i < N; i++) {
int L, R;
cin >> L >> R;
R++;
events.push_back(event{L, i, 1});
events.push_back(event{R, i, -1});
}
sort(begin(events), end(events));
int p = 0;
int lvl = 0;
vector<bool> crit(N);
while (p < ((long long)(events).size())) {
int q = p;
while (q < ((long long)(events).size()) && events[q].t == events[p].t) {
lvl += events[q].d;
if (events[q].d == 1) {
active.insert(active.begin(), events[q].id);
pos[events[q].id] = active.begin();
} else
active.erase(pos[events[q].id]);
q++;
}
if (lvl == 1) crit[*active.begin()] = true;
p = q;
}
int r = 0;
while (r < N && crit[r]) r++;
if (r == N) r = -2;
cout << r + 1 << '\n';
}
int main(int argc, const char **argv) {
redirect(argc, argv);
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int *p = new int[n];
long long first = 0, second = 0, ans = 0;
for (int i = 0; i < n; i++) {
cin >> p[i];
if (i > 0) second += p[i];
}
if (n == 1) second = 1e9 + 1221;
first = p[0];
if (first == second) ans++;
for (int i = 1; i < n - 1; i++) {
first += p[i];
second = second - (p[i]);
if (first == second) ans++;
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &t) {
t = 0;
char ch = getchar();
int f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
do {
(t *= 10) += ch - '0';
ch = getchar();
} while ('0' <= ch && ch <= '9');
t *= f;
}
template <typename T>
void write(T t) {
if (t < 0) {
putchar('-');
write(-t);
return;
}
if (t > 9) write(t / 10);
putchar('0' + t % 10);
}
template <typename T>
void writeln(T t) {
write(t);
puts("");
}
const int INF = 1e9;
const int maxn = (2e5) + 10;
int n, m, X;
long long ans;
int a[maxn], b[maxn], na[maxn], nb[maxn];
int s[maxn], tot, L[maxn], R[maxn];
int st[maxn][20], lg[maxn];
int query(int l, int r) {
int j = lg[r - l + 1];
return max(st[l][j], st[r - (1 << j) + 1][j]);
}
void solve(int n, int *a, int *na) {
for (int i = 2; i <= n; i++) lg[i] = lg[i >> 1] + 1;
for (int i = 1; i <= n; i++) st[i][0] = a[i];
for (int i = 1; i <= 19; i++)
for (int j = 1; j + (1 << i) - 1 <= n; j++)
st[j][i] = max(st[j][i - 1], st[j + (1 << (i - 1))][i - 1]);
tot = 0;
for (int i = 1; i <= n; i++) {
while (tot && a[s[tot]] > a[i]) tot--;
L[i] = s[tot];
s[++tot] = i;
}
tot = 0;
for (int i = n; i >= 1; i--) {
while (tot && a[s[tot]] >= a[i]) tot--;
R[i] = s[tot];
s[++tot] = i;
}
for (int i = 1; i <= n; i++) {
na[i] = INF;
if (L[i]) na[i] = query(L[i], i);
if (R[i]) na[i] = min(na[i], query(i, R[i]));
}
}
int id[maxn], id2[maxn];
bool cmp(int x, int y) { return a[x] < a[y]; }
bool cmp2(int x, int y) { return nb[x] < nb[y]; }
namespace Seg {
int tr[maxn];
void add(int x) {
for (; x < maxn; x += x & (-x)) tr[x]++;
}
int query(int x) {
int res = 0;
for (; x; x -= x & (-x)) res += tr[x];
return res;
}
int query(int l, int r) { return query(r) - query(l - 1); }
}; // namespace Seg
int main() {
read(n), read(m), read(X);
for (int i = 1; i <= n; i++) read(a[i]);
for (int i = 1; i <= m; i++) read(b[i]);
solve(n, a, na);
solve(m, b, nb);
for (int i = 1; i <= n; i++) id[i] = i;
sort(id + 1, id + n + 1, cmp);
for (int i = 1; i <= m; i++) id2[i] = i;
sort(id2 + 1, id2 + m + 1, cmp2);
int pos = m + 1;
for (int I = 1; I <= n; I++) {
int i = id[I];
while (pos > 1 && nb[id2[pos - 1]] > X - a[i]) {
pos--;
Seg::add(b[id2[pos]]);
}
int L = max(1, X - na[i] + 1), R = min(200000, X - a[i]);
if (L <= R) ans += Seg::query(L, R);
}
printf("%lld\n", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
std::priority_queue<int> Q;
int check[100010];
std::vector<int> V[100010], V2[100010];
int score[100010];
int main() {
int a, b;
scanf("%d%d", &a, &b);
for (int i = 1; i <= b; i++) {
int c, d;
scanf("%d%d", &c, &d);
V[c].push_back(d);
V2[d].push_back(c);
}
for (int i = 1; i <= a; i++) score[i] = V[i].size();
for (int i = 1; i <= a; i++)
if (score[i] == 0) Q.push(i);
int C = a;
while (!Q.empty()) {
int k = Q.top();
Q.pop();
check[k] = C--;
for (int i = 0; i < V2[k].size(); i++) {
score[V2[k][i]]--;
if (score[V2[k][i]] == 0) Q.push(V2[k][i]);
}
}
for (int i = 1; i <= a; i++) printf("%d ", check[i]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long s[45][45];
long long nbit[45];
int main() {
s[0][0] = 1;
for (int i = 1; i <= 42; i++) {
s[i][0] = s[i][i] = 1;
for (int j = 1; j < i; j++) s[i][j] = s[i - 1][j - 1] + s[i - 1][j];
}
long long n, t;
cin >> n >> t;
n += 2;
long long tt = t;
bool feasible = true;
long long bitcnt = 0;
while (tt > 0) {
if (tt & 1 && tt != 1) {
feasible = false;
break;
}
tt >>= 1;
bitcnt++;
}
long long nn = n;
long long nptr = 0;
while (nn > 0) {
nbit[nptr++] = nn & 1;
nn >>= 1;
}
if (feasible) {
long long answer = 0;
long long onecnt = 0;
for (int ni = nptr - 1; ni >= 0; ni--) {
if (nbit[ni] == 1) answer += s[ni][bitcnt - onecnt];
onecnt += nbit[ni];
}
if (bitcnt == 1) answer--;
cout << answer << endl;
} else
cout << 0 << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long i, j;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
string s;
cin >> s;
n = s.length();
vector<long long> x, y;
x.push_back(0);
y.push_back(0);
long long p = 0, q = 0;
for (i = 0; i < n; i++) {
if (s[i] == 'U')
q++;
else if (s[i] == 'D')
q--;
else if (s[i] == 'R')
p++;
else
p--;
x.push_back(p);
y.push_back(q);
}
long long tot = 0;
for (i = 0; i < x.size() - 1; i++) {
for (j = i + 1; j < x.size(); j++) {
if (x[i] == x[j] && y[i] == y[j]) tot++;
}
}
cout << tot << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
signed main() {
std::ios::sync_with_stdio(false);
string str;
cin >> str;
long long int n = str.size();
string prf = "";
vector<long long int> v(n, 0);
for (long long int i = 0; i < n - 1; i++)
if (str[i] != str[i + 1]) v[i] = 1;
if (str[n - 1] == 'a') v[n - 1] = 1;
for (long long int i = 0; i < n; i++) cout << v[i] << " ";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[105][105];
int l[105];
vector<int> v;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", l + i);
for (int j = 0; j < l[i]; j++) scanf("%d", &a[i][j]);
}
int cil = 0, mil = 0;
for (int i = 0; i < n; i++) {
int len = l[i];
if (!(len % 2)) {
for (int j = 0; j < len / 2; j++) cil += a[i][j];
for (int j = len / 2; j < len; j++) mil += a[i][j];
} else {
v.push_back(a[i][len / 2]);
for (int j = 0; j < len / 2; j++) cil += a[i][j];
for (int j = len / 2 + 1; j < len; j++) mil += a[i][j];
}
}
sort(v.begin(), v.end());
int in = 1;
for (int i = v.size() - 1; i > -1; i--) {
in ? cil += v[i] : mil += v[i];
in = (in + 1) % 2;
}
cout << cil << " " << mil << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, s, rt;
pair<long long, pair<long long, long long>> input[(int)1e5 + 5];
bool valid(long long x) {
for (int i = 0; i < n; i++)
input[i].first = input[i].second.first + input[i].second.second * x;
sort(input, input + n);
long long ret = 0;
for (int i = 0; i < x; i++)
ret += input[i].second.first + input[i].second.second * x;
rt = ret;
return s >= ret;
}
int main() {
cin >> n >> s;
for (int i = 0, t; i < n; i++) {
if (i == 0)
scanf("\n%d", &t);
else
scanf(" %d", &t);
input[i].second.first = t;
input[i].second.second = i + 1;
}
long long mn = 0, mx = n, mid = (mn + mx) / 2;
valid(mx);
for (int i = 0; i < 50; i++, mid = (mn + mx) / 2) {
if (valid(mid)) {
mn = mid;
} else {
mx = mid;
}
}
if (valid(mx)) {
cout << mx << " " << rt << endl;
} else {
valid(mn);
cout << mn << " " << rt << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, mod = 1e9 + 7;
void solve() {
string s;
cin >> s;
int n = s.size();
if (n % 2 != 0)
cout << "NO" << endl;
else if (s.substr(0, n / 2) == s.substr(n / 2, n / 2))
cout << "YES" << endl;
else
cout << "NO" << endl;
}
int32_t main() {
;
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long int a[n];
long long int sum = 0;
long long int mx = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
mx = max(mx, a[i]);
}
sum = ceil((double)((double)sum / (double)(n - 1)));
cout << max(mx, sum);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
const int maxm = 100005;
cin >> n >> m >> k;
int u[maxm], v[maxm], l[maxm], a[maxm] = {0};
int b;
for (int i = 0; i < m; i++) cin >> u[i] >> v[i] >> l[i];
if (k == 0) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < k; i++) {
cin >> b;
a[b] = 1;
}
int mini = 1000000005;
for (int i = 0; i < m; i++) {
if (a[u[i]] ^ a[v[i]] == 1 && l[i] < mini) mini = l[i];
}
if (mini == 1000000005)
cout << -1 << endl;
else
cout << mini << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, M = 1e6 + 6, OO = 0x3f3f3f3f;
int n, arr[N];
int tc;
int main() {
cin >> tc;
while (tc--) {
cin >> n;
for (int i = 0; i < 2 * n; i++) cin >> arr[i];
sort(arr, arr + 2 * n);
cout << abs(arr[n] - arr[(n - 1)]) << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int sqr(int x) { return x * x; }
using namespace std;
const int N = 2000000;
const int NN = 1e5 + 2;
int n, a[NN], pr[N];
bool used[N], used2[N];
bool good(int x) {
int copy_x = x;
bool ok = false;
while (x > 1) {
ok |= used2[pr[x]];
x /= pr[x];
}
if (!ok) {
x = copy_x;
while (x > 1) {
used2[pr[x]] = true;
x /= pr[x];
}
}
return !ok;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (long long i = 2; i < N; ++i) {
if (!used[i]) {
pr[i] = i;
for (long long j = i + i; j < N; j += i) {
used[j] = true;
pr[j] = i;
}
}
}
int i;
int iter = 2;
for (i = 1; i <= n; ++i) {
if (good(a[i])) {
cout << a[i] << ' ';
} else {
int x = a[i] + 1;
while (!good(x)) x++;
cout << x << ' ';
break;
}
}
i++;
for (; i <= n; ++i) {
while (!good(iter)) {
iter++;
}
cout << iter << ' ';
used2[iter] = true;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
inline int getint() {
int x = 0, p = 1;
char c = getchar();
while (c <= 32) c = getchar();
if (c == 45) p = -p, c = getchar();
while (c > 32) x = x * 10 + c - 48, c = getchar();
return x * p;
}
using namespace std;
const int N = 3e5 + 5;
bool vis[N];
vector<pair<int, int> > G[N];
int n, m;
vector<int> res;
int main() {
int t = getint();
for (int(ttt) = 0; (ttt) < (t); (ttt)++) {
n = getint();
for (int(i) = 0; (i) < (3 * n); (i)++) vis[i] = false;
for (int(i) = 0; (i) < (3 * n); (i)++) G[i].clear();
m = getint();
for (int(i) = 0; (i) < (m); (i)++) {
int x = getint() - 1, y = getint() - 1;
G[x].push_back(make_pair(i, y));
G[y].push_back(make_pair(i, x));
}
res.clear();
for (int(i) = 0; (i) < (3 * n); (i)++)
if (!vis[i]) {
for (int(j) = 0; (j) < (G[i].size()); (j)++)
if (!vis[G[i][j].second]) {
vis[i] = vis[G[i][j].second] = true;
res.push_back(G[i][j].first);
break;
}
if (vis[i]) continue;
}
if (res.size() >= n) {
printf("Matching\n");
for (int(i) = 0; (i) < (n); (i)++) printf("%d ", res[i] + 1);
printf("\n");
} else {
printf("IndSet\n");
int cnt = 0;
for (int(i) = 0; (i) < (3 * n); (i)++)
if (!vis[i]) {
++cnt;
printf("%d ", i + 1);
if (cnt >= n) break;
}
printf("\n");
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
int r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
int main() {
long long i, j, k, n, q, a, b, s, amount;
string s1, s2;
cin >> q;
while (q--) {
cin >> a >> b >> n >> s;
int mod = s % n;
if (mod > b) {
cout << "NO\n";
} else {
int big = (s - mod) / n;
if (a * n + b >= s) {
cout << "YES\n";
} else
cout << "NO\n";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
struct node {
int x, y;
};
int a[110][110];
node idx[110][110];
int main() {
cin >> n >> m >> q;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) idx[i][j].x = i, idx[i][j].y = j;
for (int i = 1; i <= q; i++) {
int t, u, v, e;
cin >> t;
if (t == 1) {
cin >> u;
idx[u][m + 1] = idx[u][1];
for (int j = 1; j <= m; j++) idx[u][j] = idx[u][j + 1];
}
if (t == 2) {
cin >> v;
idx[n + 1][v] = idx[1][v];
for (int j = 1; j <= n; j++) idx[j][v] = idx[j + 1][v];
}
if (t == 3) {
cin >> u >> v >> e;
a[idx[u][v].x][idx[u][v].y] = e;
}
}
for (int i = 1; i <= n; i++, cout << endl)
for (int j = 1; j <= m; j++) cout << a[i][j] << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tst;
cin >> tst;
while (tst--) {
long long x, y, k;
cin >> x >> y >> k;
long long coal = y * k;
long long need = coal + k;
long long f = need / (x - 1);
long long res;
for (long long i = f - 5; i < f + 5; i++) {
long long k = (x - 1) * (i) + 1;
if (k >= need) {
res = i;
break;
}
}
cout << res + k << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char f[10], m[10], s[10];
scanf("%s%s%s", &f, &m, &s);
int w = 4;
if ((f[0] == 'p') && (m[0] == 'r') && (s[0] == 'r'))
w = 1;
else if ((f[0] == 'r') && (m[0] == 's') && (s[0] == 's'))
w = 1;
else if ((f[0] == 's') && (m[0] == 'p') && (s[0] == 'p'))
w = 1;
else if ((f[0] == 'r') && (m[0] == 'p') && (s[0] == 'r'))
w = 2;
else if ((f[0] == 'p') && (m[0] == 's') && (s[0] == 'p'))
w = 2;
else if ((f[0] == 's') && (m[0] == 'r') && (s[0] == 's'))
w = 2;
else if ((f[0] == 'r') && (m[0] == 'r') && (s[0] == 'p'))
w = 3;
else if ((f[0] == 'p') && (m[0] == 'p') && (s[0] == 's'))
w = 3;
else if ((f[0] == 's') && (m[0] == 's') && (s[0] == 'r'))
w = 3;
if (w == 1)
printf("F\n");
else if (w == 2)
printf("M\n");
else if (w == 3)
printf("S\n");
else
printf("?\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
long long a[N], b[N];
int main() {
int n, d;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i] = 0;
}
long long maxx = a[n - 1];
for (int i = n - 2; i >= 0; i--) {
if (a[i] <= maxx) {
b[i] = maxx + 1 - a[i];
} else {
maxx = a[i];
}
}
for (int i = 0; i < n; i++) cout << b[i] << " ";
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
register int data = 0, w = 1;
char ch = 0;
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') w = -1, ch = getchar();
while (ch >= '0' && ch <= '9')
data = (data << 1) + (data << 3) + (ch ^ 48), ch = getchar();
return data * w;
}
int n, a[1000005], L[1000005], R[1000005], M, per[1000005], f[1000005],
pf[1000005];
int main() {
n = read();
M = read();
for (int i = 1; i <= n; i++) a[i] = read(), per[a[i]]++;
int m = 0;
for (int i = 1; i <= M; i++)
if (per[i]) f[i] = ++m, pf[m] = i;
for (int i = 1; i <= n; i++) a[i] = f[a[i]];
for (int i = 1; i <= n; i++) R[a[i]] = i;
for (int i = n; i >= 1; i--) L[a[i]] = i;
L[m + 1] = R[m + 1] = n + 1;
int t = m + 1;
while (t > 1 && R[t - 1] < L[t]) --t;
if (t == 1) return cout << 1ll * M * (M + 1) / 2 << '\n', 0;
long long ans = 1ll * (M - pf[t - 1] + 1) * pf[1];
for (int i = 1; i <= m - 1; i++) {
if (L[i] < R[i - 1]) break;
while (R[i] > L[t]) ++t;
ans += 1ll * (M - pf[t - 1] + 1) * (pf[i + 1] - pf[i]);
}
cout << ans << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char word[100010];
set<char> may;
set<char> now;
set<char>::iterator I, tI;
int main() {
int n, len, ans = 0;
char c;
cin >> n;
for (char i = 'a'; i <= 'z'; i++) {
may.insert(i);
}
for (int i = 0; i < n; i++) {
cin >> c >> word;
len = strlen(word);
if (c == '.') {
for (int j = 0; j < len; j++) {
may.erase(word[j]);
}
} else if (c == '!') {
if (may.size() == 1) {
ans++;
} else {
now.clear();
for (int j = 0; j < len; j++) {
now.insert(word[j]);
}
for (I = may.begin(); I != may.end();) {
if (now.find(*I) == now.end()) {
tI = I;
tI++;
may.erase(I);
I = tI;
} else {
I++;
}
}
}
} else {
if (may.size() == 1) {
if (word[0] != *may.begin()) {
ans++;
}
} else {
may.erase(word[0]);
}
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
float mem[201][201][401];
int k, l;
float pd(int n, int m, int c, vector<float> &probas, vector<int> &premios) {
if (n == 0) {
return c >= -k and m >= l;
}
if (mem[n][m][min(400, c + 200)] < 0) {
mem[n][m][min(400, c + 200)] =
pd(n - 1, m + 1, c + premios[n], probas, premios) * probas[n] +
pd(n - 1, m, c, probas, premios) * (1 - probas[n]);
}
return mem[n][m][min(400, c + 200)];
}
int main() {
int n, p, a;
cin >> n >> l >> k;
vector<float> probas(n + 1);
vector<int> premios(n + 1);
for (int i = 1; i <= n; ++i) {
cin >> p;
probas[i] = (float)p / 100;
}
for (int i = 1; i <= n; ++i) {
cin >> a;
premios[i] = a;
}
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= n; ++j)
for (int m = 0; m < 401; ++m) mem[i][j][m] = -1;
cout << pd(n, 0, 0, probas, premios);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, q, t, x, ans, son;
map<int, int> FW[100050], H;
void upd(int bas, int pos, int v) {
for (int t = bas; t <= (1e9); t += t & -t) FW[pos][t] += v;
}
int que(int bas, int pos) {
ans = 0;
for (int t = bas; t > 0; t -= t & -t) ans += FW[pos][t];
return ans;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d %d %d", &q, &t, &x);
if (q == 1 and H.find(x) == H.end()) H[x] = ++son;
if (q < 3)
upd(t, H[x], q & 1 ? 1 : -1);
else
printf("%d\n", que(t, H[x]));
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : (-x);
}
template <class T>
T sqr(T x) {
return x * x;
}
map<int, int> M;
int main() {
int n;
cin >> n;
vector<int> v(n);
int sum = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &v[i]);
sum += v[i];
if (i < n - 1) M[sum]++;
}
if (sum % 3) {
printf("0\n");
return 0;
}
long long res = 0;
sum /= 3;
int t = 0;
for (int i = 0; i < n - 1; i++) {
t += v[i];
M[t]--;
if (t == sum) {
int x = t + sum;
res += M[x];
}
}
cout << res << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
T f = 1;
x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
x *= f;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) print(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
T Max(T x, T y) {
return x > y ? x : y;
}
const int maxn = 3e5 + 5;
int n, a[maxn], tree[maxn], pos[maxn], cnt, ans;
unsigned long long ran[maxn], h[maxn], t[maxn];
int work(int pos) {
int maxx = -1, res = 0;
for (int i = pos + 1; a[i] != 1; ++i) {
maxx = Max(maxx, a[i]);
if (i >= maxx && i - maxx + 1 <= pos && (h[i] ^ h[i - maxx]) == t[maxx])
res++;
}
return res;
}
int main() {
read(n);
srand(2005 - 12 - 30);
a[n + 1] = 1;
for (int i = 1; i <= n; ++i) read(a[i]);
for (int i = 1; i <= n; ++i) ran[i] = rand() * rand() * 'zyzsb';
for (int i = 1; i <= n; ++i) t[i] = t[i - 1] ^ ran[i];
for (int i = 1; i <= n; ++i) h[i] = h[i - 1] ^ ran[a[i]];
for (int i = 1; i <= n; ++i)
if (a[i] == 1) ans += work(i) + 1;
a[n + 1] = 1;
reverse(a + 1, a + 1 + n);
for (int i = 1; i <= n; ++i) h[i] = h[i - 1] ^ ran[a[i]];
for (int i = 1; i <= n; ++i)
if (a[i] == 1) ans += work(i);
print(ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1000000000000000000;
class SegmentTree {
vector<vector<long long> > mx;
public:
SegmentTree() {}
SegmentTree(int N) : mx(N * 4 + 5, vector<long long>(3, -inf)) {}
void update(int l, int r, int x, int p, long long v1, long long v2) {
if (l == r) {
mx[x] = {v1, v2, -inf};
return;
}
int mid = l + r >> 1;
if (p <= mid) {
update(l, mid, x << 1, p, v1, v2);
} else {
update(mid + 1, r, x << 1 | 1, p, v1, v2);
}
mx[x][0] = max(mx[x << 1][0], mx[x << 1 | 1][0]);
mx[x][1] = max(mx[x << 1][1], mx[x << 1 | 1][1]);
mx[x][2] = max(max(mx[x << 1][2], mx[x << 1 | 1][2]),
max(mx[x << 1][0] + mx[x << 1 | 1][1],
mx[x << 1][1] + mx[x << 1 | 1][0]));
}
vector<long long> query(int l, int r, int x, int a, int b) {
if (l > b || r < a) {
return (vector<long long>){-inf, -inf, -inf};
}
if (l >= a && r <= b) {
return mx[x];
}
int mid = l + r >> 1;
auto L = query(l, mid, x << 1, a, b);
auto R = query(mid + 1, r, x << 1 | 1, a, b);
return {max(L[0], R[0]), max(L[1], R[1]),
max(max(L[2], R[2]), max(L[0] + R[1], L[1] + R[0]))};
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
vector<long long> d(n);
for (int i = 0; i < n; ++i) {
cin >> d[i];
}
vector<long long> h(n);
for (int i = 0; i < n; ++i) {
cin >> h[i];
}
SegmentTree t(n + n);
long long sum = 0;
for (int i = 0; i < n; ++i) {
t.update(0, n + n - 1, 1, i, h[i] + h[i] + sum, h[i] + h[i] - sum);
sum += d[i];
}
for (int i = 0; i < n; ++i) {
t.update(0, n + n - 1, 1, i + n, h[i] + h[i] + sum, h[i] + h[i] - sum);
sum += d[i];
}
while (m--) {
int a, b;
cin >> a >> b;
a--;
b--;
if (a <= b) {
auto o = t.query(0, n + n - 1, 1, b + 1, a - 1 + n);
cout << o[2] << '\n';
} else {
auto o = t.query(0, n + n - 1, 1, b + 1, a - 1);
cout << o[2] << '\n';
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void setmin(T &x, T y) {
if (y < x) x = y;
}
template <typename T>
inline void setmax(T &x, T y) {
if (y > x) x = y;
}
template <typename T>
inline T gcd(T a, T b) {
while (b) swap(a %= b, b);
return a;
}
const int MAX = 1e5 + 7;
const int INF = 1e9 + 7;
const long long BIG_INF = 1e18 + 5;
long double e = 2.7182818284590452353602874713526624;
long double PI = acos(-1);
long double eps = 1e-19;
int n, m, q, licznik;
int tab1[1007];
int tab2[1007];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m;
m--;
for (int i = 0; i < n; i++) {
cin >> tab1[i];
}
for (int i = 0; i < n; i++) {
cin >> tab2[i];
}
bool trzeci = 1;
for (int i = m + 1; i < n; i++) {
if (tab1[i] && tab2[i]) {
trzeci = 0;
}
}
if (!tab1[0] || (!tab1[m] && !tab2[m]) || (!(tab1[m]) && trzeci)) {
cout << "NO";
} else {
cout << "YES";
}
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
void *wmem;
char memarr[96000000];
template <class T>
inline void walloc1d(T **arr, int x, void **mem = &wmem) {
static int skip[16] = {0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
(*mem) = (void *)(((char *)(*mem)) + skip[((unsigned long long)(*mem)) & 15]);
(*arr) = (T *)(*mem);
(*mem) = ((*arr) + x);
}
template <class T>
inline void walloc1d(T **arr, int x1, int x2, void **mem = &wmem) {
walloc1d(arr, x2 - x1, mem);
(*arr) -= x1;
}
struct Modint {
unsigned val;
Modint() { val = 0; }
Modint(int a) { val = ord(a); }
Modint(unsigned a) { val = ord(a); }
Modint(long long a) { val = ord(a); }
Modint(unsigned long long a) { val = ord(a); }
inline unsigned ord(unsigned a) { return a % (998244353U); }
inline unsigned ord(int a) {
a %= (int)(998244353U);
if (a < 0) {
a += (998244353U);
}
return a;
}
inline unsigned ord(unsigned long long a) { return a % (998244353U); }
inline unsigned ord(long long a) {
a %= (int)(998244353U);
if (a < 0) {
a += (998244353U);
}
return a;
}
inline unsigned get() { return val; }
inline Modint &operator+=(Modint a) {
val += a.val;
if (val >= (998244353U)) {
val -= (998244353U);
}
return *this;
}
inline Modint &operator-=(Modint a) {
if (val < a.val) {
val = val + (998244353U) - a.val;
} else {
val -= a.val;
}
return *this;
}
inline Modint &operator*=(Modint a) {
val = ((unsigned long long)val * a.val) % (998244353U);
return *this;
}
inline Modint &operator/=(Modint a) { return *this *= a.inverse(); }
inline Modint operator+(Modint a) { return Modint(*this) += a; }
inline Modint operator-(Modint a) { return Modint(*this) -= a; }
inline Modint operator*(Modint a) { return Modint(*this) *= a; }
inline Modint operator/(Modint a) { return Modint(*this) /= a; }
inline Modint operator+(int a) { return Modint(*this) += Modint(a); }
inline Modint operator-(int a) { return Modint(*this) -= Modint(a); }
inline Modint operator*(int a) { return Modint(*this) *= Modint(a); }
inline Modint operator/(int a) { return Modint(*this) /= Modint(a); }
inline Modint operator+(long long a) { return Modint(*this) += Modint(a); }
inline Modint operator-(long long a) { return Modint(*this) -= Modint(a); }
inline Modint operator*(long long a) { return Modint(*this) *= Modint(a); }
inline Modint operator/(long long a) { return Modint(*this) /= Modint(a); }
inline Modint operator-(void) {
Modint res;
if (val) {
res.val = (998244353U) - val;
} else {
res.val = 0;
}
return res;
}
inline operator bool(void) { return val != 0; }
inline operator int(void) { return get(); }
inline operator long long(void) { return get(); }
inline Modint inverse() {
int a = val;
int b = (998244353U);
int u = 1;
int v = 0;
int t;
Modint res;
while (b) {
t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
if (u < 0) {
u += (998244353U);
}
res.val = u;
return res;
}
inline Modint pw(unsigned long long b) {
Modint a(*this);
Modint res;
res.val = 1;
while (b) {
if (b & 1) {
res *= a;
}
b >>= 1;
a *= a;
}
return res;
}
inline bool operator==(int a) { return ord(a) == val; }
inline bool operator!=(int a) { return ord(a) != val; }
};
inline Modint operator+(int a, Modint b) { return Modint(a) += b; }
inline Modint operator-(int a, Modint b) { return Modint(a) -= b; }
inline Modint operator*(int a, Modint b) { return Modint(a) *= b; }
inline Modint operator/(int a, Modint b) { return Modint(a) /= b; }
inline Modint operator+(long long a, Modint b) { return Modint(a) += b; }
inline Modint operator-(long long a, Modint b) { return Modint(a) -= b; }
inline Modint operator*(long long a, Modint b) { return Modint(a) *= b; }
inline Modint operator/(long long a, Modint b) { return Modint(a) /= b; }
inline int my_getchar() {
static char buf[1048576];
static int s = 1048576;
static int e = 1048576;
if (s == e && e == 1048576) {
e = fread(buf, 1, 1048576, stdin);
s = 0;
}
if (s == e) {
return EOF;
}
return buf[s++];
}
inline void rd(int &x) {
int k;
int m = 0;
x = 0;
for (;;) {
k = my_getchar();
if (k == '-') {
m = 1;
break;
}
if ('0' <= k && k <= '9') {
x = k - '0';
break;
}
}
for (;;) {
k = my_getchar();
if (k < '0' || k > '9') {
break;
}
x = x * 10 + k - '0';
}
if (m) {
x = -x;
}
}
struct MY_WRITER {
char buf[1048576];
int s;
int e;
MY_WRITER() {
s = 0;
e = 1048576;
}
~MY_WRITER() {
if (s) {
fwrite(buf, 1, s, stdout);
}
}
};
MY_WRITER MY_WRITER_VAR;
void my_putchar(int a) {
if (MY_WRITER_VAR.s == MY_WRITER_VAR.e) {
fwrite(MY_WRITER_VAR.buf, 1, MY_WRITER_VAR.s, stdout);
MY_WRITER_VAR.s = 0;
}
MY_WRITER_VAR.buf[MY_WRITER_VAR.s++] = a;
}
inline void wt_L(char a) { my_putchar(a); }
inline void wt_L(int x) {
int s = 0;
int m = 0;
char f[10];
if (x < 0) {
m = 1;
x = -x;
}
while (x) {
f[s++] = x % 10;
x /= 10;
}
if (!s) {
f[s++] = 0;
}
if (m) {
my_putchar('-');
}
while (s--) {
my_putchar(f[s] + '0');
}
}
inline void wt_L(long long x) {
int s = 0;
int m = 0;
char f[20];
if (x < 0) {
m = 1;
x = -x;
}
while (x) {
f[s++] = x % 10;
x /= 10;
}
if (!s) {
f[s++] = 0;
}
if (m) {
my_putchar('-');
}
while (s--) {
my_putchar(f[s] + '0');
}
}
inline void wt_L(Modint x) {
int i;
i = (int)x;
wt_L(i);
}
template <class T, class S>
inline T pow_L(T a, S b) {
T res = 1;
res = 1;
for (;;) {
if (b & 1) {
res *= a;
}
b >>= 1;
if (b == 0) {
break;
}
a *= a;
}
return res;
}
inline double pow_L(double a, double b) { return pow(a, b); }
template <class S, class T>
inline S chmin(S &a, T b) {
if (a > b) {
a = b;
}
return a;
}
template <class T>
struct DijkstraHeap {
int *hp;
int *place;
int size;
char *visited;
T *val;
void malloc(int N) {
hp = (int *)std::malloc(N * sizeof(int));
place = (int *)std::malloc(N * sizeof(int));
visited = (char *)std::malloc(N * sizeof(char));
val = (T *)std::malloc(N * sizeof(T));
}
void free() {
std::free(hp);
std::free(place);
std::free(visited);
std::free(val);
}
void walloc(int N, void **mem = &wmem) {
walloc1d(&hp, N, mem);
walloc1d(&place, N, mem);
walloc1d(&visited, N, mem);
walloc1d(&val, N, mem);
}
void init(int N) {
int i;
size = 0;
for (i = (0); i < (N); i++) {
place[i] = -1;
}
for (i = (0); i < (N); i++) {
visited[i] = 0;
}
}
void up(int n) {
int m;
while (n) {
m = (n - 1) / 2;
if (val[hp[m]] <= val[hp[n]]) {
break;
}
swap(hp[m], hp[n]);
swap(place[hp[m]], place[hp[n]]);
n = m;
}
}
void down(int n) {
int m;
for (;;) {
m = 2 * n + 1;
if (m >= size) {
break;
}
if (m + 1 < size && val[hp[m]] > val[hp[m + 1]]) {
m++;
}
if (val[hp[m]] >= val[hp[n]]) {
break;
}
swap(hp[m], hp[n]);
swap(place[hp[m]], place[hp[n]]);
n = m;
}
}
void change(int n, T v) {
if (visited[n] || (place[n] >= 0 && val[n] <= v)) {
return;
}
val[n] = v;
if (place[n] == -1) {
place[n] = size;
hp[size++] = n;
up(place[n]);
} else {
up(place[n]);
}
}
int pop(void) {
int res = hp[0];
place[res] = -1;
size--;
if (size) {
hp[0] = hp[size];
place[hp[0]] = 0;
down(0);
}
visited[res] = 1;
return res;
}
};
struct graph {
int N;
int *es;
int **edge;
void setDirectEdge(int N__, int M, int A[], int B[], void **mem = &wmem) {
int i;
N = N__;
walloc1d(&es, N, mem);
walloc1d(&edge, N, mem);
walloc1d(&edge[0], M, mem);
for (i = (0); i < (N); i++) {
es[i] = 0;
}
for (i = (0); i < (M); i++) {
es[A[i]]++;
}
for (i = (0); i < (N); i++) {
walloc1d(&edge[i], es[i], mem);
}
for (i = (0); i < (N); i++) {
es[i] = 0;
}
for (i = (0); i < (M); i++) {
edge[A[i]][es[A[i]]++] = B[i];
}
}
};
struct dimcomp2 {
int B;
dimcomp2() {}
dimcomp2(int b) { B = b; }
dimcomp2(int a, int b) { B = b; }
inline void set(int b) { B = b; }
inline void set(int a, int b) { B = b; }
inline int mask(int a, int b) { return a * B + b; }
inline int operator()(int a, int b) { return a * B + b; }
inline void para(int mask, int &a, int &b) {
a = mask / B;
b = mask % B;
}
inline void operator()(int mask, int &a, int &b) {
a = mask / B;
b = mask % B;
}
};
int N;
int M;
int A[200000];
int B[200000];
graph g[2];
int dist[20][200000];
int q[10000000];
int qs;
int qe;
int main() {
wmem = memarr;
int t;
int i;
int j;
int k;
long long nres;
long long c;
Modint res;
DijkstraHeap<long long> hp;
rd(N);
rd(M);
{
int Lj4PdHRW;
for (Lj4PdHRW = (0); Lj4PdHRW < (M); Lj4PdHRW++) {
rd(A[Lj4PdHRW]);
A[Lj4PdHRW] += (-1);
rd(B[Lj4PdHRW]);
B[Lj4PdHRW] += (-1);
}
}
g[0].setDirectEdge(N, M, A, B);
g[1].setDirectEdge(N, M, B, A);
dimcomp2 dm(N);
for (i = (0); i < (20); i++) {
for (j = (0); j < (N); j++) {
dist[i][j] = 1073709056;
}
}
dist[0][0] = 0;
qs = qe = 5000000;
q[qe++] = 0;
while (qe > qs) {
int t_ynMSdg;
dm(q[qs++], t, i);
for (t_ynMSdg = (0); t_ynMSdg < (g[t % 2].es[i]); t_ynMSdg++) {
auto &k = g[t % 2].edge[i][t_ynMSdg];
if (dist[t][k] != 1073709056) {
continue;
}
dist[t][k] = dist[t][i] + 1;
q[qe++] = dm(t, k);
}
if (t + 1 < 20 && dist[t + 1][i] == 1073709056) {
dist[t + 1][i] = dist[t][i];
q[--qs] = dm(t + 1, i);
}
}
nres = 4611686016279904256LL;
for (i = (0); i < (20); i++) {
if (dist[i][N - 1] != 1073709056) {
chmin(nres, dist[i][N - 1] + (1LL << i) - 1);
}
}
if (nres != 4611686016279904256LL) {
wt_L(nres);
wt_L('\n');
return 0;
}
hp.walloc(2 * N);
hp.init(2 * N);
hp.change(0, 0LL);
while (hp.size) {
int APIVbQlN;
dm(hp.pop(), t, i);
c = hp.val[dm(t, i)];
hp.change(dm((t + 1) % 2, i), c + 10000000000LL);
for (APIVbQlN = (0); APIVbQlN < (g[t % 2].es[i]); APIVbQlN++) {
auto &k = g[t % 2].edge[i][APIVbQlN];
hp.change(dm(t, k), c + 1);
}
}
for (t = (0); t < (2); t++) {
if (hp.visited[dm(t, N - 1)]) {
chmin(nres, hp.val[dm(t, N - 1)]);
}
}
res = (pow_L(Modint(2), (nres / 10000000000LL))) + nres % 10000000000LL - 1;
wt_L(res);
wt_L('\n');
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
int n, a[55], ck[55], vis[55][55][55], cs;
long double dp[55][55][55], fac[55];
long double go(int u, int tk, int pt) {
if (tk == 0 && pt == 0) return 1.00;
if (u == n || tk < 0 || pt < 0) return 0.00;
if (vis[u][tk][pt] == cs) return dp[u][tk][pt];
vis[u][tk][pt] = cs;
dp[u][tk][pt] = go(u + 1, tk, pt);
if (ck[u] == 0) dp[u][tk][pt] += go(u + 1, tk - a[u], pt - 1);
return dp[u][tk][pt];
}
long double DP[55];
int same[55];
int main() {
fac[0] = 1;
for (int i = 1; i < 51; i++) fac[i] = fac[i - 1] * i;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int p;
cin >> p;
sort(a, a + n);
long double ans = 0.00;
cs++;
for (int i = 0; i < p; i++) ans += n * go(0, p - i, n) * fac[n];
for (int i = 0; i < n; i++) {
if (same[a[i]] == 1) ans += DP[a[i]];
ck[i] = 1;
cs++;
for (int faka = 0; faka < a[i]; faka++) {
for (int koyta = 1; koyta < n; koyta++) {
ans += koyta * go(0, p - faka, koyta) * fac[n - koyta - 1] * fac[koyta];
}
}
ck[i] = 0;
}
ans /= fac[n];
cout << fixed << setprecision(20) << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long int Mod = 998244353;
long long int dp[100][100], pd[100][100], w[100], r[100], a[100], sum[2];
int n, m;
long long int Pow(long long int x, long long int y) {
long long int ans = 1, an = x;
while (y) {
if (y & 1LL) ans = (ans * an) % Mod;
an = an * an % Mod;
y >>= 1;
}
return ans;
}
long long int Div(long long int x, long long int y) {
return x * Pow(y, Mod - 2) % Mod;
}
long long int gp(long long int x, long long int y) { return Div(x, x + y); }
long long int bp(long long int x, long long int y) { return Div(y, x + y); }
void gsolve(int id) {
memset(pd, 0, sizeof pd);
pd[0][0] = 1;
for (int i = 0; i <= m; i++)
for (int j = 0; j <= i; j++) {
pd[i][j] %= Mod;
if (!pd[i][j]) continue;
r[id] = (r[id] + ((w[id] + j) * pd[i][j] % Mod) * dp[i][m - i]) % Mod;
long long int p = gp(w[id] + j, sum[1] - w[id] + i - j);
pd[i + 1][j + 1] += pd[i][j] * p;
pd[i + 1][j] += pd[i][j] * (1 - p);
}
r[id] += Mod;
r[id] %= Mod;
}
void bsolve(int id) {
memset(pd, 0, sizeof pd);
pd[0][0] = 1;
for (int i = 0; i <= m; i++)
for (int j = 0; j <= i; j++) {
pd[i][j] %= Mod;
if (!pd[i][j]) continue;
r[id] = (r[id] + ((w[id] - j) * pd[i][j] % Mod) * dp[m - i][i]) % Mod;
long long int p = gp(w[id] - j, sum[0] - w[id] - i + j);
pd[i + 1][j + 1] += pd[i][j] * p;
pd[i + 1][j] += pd[i][j] * (1 - p);
}
r[id] += Mod;
r[id] %= Mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
cin >> w[i];
sum[a[i]] += w[i];
}
dp[0][0] = 1;
for (int i = 0; i <= m; i++)
for (int j = 0; j <= m; j++) {
dp[i][j] %= Mod;
if (!dp[i][j]) continue;
dp[i + 1][j] += dp[i][j] * gp(sum[1] + i, sum[0] - j);
dp[i][j + 1] += dp[i][j] * bp(sum[1] + i, sum[0] - j);
}
for (int i = 0; i < n; i++) {
if (a[i])
gsolve(i);
else
bsolve(i);
}
for (int i = 0; i < n; i++) cout << r[i] << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
int ar[10001][4];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long a, b = 0, c, d = 0, e, f = 0, g, h = 0, x, y, z = 0;
cin >> a >> b;
c = 1;
for (int i = (1); i < (a + 1); ++i) {
ar[i][0] = c;
ar[i][1] = c + 1;
ar[i][2] = c + 2;
ar[i][3] = c + 4;
if (i == a) d = ar[i][3];
c += 6;
}
cout << d * b << endl;
for (int i = (1); i < (a + 1); ++i) {
for (int j = (0); j < (4); ++j) cout << ar[i][j] * b << " ";
cout << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int p[100005], type[100005], lvl[100005];
int anc[100005][20], weight[100005][20], comp, component[100005];
vector<int> G[100005];
void dfs(int v, int l) {
component[v] = comp;
lvl[v] = l;
for (int x : G[v])
if (lvl[x] == -1) {
anc[x][0] = v;
weight[x][0] = type[x];
dfs(x, l + 1);
}
}
pair<int, pair<int, int>> LCA(int u, int v) {
int left = -10, right = -10;
for (int i = 14; i >= 0; i--)
if (lvl[u] - (1 << i) >= lvl[v]) {
if (left == -10)
left = weight[u][i];
else
left = weight[u][i] != left ? -5 : left;
u = anc[u][i];
}
for (int i = 14; i >= 0; i--)
if (lvl[v] - (1 << i) >= lvl[u]) {
if (right == -10)
right = weight[v][i];
else
right = weight[v][i] != right ? -5 : right;
v = anc[v][i];
}
if (u == v) return make_pair(u, make_pair(left, right));
for (int i = 14; i >= 0; i--) {
if (anc[u][i] != -1 && anc[u][i] != anc[v][i]) {
left = weight[u][i] != left && left != -10 ? -5 : weight[u][i];
right = weight[v][i] != right && right != -10 ? -5 : weight[v][i];
u = anc[u][i];
v = anc[v][i];
}
}
left = weight[u][0] != left && left != -10 ? -5 : weight[u][0];
right = weight[v][0] != right && right != -10 ? -5 : weight[v][0];
return make_pair(anc[u][0], make_pair(left, right));
}
int main() {
int n, i, j, t, a, b;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &p[i], &type[i]);
G[p[i]].push_back(i);
}
for (i = 1; i <= n; i++) lvl[i] = -1;
anc[1][0] = 1;
weight[1][0] = 1e8;
for (i = 1; i <= n; i++)
for (j = 0; j < 15; j++) anc[i][j] = -1, weight[i][j] = -5;
comp = 1;
for (i = 1; i <= n; i++) {
if (component[i] == 0) dfs(i, 0);
comp++;
}
for (j = 1; j < 15; j++)
for (i = 1; i <= n; i++)
if (anc[i][j - 1] != -1) {
anc[i][j] = anc[anc[i][j - 1]][j - 1];
if (weight[i][j - 1] == weight[anc[i][j - 1]][j - 1])
weight[i][j] = weight[anc[i][j - 1]][j - 1];
}
int q;
scanf("%d", &q);
while (q--) {
scanf("%d%d%d", &t, &a, &b);
if (b == a or component[b] != component[a]) {
printf("NO\n");
continue;
}
pair<int, pair<int, int>> res = LCA(a, b);
if (t == 1) {
if (res.first == a and res.second.second == 0)
printf("YES\n");
else
printf("NO\n");
} else {
if (res.first == a and res.second.second == 1)
printf("YES\n");
else if (res.second.second == 1 and res.second.first == 0)
printf("YES\n");
else
printf("NO\n");
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
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;
}
vector<int> E[N];
vector<int> cir[N];
map<pair<int, int>, int> vis;
int ans[N], pj[N], s, n, m, rd[N], tim = 0, dfn[N], low[N], col[N];
stack<int> st;
bool jr[N], pd[N], in[N];
void dfs(int u, int k) {
for (int i = 0; i < E[u].size(); i++) {
int v = E[u][i];
if (vis[make_pair(v, k ^ 1)]) continue;
vis[make_pair(v, k ^ 1)] = u;
dfs(v, k ^ 1);
}
}
void getans(int u, int st, int tot) {
if (u == s && st == 0) {
printf("%d ", u);
return;
}
getans(vis[make_pair(u, st)], st ^ 1, tot + 1);
printf("%d ", u);
}
void tarjan(int u) {
dfn[u] = low[u] = ++tim;
st.push(u);
pd[u] = 1;
in[u] = 1;
for (int i = 0; i < E[u].size(); i++) {
int v = E[u][i];
if (!dfn[v]) {
tarjan(v);
low[u] = min(low[u], low[v]);
} else {
if (in[v]) low[u] = min(low[u], dfn[v]);
}
}
if (low[u] == dfn[u]) {
++col[0];
while (!st.empty()) {
int now = st.top();
st.pop();
col[now] = col[0];
cir[col[0]].push_back(now);
in[now] = 0;
if (now == u) break;
}
}
}
int main() {
n = read(), m = read();
for (int i = 1; i <= n; i++) {
int k = read();
for (int j = 1; j <= k; j++) {
int pd = read();
E[i].push_back(pd);
rd[E[i][j - 1]]++;
}
if (k == 0) pj[++pj[0]] = i;
}
s = read();
vis[make_pair(s, 0)] = s;
dfs(s, 0);
for (int i = 1; i <= pj[0]; i++) {
if (vis[make_pair(pj[i], 1)]) {
printf("Win\n");
getans(pj[i], 1, 1);
printf("\n");
return 0;
}
}
for (int i = 1; i <= n; i++) {
if (!dfn[i]) tarjan(i);
}
for (int i = 1; i <= col[0]; i++) {
if (cir[i].size() <= 1) continue;
for (int j = 0; j < cir[i].size(); j++) {
int v = cir[i][j];
if (vis[make_pair(v, 0)] || vis[make_pair(v, 1)]) {
printf("Draw\n");
return 0;
}
}
}
printf("Lose\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
int m = n * n;
int Count = 0;
for (int i = 1; i <= m / 2; i++) {
cout << i << ' ' << m - i + 1 << ' ';
Count += 2;
if (Count == n) {
Count = 0;
cout << '\n';
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 4e5 + 10;
int main() {
int n;
cin >> n;
vector<string> a(n);
for (string& x : a) cin >> x;
vector<int> bal(n), mn(n);
vector<vector<int>> occ(n), nocc(n);
for (int i = 0; i < n; i++) {
int b = 0, mn0 = 1e9;
occ[i].resize(mx * 2);
nocc[i].resize(mx * 2);
int mini = 1e9;
for (char x : a[i]) {
if (x == ')')
b--;
else
b++;
mini = min(b, mini);
mn0 = min(mn0, b);
occ[i][b + mx]++;
if (b == mini) nocc[i][b + mx]++;
}
bal[i] = b, mn[i] = mn0;
}
vector<vector<int>> answer((1 << n), vector<int>(2, -1e9));
answer[0] = {0, 0};
vector<int> sum(1 << n);
for (int mask = 0; mask < (1 << n); mask++) {
for (int i = 0; i < n; i++) {
if ((1 << i) & mask) {
sum[mask] = sum[mask ^ (1 << i)] + bal[i];
break;
}
}
for (int i = 0; i < n; i++) {
if ((1 << i) & mask) {
int nmask = (1 << i) ^ mask;
if (sum[nmask] + mn[i] < 0) {
answer[mask][1] =
max(answer[nmask][0] + nocc[i][mx - sum[nmask]], answer[mask][1]);
} else {
answer[mask][0] =
max(answer[mask][0], answer[nmask][0] + occ[i][mx - sum[nmask]]);
}
}
}
}
int ans = 0;
for (auto x : answer) ans = max({x[0], x[1], ans});
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void k_007() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
bool sortbysec(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.second < b.second);
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long prime(long long n) {
long long flag = 1;
for (long long i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
flag = 0;
break;
}
}
return flag;
}
long long power(long long x, long long y) {
if (y == 0)
return 1;
else if (y % 2 == 0)
return ((power(x, y / 2) % 1000000007) * (power(x, y / 2) % 1000000007)) %
1000000007;
else
return ((x % 1000000007) * (power(x, y / 2) % 1000000007) *
(power(x, y / 2) % 1000000007)) %
1000000007;
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
int32_t main() {
k_007();
long long x;
cin >> x;
while (x--) {
long long n, T;
cin >> n >> T;
long long a[n];
map<long long, long long> make_pair;
for (long long i = 0; i < n; i++) {
cin >> a[i];
make_pair[a[i]]++;
}
map<long long, long long> used;
vector<long long> white, black;
for (long long i = 0; i < n; i++) {
if (T - a[i] != a[i] && make_pair.count(T - a[i]) > 0 &&
used.count(a[i]) == 0) {
used[T - a[i]]++;
white.push_back(i);
} else if (T - a[i] == a[i] && make_pair.count(T - a[i]) > 0) {
used[a[i]]++;
if (used[a[i]] <= make_pair[a[i]] / 2) {
white.push_back(i);
}
}
}
vector<long long> ans(n, 0);
for (long long i = 0; i < (long long)(white.size()); i++) {
ans[white[i]]++;
}
for (long long i = 0; i < n; i++) {
cout << ans[i] << " ";
}
cout << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n,p,r,i,f,j,t,k;
string s,c;
int main() {
cin>>t;
while(t--){
f=0;
cin>>n>>s;
for(int i=97;i<123;i++)
if(s.find(i)==-1){
c=i;
cout<<c<<endl;
f=1;
break;
}
if(f==1)
continue;
for(i=97;i<123;i++){
for(j=97;j<123;j++){
c=i;
c+=j;
if(s.find(c)==-1){
cout<<c<<endl;
f=1;
break;
}
}
if(f==1)
break;
}
if(f==1)
continue;
for(i=97;i<123;i++){
for(j=97;j<123;j++){
for(k=97;k<123;k++){
c=i;
c+=j;
c+=k;
if(s.find(c)==-1){
cout<<c<<endl;
f=1;
break;
}
}
if(f==1)
break;
}
if(f==1)
break;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 3030;
const long long mod = 1000000007;
const long long mod2 = 998244353;
const long double eps = 1e-9;
const long long inf = ((1ll << 31ll) - 1ll);
const long long INF = 1ll * mod * mod;
const long double pi = acos(-1);
long long qpow(long long b, long long e) {
if (!e) return 1;
if (e & 1) return qpow(b, e - 1) * b % mod;
long long pwur = qpow(b, e >> 1);
return pwur * pwur % mod;
}
long long modinv(long long x) { return qpow(x, mod - 2); }
bool isprime(long long x) {
for (long long i = 2; i * i <= x; i++)
if (x % i == 0) return false;
return true;
}
vector<pair<long long, long long>> fact(long long x) {
vector<pair<long long, long long>> ret;
for (long long i = 2; i * i <= x; i++) {
if (x % i == 0) {
long long cnt_ = 0;
while (x % i == 0) x /= i, cnt_++;
ret.push_back({i, cnt_});
}
}
if (x > 1) {
ret.push_back({x, 1});
}
return ret;
}
template <typename flow_type, typename cost_type>
struct min_cost_max_flow {
struct edge {
size_t src, dst, rev;
flow_type flow, cap;
cost_type cost;
};
long long n;
vector<vector<edge>> adj;
min_cost_max_flow(long long n)
: n(n), adj(n), potential(n), dist(n), back(n) {}
void add_edge(size_t src, size_t dst, flow_type cap, cost_type cost) {
adj[src].push_back({src, dst, adj[dst].size(), 0, cap, cost});
if (src == dst) adj[src].back().rev++;
adj[dst].push_back({dst, src, adj[src].size() - 1, 0, 0, -cost});
}
vector<cost_type> potential;
inline cost_type rcost(const edge &e) {
return e.cost + potential[e.src] - potential[e.dst];
}
void bellman_ford(long long source) {
for (long long k = 0; k < n; ++k)
for (long long u = 0; u < n; ++u)
for (edge &e : adj[u])
if (e.cap > 0 && rcost(e) < 0) potential[e.dst] += rcost(e);
}
const cost_type oo = numeric_limits<cost_type>::max();
vector<cost_type> dist;
vector<edge *> back;
cost_type dijkstra(long long source, long long sink) {
fill(dist.begin(), dist.end(), oo);
priority_queue<pair<cost_type, long long>,
vector<pair<cost_type, long long>>,
greater<pair<cost_type, long long>>>
pq;
for (pq.push({dist[source] = 0, source}); !pq.empty();) {
pair<cost_type, long long> p = pq.top();
pq.pop();
if (dist[p.second] < p.first) continue;
if (p.second == sink) break;
for (edge &e : adj[p.second])
if (e.flow < e.cap && dist[e.dst] > dist[e.src] + rcost(e)) {
back[e.dst] = &e;
pq.push({dist[e.dst] = dist[e.src] + rcost(e), e.dst});
}
}
return dist[sink];
}
pair<flow_type, cost_type> max_flow(long long source, long long sink) {
flow_type flow = 0;
cost_type cost = 0;
for (long long u = 0; u < n; ++u)
for (edge &e : adj[u]) e.flow = 0;
potential.assign(n, 0);
dist.assign(n, 0);
back.assign(n, nullptr);
bellman_ford(source);
while (dijkstra(source, sink) < oo) {
for (long long u = 0; u < n; ++u)
if (dist[u] < dist[sink]) potential[u] += dist[u] - dist[sink];
flow_type first = numeric_limits<flow_type>::max();
for (edge *e = back[sink]; e; e = back[e->src])
first = min(first, e->cap - e->flow);
for (edge *e = back[sink]; e; e = back[e->src])
e->flow += first, adj[e->dst][e->rev].flow -= first;
flow += first;
cost += first * (potential[sink] - potential[source]);
}
return {flow, cost};
}
};
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.setf(ios::fixed);
cout.precision(10);
srand(time(NULL));
long long n, m;
string second;
cin >> second;
n = second.size();
second = '&' + second;
vector<long long> cnt(26);
min_cost_max_flow<long long, long long> graph =
min_cost_max_flow<long long, long long>(maxn);
for (long long i = 1; i <= n; i++) {
cnt[second[i] - 'a']++;
}
for (long long i = 1; i <= 26; i++) {
graph.add_edge(i, maxn - 1, cnt[i - 1], 0);
}
cin >> m;
long long sum = 0;
long long curr = 26;
for (long long i = 1; i <= m; i++) {
string t;
cin >> t;
long long c;
cin >> c;
sum += c;
curr++;
fill(cnt.begin(), cnt.end(), 0);
for (long long j = 0; j < t.size(); j++) {
cnt[t[j] - 'a']++;
}
graph.add_edge(0, curr, c, 0);
graph.add_edge(curr, maxn - 2, c, 0);
for (long long j = 1; j <= 26; j++) {
graph.add_edge(curr, curr + j, cnt[j - 1], i);
for (long long k = 1; k <= 26; k++) {
if ((j - 1) == (k - 1)) {
graph.add_edge(curr + j, k, cnt[j - 1], 0);
}
}
}
curr += 26;
}
if (sum - n < 0) {
cout << -1 << '\n';
return 0;
}
graph.add_edge(maxn - 2, maxn - 1, sum - n, 0);
pair<long long, long long> flow = graph.max_flow(0, maxn - 1);
cerr << "flow.f"
<< ": " << (flow.first) << '\n';
if (flow.first == sum)
cout << flow.second << '\n';
else
cout << -1 << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 200009;
inline long long read() {
register long long x = 0, f = 1;
register char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + c - 48, c = getchar();
}
return x * f;
}
long long T, n, w, k, a[N];
vector<long long> ans;
signed main() {
T = read();
while (T--) {
n = read(), w = read();
k = (w + 1) / 2;
for (register long long i = (1); i <= (n); i++) a[i] = read();
ans.clear();
long long sum = 0;
bool flg = 0;
for (register long long i = (1); i <= (n); i++) {
if (a[i] > w) continue;
if (sum + a[i] > w) {
ans.clear();
ans.push_back(i);
flg = 1;
break;
}
sum += a[i];
ans.push_back(i);
if (sum >= k) {
flg = 1;
break;
}
}
if (!flg)
puts("-1");
else {
cout << ans.size() << endl;
for (long long i = 0; i < ans.size(); i++) printf("%lld ", ans[i]);
puts("");
}
}
return 0;
}
| 2 |
#include "bits/stdc++.h"
using namespace std;
#define rep(i, a, b) for(int i=a; i<=b; i++)
#define trav(a, x) for(auto& a : x)
#define all(x) begin(x), end(x)
#define sz(x) (int) x.size()
#define f first
#define s second
#define nl "\n"
#define pb push_back
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pii;
const int MOD = 1e9+7;
template<class T> using pqg = priority_queue<T,vector<T>,greater<T>>;
int t, n;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
cin >> t;
while(t--){
cin >> n;
map<int, int> cnt;
rep(i, 1, n){
int a; cin >> a; cnt[a]++;
}
int mx=0;
trav(p, cnt) mx=max(mx, p.s);
if(mx>n/2) cout << 2*mx-n << nl;
else cout << (n&1?1:0) << nl;
}
} | 3 |
#include <bits/stdc++.h>
using namespace std;
static int rowNbr[] = {-1, -1, -1, 0, 0, 1, 1, 1};
static int colNbr[] = {-1, 0, 1, -1, 1, -1, 0, 1};
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
long long int power(long long int base, long long int p) {
long long int ans = 1;
while (p) {
if (p & 1) ans = (ans * base);
base = (base * base);
p /= 2;
}
return ans;
}
long long int modPower(long long int base, long long int p, long long int mod) {
long long int ans = 1;
while (p) {
if (p & 1) ans = (ans * base) % mod;
base = (base * base) % mod;
p /= 2;
}
return ans;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int dp[100005][330];
int solve(int p, int k, int *a, int n) {
int ans = 0;
while (p <= n) {
p += a[p - 1] + k;
++ans;
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int a[100005];
for (int i = 0; i < n; ++i) cin >> a[i];
for (int j = 1; j < 320; ++j) {
for (int i = n; i >= 1; --i) {
if (i + a[i - 1] + j > n)
dp[i][j] = 1;
else {
dp[i][j] = 1 + dp[i + a[i - 1] + j][j];
}
}
}
int Q;
cin >> Q;
while (Q--) {
int p, k;
cin >> p >> k;
if (k >= 320) {
cout << solve(p, k, a, n) << endl;
} else {
cout << dp[p][k] << endl;
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
const int N = 5e5 + 7;
const int M = 1e9 + 7;
const int MEM = 2e6;
int c[MEM];
int ptr = 0;
struct Vector {
int* v;
int n = 0;
Vector() { v = &c[ptr]; }
int size() const { return n; };
int& operator[](const int i) {
assert(i < n);
return v[i];
}
int& back() { return v[n - 1]; };
void push_back(int val) {
v[n] = val;
ptr++;
n++;
}
int* begin() { return &v[0]; }
int* end() { return &v[n - 1] + 1; }
};
vector<int> g[N];
vector<int> eg[N], erg[N];
int mul(int a, int b) { return (a * (long long)b) % M; }
int add(int a, int b) {
int c = a + b;
if (c < 0) c += M;
if (c >= M) c -= M;
return c;
}
int pw(int a, int n) {
int res = 1;
while (n) {
if (n % 2 == 0) {
a = mul(a, a);
n /= 2;
} else {
res = mul(res, a);
n--;
}
}
return res;
}
int inv(int x) { return pw(x, M - 2); }
int tin[N], tout[N], park[N];
bool par(int a, int b) { return tin[a] <= tin[b] && tout[a] >= tout[b]; }
int tt = 0;
void dfs(int v, int pr) {
tin[v] = tt++;
for (int to : g[v]) {
if (to != pr) {
park[to] = v;
dfs(to, v);
}
}
tout[v] = tt++;
}
Vector gen_path(int a, int b) {
Vector ret;
while (!par(a, b)) {
ret.push_back(a);
a = park[a];
}
ret.push_back(a);
vector<int> go;
while (b != a) {
go.push_back(b);
b = park[b];
}
reverse(go.begin(), go.end());
for (int v : go) {
ret.push_back(v);
}
return ret;
}
int vis[N];
void zhfs(int v) {
vis[v] = 1;
for (int to : eg[v]) {
if (!vis[to]) {
zhfs(to);
} else if (vis[to] == 1) {
cout << 0 << '\n';
exit(0);
}
}
vis[v] = 2;
}
struct hsh {
int operator()(const pair<int, int>& a) const {
return a.first * (long long)1e9 + a.second;
}
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
unordered_map<pair<int, int>, int, hsh> mp;
unordered_map<pair<int, int>, int, hsh> nxt;
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
a--, b--;
g[a].push_back(b);
g[b].push_back(a);
mp[{a, b}] = mp[{b, a}] = i;
}
dfs(0, -1);
auto add_edge = [&](int s, int t) {
eg[s].push_back(t);
erg[t].push_back(s);
};
vector<int> arr(n);
vector<int> first(n, -1);
vector<int> last(n, -1);
long long tot = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
arr[i]--;
if (arr[i] != -1) {
if (i == arr[i]) {
cout << 0 << '\n';
exit(0);
}
ptr = 0;
auto b = gen_path(i, arr[i]);
tot += b.size();
if (tot > 3 * n) {
cout << 0 << '\n';
return 0;
}
Vector ids;
for (int i = 1; i < (int)b.size(); i++) {
ids.push_back(mp[{b[i - 1], b[i]}]);
}
for (int i = 1; i < (int)ids.size(); i++) {
if (nxt.count({b[i], ids[i - 1]})) {
cout << 0 << '\n';
return 0;
}
nxt[{b[i], ids[i - 1]}] = ids[i];
}
first[i] = ids[0];
last[arr[i]] = ids.back();
}
ptr = 0;
}
int ans = 1;
for (int i = 0; i < n; i++) {
ptr = 0;
Vector ids;
map<int, int> t;
map<int, int> d;
for (int j : g[i]) {
ids.push_back(mp[{i, j}]);
}
unordered_set<int> q;
for (int x : ids) {
t[x] = 0;
q.insert(x);
}
unordered_set<int> nq;
unordered_map<int, int> mp;
function<int(int)> get = [&](int v) {
if (!mp.count(v)) {
mp[v] = v;
}
if (mp[v] == v) {
return v;
} else {
return mp[v] = get(mp[v]);
}
};
for (int x : ids) {
if (nxt.count({i, x}))
if (t.count(nxt[{i, x}])) {
d[nxt[{i, x}]] = x;
t[nxt[{i, x}]]++;
if (get(nxt[{i, x}]) == get(x)) {
cout << 0 << '\n';
return 0;
}
mp[get(nxt[{i, x}])] = get(x);
q.erase(nxt[{i, x}]);
}
}
for (auto& c : t) {
if (c.second > 1) {
cout << 0 << '\n';
return 0;
}
}
int need = q.size();
if (first[i] != -1) {
need--;
if (t[first[i]] > 0) {
cout << 0 << '\n';
return 0;
}
}
if (last[i] != -1) {
need--;
if (nxt.count({i, last[i]})) {
cout << 0 << '\n';
return 0;
}
}
if (first[i] != -1 && last[i] != -1 && get(first[i]) == get(last[i]) &&
q.size() > 1) {
cout << 0 << '\n';
return 0;
}
for (int i = 1; i <= need; i++) {
ans = mul(ans, i);
}
}
cout << ans << endl;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n, a = 2, b = 1, c = 1, t, cnt = 0;
cin >> n;
t = n;
while (cnt < 2 && n > 1) {
if (n % a == 0) {
if (cnt == 0) {
b = a;
} else {
c = a;
}
n = n / a;
cnt++;
a++;
} else if (a * a >= n) {
break;
} else
a++;
}
if (cnt == 2 && c != t / (b * c) && b != t / (b * c) && t / (b * c) != 1) {
cout << "YES\n";
cout << b << " " << c << " " << t / (b * c) << endl;
} else {
cout << "NO\n";
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int a[105][2];
int f[3005][105][2];
int main() {
int n, len;
scanf("%d %d", &n, &len);
for (int i = 0; i < n; ++i) {
scanf("%d %d", a[i] + 0, a[i] + 1);
}
memset(f, 0, sizeof f);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 1 + int(a[i][0] != a[i][1]); ++j) {
f[a[i][j]][i][j] += 1;
}
}
for (int i = 1; i <= len; ++i) {
for (int last = 0; last < n; ++last) {
for (int pos = 0; pos < 2; ++pos) {
int w = a[last][pos];
int h = a[last][1 - pos];
for (int nlast = 0; nlast < n; ++nlast) {
if (nlast != last) {
for (int npos = 0; npos < 1 + int(a[nlast][0] != a[nlast][1]);
++npos) {
int nw = a[nlast][npos];
int nh = a[nlast][1 - npos];
if (nw == h) {
if (i + nw <= len) {
f[i + nw][nlast][npos] += f[i][last][pos];
if (f[i + nw][nlast][npos] >= mod) {
f[i + nw][nlast][npos] -= mod;
}
}
}
}
}
}
}
}
}
int ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 2; ++j) {
ans += f[len][i][j];
if (ans >= mod) {
ans -= mod;
}
}
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000, M = 1e9 + 7;
int n, m, k, dp[N + 2][N + 2];
int mul(int a, int b) {
return (int)((((long long)(a % M)) * ((long long)(b % M))) % M);
}
int main() {
dp[0][0] = 1;
for (int i = 1; i <= N; i++) {
dp[i][0] = 1;
for (int j = 1; j < i; j++)
dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1]) % M;
dp[i][i] = 1;
}
scanf("%d%d%d", &n, &m, &k);
int a = 0, b = 0;
if (n - 2 >= 2 * k) a = (a + dp[n - 2][2 * k]) % M;
if (n - 2 >= 2 * k - 1) a = (a + dp[n - 2][2 * k - 1]) % M;
if (m - 2 >= 2 * k) b = (b + dp[m - 2][2 * k]) % M;
if (m - 2 >= 2 * k - 1) b = (b + dp[m - 2][2 * k - 1]) % M;
printf("%d\n", mul(a, b));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long Maxn = 3e5 + 20;
vector<pair<bool, long long> > V[Maxn], G[Maxn];
bool mark[Maxn], vis[Maxn], Vis[Maxn], circle[Maxn];
queue<long long> q;
long long ans[Maxn];
void bfs() {
while (q.size()) {
long long u = q.front();
q.pop();
mark[u]++;
for (long long i = 0; i < V[u].size(); i++) {
long long v = V[u][i].second;
if (G[v].size() > 1) {
long long d = G[v][0].first, c = G[v][1].first;
if (d == c) continue;
long long t = G[v][0].second;
if (t == u)
t = G[v][1].second, ans[v] = d;
else
ans[v] = c;
if (!mark[t]) q.push(t);
}
}
}
}
void dfs(long long u) {
vis[u]++;
for (long long i = 0; i < V[u].size(); i++) {
long long k = V[u][i].second, val = V[u][i].first;
long long v = G[k][0].second;
if (!Vis[k]) {
Vis[k]++;
if (v == u) v = G[k][1].second;
if (!vis[v])
dfs(v);
else
circle[v]++;
}
}
}
void DFS(long long u) {
mark[u]++;
for (long long i = 0; i < V[u].size(); i++) {
long long k = V[u][i].second, val = V[u][i].first;
long long v = G[k][0].second;
if (v == u) v = G[k][1].second;
if (ans[k] == 2) {
ans[k] = !val;
if (!mark[v]) DFS(v);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
long long n, m;
cin >> m >> n;
for (long long i = 1; i <= m; i++) {
long long Size;
cin >> Size;
for (long long j = 1; j <= Size; j++) {
long long v;
cin >> v;
if (v < 0)
V[i].push_back(make_pair(0, -v)), G[-v].push_back(make_pair(0, i));
else
V[i].push_back(make_pair(1, v)), G[v].push_back(make_pair(1, i));
}
}
for (long long i = 1; i <= n; i++) ans[i] = 2;
for (long long i = 1; i <= n; i++) {
long long Size = G[i].size();
if (!Size) continue;
if (Size == 1) {
q.push(G[i][0].second);
ans[i] = G[i][0].first;
} else {
long long v = G[i][0].second, u = G[i][1].second;
long long v1 = G[i][0].first, u1 = G[i][1].first;
if (u1 == v1) ans[i] = v1, q.push(v), q.push(u);
if (v == u) q.push(v), ans[i] = v1;
}
}
bfs();
for (long long i = 1; i <= m; i++)
if (!mark[i] && !vis[i]) dfs(i);
for (long long i = 1; i <= m; i++)
if (!mark[i] && circle[i]) DFS(i);
for (long long i = 1; i <= m; i++)
if (!mark[i]) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
for (long long i = 1; i <= n; i++)
if (ans[i] != 2)
cout << ans[i];
else
cout << 0;
cout << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 2 * asin(1.0);
const long long mod = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
string texto;
cin >> texto;
int cont = 0;
int vetor[((int)texto.size())];
memset(vetor, 0, sizeof vetor);
bool primeiro = false;
bool possivel = true;
int pos = 0;
for (int i = 0; i < ((int)texto.size()); ++i) {
if (texto[i] == '(')
cont++;
else if (!primeiro && texto[i] == ')') {
cont--;
if (cont < 0) {
possivel = false;
break;
}
} else if (texto[i] == '#') {
primeiro = true;
vetor[i] = cont;
cont = 0;
pos = i;
}
}
if (!possivel)
cout << "-1\n";
else {
int aux = 0;
if (cont > 0) {
for (int i = ((int)texto.size()) - 1; i >= pos + 1; --i) {
if (texto[i] == ')')
aux++;
else if (texto[i] == '(')
aux--;
if (aux < 0) {
possivel = false;
break;
}
}
} else {
for (int i = pos + 1; i < ((int)texto.size()); ++i) {
if (texto[i] == ')') aux++;
}
}
if (!possivel)
cout << "-1\n";
else {
cont = 0;
int aux2 = 0;
int aux3 = 0;
for (int i = pos - 1; i >= 0; --i) {
if (texto[i] == ')')
aux3++;
else if (texto[i] == '#') {
vetor[i] -= aux3;
aux3 = 0;
}
}
vetor[pos] -= aux;
for (int i = 0; i < ((int)texto.size()); ++i) {
if (texto[i] == '#') {
cont += vetor[i];
aux2++;
}
}
if (aux2 > cont)
cout << "-1\n";
else {
bool ult = true;
int aux4 = 0;
for (int i = 0; i < ((int)texto.size()); ++i) {
if (texto[i] == '(')
aux4++;
else if (texto[i] == ')')
aux4--;
else {
if (aux4 <= 0) {
ult = false;
break;
}
aux4--;
}
}
if (!ult)
cout << "-1\n";
else {
for (int i = 0; i < ((int)texto.size()); ++i) {
if (texto[i] == '#') {
if (i == pos)
cout << cont << endl;
else {
cout << "1\n";
cont--;
}
}
}
}
}
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e2 + 20;
char s[maxn][maxn];
int Rt[maxn][maxn], Ct[maxn][maxn];
void init(int h, int w) {
for (int i = 1; i <= h; ++i) {
Rt[i][0] = 0;
Rt[i][1] = 0;
for (int j = 2; j <= w; ++j) {
Rt[i][j] = Rt[i][j - 1];
Rt[i][j] += (s[i][j] == '.' && s[i][j - 1] == '.');
}
}
for (int i = 1; i <= w; ++i) {
Ct[i][0] = Ct[i][1] = 0;
for (int j = 2; j <= h; ++j) {
Ct[i][j] = Ct[i][j - 1];
Ct[i][j] += (s[j - 1][i] == '.' && s[j][i] == '.');
}
}
}
int main() {
int h, w;
while (scanf("%d%d", &h, &w) == 2) {
memset(s, '#', sizeof s);
for (int i = 1; i <= h; ++i) scanf("%s", s[i] + 1);
init(h, w);
int Q;
scanf("%d", &Q);
while (Q--) {
int x, y, a, b;
scanf("%d%d%d%d", &x, &y, &a, &b);
long long ans = 0;
for (int i = x; i <= a; ++i) ans += Rt[i][b] - Rt[i][y];
for (int i = y; i <= b; ++i) ans += Ct[i][a] - Ct[i][x];
cout << ans << endl;
}
}
return 0;
}
| 3 |
/**
* @author yuzining
* @date 2021/03/06 23:15
*/
#ifdef local
#include "D:\VSCODE\debug.hpp"
#else
#include <bits/stdc++.h>
#define DEBUG(...) do { } while (0)
const int _______ = []() { std::ios::sync_with_stdio(false), std::cin.tie(nullptr); return 0; }();
#endif
int main() {
int n; std::cin >> n;
std::string s, t; std::cin >> s >> t;
if (t == "0") {
std::cout << "0\n";
return 0;
}
if (s[0] == '0') {
std::cout << std::string(n, '1') << '\n';
return 0;
}
if (t.back() == '1' || s == t) {
std::cout << t << '\n';
return 0;
}
int id = -1;
for (int i = 0; i < n; i++) {
if (s[i] != t[i]) {
id = i;
break;
}
}
bool ok = false;
for (int i = id + 1; i < n; i++) {
if (t[i] == '1' || s[i] == '0') {
ok = true;
break;
}
}
if (ok) {
t.back() = '1';
}
std::cout << t << '\n';
return 0;
} | 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + ch - '0';
ch = getchar();
}
return x * f;
}
int mod = 1000000007;
int n, m, K;
int ans;
int f[1005];
int a[15][15];
int s[15][15];
bool vis[1005];
void dfs(int x, int y, int tot) {
if (tot > K) return;
if (y == m + 1) {
x++;
y = 1;
}
if (x == n + 1) {
int num = 0;
int res = 1;
for (int i = 1; i <= K; i++) {
if (f[i]) num++;
}
for (int i = K - tot + 1; i <= K - num; i++) {
res *= i;
}
ans = (ans + res) % mod;
return;
}
s[x][y] = s[x - 1][y] | s[x][y - 1];
if (a[x][y]) {
if (f[a[x][y]]) {
if ((s[x][y] >> f[a[x][y]]) & 1) {
return;
}
s[x][y] |= 1 << f[a[x][y]];
dfs(x, y + 1, tot);
} else {
for (int i = 1; i <= tot + 1; ++i) {
if (((s[x][y] >> i) & 1) == 0 and !vis[i]) {
s[x][y] ^= 1 << i;
f[a[x][y]] = i;
vis[i] = 1;
dfs(x, y + 1, max(i, tot));
s[x][y] ^= 1 << i;
f[a[x][y]] = 0;
vis[i] = 0;
}
}
}
return;
}
for (int i = 1; i <= tot + 1; i++) {
if (((s[x][y] >> i) & 1) == 0) {
s[x][y] ^= 1 << i;
dfs(x, y + 1, max(i, tot));
s[x][y] ^= 1 << i;
}
}
}
int main() {
cin >> n >> m >> K;
if (n + m - 1 > K) {
cout << 0;
return 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
}
}
dfs(1, 1, 0);
cout << ans;
return 0;
}
| 9 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.