solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<int> a(n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
vector<int> b(n);
for (int i = 0; i < n; i++) {
scanf("%d", &b[i]);
}
map<int, queue<int> > m;
for (int i = 0; i < n; i++) {
m[a[i]].push(i);
}
vector<int> c(n);
for (int i = 0; i < n; i++) {
c[i] = m[b[i]].front();
m[b[i]].pop();
}
vector<int> ans;
for (int to_search = 0; to_search < n; to_search++) {
for (int i = to_search; i < n; i++) {
if (c[i] == to_search) {
for (int j = i; j > to_search; j--) {
ans.push_back(j);
swap(c[j - 1], c[j]);
}
break;
}
}
}
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) {
printf("%d %d\n", ans[i], ans[i] + 1);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxl = 10;
int dx[4][4] = {{0, 0, 1, -1}, {1, -1, 1, 1}, {0, 0, 1, -1}, {1, -1, -1, -1}};
int dy[4][4] = {{1, -1, 1, 1}, {0, 0, 1, -1}, {1, -1, -1, -1}, {0, 0, 1, -1}};
int a[maxl][maxl];
int n, m;
int ans[maxl][maxl];
int mx;
bool rev;
int cnt;
void bt(int i = 1, int j = 1) {
if (i >= n - 1) {
if (cnt > mx)
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) ans[i][j] = a[i][j];
mx = max(mx, cnt);
return;
}
if (j >= m - 1) {
bt(i + 1);
return;
}
bool flag = false;
if (!a[i][j])
for (int k = 0; k < 4; k++) {
bool flg = true;
for (int l = 0; l < 4; l++)
if (a[i + dx[k][l]][j + dy[k][l]]) flg = false;
if (flg) {
flag = true;
for (int l = 0; l < 4; l++) a[i + dx[k][l]][j + dy[k][l]] = cnt + 1;
a[i][j] = cnt + 1;
cnt++;
bt(i, j + 1);
cnt--;
for (int l = 0; l < 4; l++) a[i + dx[k][l]][j + dy[k][l]] = 0;
a[i][j] = 0;
}
}
if (!flag || n + m < 16) bt(i, j + 1);
}
int main() {
scanf("%d %d", &n, &m);
if (n == 8 && m == 9) {
swap(n, m);
rev = true;
}
bt();
if (rev) {
printf("%d\n", mx);
for (int j = 0; j < m; j++) {
for (int i = 0; i < n; i++)
if (ans[i][j])
printf("%c", 'A' + ans[i][j] - 1);
else
printf(".");
printf("\n");
}
return 0;
}
printf("%d\n", mx);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (ans[i][j])
printf("%c", 'A' + ans[i][j] - 1);
else
printf(".");
printf("\n");
}
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
long long n;
long long summ;
long long pw(long long b, long long ex) {
long long sol = 1;
while (ex) {
if (ex & 1) sol = (sol * b) % 998244353;
b = (b * b) % 998244353;
ex >>= 1;
}
return sol;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
long long sol = 0;
for (int i = 1; i <= n; ++i) {
long long nr;
cin >> nr;
long long px = pw(2, n - i);
if (n > i) px = (px + 1LL * (n - i) * pw(2, n - i - 1)) % 998244353;
sol = (sol + nr * px) % 998244353;
}
cout << sol;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::string;
using std::vector;
vector<int> good(32);
bool better(int x, int y) {
for (int i = 30; i >= 0; --i) {
bool xwin = (good[i] && (x & (1 << i)));
bool ywin = (good[i] && (y & (1 << i)));
if (xwin) return true;
if (ywin) return false;
}
return false;
}
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j <= 30; ++j) {
bool t = v[i] & (1 << j);
if (t) good[j] += 1;
}
}
for (int i = 0; i < good.size(); ++i)
if (good[i] > 1) good[i] = 0;
std::sort(v.begin(), v.end(), better);
for (int i = 0; i < n; ++i) cout << v[i] << ' ';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxx = 2e5 + 20, mxsg = 4 * maxx + 10;
int st[mxsg], n, co = 0;
long long ans = 0;
map<int, int> m;
vector<int> v;
vector<pair<int, int> > q;
int get_sum(int x, int y, int id = 1, int l = 0, int r = 2 * n + 2) {
if (x >= r || l >= y) return 0;
if (x <= l && r <= y) return st[id];
int mid = (l + r) / 2;
return get_sum(x, y, id * 2, l, mid) + get_sum(x, y, id * 2 + 1, mid, r);
}
void modify(int x, int id = 1, int l = 0, int r = 2 * n + 2) {
st[id]++;
if (l + 1 == r) return;
int mid = (l + r) / 2;
if (x < mid)
modify(x, id * 2, l, mid);
else
modify(x, id * 2 + 1, mid, r);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
int a, b, x, y;
cin >> a >> b;
if (m.find(a) != m.end())
x = m[a];
else
x = a;
if (m.find(b) != m.end())
y = m[b];
else
y = b;
m[a] = y, m[b] = x;
}
for (pair<int, int> x : m) {
v.push_back(x.first);
}
for (pair<int, int> x : m) {
int e1 = min(x.first, x.second);
int e2 = max(x.first, x.second);
int r1 = upper_bound(v.begin(), v.end(), e1) - v.begin();
int r2 = lower_bound(v.begin(), v.end(), e2) - v.begin();
int g = r2 - r1;
g = (e2 - e1 - 1) - g;
ans += g;
q.push_back(make_pair(x.second, co));
co++;
}
sort(q.begin(), q.end());
for (pair<int, int> x : q) {
ans += get_sum(x.second, 2 * n + 2);
modify(x.second);
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long const mod = 1073741824;
long long c[101] = {0};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t, n, m, i, j, k, cnt = 0, sum1 = 0, ccnt = 0, x = 0, y = 0, z, x1,
y1 = 0, z1, total = 0, sum = 0, x2, y2;
cin >> n >> m;
if (n == 0 && m != 0) {
cout << "Impossible" << endl;
} else if (n == 0 && m == 0) {
cout << "0 0" << endl;
} else if (m == 0) {
cout << n << " " << n << endl;
} else {
if (m >= n) {
if (m % n == 0) {
x = m / n;
sum += n;
sum += (x - 1);
sum1 += 1;
sum1 += (m - 1);
sum1 += (n - 1);
} else {
sum += m;
sum1 += 1;
sum1 += (m - 1);
sum1 += (n - 1);
}
} else {
x = n;
sum += x;
sum1 += 1;
sum1 += (m - 1);
sum1 += (n - 1);
}
cout << sum << " " << sum1 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
class UnionFind {
private:
int n;
vector<int> parent, r;
int _find(int x) {
if (parent[x] == x)
return x;
else
return parent[x] = _find(parent[x]);
}
void _unite(int x, int y) {
x = _find(x);
y = _find(y);
if (x == y) return;
if (r[x] < r[y]) {
parent[x] = y;
} else {
parent[y] = x;
if (r[x] == r[y]) r[x]++;
}
}
public:
int find(int x) { return _find(x); }
void unite(int x, int y) { return _unite(x, y); }
int operator[](int i) { return find(i); }
UnionFind() {}
UnionFind(size_t _n) : n(_n) {
parent = vector<int>(n);
r = vector<int>(n);
for (int i = 0; i < n; i++) {
parent[i] = i;
r[i] = 0;
}
}
};
class BBearAndFriendshipCondition {
public:
int N, M;
vector<pair<int, int> > A;
UnionFind uf;
void input(std::istream& in, std::ostream& out) {
ios_base::sync_with_stdio(false);
in >> N >> M;
uf = UnionFind(N);
A = vector<pair<int, int> >(M);
for (int(i) = (0); (i) < (M); ++(i)) {
in >> A[i].first >> A[i].second;
A[i].first--, A[i].second--;
uf.unite(A[i].first, A[i].second);
}
}
void solve(std::istream& in, std::ostream& out) {
input(in, out);
bool ok = true;
vector<long long> B(N, 0), C(N, 0);
for (int(i) = (0); (i) < (N); ++(i)) {
B[uf.find(i)]++;
}
for (auto p : A) {
C[uf.find(p.first)]++;
}
for (int(i) = (0); (i) < (N); ++(i)) {
if (B[i] * (B[i] - 1) / 2 != C[i]) {
out << "NO\n";
return;
}
}
out << "YES\n";
}
};
int main() {
BBearAndFriendshipCondition solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7, N = 1e6 + 5;
long long inv[N + 5], s[N + 5], p[N + 5], y[N + 5];
long long qm(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
void init() {
inv[0] = inv[1] = 1;
for (int i = 2; i <= N; i++) inv[i] = inv[i - 1] * i % mod;
inv[N] = qm(inv[N], mod - 2);
for (int i = N - 1; i >= 2; i--) inv[i] = inv[i + 1] * (i + 1) % mod;
}
long long lag(int n, int k) {
for (int i = 1; i <= k + 1; i++) y[i] = (y[i - 1] + qm(i, k)) % mod;
k++;
p[0] = n;
s[k + 1] = 1;
for (int i = 1; i <= k - 1; i++) p[i] = (n - i) * p[i - 1] % mod;
for (int i = k; i >= 1; i--) s[i] = (n - i) * s[i + 1] % mod;
long long ans = 0;
for (int i = 1; i <= k; i++)
ans = (ans + y[i] * p[i - 1] % mod * s[i + 1] % mod * inv[i] % mod *
(((k - i) & 1) ? -1 : 1) * inv[k - i]) %
mod;
return (ans + mod) % mod;
}
int main() {
init();
int n, k;
scanf("%d%d", &n, &k);
printf("%lld\n", lag(n, k));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1000000000000000000;
long long mod = 1000000000;
long double pi = 3.141592653589793238;
void pls() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long mul_mod(long long a, long long b, long long m) {
long long x = 0, y = a;
while (b > 0) {
if (b & 1) {
x = (x + y) % m;
}
y = (y + y) % m;
b >>= 1;
}
return x;
}
inline long long modu(long long val, long long modul) {
return (val % modul + modul) % modul;
}
inline int madd(int x, int y) { return (x % mod + y % mod) % mod; }
inline int msub(int x, int y) { return (mod + x % mod - y % mod) % mod; }
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long powmod(long long a, long long mod, long long p) {
if (p == 0) return 1;
long long res;
long long x = powmod(a, mod, p / 2);
res = x;
if (p & 1) x = mul_mod(x, a, mod);
return mul_mod(x, res, mod);
}
long long exp(long long a, long long p) {
if (p == 0) return 1;
long long res;
long long x = exp(a, p / 2);
res = x;
if (p & 1) x = (x * a);
return (x * res);
}
long long sqt(long long x) {
long long l = 1LL;
long long r = x;
long long res;
while (l <= r) {
long long mid = l + (r - l) / 2;
if (mid * mid <= x) {
res = mid;
l = mid + 1;
} else
r = mid - 1;
}
return res;
}
bool isprime(long long n) {
for (int i = 2; i <= sqt(n); i++)
if (n % i == 0) return 0;
return 1;
}
vector<int> soe(long long upto) {
vector<bool> prime(upto + 1, 0);
prime[1] = 1;
prime[0] = 1;
for (int i = 2; i <= sqt(upto); i++) {
if (!prime[i]) {
for (int j = 2 * i; j <= upto; j += i) prime[j] = 1;
}
}
vector<int> res;
res.push_back(2);
for (int i = 3; i < prime.size(); i += 2) {
if (!prime[i]) res.push_back(i);
}
return res;
}
int di[8] = {-1, -1, -1, 1, 1, 1, 0, 0};
int dj[8] = {-1, 0, 1, -1, 0, 1, -1, 1};
int ii[4] = {0, 0, -1, 1};
int jj[4] = {-1, 1, 0, 0};
struct node {
int o, c, p;
};
int n;
string s;
class sg {
public:
vector<node> seg;
sg(int n) {
int p = ceil(log2(n));
seg.resize(pow(2, p + 1) - 1, {0, 0, 0});
}
node query(int qs, int qe, int si = 0, int ss = 0, int se = n - 1) {
if (ss > qe || se < qs || ss > se) return {0, 0, 0};
if (ss >= qs && se <= qe) return seg[si];
int mid = (se + ss) / 2;
node l = query(qs, qe, 2 * si + 1, ss, mid);
node r = query(qs, qe, 2 * si + 2, mid + 1, se);
int mn = min(l.o, r.c);
return {l.o + r.o - mn, l.c + r.c - mn, l.p + r.p + mn};
}
void build(int si = 0, int ss = 0, int se = n - 1) {
if (ss > se) return;
if (ss == se) {
if (s[ss] == '(') {
seg[si] = {1, 0, 0};
} else {
seg[si] = {0, 1, 0};
}
return;
}
int mid = (ss + se) / 2;
build(2 * si + 1, ss, mid);
build(2 * si + 2, mid + 1, se);
int lo = seg[2 * si + 1].o;
int rc = seg[2 * si + 2].c;
int mn = min(lo, rc);
seg[si] = {seg[2 * si + 1].o + seg[2 * si + 2].o - mn,
seg[2 * si + 1].c + seg[2 * si + 2].c - mn,
seg[2 * si + 1].p + seg[2 * si + 2].p + mn};
}
};
void solve() {
cin >> s;
n = s.size();
sg res(n);
res.build();
int q;
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
l--;
r--;
cout << 2 * res.query(l, r).p << endl;
}
}
int main() {
pls();
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0xffffffffffffff;
const int maxn = (int)3e5 + 5e4;
int n, m, cnt = 0;
long long d[maxn];
long long cost[maxn];
int Ed[maxn];
unsigned long long W = 0;
struct E {
int to, id;
long long cost;
E() {}
E(int to, long long cost, int id) : to(to), cost(cost), id(id) {}
};
vector<E> G[maxn];
struct P {
long long d;
int id;
P(){};
P(long long d, int id) : d(d), id(id){};
bool operator<(const P& p) const { return p.d < d; }
};
void dijkstra(int U) {
fill(cost, cost + n + 1, inf);
fill(d, d + n + 1, inf);
d[U] = 0LL;
priority_queue<P> que;
P p = P(0LL, U);
que.push(p);
while (que.size()) {
P p = que.top();
que.pop();
if (d[p.id] < p.d) continue;
for (int i = 0; i < G[p.id].size(); i++) {
E v = G[p.id][i];
if (d[v.to] > d[p.id] + v.cost ||
(d[v.to] == d[p.id] + v.cost && cost[v.to] > v.cost)) {
int F = (d[v.to] > d[p.id] + v.cost) ? 1 : 0;
Ed[v.to] = v.id;
cost[v.to] = v.cost;
d[v.to] = d[p.id] + v.cost;
if (F) que.push(P(d[v.to], v.to));
}
}
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int x, y;
long long z;
scanf("%d %d %I64d", &x, &y, &z);
G[x].push_back(E(y, z, i + 1));
G[y].push_back(E(x, z, i + 1));
}
int u;
scanf("%d", &u);
dijkstra(u);
for (int i = 1; i <= n; i++) {
if (i != u) W += cost[i];
}
printf("%I64u\n", W);
for (int i = 1; i <= n; i++) {
if (i != u) printf("%d ", Ed[i]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vb = vector<bool>;
using vvi = vector<vector<int>>;
using vll = vector<long long>;
using vpi = vector<pair<int, int>>;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
const char nl = '\n';
const ll MOD = 1e9 + 7;
const int MAXN = 5005;
int n, m, n1, n2, n3;
vi adj[MAXN];
int vis[MAXN];
int ans[MAXN];
pii Dfs1(int u, int color) {
vis[u] = color;
pii count = {color == 1, color == 2};
for (int x : adj[u]) {
if (vis[x] == color) {
cout << "NO" << nl;
exit(0);
} else if (vis[x] == 0) {
pii res = Dfs1(x, color == 1 ? 2 : 1);
count.first += res.first;
count.second += res.second;
}
}
return count;
}
void Dfs2(int u, int c) {
if (c == 1) {
if (n1 > 0) {
ans[u] = 1;
n1--;
} else {
ans[u] = 3;
}
} else {
ans[u] = 2;
}
for (int x : adj[u]) {
if (ans[x] == 0) Dfs2(x, c == 1 ? 2 : 1);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> n1 >> n2 >> n3;
for (int i = 0; i < (m); ++i) {
int u, v;
cin >> u >> v;
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
vpi comp;
vi roots;
for (int i = 0; i < (n); ++i) {
if (vis[i] == 0) {
comp.push_back(Dfs1(i, 1));
roots.push_back(i);
}
}
int C = (int)comp.size();
vector<vector<pair<bool, bool>>> dp(
C, vector<pair<bool, bool>>(n2 + 1, {false, false}));
if (comp[0].first <= n2) dp[0][comp[0].first].first = true;
if (comp[0].second <= n2) dp[0][comp[0].second].second = true;
for (int i = (1); i <= (C - 1); ++i) {
for (int j = 0; j < (n2 + 1); ++j) {
if (comp[i].first <= j) {
auto p = dp[i - 1][j - comp[i].first];
if (p.first || p.second) dp[i][j].first = true;
}
if (comp[i].second <= j) {
auto p = dp[i - 1][j - comp[i].second];
if (p.first || p.second) dp[i][j].second = true;
}
}
}
if (!dp[C - 1][n2].first && !dp[C - 1][n2].second) {
cout << "NO" << nl;
return 0;
}
int current = n2;
for (int i = (C - 1); i >= (0); --i) {
int color;
if (dp[i][current].first) {
color = 2;
current -= comp[i].first;
} else {
color = 1;
current -= comp[i].second;
}
Dfs2(roots[i], color);
}
cout << "YES" << nl;
for (int i = 0; i < (n); ++i) cout << ans[i];
cout << nl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, k, i, j, s = 0, cnt = 0, t = 0;
int main() {
cin >> n >> k;
int a[n], b[n];
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) b[i] = a[i];
sort(a, a + n);
for (i = 0; i < n; i++) {
cnt++;
s += a[i];
if (s > k) {
cnt--;
break;
} else if (s == k)
break;
}
cout << cnt << endl;
for (j = t; j < n, cnt != 0; j++) {
for (i = 0; i < cnt;) {
if (a[i] == b[j]) {
cout << j + 1 << " ";
t++;
break;
}
i++;
if (t == cnt) break;
}
if (t == cnt) break;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << (n - 4) / 2;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct query {
long long l;
long long r;
long long i;
};
query Q[200001];
long long ar[200001];
long long ans[200001];
long long freq[1000001];
long long power = 0;
bool comp(query a, query b) {
if (a.l / 555 != b.l / 555) return a.l / 555 < b.l / 555;
return a.r < b.r;
}
void add(long long pos) {
long long ele = ar[pos];
long long cur = freq[ele];
freq[ele]++;
long long curF = freq[ele];
power -= (cur * cur * ele);
power += (curF * curF * ele);
}
void remove(long long pos) {
long long ele = ar[pos];
long long cur = freq[ele];
freq[ele]--;
long long curF = freq[ele];
power -= (cur * cur * ele);
power += (curF * curF * ele);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, q;
cin >> n >> q;
for (long long i = 0; i < n; i++) cin >> ar[i];
for (long long i = 0; i < q; i++) {
cin >> Q[i].l >> Q[i].r;
Q[i].i = i, Q[i].l--, Q[i].r--;
}
sort(Q, Q + q, comp);
long long ML = 0, MR = -1;
for (int i = 0; i < q; i++) {
long long L = Q[i].l;
long long R = Q[i].r;
int idx = Q[i].i;
while (ML > L) ML--, add(ML);
while (MR < R) MR++, add(MR);
while (ML < L) remove(ML), ML++;
while (MR > R) remove(MR), MR--;
ans[idx] = power;
}
for (long long i = 0; i < q; i++) cout << ans[i] << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 1;
int n, m;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int T;
for (cin >> T; T--;) {
cin >> n >> m;
int sum = 0, a;
for (int i = 1; i <= n; ++i) {
cin >> a;
sum += a;
}
if (n != m || n == 2)
cout << -1 << '\n';
else {
cout << 2 * sum << '\n';
for (int i = 1; i <= n - 1; ++i) cout << i << ' ' << i + 1 << '\n';
cout << n << ' ' << 1 << '\n';
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD1 = 998244353;
const long long int MOD = 1e9 + 7;
const long long int MAXN = 2e5 + 1;
const long double PI = acos(-1);
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
long long int n, m;
cin >> n >> m;
;
long long int all = n * (n - 1) * (n - 2) / 6, bad = 0;
vector<long long int> g(n + 1, 0);
for (long long int i = 0; i < (m); ++i) {
int a, b;
cin >> a >> b;
;
g[a]++;
g[b]++;
}
for (long long int i = 1; i < (n + 1); ++i) {
bad += g[i] * (n - 1 - g[i]);
}
bad /= 2;
all -= bad;
cout << all;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
constexpr int INF = 1e9;
int main() {
using namespace std;
ios_base::sync_with_stdio(false), cin.tie(nullptr);
int n, q;
cin >> n >> q;
vector<char> str(n + 1);
for (int i = 1; i <= n; ++i) cin >> str[i];
vector<array<int, 26>> next(n + 2);
for (int i = 0; i < 26; ++i) {
next[n + 1][i] = INF;
for (int j = n; j; --j) {
if (str[j] == 'a' + i) {
next[j][i] = j;
} else {
next[j][i] = next[j + 1][i];
}
}
}
static array<int, 4> len;
static array<array<char, 255>, 4> cur;
static array<array<array<int, 255>, 255>, 255> dp;
auto update = [&](int x) -> void {
for (int i = x == 1 ? len[1] : 0; i <= len[1]; ++i) {
for (int j = x == 2 ? len[2] : 0; j <= len[2]; ++j) {
for (int k = x == 3 ? len[3] : 0; k <= len[3]; ++k) {
dp[i][j][k] = INF;
if (i && dp[i - 1][j][k] != INF) {
dp[i][j][k] =
min(dp[i][j][k], next[dp[i - 1][j][k] + 1][cur[1][i] - 'a']);
}
if (j && dp[i][j - 1][k] != INF) {
dp[i][j][k] =
min(dp[i][j][k], next[dp[i][j - 1][k] + 1][cur[2][j] - 'a']);
}
if (k && dp[i][j][k - 1] != INF) {
dp[i][j][k] =
min(dp[i][j][k], next[dp[i][j][k - 1] + 1][cur[3][k] - 'a']);
}
}
}
}
};
while (q--) {
char c;
cin >> c;
if (c == '+') {
int i;
cin >> i >> c;
cur[i][++len[i]] = c;
update(i);
} else {
int i;
cin >> i;
--len[i];
}
cout << (dp[len[1]][len[2]][len[3]] != INF ? "YES\n" : "NO\n");
}
}
| 7 |
#include <bits/stdc++.h>
typedef long long ll;
#define int long long
inline ll read() {
char c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
ll k = 0, kk = 1;
if (c == '-') c = getchar() , kk = -1;
while (c >= '0' && c <= '9') k = k * 10 + c - '0', c = getchar();
return kk * k;
}
void write(ll x) {
if (x < 0) x = -x, putchar('-');
if (x / 10) write(x / 10);
putchar(x % 10 + '0');
}
void writeln(ll x) {write(x); puts("");}
using namespace std;
int n,x,y,a[1000010],b[1000010],da,db;
signed main() {
int t=read();while (t--){
n = read();da=db=0;
for (int i = 1; i <= n * 2; i++) {
x = read();
y = read();
if (x == 0) {
a[++da] = abs(y);
} else {
b[++db] = abs(x);
}
}
sort(a+1,a+1+n);sort(b+1,b+1+n);
double ans=0;
for (int i=1;i<=n;i++) {
ans+=sqrt(a[i]*a[i]+b[i]*b[i]);
}printf("%.20lf\n",ans);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, w = 0;
char ch = getchar();
while (!isdigit(ch)) w |= ch == '-', ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + ch - '0', ch = getchar();
return w ? -x : x;
}
long long f[504032], n, K, cnt;
long long find(long long k) { return f[k] == k ? k : f[k] = find(f[k]); }
void link(long long x, long long y) { f[find(x)] = find(y); }
signed main() {
n = read(), K = read();
for (long long i = 1; i <= 2 * n + 4; ++i) f[i] = i;
for (long long i = 1; i <= K; ++i) {
long long x = read(), y = read(), d = getchar() == 'o';
long long l = abs(y - x) + 1,
r = y + x - 1 > n ? 2 * n - y - x + 1 : y + x - 1;
if (d)
link(l, r + 2 + n + 2), link(l + n + 2, r + 2);
else
link(l, r + 2), link(l + n + 2, r + 2 + n + 2);
}
for (long long i = 1; i <= n; ++i)
if (find(i) == find(i + n + 2)) {
puts("0");
return 0;
}
for (long long i = 1; i <= 2 * n + 4; ++i)
if (f[i] == i) ++cnt;
cnt = (cnt - 4) >> 1;
long long ans = 1;
while (cnt--) ans = ans * 2 % 1000000007;
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
pair<int, int> m[100025];
for (int i = 0; i <= n; i++) {
m[i].first = 200000;
m[i].second = -1;
}
int x;
for (int i = 1; i <= k; i++) {
cin >> x;
m[x].first = min(m[x].first, i);
m[x].second = max(m[x].second, i);
}
int sum = 0;
for (int i = 1; i <= n; i++) {
if (m[i].second == -1 && m[i].first == 200000) sum++;
if (i != 1) {
if (m[i].second < m[i - 1].first ||
m[i - 1].second == -1 && m[i - 1].first == 200000)
sum++;
}
if (i != n) {
if (m[i].second < m[i + 1].first ||
m[i + 1].second == -1 && m[i + 1].first == 200000)
sum++;
}
}
cout << sum << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[400005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
;
string s;
cin >> s;
int cnt = 0;
int ans = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '(') cnt++;
if (s[i] == ')') {
if (cnt > 0) {
cnt--;
ans += 2;
}
}
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[60][60];
int odd[3000];
int even[3000];
int op, ep;
int T;
void Init() {
memset(a, 0, sizeof(a));
memset(odd, 0, sizeof(odd));
memset(even, 0, sizeof(even));
op = 0, ep = 0;
for (int i = 1; i <= T * T; i++) {
if (i & 1)
odd[++op] = i;
else
even[++ep] = i;
}
}
int cd, cp;
void cross() {
int pp = (T + 1) / 2;
for (int i = 1; i <= T; i++) a[pp][i] = odd[++cd];
for (int i = 1; i <= T; i++)
if (!a[i][pp]) a[i][pp] = odd[++cd];
}
void odd_put() {
for (int i = 1; i <= T; i++) {
if (cd > (T * T + 1) / 2) break;
for (int j = 1; j <= T; j++)
if (!a[i][j]) {
a[i][j] = odd[++cd];
a[i][T - j + 1] = odd[++cd];
a[T - i + 1][j] = odd[++cd];
a[T - i + 1][T - j + 1] = odd[++cd];
}
}
}
void even_put() {
for (int i = 1; i <= T; i++)
for (int j = 1; j <= T; j++)
if (!a[i][j]) a[i][j] = even[++cp];
}
void out() {
for (int i = 1; i <= T; i++) {
for (int j = 1; j <= T; j++) {
printf("%d ", a[i][j]);
}
printf("\n");
}
printf("\n");
}
int main() {
while (cin >> T) {
cd = 0;
cp = 0;
Init();
cross();
odd_put();
even_put();
out();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const int MOD = 998244353;
struct Mint {
int val;
Mint() { val = 0; }
Mint(ll x) {
val = (-MOD <= x && x < MOD) ? x : x % MOD;
if (val < 0) val += MOD;
}
template <typename U>
explicit operator U() const {
return (U)val;
}
friend bool operator==(const Mint& a, const Mint& b) {
return a.val == b.val;
}
friend bool operator!=(const Mint& a, const Mint& b) { return !(a == b); }
friend bool operator<(const Mint& a, const Mint& b) { return a.val < b.val; }
Mint& operator+=(const Mint& m) {
if ((val += m.val) >= MOD) val -= MOD;
return *this;
}
Mint& operator-=(const Mint& m) {
if ((val -= m.val) < 0) val += MOD;
return *this;
}
Mint& operator*=(const Mint& m) {
val = (ll)val * m.val % MOD;
return *this;
}
friend Mint modex(Mint a, ll p) {
assert(p >= 0);
Mint ans = 1;
for (; p; p >>= 1, a *= a)
if (p & 1) ans *= a;
return ans;
}
Mint& operator/=(const Mint& m) { return *this *= modex(m, MOD - 2); }
Mint& operator++() { return *this += 1; }
Mint& operator--() { return *this -= 1; }
Mint operator++(int) {
Mint result(*this);
*this += 1;
return result;
}
Mint operator--(int) {
Mint result(*this);
*this -= 1;
return result;
}
Mint operator-() const { return Mint(-val); }
friend Mint operator+(Mint a, const Mint& b) { return a += b; }
friend Mint operator-(Mint a, const Mint& b) { return a -= b; }
friend Mint operator*(Mint a, const Mint& b) { return a *= b; }
friend Mint operator/(Mint a, const Mint& b) { return a /= b; }
friend ostream& operator<<(ostream& os, const Mint& x) { return os << x.val; }
friend string to_string(const Mint& b) { return to_string(b.val); }
};
vector<Mint> fac(1, 1), invfac(1, 1);
Mint binom(int n, int k) {
if (k < 0 || k > n) return 0;
while (fac.size() <= n) {
fac.push_back(fac.back() * fac.size());
invfac.push_back(1 / fac.back());
}
return fac[n] * invfac[k] * invfac[n - k];
}
struct PqTree {
int n;
int fail = 0;
vector<vector<int>> G;
vector<int> ty, sz, szc;
vector<bool> s;
PqTree(int _n) : n(_n), G(n + 2), ty(n + 2), sz(n + 2), szc(n + 2), s(n + 1) {
assert(n >= 1);
for (int i = 1; i <= n; ++i) G[n + 1].push_back(i);
}
inline int getstate(int u) {
if (szc[u] == 0) return 0;
if (szc[u] == sz[u]) return 2;
return 1;
}
void addson(int x, int y) {
if (y) G[x].push_back(y);
}
void join(int x, int y) {
for (auto v : G[y]) G[x].push_back(v);
}
int mergeP(const vector<int>& vec) {
if (vec.size() == 0) return 0;
if (vec.size() == 1) return vec[0];
G.push_back(vec);
ty.push_back(0);
sz.push_back(0);
szc.push_back(0);
return G.size() - 1;
}
void dfs(int u) {
sz[u] = u <= n;
szc[u] = u <= n && s[u];
for (auto v : G[u]) {
dfs(v);
sz[u] += sz[v];
szc[u] += szc[v];
}
}
int check(int u, int t) {
if (fail) return 0;
vector<int> vec[3];
for (auto v : G[u]) vec[getstate(v)].push_back(v);
if (vec[1].size() > 2 || (t && vec[1].size() > 1)) return fail = 1, 0;
if (t == 0 && vec[1].size() == 1 && vec[2].size() == 0)
return check(vec[1][0], 0);
if (ty[u] == 0) {
int p2 = mergeP(vec[2]);
if (t == 0) {
G[u] = vec[0];
if (vec[1].size() == 0)
addson(u, p2);
else {
int tmp1 = check(vec[1][0], 2);
addson(tmp1, p2);
if (vec[1].size() == 2) join(tmp1, check(vec[1][1], 1));
addson(u, tmp1);
}
return u;
}
ty[u] = 1;
G[u].clear();
addson(u, p2);
if (vec[1].size() == 1) join(u, check(vec[1][0], 1));
addson(u, mergeP(vec[0]));
if (t == 2) reverse(G[u].begin(), G[u].end());
return u;
}
if (getstate(G[u].front()) > getstate(G[u].back()))
reverse(G[u].begin(), G[u].end());
int flag = 0;
vector<int> tG;
for (auto v : G[u]) {
int sta = getstate(v);
if (sta == 0) {
if (flag == 1) flag = 2;
tG.push_back(v);
} else if (sta == 2) {
if (flag == 0)
flag = 1;
else if (flag == 2)
return fail = 2, 0;
tG.push_back(v);
} else {
if (flag == 0)
flag = 1, check(v, 2);
else if (flag == 1)
flag = 2, check(v, 1);
else
return fail = 3, 0;
for (auto x : G[v]) tG.push_back(x);
}
}
if (t && flag == 2) return fail = 4, 0;
if (t == 1) reverse(tG.begin(), tG.end());
G[u] = tG;
return u;
}
void dfsPermutation(int u, vector<int>& per) {
if (u <= n) per.push_back(u);
for (auto v : G[u]) dfsPermutation(v, per);
}
vector<int> getPermutation() {
vector<int> res;
dfsPermutation(n + 1, res);
return res;
}
Mint dfsCount(int u) {
if (u <= n) {
assert(G[u].empty());
return 1;
}
assert(!G[u].empty());
Mint ret = 1;
if (!ty[u]) {
ret *= fac[G[u].size()];
} else if (G[u].size() != 1) {
ret *= 2;
}
for (auto v : G[u]) ret *= dfsCount(v);
return ret;
}
Mint countPermutations() {
if (fail) return 0;
binom(n, 0);
return dfsCount(n + 1);
}
void restrict(const vector<int>& res) {
for (int i = 1; i <= n; ++i) s[i] = 0;
for (auto x : res) s[x] = 1;
dfs(n + 1);
check(n + 1, 0);
}
};
int main() {
int n, m;
scanf("%d%d", &n, &m);
PqTree pq(n);
for (int i = 0; i < m; ++i) {
int q;
scanf("%d", &q);
vector<int> res;
while (q--) {
int s;
scanf("%d", &s);
res.push_back(s);
}
pq.restrict(res);
}
Mint ans = pq.countPermutations();
printf("%d\n", ans.val);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 300000 + 100;
multiset<int> st;
int n, tmp;
int main() {
while (~scanf("%d", &n)) {
st.clear();
long long ans = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &tmp);
if (!st.empty() && *st.begin() < tmp) {
ans += (long long)(tmp - *st.begin());
st.erase(st.begin());
st.insert(tmp);
st.insert(tmp);
} else {
st.insert(tmp);
}
}
printf("%lld\n", ans);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3f3f;
const long long mod = 1000000007;
const double eps = 1e-5;
const int maxn = 2005;
const int maxm = 20005;
const int base = 27;
int n, m;
char str[2505][5005];
int hanming[5005];
int cnt[30];
int cnt0[30];
char ans[5005];
bool isdup = 0;
bool check(int now) {
for (int i = 0; i < n; i++) {
if (i == now) continue;
int nowcnt = 0;
for (int j = 0; j < m; j++) {
if (str[now][j] != str[i][j]) {
nowcnt++;
}
}
if (nowcnt != 2 && nowcnt != 0) return 0;
if (nowcnt == 0 && isdup == 0) return 0;
}
for (int i = 0; i < m; i++) ans[i] = str[now][i];
ans[m] = '\0';
return 1;
}
void solve() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", str[i]);
}
int mark1 = -1, mark2 = -1;
memset(hanming, 0, sizeof(hanming));
for (int i = 1; i < n; i++) {
for (int j = 0; j < m; j++) {
if (str[0][j] != str[i][j]) {
hanming[i]++;
}
}
}
bool ok = 1;
memset(cnt0, 0, sizeof(cnt0));
for (int i = 0; i < m; i++) {
cnt0[str[0][i] - 'a']++;
if (cnt0[str[0][i] - 'a'] > 1) isdup = 1;
}
for (int i = 1; i < n; i++) {
memset(cnt, 0, sizeof(cnt));
for (int j = 0; j < m; j++) {
cnt[str[i][j] - 'a']++;
}
for (int j = 0; j < 26; j++) {
if (cnt[j] != cnt0[j]) {
ok = 0;
}
}
}
int mark = -1;
int marklen = 0;
if (ok) {
for (int i = 1; i < n; i++) {
if (hanming[i] > 4 || hanming[i] == 1) {
ok = 0;
}
if (hanming[i] > marklen) mark = i;
}
}
if (mark == -1) ok = 0;
if (ok) {
vector<int> v;
v.clear();
for (int i = 0; i < m; i++) {
if (str[0][i] != str[mark][i]) {
v.push_back(i);
}
}
bool flag = 0;
for (int i = 0; i < v.size(); i++) {
int now = v[i];
for (int j = 0; j < m; j++) {
if (j == now) continue;
swap(str[0][now], str[0][j]);
if (check(0)) {
flag = 1;
break;
}
swap(str[0][now], str[0][j]);
swap(str[mark][now], str[mark][j]);
if (check(mark)) {
flag = 1;
break;
}
swap(str[mark][now], str[mark][j]);
}
if (flag) break;
}
ok = flag;
}
bool flag = 0;
for (int i = 0; i < n; i++) {
if (hanming[i] != 0) {
flag = 1;
}
}
if (flag == 0 || n == 1) {
for (int i = 0; i < m; i++) ans[i] = str[0][i];
ans[m] = '\0';
swap(ans[0], ans[1]);
ok = 1;
}
if (ok)
printf("%s\n", ans);
else
printf("-1\n");
return;
}
int main() {
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int P[2002];
int best(int i, int j) {
if (P[i] > P[j]) return i;
return j;
}
struct SegmentTree {
SegmentTree *L, *R;
int fr, to, maxI;
void update(int i) {
if (fr == to) return;
if (i <= L->to)
L->update(i);
else
R->update(i);
maxI = best(L->maxI, R->maxI);
}
int query(int a, int b) {
if (a == fr && b == to) return maxI;
if (b <= L->to) return L->query(a, b);
if (a >= R->fr) return R->query(a, b);
return best(L->query(a, L->to), R->query(R->fr, b));
}
SegmentTree(int a, int b) : fr(a), to(b) {
if (a == b) {
maxI = a;
L = R = nullptr;
} else {
L = new SegmentTree(a, (a + b) / 2);
R = new SegmentTree((a + b) / 2 + 1, b);
maxI = best(L->maxI, R->maxI);
}
}
};
vector<int> ans1, ans2;
int totCost = 0;
SegmentTree *stree;
void doSwap(int i, int j) {
ans1.push_back(i);
ans2.push_back(j);
swap(P[i], P[j]);
stree->update(i);
stree->update(j);
totCost += abs(j - i);
}
int target[2002], posInTarget[2002], n;
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> P[i];
for (int i = 1; i <= n; ++i) {
cin >> target[i];
posInTarget[target[i]] = i;
}
for (int i = 1; i <= n; ++i) P[i] = posInTarget[P[i]];
stree = new SegmentTree(1, n);
for (int i = 1; i <= n; ++i) {
int posi = i;
while (P[posi] != i) posi++;
while (posi > i) {
int j = stree->query(1, posi - 1);
doSwap(posi, j);
posi = j;
}
}
cout << totCost << "\n" << ans1.size() << endl;
for (int i = 0; i < ans1.size(); ++i) printf("%d %d\n", ans1[i], ans2[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000009;
const int MAXN = 100000;
int n, m;
vector<pair<int, int> > graph[MAXN + 3];
bool vis[MAXN + 3];
bool color[MAXN + 3];
vector<int> ans[2], curr, output;
int counter;
void Read() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b, c;
char col;
scanf("%d %d %c", &a, &b, &col);
if (col == 'B')
c = 1;
else
c = 0;
graph[a].push_back(make_pair(b, c));
graph[b].push_back(make_pair(a, c));
}
}
void Clean() {
for (int i = 1; i <= n; i++) vis[i] = false;
for (int i = 1; i <= n; i++) color[i] = 0;
for (int i = 1; i <= n; i++)
for (int j = 0; j < (int)graph[i].size(); j++)
graph[i][j].second = (graph[i][j].second + 1) % 2;
curr.clear();
}
bool Dfs(int v) {
vis[v] = true;
curr.push_back(v);
if (color[v] == 0) counter++;
for (int i = 0; i < (int)graph[v].size(); i++) {
int u = graph[v][i].first;
int sum = graph[v][i].second;
if (!vis[u]) {
color[u] = (sum - color[v] + 2) % 2;
if (Dfs(u) == false) return false;
} else {
if (color[u] != (sum - color[v] + 2) % 2) return false;
}
}
return true;
}
bool Solve(int ind) {
for (int v = 1; v <= n; v++) {
if (!vis[v]) {
if (Dfs(v) == false) return false;
}
for (int i = 0; i < (int)curr.size(); i++) {
if (color[curr[i]] == 0 && 2 * counter < (int)curr.size())
ans[ind].push_back(curr[i]);
else if (color[curr[i]] == 1 && 2 * counter >= (int)curr.size())
ans[ind].push_back(curr[i]);
}
curr.clear();
counter = 0;
}
return true;
}
int main() {
Read();
bool check0 = Solve(0);
Clean();
bool check1 = Solve(1);
if (!check0 && !check1) {
puts("-1");
return 0;
}
if (!check1 || (ans[0].size() < ans[1].size() && check0))
output = ans[0];
else
output = ans[1];
printf("%d\n", (int)output.size());
for (int i = 0; i < (int)output.size(); i++) {
printf("%d ", output[i]);
}
puts("");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int b[n];
for (int i = 0; i < n; i++) {
if ((i + 1) % 2 == 0) {
b[i - 1] = -a[i];
} else {
b[i + 1] = a[i];
}
}
for (int i = 0; i < n; i++) {
cout << b[i] << " ";
}
cout << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, pos, l, r;
cin >> n >> pos >> l >> r;
if (l == 1 & r == n)
cout << 0 << endl;
else if (l == 1 & r != n) {
if (l <= pos & pos <= r)
cout << r - pos + 1 << endl;
else
cout << pos - r + 1 << endl;
} else if (r == n & l != 1) {
if (l <= pos & pos <= r)
cout << pos - l + 1 << endl;
else
cout << l - pos + 1 << endl;
} else {
if (l <= pos & pos <= r) {
if ((pos - l) < (r - pos))
cout << pos + r - 2 * l + 2 << endl;
else if ((pos - l) >= (r - pos))
cout << 2 * r - pos + 2 - l << endl;
} else {
if (pos < l)
cout << r + 2 - pos << endl;
else if (pos > r)
cout << pos + 2 - l << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
const int MAXN = 100000 + 5, MAXM = 100000 + 5;
int n, m, Head[MAXN], cnt_Edge = 1;
long long ans, dis[MAXN], d[70];
bool book[MAXN];
struct node {
int to;
long long val;
int Next;
} Edge[MAXM << 1];
long long Read() {
long long sum = 0, fh = 1;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar()) fh -= (ch == '-') << 1;
for (; ch >= '0' && ch <= '9'; ch = getchar()) sum = sum * 10 + (ch ^ 48);
return sum * fh;
}
long long Max(long long fir, long long sec) { return (fir > sec) ? fir : sec; }
long long Min(long long fir, long long sec) { return (fir < sec) ? fir : sec; }
void add_Edge(int x, int y, long long z) {
++cnt_Edge;
Edge[cnt_Edge] = (node){y, z, Head[x]};
Head[x] = cnt_Edge;
}
void Add(long long x) {
for (int i = 63; i >= 0; --i) {
if (x & (1ll << i)) {
if (d[i] & x)
x ^= d[i];
else {
d[i] = x;
return;
}
}
}
}
void dfs(int now, long long sum) {
book[now] = 1;
dis[now] = sum;
for (int i = Head[now]; i; i = Edge[i].Next) {
int u = Edge[i].to;
if (!book[u])
dfs(u, sum ^ Edge[i].val);
else
Add(sum ^ Edge[i].val ^ dis[u]);
}
}
int main() {
n = Read(), m = Read();
for (int i = 1; i <= m; ++i) {
int x = Read(), y = Read();
long long z = Read();
add_Edge(x, y, z);
add_Edge(y, x, z);
}
dfs(1, 0);
ans = dis[n];
for (int i = 63; i >= 0; --i) ans = Min(ans, ans ^ d[i]);
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e6 + 10;
int N, Q, go[MAXN];
long long ar[MAXN];
int main() {
scanf("%d%d", &N, &Q);
long long sum = 0;
for (int i = 1; i <= N; i++) {
scanf("%lld", &ar[i]);
ar[i + N] = ar[i];
sum += ar[i];
}
const int n = N;
N <<= 1;
while (Q--) {
long long t;
scanf("%lld", &t);
if (sum <= t) {
printf("1\n");
continue;
}
long long cur = 0;
int l = 0, r = N;
for (int i = 1, j = 1; i <= N; i++) {
while (j <= N and cur + ar[j] <= t) cur += ar[j++];
if (j <= N and j - i < r - l) {
l = i;
r = j;
}
go[i] = j;
cur -= ar[i];
}
int ans = n;
for (int i = l; i <= r; i++) {
int cur = i > N ? i - N : i, cnt = 0;
for (int j = cur; j < cur + n; j = go[j]) cnt++;
ans = min(ans, cnt);
}
printf("%d\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int desll[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
const long long mod = 1e9 + 7;
const int maxn = 1e6 + 7;
const int maxm = 1e8 + 7;
const double eps = 1e-4;
int m, n, ar[maxn];
char ch[maxn];
int armid[maxn];
struct node {
int val, num;
char c;
node *pre, *l, *r;
void clear() { l = r = NULL; }
} no[maxn];
int ma, ans = 0;
int newCal(node* u) {
if (u->c == 'N')
return 1 - (u->l->val);
else if (u->c == 'A')
return u->l->val & u->r->val;
else if (u->c == 'X')
return u->l->val ^ u->r->val;
else if (u->c == 'O')
return u->l->val | u->r->val;
}
void dfs(node* u, int x) {
int now = u->val;
u->val = x;
if (u->pre == NULL || now == x) {
ans = no[1].val;
} else {
if (armid[u->num] != -1) {
ans = armid[u->num];
} else {
dfs(u->pre, newCal(u->pre));
armid[u->num] = ans;
}
}
u->val = now;
}
void init(node* u) {
if (u->c == 'I') return;
init(u->l);
if (u->r != NULL) init(u->r);
if (u->c == 'N')
u->val = 1 - (u->l->val);
else if (u->c == 'A')
u->val = u->l->val & u->r->val;
else if (u->c == 'X')
u->val = u->l->val ^ u->r->val;
else if (u->c == 'O')
u->val = u->l->val | u->r->val;
}
int main() {
scanf("%d", &n);
int x, y;
no[1].pre = NULL;
for (int i = 0; i <= n; i++) no[i].clear();
for (int i = 1; i <= n; i++) {
scanf("%s", ch);
scanf("%d", &x);
if (ch[0] == 'A' || ch[0] == 'O' || ch[0] == 'X') {
scanf("%d", &y);
no[i].l = &no[x];
no[i].r = &no[y];
no[x].pre = &no[i];
no[y].pre = &no[i];
no[i].c = ch[0];
} else if (ch[0] == 'N') {
no[i].l = &no[x];
no[x].pre = &no[i];
no[i].c = ch[0];
} else {
no[i].val = x;
no[i].c = ch[0];
}
no[i].num = i;
}
memset(armid, -1, sizeof(armid));
init(&no[1]);
int len = 0;
for (int i = 1; i <= n; i++) {
ma = 0;
if (no[i].c == 'I') {
dfs(&no[i], 1 - no[i].val);
ar[len++] = ans;
}
}
for (int i = 0; i < len; i++) {
printf("%d", ar[i]);
}
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxx = 1e6 + 5;
int main() {
long long int n, temp, maxi;
cin >> n;
temp = n;
int ans = 0;
while (n) {
temp = n;
maxi = 0;
while (temp) {
maxi = max(maxi, temp % 10);
temp /= 10;
}
n -= maxi;
ans++;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int nmax = 200010;
long long res, rs1;
vector<vector<pair<int, int> > > vr;
vector<vector<int> > rs;
int n, md, a, b, l, t, m;
int ch[nmax], ans[nmax];
void dfs(int v, int p) {
for (int i = 0; i < vr[v].size(); ++i) {
int to = vr[v][i].first;
if (to != p) {
ch[1] += vr[v][i].second;
dfs(to, v);
}
}
}
void dfs1(int v, int p) {
for (int i = 0; i < vr[v].size(); ++i) {
int to = vr[v][i].first;
if (to != p) {
ans[to] = ans[v] - vr[v][i].second + (1 - vr[v][i].second);
rs[ans[to]].push_back(to);
dfs1(to, v);
}
}
}
int main() {
cin >> n;
vr.resize(n + 3);
rs.resize(n + 1);
for (int i = 0; i < n - 1; ++i) {
scanf("%d %d", &a, &b);
vr[a].push_back(make_pair(b, 0));
vr[b].push_back(make_pair(a, 1));
}
dfs(1, 1);
ans[1] = ch[1];
dfs1(1, 1);
rs[ch[1]].push_back(1);
for (int i = 0; i < n + 1; ++i) {
if (rs[i].size()) {
sort(rs[i].begin(), rs[i].end());
printf("%d\n", i);
for (int j = 0; j < rs[i].size(); ++j) {
printf("%d ", rs[i][j]);
}
break;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 2;
int a[maxn], ans[maxn];
void no() {
cout << -1 << endl;
exit(0);
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a[i];
}
vector<int> v(n);
iota(v.begin(), v.end(), 0);
for (int i = 0; i < m; i++) {
if (a[v[i]] > n - i) {
no();
}
ans[v[i]] = i + 1;
}
int c = n;
for (int i = m - 1; i >= 0; i--) {
ans[v[i]] = max(ans[v[i]], c - a[v[i]] + 1);
c = ans[v[i]] - 1;
}
if (c) no();
for (int i = 0; i < m; i++) {
cout << ans[i] << ' ';
}
cout << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const bool test_cases = 1;
const ll maxn = 2e5 + 55;
const ll mod = 998244353;
void solve() {
ll n, cnt = 0;
cin >> n;
while (n >= 2) {
ll l = 1, r = 1e9;
ll most = 0;
while (l <= r) {
ll m = (l + r) / 2;
ll cardsused = m * (m + 1) + (m - 1) * m / 2;
if (n >= cardsused) {
most = max(most, cardsused);
l = m + 1;
} else {
r = m - 1;
}
}
n -= most;
++cnt;
}
cout << cnt;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
if (test_cases) cin >> t;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const long long N = 1e5 + 5;
const long long inf = 1e12;
void add_self(long long &a, long long b) {
a += b;
if (a >= mod) a -= mod;
}
void sub_self(long long &a, long long b) {
a -= b;
if (a < 0) a += mod;
}
void mul_self(long long &a, long long b) {
a *= b;
a %= mod;
}
void max_self(long long &a, long long b) {
if (b > a) a = b;
}
long long power(long long a, long long x) {
long long ret = 1;
while (x) {
if (x % 2) mul_self(ret, a);
x /= 2;
mul_self(a, a);
}
return ret;
}
set<pair<long long, long long>> ans;
void go_right(long long y, long long st, long long en) {
for (long long i = st; i <= en; i++) ans.insert(make_pair(i, y));
}
void go_up(long long x, long long st, long long en) {
for (long long i = st; i <= en; i++) ans.insert(make_pair(x, i));
}
int main() {
ios_base::sync_with_stdio(false);
pair<long long, long long> p[3];
for (long long i = 0; i < (3); i++) cin >> p[i].first >> p[i].second;
sort(p, p + 3);
long long min_y = inf, max_y = -inf, x_mid;
x_mid = p[1].first;
for (long long i = 0; i < (3); i++) {
min_y = min(min_y, p[i].second);
max_y = max(max_y, p[i].second);
}
go_right(p[0].second, p[0].first, x_mid);
go_right(p[2].second, x_mid, p[2].first);
go_up(x_mid, min_y, max_y);
cout << ans.size() << endl;
for (auto i : ans) cout << i.first << " " << i.second << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100005;
long long int ans[MAX];
pair<long long int, pair<long long int, long long int> > p[MAX];
int main() {
long long int n, k, i, j, sum = 0;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> p[i].first;
}
for (int i = 0; i < n; i++) {
cin >> p[i].second.first;
p[i].second.second = i;
}
sort(p, p + n);
multiset<long long int> q;
for (int i = 0; i < n; i++) {
if (i == 0) {
ans[p[i].second.second] = p[i].second.first;
} else {
ans[p[i].second.second] = p[i].second.first;
long long int sz = q.size();
sz = min(sz, k);
multiset<long long int>::iterator it = q.begin();
while (sz--) {
ans[p[i].second.second] += (0 - *it);
it++;
}
}
q.insert(-p[i].second.first);
}
for (int i = 0; i < n; i++) {
printf("%lld ", ans[i]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int last[100009];
int main() {
int a, b, m, r0;
scanf("%d %d %d %d", &a, &b, &m, &r0);
last[r0] = 1;
int step = 2;
while (1) {
r0 = (a * r0 + b) % m;
if (last[r0]) {
printf("%d\n", step - last[r0]);
return 0;
}
last[r0] = step++;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
signed main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
long long int TESTS = 1;
while (TESTS--) {
long long n, k;
cin >> n >> k;
vector<pair<long long, long long> > vp(n);
vector<long long> b(n);
for (long long int i = 0; i < n; i++) {
cin >> vp[i].first;
vp[i].second = i;
}
for (long long int i = 0; i < n; i++) cin >> b[i];
sort((vp).begin(), (vp).end());
priority_queue<long long> pq;
for (long long int i = 0; i < n; i++) {
long long u = 0, p = b[vp[i].second];
vector<long long> a;
while (!pq.empty() && u < k) {
long long z = pq.top();
a.push_back(z);
pq.pop();
b[vp[i].second] += z;
u++;
}
for (auto j : a) pq.push(j);
pq.push(p);
}
for (auto i : b) cout << i << " ";
cout << endl;
}
return (0);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
int i = str.length() - 1;
while (str[i] == '0' && i-- >= 0) {
}
for (int j = 0; j <= i; j++) {
if (str[j] != str[i - j]) {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int maxn = 2007, inf = 0x3f3f3f3f;
int n, u[maxn], v[maxn], f[maxn][11][11][11][11];
int dist(int a, int b) { return abs(a - b); }
int min(int a, int b) { return a < b ? a : b; }
int dfs(int i, int cur, int a, int b, int c) {
if (~f[i][cur][a][b][c]) return f[i][cur][a][b][c];
int ret = inf;
if (i > n) {
if (a == 0 && b == 0 && c == 0) return 0;
if (a) ret = min(ret, dfs(i, a, 0, b, c) + dist(cur, a) + 1);
if (b) ret = min(ret, dfs(i, b, a, 0, c) + dist(cur, b) + 1);
if (c) ret = min(ret, dfs(i, c, a, b, 0) + dist(cur, c) + 1);
return f[i][cur][a][b][c] = ret;
}
if (a) ret = min(ret, dfs(i, a, 0, b, c) + dist(cur, a) + 1);
if (b) ret = min(ret, dfs(i, b, a, 0, c) + dist(cur, b) + 1);
if (c) ret = min(ret, dfs(i, c, a, b, 0) + dist(cur, c) + 1);
if (a && b && c) {
ret = min(ret, dfs(i + 1, v[i], a, b, c) + dist(cur, u[i]) +
dist(u[i], v[i]) + 2);
ret = min(ret,
dfs(i + 1, a, v[i], b, c) + dist(cur, u[i]) + dist(u[i], a) + 2);
ret = min(ret,
dfs(i + 1, b, a, v[i], c) + dist(cur, u[i]) + dist(u[i], b) + 2);
ret = min(ret,
dfs(i + 1, c, a, b, v[i]) + dist(cur, u[i]) + dist(u[i], c) + 2);
} else {
if (!a)
ret = min(ret, dfs(i + 1, u[i], v[i], b, c) + dist(cur, u[i]) + 1);
else if (!b)
ret = min(ret, dfs(i + 1, u[i], a, v[i], c) + dist(cur, u[i]) + 1);
else
ret = min(ret, dfs(i + 1, u[i], a, b, v[i]) + dist(cur, u[i]) + 1);
}
return f[i][cur][a][b][c] = ret;
}
int main() {
memset(f, 0xff, sizeof(f));
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", u + i, v + i);
printf("%d\n", dfs(1, 1, 0, 0, 0));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool used[100][100];
int main() {
int r, c, n, h;
cin >> r >> c >> n >> h;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
used[x][y] = true;
}
if (n < h) {
cout << "0";
return 0;
}
int ans = 0;
for (int i = 1; i <= r; i++) {
for (int j = 1; j <= c; j++) {
for (int k = i; k <= r; k++) {
for (int q = j; q <= c; q++) {
int now = 0;
for (int pref = i; pref <= k; pref++) {
for (int suf = j; suf <= q; suf++) {
if (used[pref][suf] == true) {
now++;
}
}
}
if (now >= h) {
ans++;
}
}
}
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void fre() {
freopen("c://test//input.in", "r", stdin);
freopen("c://test//output.out", "w", stdout);
}
template <class T1, class T2>
inline void gmax(T1 &a, T2 b) {
if (b > a) a = b;
}
template <class T1, class T2>
inline void gmin(T1 &a, T2 b) {
if (b < a) a = b;
}
const int N = 0, M = 0, Z = 1e9 + 7, ms63 = 0x3f3f3f3f;
int n;
pair<int, int> a[105];
int c[105];
int main() {
scanf("%d%*d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i].first), a[i].second = i;
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; ++i) c[a[i].second] = (i & 1);
for (int i = 1; i <= n; ++i) printf("%d ", c[i]);
puts("");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
int m, n;
int a[N], ans[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> m >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
ans[i] = i;
if (ans[i] + a[i] - 1 > m) {
cout << "-1";
return 0;
}
}
for (int i = n; i >= 1; i--) {
if (i == n and ans[i] + a[i] - 1 < m)
ans[i] = m - a[i] + 1;
else if (i != n and ans[i] + a[i] - 1 < ans[i + 1])
ans[i] = ans[i + 1] - a[i];
else
break;
}
if (ans[1] != 1)
cout << "-1";
else
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int days, n;
while (scanf("%d%d", &days, &n) == 2) {
vector<unordered_set<int> > vs;
while (days--) {
int k;
scanf("%d", &k);
unordered_set<int> s;
for (int i = 0; i < k; ++i) {
int x;
scanf("%d", &x);
s.insert(x);
}
vs.push_back(move(s));
}
bool possible = true;
for (int i = 0; i < vs.size(); ++i) {
for (int j = i + 1; j < vs.size(); ++j) {
int common = 0;
for (int x : vs[i]) {
if (vs[j].find(x) != vs[j].end()) {
++common;
}
}
if (common == 0) {
possible = false;
goto esc;
}
}
}
esc:
printf("%s\n", possible ? "possible" : "impossible");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[6];
for (int i = 0; i < 6; ++i) cin >> a[i];
int a123 = a[0] + a[1] + a[2], a1 = a[0], a3 = a[2], a5 = a[4];
cout << a123 * a123 - a1 * a1 - a3 * a3 - a5 * a5 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, t, d;
cin >> t;
while (t--) {
long long ans = 0;
cin >> n >> d;
bool l = 0;
for (long long i = max(0ll, (n - 1) / 2 - 10); i <= (n - 1) / 2 + 10; ++i) {
if (i + (d + i) / (i + 1) <= n) {
l = 1;
break;
}
}
if (l)
cout << "YES" << endl;
else {
cout << "NO" << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("-Ofast", "-funroll-all-loops")
using namespace std;
long long int CeilIndex(std::vector<long long int>& v, long long int l,
long long int r, long long int key) {
while (r - l > 1) {
long long int m = l + (r - l) / 2;
if (v[m] > key)
r = m;
else
l = m;
}
return r;
}
long long int LongestIncreasingSubsequenceLength(
std::vector<long long int>& v) {
if (v.size() == 0) return 0;
std::vector<long long int> tail(v.size(), 0);
long long int length = 1;
tail[0] = v[0];
for (size_t i = 1; i < v.size(); i++) {
if (v[i] < tail[0])
tail[0] = v[i];
else if (v[i] >= tail[length - 1])
tail[length++] = v[i];
else
tail[CeilIndex(tail, -1, length - 1, v[i])] = v[i];
}
return length;
}
bool check(int m, vector<pair<int, int>> v) {
int f = 0;
for (int i = 0; i < v.size(); i++) {
int x = v[i].first;
int y = v[i].second;
if (x > m && y > m) {
f = 1;
break;
}
}
if (f == 1)
return false;
else
return true;
}
long long int subsetSumToK(long long int arr[], long long int n,
long long int output[][50], long long int k) {
if (n == 0) {
if (k == 0) {
output[0][0] = 0;
return 1;
} else {
return 0;
}
}
long long int output1[1000][50];
long long int output2[1000][50];
long long int size1 = subsetSumToK(arr + 1, n - 1, output1, k - arr[0]);
long long int size2 = subsetSumToK(arr + 1, n - 1, output2, k);
long long int i, j;
for (i = 0; i < size1; i++) {
output[i][0] = output1[i][0] + 1;
output[i][1] = arr[0];
}
for (i = 0; i < size1; i++) {
for (j = 1; j <= output1[i][0]; j++) {
output[i][j + 1] = output1[i][j];
}
}
for (i = 0; i < size2; i++) {
for (j = 0; j <= output2[i][0]; j++) {
output[i + size1][j] = output2[i][j];
}
}
return size1 + size2;
}
void countSubsequences(long long int arr[], long long int n,
long long int output[][50], long long int k) {
int size = subsetSumToK(arr, n, output, k);
for (long long int i = 0; i < size; i++) {
for (long long int j = 1; j <= output[i][0]; j++) {
cout << output[i][j] << " ";
}
cout << endl;
}
}
long long int subCount(long long int arr[], long long int n, long long int k) {
long long int mod[k];
memset(mod, 0, sizeof(mod));
long long int cumSum = 0;
for (long long int i = 0; i < n; i++) {
cumSum += arr[i];
mod[((cumSum % k) + k) % k]++;
}
long long int result = 0;
for (long long int i = 0; i < k; i++)
if (mod[i] > 1) result += (mod[i] * (mod[i] - 1)) / 2;
result += mod[0];
return result;
}
long long int fact(long long int n);
long long int nCr(long long int n, long long int r) {
return fact(n) / (fact(r) * fact(n - r));
}
long long int fact(long long int n) {
long long int res = 1;
for (long long int i = 2; i <= n; i++) res = res * i;
return res;
}
long long int subsetPairNotDivisibleByK(long long int arr[], long long int N,
long long int K) {
long long int f[K];
memset(f, 0, sizeof(f));
for (long long int i = 0; i < N; i++) f[arr[i] % K]++;
if (K % 2 == 0) f[K / 2] = min(f[K / 2], 1LL);
long long int res = min(f[0], 1LL);
for (long long int i = 1; i <= K / 2; i++) res += max(f[i], f[K - i]);
return res;
}
bool isPerfectSquare(long double x) {
if (x >= 0) {
long double sr = sqrt(x);
return (sr * sr == x);
}
return false;
}
vector<long long int> v[1000001];
long long int dis[50][50];
long long int deg[1000001];
long long int ask(long long int x, long long int y) {
cout << '?' << " " << x << " " << y << '\n';
cout.flush();
long long int w;
cin >> w;
return w;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n;
cin >> n;
long long int x12 = ask(1, n);
long long int x13 = ask(1, n - 1);
long long int x23 = ask(n, n - 1);
long long int a[n + 1];
a[n] = (x12 - x13 + x23) / 2;
a[1] = x12 - a[n];
a[n - 1] = x13 - a[1];
for (long long int i = n - 2; i >= 2; i--) {
long long int y = ask(i, i + 1);
a[i] = y - a[i + 1];
}
cout << '!' << " ";
for (long long int i = 1; i <= n; i++) cout << a[i] << " ";
cout.flush();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
double a[maxn], b[maxn], c[maxn], v[maxn];
double d[maxn], x[maxn];
void solveMatrix(int n, double *a, double *b, double *c, double *v, double *x) {
int i;
for (i = 1; i < n; i++) {
double m = a[i] / b[i - 1];
b[i] = b[i] - m * c[i - 1];
v[i] = v[i] - m * v[i - 1];
}
x[n - 1] = v[n - 1] / b[n - 1];
for (i = n - 2; i >= 0; --i) x[i] = (v[i] - c[i] * x[i + 1]) / b[i];
}
int main() {
int N, M;
int X, Y;
int i, j;
while (scanf("%d%d", &N, &M) != EOF) {
scanf("%d%d", &X, &Y);
memset(x, 0, sizeof(x));
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
memset(c, 0, sizeof(c));
for (i = N - 1; i >= X; i--) {
for (j = 0; j < M; j++) {
double cnt = 2;
if (j > 0) cnt++;
if (j < M - 1) cnt++;
if (j > 0) a[j] = -1 / cnt;
if (j < M - 1) c[j] = -1 / cnt;
b[j] = 1 - 1.0 / cnt;
d[j] = 1 + x[j] / cnt;
}
solveMatrix(M, a, b, c, d, x);
}
printf("%lf\n", x[Y - 1]);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> build_forest_from_leaves(vector<int>& degrees,
vector<int>& sums,
queue<int>& leaves) {
vector<pair<int, int>> result;
int current_node;
while (!leaves.empty()) {
current_node = leaves.front();
if (degrees[current_node] == 0)
leaves.pop();
else {
leaves.pop();
degrees[current_node]--;
degrees[sums[current_node]]--;
if (degrees[sums[current_node]] == 1) leaves.push(sums[current_node]);
sums[sums[current_node]] ^= current_node;
result.emplace_back(make_pair(current_node, sums[current_node]));
}
}
return result;
}
int main() {
int num_vertices, deg, sum;
cin >> num_vertices;
vector<int> degrees;
vector<int> sums;
degrees.reserve(num_vertices);
sums.reserve(num_vertices);
queue<int> leaves;
for (int i = 0; i < num_vertices; ++i) {
cin >> deg >> sum;
degrees.push_back(deg);
sums.push_back(sum);
if (deg == 1) leaves.push(i);
}
auto edges = build_forest_from_leaves(degrees, sums, leaves);
cout << edges.size() << endl;
for (auto e : edges) cout << e.first << " " << e.second << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<string> table;
vector<string> ftable;
int fans = INT_MAX;
void tryRows(string ch) {
int ans = 0;
vector<string> t;
for (int i = 0; i < n; i++) {
int cnt1 = 0, cnt2 = 0;
string s1 = "", s2 = "";
for (int j = 0; j < m; j++) {
if (table[i][j] != ch[j % 2 + 2 * (i % 2)]) cnt1++;
s1 += ch[j % 2 + 2 * (i % 2)];
}
for (int j = 0; j < m; j++) {
if (table[i][j] != ch[(j + 1) % 2 + 2 * (i % 2)]) cnt2++;
s2 += ch[(j + 1) % 2 + 2 * (i % 2)];
}
if (cnt1 < cnt2)
t.push_back(s1);
else
t.push_back(s2);
ans += min(cnt1, cnt2);
}
if (ans < fans) {
ftable = t;
fans = ans;
}
}
void tryCols(string ch) {
int ans = 0;
vector<string> t;
for (int i = 0; i < m; i++) {
int cnt1 = 0, cnt2 = 0;
string s1 = "", s2 = "";
for (int j = 0; j < n; j++) {
if (table[j][i] != ch[j % 2 + 2 * (i % 2)]) cnt1++;
s1 += ch[j % 2 + 2 * (i % 2)];
}
for (int j = 0; j < n; j++) {
if (table[j][i] != ch[(j + 1) % 2 + 2 * (i % 2)]) cnt2++;
s2 += ch[(j + 1) % 2 + 2 * (i % 2)];
}
if (cnt1 < cnt2)
t.push_back(s1);
else
t.push_back(s2);
ans += min(cnt1, cnt2);
}
if (ans < fans) {
ftable = t;
fans = ans;
for (int i = 0; i < n; i++) {
string s = "";
if (i >= ftable.size()) ftable.push_back(s);
for (int j = 0; j < m; j++) {
if (ftable[i].size() > j)
ftable[i][j] = t[j][i];
else
ftable[i] += t[j][i];
}
}
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
string t;
cin >> t;
table.push_back(t);
}
string ch = "AGCT";
int ans = INT_MAX;
do {
tryRows(ch);
tryCols(ch);
} while (next_permutation(ch.begin(), ch.end()));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << ftable[i][j];
}
cout << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n;
vector<int> ans[2];
int fl;
struct Tree {
struct Edge {
int t, nxt;
} e[N];
int cnt, head[N], siz[N], dep[N], son[N], fa[N], vis[N], top[N];
int id, idx[N];
vector<int> num[N << 2];
void add(int u, int v) {
e[++cnt].t = v;
e[cnt].nxt = head[u];
head[u] = cnt;
}
void dfs1(int x) {
siz[x] = 1;
dep[x] = dep[fa[x]] + 1;
for (int i = head[x]; i; i = e[i].nxt) {
dfs1(e[i].t);
siz[x] += siz[e[i].t];
if (siz[e[i].t] > siz[son[x]]) son[x] = e[i].t;
}
}
void dfs2(int x, int tp) {
top[x] = tp;
idx[x] = ++id;
if (son[x]) dfs2(son[x], tp);
for (int i = head[x]; i; i = e[i].nxt)
if (e[i].t != son[x]) dfs2(e[i].t, e[i].t);
}
void add(int x, int l, int r, int L, int R, int y) {
if (r < L || l > R) return;
if (l >= L && r <= R) {
num[x].push_back(y);
return;
}
int mid = (l + r) >> 1;
add(x << 1, l, mid, L, R, y);
add((x << 1) + 1, mid + 1, r, L, R, y);
}
void del(int x, int l, int r, int L) {
if (r < L || l > L) return;
for (int i = 0; i < num[x].size(); ++i) {
int t = num[x][i];
if (vis[t]) continue;
vis[t] = 1;
ans[fl].push_back(t);
}
num[x].clear();
if (l == r) return;
int mid = (l + r) >> 1;
del(x << 1, l, mid, L);
del((x << 1) + 1, mid + 1, r, L);
}
void add(int u, int v, int y) {
while (top[u] != top[v]) {
if (dep[top[u]] < dep[top[v]]) swap(u, v);
add(1, 1, n, idx[top[u]], idx[u], y);
u = fa[top[u]];
}
if (dep[u] < dep[v]) swap(u, v);
if (u != v) add(1, 1, n, idx[v] + 1, idx[u], y);
}
void del(int u) { del(1, 1, n, idx[u]); }
} Tr[2];
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; ++i) {
scanf("%d", &Tr[0].fa[i]);
Tr[0].add(Tr[0].fa[i], i);
}
for (int i = 2; i <= n; ++i) {
scanf("%d", &Tr[1].fa[i]);
Tr[1].add(Tr[1].fa[i], i);
}
Tr[0].dfs1(1);
Tr[0].dfs2(1, 1);
Tr[1].dfs1(1);
Tr[1].dfs2(1, 1);
for (int i = 2; i <= n; ++i) {
Tr[0].add(Tr[1].fa[i], i, i);
Tr[1].add(Tr[0].fa[i], i, i);
}
int p;
scanf("%d", &p);
Tr[1].vis[p + 1] = 1;
fl = 0;
ans[fl].push_back(p + 1);
while (ans[fl].size()) {
puts(fl ? "Red" : "Blue");
sort(ans[fl].begin(), ans[fl].end());
for (int i = 0; i < ans[fl].size(); ++i) printf("%d ", ans[fl][i] - 1);
puts("");
fl ^= 1;
ans[fl].clear();
for (int i = 0; i < ans[fl ^ 1].size(); ++i) Tr[fl ^ 1].del(ans[fl ^ 1][i]);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char ch = getchar();
long long nega = 1;
while (!isdigit(ch)) {
if (ch == '-') nega = -1;
ch = getchar();
}
long long ans = 0;
while (isdigit(ch)) {
ans = ans * 10 + ch - 48;
ch = getchar();
}
if (nega == -1) return -ans;
return ans;
}
long long a[200005], b[200005], sum[200005];
signed main() {
long long n = read();
if (n == 1) {
cout << read() << endl;
return 0;
}
for (long long i = 1; i <= n; i++) a[i] = b[i] = read();
sort(b + 1, b + n + 1);
for (long long i = 1; i <= n; i++) sum[i] = sum[i - 1] + b[i];
long long l;
if (n % 3 == 0)
l = n - 2;
else if (n % 3 == 1)
l = n - 1;
else
l = n;
long long ans = -0x3f3f3f3f3f3f3f3f;
while (l >= 0) {
long long tmp = (sum[n] - sum[l]) - (sum[l]);
if (l * 2 + 1 == n) {
long long res = 0;
for (long long i = 1; i <= n; i++) {
if (i & 1)
res += a[i];
else
res -= a[i];
}
if (res == tmp) tmp -= (b[n / 2 + 1] - b[n / 2]) * 2;
}
ans = max(ans, tmp);
l -= 3;
}
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n;
scanf("%d", &n);
printf("%d\n", n);
for (int i = 1; i <= n; ++i) {
printf("%d ", i);
}
printf("\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[110];
int main() {
int n, num = 0, x = 0, y = 0, z = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n; i++) {
a[-1] = 2;
if (a[i] == 1) {
num = num + 1;
x = 1;
if (y == 1) num = num + 1;
y = 0;
} else if (a[i] == 0 && x == 1) {
y = y + 1;
}
}
cout << num << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long dp[400000];
int k;
int gcd(int a, int b) {
for (int t; t = b; b = a % b, a = t)
;
return a;
}
long long gao(long long a, long long b) {
int i, j, s;
dp[0] = 0;
for (i = 1; i <= a - b; ++i) {
dp[i] = dp[i - 1] + 1;
for (j = 2; j <= k; ++j) {
s = (b + i) % j;
if (i - s >= 0 && dp[i - s] + 1 < dp[i]) dp[i] = dp[i - s] + 1;
}
}
return dp[a - b];
}
int main() {
long long a, b, ans;
int i, j, c;
while (cin >> a >> b >> k) {
c = 1;
for (i = 2; i <= k; ++i) {
c = c * i / gcd(c, i);
}
if (a / c == b / c) {
cout << gao(a, b) << endl;
} else if (a / c - b / c == 1) {
cout << gao(a % c, 0) + gao(c, b % c) << endl;
} else {
cout << (a / c - b / c - 1) * gao(c, 0) + gao(a % c, 0) + gao(c, b % c)
<< endl;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
if (n == 1) {
printf("2 1\n 2\n");
} else {
n--;
printf("%d 2\n2 3\n", 6 * n);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005, M = 15, BCKTS = 300, BCKT_SZ = N / BCKTS + 2;
int n, m;
char grid[N][M];
pair<int, int> outside_bucket[N][M];
int bckt_id[N];
int mark[N][M];
bool in_loop[N][M];
inline bool inside(int r, int c) { return r >= 0 && c >= 0 && r < n && c < m; }
pair<pair<int, int>, bool> dfs(int r, int c, int initial_bucket) {
if (!inside(r, c)) return make_pair(pair<int, int>(r, c), false);
if (bckt_id[r] != initial_bucket)
return make_pair(pair<int, int>(r, c), false);
if (mark[r][c] == 1 || in_loop[r][c])
return make_pair(pair<int, int>(r, c), true);
if (mark[r][c] == 2) return make_pair(outside_bucket[r][c], false);
mark[r][c] = 1;
pair<pair<int, int>, bool> ret;
if (grid[r][c] == '>') {
ret = dfs(r, c + 1, initial_bucket);
} else if (grid[r][c] == '<') {
ret = dfs(r, c - 1, initial_bucket);
} else {
ret = dfs(r - 1, c, initial_bucket);
}
mark[r][c] = 2;
if (ret.second) {
in_loop[r][c] = true;
return ret;
} else {
outside_bucket[r][c] = ret.first;
return ret;
}
}
void build() {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
dfs(i, j, bckt_id[i]);
}
}
}
pair<int, int> query(int r, int c) {
pair<int, int> ret = pair<int, int>(r, c);
while (inside(ret.first, ret.second)) {
if (in_loop[ret.first][ret.second]) return pair<int, int>(-1, -1);
ret = outside_bucket[ret.first][ret.second];
}
ret.first += 1;
ret.second += 1;
return ret;
}
void update(int r, int c, char new_char) {
int id = bckt_id[r];
int start = id * BCKT_SZ, end = min(n, (id + 1) * BCKT_SZ);
for (int i = start; i <= end; ++i) {
for (int j = 0; j < m; ++j) {
mark[i][j] = 0;
in_loop[i][j] = false;
}
}
grid[r][c] = new_char;
for (int i = start; i <= end; ++i) {
for (int j = 0; j < m; ++j) {
dfs(i, j, bckt_id[i]);
}
}
}
int main() {
int q;
scanf("%d %d %d", &n, &m, &q);
for (int i = 0; i < n; ++i) {
scanf("%s", grid[i]);
bckt_id[i] = i / BCKT_SZ;
}
build();
while (q-- > 0) {
char type;
int r, c;
scanf(" %c %d %d", &type, &r, &c);
--r;
--c;
if (type == 'A') {
pair<int, int> ans = query(r, c);
printf("%d %d\n", ans.first, ans.second);
} else {
char new_char;
scanf(" %c", &new_char);
update(r, c, new_char);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
int l = 0, f = 0, s = 0, b = 0;
cin >> n >> k;
int *a = new int[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
if (f == 1) {
if ((a[i] + l) <= 8) {
s += (a[i] + l);
l = 0;
f = 0;
} else {
l += a[i] - 8;
s += 8;
f = 1;
}
} else {
if (a[i] <= 8) {
s += a[i];
f = 0;
} else {
l = a[i] - 8;
s += 8;
f = 1;
}
}
if (s >= k) {
cout << (i + 1) << endl;
b = 1;
i = n;
}
}
if (b == 0) cout << "-1" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
inline int read() {
int x = 0;
char c;
while ((c = getchar()) < '0' || c > '9')
;
for (; c >= '0' && c <= '9'; c = getchar()) x = x * 10 + c - '0';
return x;
}
struct edge {
int nx, t;
} e[100000 * 4 + 5];
int h[100000 * 2 + 5], en, ans[100000 * 2 + 5], a[100000 + 5], b[100000 + 5];
inline void ins(int x, int y) {
e[++en] = (edge){h[x], y};
h[x] = en;
e[++en] = (edge){h[y], x};
h[y] = en;
}
void dfs(int x) {
for (int i = h[x]; i; i = e[i].nx)
if (!ans[e[i].t]) ans[e[i].t] = 3 - ans[x], dfs(e[i].t);
}
int main() {
int n = read(), i;
for (i = 0; i < n; ++i) a[i] = read(), ins(a[i], b[i] = read());
for (i = 1; i <= n; ++i) ins(i * 2 - 1, i * 2);
for (i = 1; i <= n * 2; ++i)
if (!ans[i]) ans[i] = 1, dfs(i);
for (i = 0; i < n; ++i) printf("%d %d\n", ans[a[i]], ans[b[i]]);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
cin.tie(0)->sync_with_stdio(0);
cin.exceptions(cin.failbit);
long long k, b, n, t, z = 1;
cin >> k >> b >> n >> t;
while (n && k * z + b <= t) {
z = z * k + b;
n--;
}
cout << n;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e5 + 5;
int a[M], mark[M];
int32_t main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == i) {
cout << "YES" << endl;
for (int j = 1; j <= n; j++)
if (i != j) cout << i << ' ' << j << endl;
return 0;
}
}
int ras = 0;
for (int i = 1; i <= n; i++) {
if (mark[i]) continue;
if (i == a[a[i]]) ras = i;
int p = a[i];
mark[i] = 1;
int len = 1;
while (p != i) {
mark[p] = 1, len++;
p = a[p];
}
if (len & 1) return cout << "NO" << endl, 0;
}
if (!ras) return cout << "NO" << endl, 0;
cout << "YES" << endl;
cout << ras << ' ' << a[ras] << endl;
memset(mark, 0, sizeof mark);
mark[ras] = mark[a[ras]] = 1;
for (int i = 1; i <= n; i++)
if (!mark[i]) {
cout << i << ' ' << ras << endl;
mark[i] = 1;
int p = a[i];
int l = 0;
while (p != i) {
mark[p] = 1;
cout << p << ' ';
if (l & 1)
cout << ras;
else
cout << a[ras];
cout << endl;
p = a[p];
l++;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long max(long long x, long long y) { return x > y ? x : y; }
long long min(long long x, long long y) { return x < y ? x : y; }
void _(long long& a, long long b) {
a = (a % 1000000007 + b % 1000000007) % 1000000007;
a = (a + 1000000007) % 1000000007;
}
long long cl(long long a, long long b) { return (a / b) + (!(!(a % b))); }
void query(vector<long long>& v) {
cout << "? " << v.size() << " ";
for (long long i = 0; i < v.size(); ++i) {
cout << v[i] + 1 << " ";
}
cout << endl;
}
long long dans;
long long uuans[1010];
vector<long long> udis[1010];
long long ans;
bool bs(long long mid) {
if (udis[mid].empty()) return 0;
query(udis[mid]);
long long x, d;
cin >> x >> d;
if (d == -1) exit(0);
x--;
ans = x;
uuans[mid] = ans;
if (d == dans) return 1;
return 0;
}
void solve() {
long long n;
cin >> n;
memset(uuans, -1, sizeof(uuans));
vector<long long> e[n];
for (long long i = 0; i < n - 1; ++i) {
long long u, v;
cin >> u >> v;
u--;
v--;
e[u].push_back(v);
e[v].push_back(u);
}
long long x, d;
vector<long long> v;
for (long long i = 0; i < n; ++i) {
v.push_back(i);
}
query(v);
cin >> x >> d;
x--;
dans = d;
long long dis[n];
bool vis[n];
memset(vis, 0, sizeof(vis));
vis[x] = 1;
dis[x] = 0;
queue<long long> q;
q.push(x);
while (!q.empty()) {
long long j = q.front();
q.pop();
for (auto u : e[j]) {
if (!vis[u]) {
dis[u] = dis[j] + 1;
vis[u] = 1;
q.push(u);
}
}
}
for (long long i = 0; i < n; ++i) {
udis[dis[i]].push_back(i);
}
long long l, r, mid;
l = cl(d, 2);
r = d;
mid = (l + r + 1) / 2;
while (l < r) {
if (bs(mid))
l = mid;
else
r = mid - 1;
mid = (l + r + 1) / 2;
}
if (uuans[l] == -1) bs(l);
ans = uuans[l];
vector<long long> vans;
memset(vis, 0, sizeof(vis));
q.push(ans);
vis[ans] = 1;
dis[ans] = 0;
while (!q.empty()) {
long long i = q.front();
q.pop();
for (auto j : e[i]) {
if (!vis[j]) {
vis[j] = 1;
dis[j] = dis[i] + 1;
q.push(j);
}
}
}
for (long long i = 0; i < n; ++i) {
if (dis[i] == d) vans.push_back(i);
}
query(vans);
long long ans2;
cin >> ans2 >> d;
ans2--;
cout << "! " << ans + 1 << " " << ans2 + 1 << endl;
for (long long i = 0; i < n; ++i) {
udis[i].clear();
}
string s;
cin >> s;
if (s != "Correct") exit(0);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
solve();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long have;
long long a, b, c, d;
void run() {
scanf("%I64d%I64d%I64d%I64d", &have, &a, &b, &c);
d = b - c;
long long ret = 0;
if (d < a && have >= c) {
long long x = (have - c) / d;
ret += x;
have -= x * d;
}
ret += have / a;
printf("%I64d\n", ret);
}
int main() {
run();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(int n) {
if (n <= 3) {
return true;
}
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
int i = 1;
int sum;
while (1) {
sum = n * i;
if (sum % 10 == k || sum % 10 == 0) {
break;
}
i++;
}
cout << i;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
long long dp[500000];
int main() {
int a, b;
scanf("%d %d", &a, &b);
int temp = a + b;
int h = sqrt(temp * 2);
while (h * (h + 1) > 2 * temp) {
h--;
}
dp[0] = 1;
for (int i = 1; i <= h; i++) {
for (int j = a; j >= 0; j--) {
dp[i + j] = (dp[i + j] + dp[j]) % mod;
}
}
int sum = h * (h + 1) / 2 - b;
if (sum < 0) sum = 0;
long long ans = 0;
for (int i = sum; i <= a; i++) {
ans = (ans + dp[i]) % mod;
}
printf("%I64d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int K;
int h[105][105];
int main() {
cin >> K;
for (long long int i = 1; i <= 100; i++)
for (long long int j = 1; j <= i - 1; j++) {
int t = 0;
for (long long int k = 1; k <= 100; k++)
if (h[i][k] and h[k][j]) t++;
if (t > K) continue;
K -= t;
h[i][j] = 1;
h[j][i] = 1;
}
assert(!K);
cout << 100 << endl;
for (long long int i = 1; i <= 100; i++) {
for (long long int j = 1; j <= 100; j++) cout << h[i][j];
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int a[N];
int last[N];
vector<int> ans[N];
int n;
int main() {
scanf("%d", &n);
for (int i = 0; i < N; i++) last[i] = -1;
for (int i = 0; i < n; i++) scanf("%d", a + i);
last[0] = a[0];
ans[0].push_back(a[0]);
int used = 0;
for (int i = 1; i < n; i++) {
if (last[used] > a[i]) {
used++;
last[used] = a[i];
ans[used].push_back(a[i]);
} else {
int lo = 0, hi = used, res = -1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (last[mid] < a[i]) {
res = mid;
hi = mid - 1;
} else {
lo = mid + 1;
}
}
last[res] = a[i];
ans[res].push_back(a[i]);
}
}
for (int i = 0; i <= used; i++) {
for (int x : ans[i]) printf("%d ", x);
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int t;
scanf("%d", &t);
int i;
for (i = 0; i < t; i++) {
int n, m, steps = 0;
scanf("%d%d", &n, &m);
int j;
char arr[n][m + 2];
for (j = 0; j < n; j++) {
scanf("%s", arr[j]);
}
for (j = 0; j < m - 1; j++) {
if (arr[n - 1][j] == 'D') steps += 1;
}
for (j = 0; j < n - 1; j++) {
if (arr[j][m - 1] == 'R') steps += 1;
}
printf("%d\n", steps);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x1, y1, z1, x2, y2, z2;
cin >> x1 >> y1 >> z1 >> x2 >> y2 >> z2;
cout << ((x1 != x2 && y1 != y2 && z1 != z2) ? "NO" : "YES") << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 10;
const int mod = 1e9 + 7;
int prime[N], pp, pri[N], ans = 1, p[N], n, cnt[N], mx[N];
bool iscomp[N];
void primetable() {
for (int i = 2; i < N; i++) {
if (!iscomp[i]) prime[pp++] = i, pri[i] = i;
for (int j = 0; j < pp && 1ll * i * prime[j] < N; j++) {
iscomp[i * prime[j]] = 1;
pri[i * prime[j]] = prime[j];
if (i % prime[j] == 0) break;
}
}
}
int main() {
primetable();
scanf("%d\n", &n);
for (int i = 1; i <= n; i++) scanf("%d", &p[i]);
sort(p + 1, p + n + 1);
for (int i = n; i; i--) {
if (!cnt[p[i]])
cnt[p[i]]++, mx[p[i]] = 1, ans = (1ll * ans * p[i]) % mod;
else {
int v = --p[i];
while (v != 1) {
int u = pri[v], ci = 0;
while (v % u == 0) v /= u, ci++;
if (cnt[u] < ci) {
for (int j = cnt[u] + 1; j <= ci; j++) ans = (1ll * ans * u) % mod;
cnt[u] = ci;
mx[u] = 1;
} else
mx[u] += (cnt[u] == ci);
}
}
}
for (int i = 1; i <= n; i++) {
int v = p[i], flag = 0;
while (v != 1) {
int u = pri[v], ci = 0;
while (v % u == 0) v /= u, ci++;
if (cnt[u] == ci && mx[u] == 1) flag = 1;
}
if (!flag) {
ans++;
break;
}
}
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int i = 0, j, k = 0, ans = 0, r, len, f = 0, m = 0, n, l = 0, p;
string s, t;
cin >> n;
cin >> s >> t;
vector<int> ind;
map<char, int> freq;
for (i = (0); i < (n) && !(0); i++) freq[s[i]]++;
for (i = (0); i < (n) && !(f); i++) {
freq[t[i]]--;
if (freq[t[i]] < 0) f = 1;
if (s[i] != t[i]) ind.push_back(i);
}
k = 0;
int maxi = 0, mini = 0;
for (i = (0); i < (ind.size()) && !(0); i++) {
if (s[ind[i]] == '1')
k++;
else
k--;
maxi = max(maxi, k);
mini = min(mini, k);
}
if (f)
cout << "-1";
else
cout << maxi - mini;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1, i = 1;
while (t--) {
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, n;
cin >> t;
while (t > 0) {
cin >> n;
long long a[n];
vector<long long> ind[26];
long long freq[n][26];
memset(freq, 0, n * 26 * sizeof(long long));
for (long long i = 0; i < n; i++) {
cin >> a[i];
ind[a[i] - 1].push_back(i);
for (long long j = 0; j < 26; j++) {
if (i > 0) {
freq[i][j] = freq[i - 1][j];
}
}
freq[i][a[i] - 1]++;
}
long long ans = 0;
for (long long i = 0; i < 26; i++) {
ans = max(ans, (long long)ind[i].size());
for (long long j = 0; j < ind[i].size() / 2; j++) {
long long x = 2 * (j + 1);
long long lb = ind[i][j] + 1;
long long rb = ind[i][ind[i].size() - 1 - j] - 1;
long long y = 0;
for (long long k = 0; k < 26; k++) {
y = max(y, freq[rb][k] - freq[lb - 1][k]);
}
ans = max(ans, x + y);
}
}
cout << ans << endl;
t--;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, x;
cin >> n;
int f = 0, z = 0;
while (n--) {
cin >> x;
if (x)
f++;
else
z++;
}
string ans = "";
n = (((f * 5) / 45) * 45) / 5;
while (n--) ans += '5';
if (z == 0)
ans = "-1";
else
while (z--) ans += '0';
if (ans[0] == '0') ans = "0";
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int dr[] = {0, -1, 0, 1, -1, 1, 1, -1};
const int dc[] = {1, 0, -1, 0, 1, 1, -1, -1};
const double eps = 1e-9;
template <class T>
void print(const vector<T> &v) {
ostringstream os;
for (int i = 0; i < (int)v.size(); ++i) {
if (i) os << ' ';
os << v[i];
}
cout << os.str() << endl;
}
template <class T>
int sz(const T &c) {
return (int)c.size();
}
template <class T>
void srt(T &c) {
sort(c.begin(), c.end());
}
template <class T>
void checkmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
void checkmax(T &a, T b) {
if (b > a) a = b;
}
template <class T>
T sqr(T x) {
return x * x;
}
template <class T, class U>
T cast(U x) {
ostringstream os;
os << x;
T res;
istringstream is(os.str());
is >> res;
return res;
}
template <class T>
vector<T> split(string s, string x = " ") {
vector<T> res;
for (int i = 0; i < s.size(); i++) {
string a;
while (i < (int)s.size() && x.find(s[i]) == string::npos) a += s[i++];
if (!a.empty()) res.push_back(cast<T>(a));
}
return res;
}
template <class T>
bool inside(T r, T c, T R, T C) {
return r >= 0 && r < R && c >= 0 && c < C;
}
int minPos[128][64][2];
int maxPos[128][64][2];
int main(int argc, char *argv[]) {
string s;
cin >> s;
int n;
cin >> n;
fill(&minPos[0][0][0], &minPos[128][0][0], 1000);
fill(&maxPos[0][0][0], &maxPos[128][0][0], -1000);
minPos[0][0][0] = 0;
minPos[0][0][1] = 0;
maxPos[0][0][0] = 0;
maxPos[0][0][1] = 0;
int res = 0;
for (int len(1), _b(sz(s)); len <= _b; ++len) {
for (int used(0), _b(n); used <= _b; ++used) {
for (int d(0), _n(2); d < _n; ++d) {
if (s[len - 1] == 'T') {
checkmin(minPos[len][used][d], minPos[len - 1][used][1 - d]);
checkmax(maxPos[len][used][d], maxPos[len - 1][used][1 - d]);
checkmin(minPos[len][used + 1][d],
minPos[len - 1][used][d] + (2 * d - 1));
checkmax(maxPos[len][used + 1][d],
maxPos[len - 1][used][d] + (2 * d - 1));
} else {
checkmin(minPos[len][used][d],
minPos[len - 1][used][d] + (2 * d - 1));
checkmax(maxPos[len][used][d],
maxPos[len - 1][used][d] + (2 * d - 1));
checkmin(minPos[len][used + 1][d], minPos[len - 1][used][1 - d]);
checkmax(maxPos[len][used + 1][d], maxPos[len - 1][used][1 - d]);
}
if (len == sz(s) && (used - n) % 2 == 0) {
checkmax(res, -minPos[len][used][d]);
checkmax(res, maxPos[len][used][d]);
}
}
}
}
cout << res << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct c {
long long x, y, a, b;
};
long long sqr(long long x) { return x * x; }
bool check_square(vector<c> v) {
map<long long, long long> s;
for (long long i = 0; i < 4; i++) {
for (long long j = 0; j < 4; j++) {
if (i != j) {
long long d = sqr(v[i].x - v[j].x) + sqr(v[i].y - v[j].y);
s[d]++;
}
}
}
if (s.size() != 2)
return false;
else {
auto itr = s.begin();
itr++;
if (s.begin()->second == 8 && itr->second == 4) return true;
return false;
}
}
c rotate(c c1) {
c c2 = c1;
c2.x = -(c1.y - c1.a - c1.b);
c2.y = (c1.x - c1.a + c1.b);
return c2;
}
set<long long> check(vector<c> v) {
c arr[4][4];
for (long long i = 0; i < 4; i++) {
arr[i][0] = v[i];
for (long long j = 1; j < 4; j++) arr[i][j] = rotate(arr[i][j - 1]);
}
set<long long> ans;
for (long long i = 0; i < 4; i++) {
for (long long j = 0; j < 4; j++) {
for (long long k = 0; k < 4; k++) {
for (long long l = 0; l < 4; l++) {
vector<c> temp;
temp.push_back(arr[0][i]);
temp.push_back(arr[1][j]);
temp.push_back(arr[2][k]);
temp.push_back(arr[3][l]);
if (check_square(temp)) {
ans.insert(i + j + k + l);
}
}
}
}
}
return ans;
}
int32_t main() {
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
vector<c> v;
for (long long j = 0; j < 4; j++) {
c t;
cin >> t.x >> t.y >> t.a >> t.b;
v.push_back(t);
}
set<long long> ans = check(v);
if (ans.size() == 0)
cout << -1;
else
cout << *ans.begin();
cout << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector,fast-math,inline")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
using namespace std;
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << '{';
string sep;
for (const auto &x : v) os << sep << x, sep = ", ";
return os << '}';
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
template <const int &MOD>
struct _m_int {
int val;
_m_int(int64_t v = 0) {
if (v < 0) v = v % MOD + MOD;
if (v >= MOD) v %= MOD;
val = v;
}
static int inv_mod(int a, int m = MOD) {
int g = m, r = a, x = 0, y = 1;
while (r != 0) {
int q = g / r;
g %= r;
swap(g, r);
x -= q * y;
swap(x, y);
}
return x < 0 ? x + m : x;
}
explicit operator int() const { return val; }
explicit operator int64_t() const { return val; }
_m_int &operator+=(const _m_int &other) {
val -= MOD - other.val;
if (val < 0) val += MOD;
return *this;
}
_m_int &operator-=(const _m_int &other) {
val -= other.val;
if (val < 0) val += MOD;
return *this;
}
static unsigned fast_mod(uint64_t x, unsigned m = MOD) {
return x % m;
unsigned x_high = x >> 32, x_low = (unsigned)x;
unsigned quot, rem;
asm("divl %4\n" : "=a"(quot), "=d"(rem) : "d"(x_high), "a"(x_low), "r"(m));
return rem;
}
_m_int &operator*=(const _m_int &other) {
val = fast_mod((uint64_t)val * other.val);
return *this;
}
_m_int &operator/=(const _m_int &other) { return *this *= other.inv(); }
friend _m_int operator+(const _m_int &a, const _m_int &b) {
return _m_int(a) += b;
}
friend _m_int operator-(const _m_int &a, const _m_int &b) {
return _m_int(a) -= b;
}
friend _m_int operator*(const _m_int &a, const _m_int &b) {
return _m_int(a) *= b;
}
friend _m_int operator/(const _m_int &a, const _m_int &b) {
return _m_int(a) /= b;
}
_m_int &operator++() {
val = val == MOD - 1 ? 0 : val + 1;
return *this;
}
_m_int &operator--() {
val = val == 0 ? MOD - 1 : val - 1;
return *this;
}
_m_int operator++(int) {
_m_int before = *this;
++*this;
return before;
}
_m_int operator--(int) {
_m_int before = *this;
--*this;
return before;
}
_m_int operator-() const { return val == 0 ? 0 : MOD - val; }
bool operator==(const _m_int &other) const { return val == other.val; }
bool operator!=(const _m_int &other) const { return val != other.val; }
_m_int inv() const { return inv_mod(val); }
_m_int pow(int64_t p) const {
if (p < 0) return inv().pow(-p);
_m_int a = *this, result = 1;
while (p > 0) {
if (p & 1) result *= a;
a *= a;
p >>= 1;
}
return result;
}
friend ostream &operator<<(ostream &os, const _m_int &m) {
return os << m.val;
}
};
extern const int MOD = 998244353;
using mod_int = _m_int<MOD>;
const int BITS = 53;
template <typename T>
struct xor_basis {
T basis[BITS];
int n = 0;
T min_value(T start) const {
if (n == BITS) return 0;
for (int i = 0; i < n; i++) start = min(start, start ^ basis[i]);
return start;
}
T max_value(T start = 0) const {
if (n == BITS) return ((T)1 << BITS) - 1;
for (int i = 0; i < n; i++) start = max(start, start ^ basis[i]);
return start;
}
bool add(T x) {
x = min_value(x);
if (x == 0) return false;
basis[n++] = x;
for (int k = n - 1; k > 0 && basis[k] > basis[k - 1]; k--)
swap(basis[k], basis[k - 1]);
return true;
}
void merge(const xor_basis<T> &other) {
for (int i = 0; i < other.n && n < BITS; i++) add(other.basis[i]);
}
void merge(const xor_basis<T> &a, const xor_basis<T> &b) {
if (a.n > b.n) {
*this = a;
merge(b);
} else {
*this = b;
merge(a);
}
}
};
int N, M, B;
vector<int64_t> basis;
vector<int64_t> answers;
void generate_all() {
vector<int64_t> change(B + 1, 0);
int64_t prefix = 0;
for (int i = 0; i < B; i++) {
prefix ^= basis[i];
change[i] = prefix;
}
change[B] = prefix;
int64_t value = 0;
for (unsigned mask = 0; mask < 1U << B; mask++) {
answers[__builtin_popcountll(value)]++;
value ^= change[__builtin_ctz(mask + 1)];
}
}
void dp_on_repeats() {
;
for (int i = 0; i < B; i++)
for (int j = i + 1; j < B; j++)
basis[i] = min(basis[i], basis[i] ^ basis[j]);
;
vector<int> repeats;
for (int bit = 0; bit < M; bit++) {
int count = 0;
for (int i = 0; i < B; i++)
if (basis[i] >> bit & 1) count++;
if (count > 1) repeats.push_back(bit);
}
int R = repeats.size();
vector<pair<int, int>> options(B);
int count_sum = 0;
for (int i = 0; i < B; i++) {
int64_t value = basis[i];
int count = __builtin_popcountll(value);
int repeat_mask = 0;
for (int r = 0; r < R; r++)
if (value >> repeats[r] & 1) {
count--;
repeat_mask |= 1 << r;
}
options[i] = {count, repeat_mask};
count_sum += count;
};
sort(options.begin(), options.end());
if (R <= 20) {
vector<vector<int64_t>> dp(count_sum + 1, vector<int64_t>(1 << R, 0));
dp[0][0] = 1;
int max_count = 0;
for (pair<int, int> &option : options) {
int opt_count = option.first;
int opt_mask = option.second;
for (int count = max_count; count >= 0; count--)
for (int mask = 0; mask < 1 << R; mask++)
dp[count + opt_count][mask ^ opt_mask] += dp[count][mask];
max_count += opt_count;
}
for (int count = 0; count <= count_sum; count++)
for (int mask = 0; mask < 1 << R; mask++)
if (dp[count][mask] > 0)
answers[count + __builtin_popcount(mask)] += dp[count][mask];
} else {
vector<vector<unsigned>> dp(count_sum - 1, vector<unsigned>(1 << R, 0));
int max_count = 0;
for (pair<int, int> &option : options) {
int opt_count = option.first;
int opt_mask = option.second;
for (int count = min(max_count - 1, count_sum - 1 - opt_count - 1);
count >= 0; count--)
for (int mask = 0; mask < 1 << R; mask++)
dp[count + opt_count][mask ^ opt_mask] += dp[count][mask];
dp[opt_count - 1][opt_mask]++;
max_count += opt_count;
}
for (int count = 0; count < count_sum - 1; count++)
for (int mask = 0; mask < 1 << R; mask++)
if (dp[count][mask] > 0)
answers[count + 1 + __builtin_popcount(mask)] += dp[count][mask];
int everything = 0;
for (int i = 0; i < B; i++) everything ^= options[i].second;
answers[count_sum + __builtin_popcount(everything)]++;
answers[0]++;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> N >> M;
xor_basis<int64_t> basis_obj;
for (int i = 0; i < N; i++) {
int64_t a;
cin >> a;
basis_obj.add(a);
}
B = basis_obj.n;
basis.resize(B);
for (int i = 0; i < B; i++) basis[i] = basis_obj.basis[i];
answers.assign(M + 1, 0);
if (B <= 0.57 * M)
generate_all();
else
dp_on_repeats();
for (int i = 0; i <= M; i++) {
mod_int answer = answers[i];
answer *= mod_int(2).pow(N - B);
cout << answer << (i < M ? ' ' : '\n');
}
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 20;
const int base = 1e9 + 7;
int f[500][maxn];
int pw25[maxn], sz, a[maxn];
int fct[maxn], t, type, invfct[maxn];
string s;
int C(int n, int k) {
int zn = fct[n];
zn = (1ll * zn * invfct[k]) % base;
zn = (1ll * zn * invfct[n - k]) % base;
return zn;
}
void answer(int m, int n) {
if (m > n) {
cout << "0\n";
return;
}
for (int i = 1; i <= sz; i++)
if (a[i] == m) {
cout << f[i][n - m] << "\n";
break;
}
}
int my_pw(int x, int y) {
if (y == 0)
return 1;
else if (y % 2 == 0) {
int g = my_pw(x, y / 2);
return (1ll * g * g) % base;
} else {
int g = my_pw(x, y - 1);
return (1ll * g * x) % base;
}
}
void set_new_len(int m) {
for (int i = 1; i <= sz; i++)
if (a[i] == m) return;
sz++;
a[sz] = m;
f[sz][0] = 1;
for (int k = 1; k <= 100000 - m; k++) {
f[sz][k] = (26ll * f[sz][k - 1]) % base;
int zn = C(m + k - 1, m - 1);
zn = (1ll * zn * pw25[k]) % base;
f[sz][k] = (f[sz][k] + zn) % base;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> t;
cin >> s;
fct[0] = 1;
pw25[0] = 1;
invfct[0] = 1;
for (int i = 1; i <= 100000; i++) {
fct[i] = (1ll * fct[i - 1] * i) % base;
pw25[i] = (25ll * pw25[i - 1]) % base;
invfct[i] = my_pw(fct[i], base - 2);
}
int m = s.size();
set_new_len(m);
for (int i = 1; i <= t; i++) {
int n, type;
cin >> type;
if (type == 2) {
cin >> n;
answer(m, n);
} else {
cin >> s;
m = s.size();
set_new_len(m);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t;
string s;
cin >> n >> t >> s;
while (t--) {
for (int i = 1; i < n; ++i) {
if (s[i] == 'G' && s[i - 1] == 'B') {
s[i] = 'B';
s[i - 1] = 'G';
++i;
}
}
}
cout << s << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, k;
cin >> A >> B >> k;
int y = 2;
while (y * y <= k) {
if (k % y == 0) {
cout << 0 << endl;
return 0;
}
y++;
}
int n = B / k;
vector<bool> a(n + 1);
for (int _n(min(k, n + 1)), i(2); i < _n; i++)
if (!a[i])
for (int x = i; x <= n; x += i) a[x] = true;
int n0 = A / k;
if (A % k) n0++;
int res = 0;
for (int _n(n + 1), i(n0); i < _n; i++)
if (!a[i]) res++;
cout << res << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t;
cin >> t;
while (t--) {
long long x, y, n;
cin >> x >> y >> n;
long long rem = n % x;
long long ans = n - rem;
if (ans + y <= n) {
cout << ans + y << "\n";
} else {
ans -= (x - y);
cout << ans << "\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int IN() {
int c, f, x;
while (!isdigit(c = getchar()) && c != '-')
;
c == '-' ? (f = 1, x = 0) : (f = 0, x = c - '0');
while (isdigit(c = getchar())) x = (x << 1) + (x << 3) + c - '0';
return !f ? x : -x;
}
vector<int> V, T;
int n;
vector<int> gao(int w, vector<int> V) {
V.resize(unique(V.begin(), V.end()) - V.begin());
vector<int> V2;
for (int x : V)
if (x) V2.push_back(x);
V = V2;
if (V.size() == 0) return {};
if (V.size() == 1 && abs(V[0]) == 1) {
return {V[0] * (1 << w)};
}
bool b = 0;
for (int x : V)
if (x & 1) b = 1;
if (!b) {
for (int i = 0; i < V.size(); i++) V[i] /= 2;
return gao(w + 1, V);
} else {
vector<int> A, B, C, D;
for (int x : V) {
if (x & 1) {
C.push_back((x + 1) / 2);
D.push_back((x - 1) / 2);
} else {
C.push_back(x / 2);
D.push_back(x / 2);
}
}
A = gao(w + 1, C);
B = gao(w + 1, D);
if (A.size() < B.size()) {
A.push_back(-(1 << w));
return A;
} else {
B.push_back(1 << w);
return B;
}
}
}
int main() {
n = IN();
for (int i = 0; i < n; i++) V.push_back(IN());
sort(V.begin(), V.end(), greater<int>());
T = gao(0, V);
printf("%d\n", T.size());
for (int w : T) printf("%d ", w);
puts("");
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5, maxb = 30;
int N, M, x, y, w, basis[maxb], vis[maxn], d[maxn];
vector<array<int, 2> > ady[maxn];
queue<int> q;
int main() {
ios_base::sync_with_stdio(0);
cin >> N >> M;
for (int i = (0); i < (M); i++) {
cin >> x >> y >> w;
ady[x].push_back({y, w});
ady[y].push_back({x, w});
}
q.push(1);
vis[1] = 1;
d[1] = 0;
while (!q.empty()) {
x = q.front();
q.pop();
for (auto [y, w] : ady[x])
if (vis[y]) {
int k = d[x] ^ d[y] ^ w;
for (int i = (maxb)-1; i >= (0); i--)
if (k & 1 << i) {
if (!basis[i]) basis[i] = k;
k ^= basis[i];
}
} else
q.push(y), vis[y] = 1, d[y] = d[x] ^ w;
}
int ans = d[N];
for (int i = (maxb)-1; i >= (0); i--)
if (ans & 1 << i) ans ^= basis[i];
cout << ans << "\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int c1, c2, c3, c4;
int main() {
cin >> c1 >> c2 >> c3 >> c4;
if (c1 == c4 && c1)
cout << 1 << endl;
else if (c1 == c4 && c1 == 0 && c3 == 0)
cout << 1 << endl;
else
cout << 0 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int setBit(int N, int pos) { return N = N | (1 << pos); }
inline int resetBit(int N, int pos) { return N = N & ~(1 << pos); }
inline bool checkBit(int N, int pos) { return (bool)(N & (1 << pos)); }
char s[5010];
int len;
vector<int> stck;
int solve(int st) {
stck.clear();
int have = 0;
int ret = 0;
for (int i = st; i < len; i++) {
if (s[i] == '(')
stck.push_back(1);
else if (s[i] == '?') {
if (stck.empty())
stck.push_back(1);
else
stck.pop_back(), have++;
} else {
if (stck.empty()) {
if (have) {
have--;
stck.push_back(1);
} else
return ret;
} else
stck.pop_back();
}
if (stck.empty()) ret++;
}
return ret;
}
int main() {
scanf("%s", s);
len = strlen(s);
int ans = 0;
for (int i = 0; i < len; i++) ans += solve(i);
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sum = 0, count = 0;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
if (a[i] != -1) sum = sum + a[i];
if (a[i] == -1) {
if (sum != 0)
sum--;
else
count++;
}
}
cout << count << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int ms = 1e5 + 5, me = 2e5 + 5, mlg = 21;
int adj[ms], to[me], ant[me], z;
int num[ms], low[ms], timer;
int art[ms], bridge[me], rch;
int bc[ms], nbc;
stack<int> st;
bool f[me];
int n, m, k;
vector<int> g[ms];
int par[ms][mlg + 1], lvl[ms];
void clear() {
memset(adj, -1, sizeof adj);
z = 0;
}
void add(int u, int v) {
to[z] = v;
ant[z] = adj[u];
adj[u] = z++;
}
void generateBc(int v) {
while (!st.empty()) {
int u = st.top();
st.pop();
bc[u] = nbc;
if (v == u) break;
}
++nbc;
}
void dfs(int v, int p) {
st.push(v);
low[v] = num[v] = ++timer;
for (int i = adj[v]; i != -1; i = ant[i]) {
if (f[i] || f[i ^ 1]) continue;
f[i] = 1;
int u = to[i];
if (num[u] == -1) {
dfs(u, v);
if (low[u] > num[v]) bridge[i] = bridge[i ^ 1] = 1;
art[v] |= p != -1 && low[u] >= num[v];
if (p == -1 && rch > 1)
art[v] = 1;
else
rch++;
low[v] = min(low[v], low[u]);
} else {
low[v] = min(low[v], num[u]);
}
}
if (low[v] == num[v]) generateBc(v);
}
void biCon(int n) {
memset(num, -1, sizeof num);
for (int i = 0; i < n; i++) {
if (num[i] == -1) dfs(i, 0);
}
}
void dfs2(int v, int p, int l = 0) {
lvl[v] = l;
par[v][0] = p;
for (int k = 1; k <= mlg; ++k) {
par[v][k] = par[par[v][k - 1]][k - 1];
}
for (int u : g[v]) {
if (u != p) {
dfs2(u, v, l + 1);
}
}
}
int lca(int a, int b) {
if (lvl[b] > lvl[a]) swap(a, b);
for (int i = mlg; i >= 0; --i) {
if (lvl[a] - (1 << i) >= lvl[b]) a = par[a][i];
}
if (a == b) return a;
for (int i = mlg; i >= 0; --i) {
if (par[a][i] != par[b][i]) a = par[a][i], b = par[b][i];
}
return par[a][0];
}
int dist(int a, int b) { return lvl[a] + lvl[b] - (2 * lvl[lca(a, b)]); }
int main() {
clear();
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int v, u;
scanf("%d%d", &v, &u);
v--;
u--;
add(v, u);
add(u, v);
}
biCon(n);
cin >> k;
for (int v = 0; v < n; ++v) {
for (int i = adj[v]; i != -1; i = ant[i]) {
if ((i & 1) == 0 && bridge[i]) {
g[bc[v]].push_back(bc[to[i]]);
g[bc[to[i]]].push_back(bc[v]);
}
}
}
dfs2(0, 0);
while (k--) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
printf("%d\n", dist(bc[x], bc[y]));
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, ans = 1;
int main() {
scanf("%lld%lld%lld", &n, &m, &k);
if (k > n + m - 2) {
puts("-1");
return 0;
}
for (int i = 1, t = 0; i <= n; i = t + 1) {
t = n / (n / i);
if (t > k + 1) {
ans = max(ans, n / (k + 1) * m);
break;
}
ans = max(ans, (n / t) * (m / (k - t + 2)));
}
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
const int gmod = 2;
const int inf = 1039074182;
const long long llinf = 1LL * inf * inf;
template <typename T1, typename T2>
inline void chmin(T1 &x, T2 b) {
if (b < x) x = b;
}
template <typename T1, typename T2>
inline void chmax(T1 &x, T2 b) {
if (b > x) x = b;
}
template <typename T1, typename T2>
inline void chadd(T1 &x, T2 b) {
x += b;
if (x >= mod) x -= mod;
}
template <typename T1, typename T2>
inline void chmul(T1 &x, T2 b) {
x = 1LL * x * b % mod;
}
template <typename T1, typename T2>
inline void chmod(T1 &x, T2 b) {
x %= b, x += b;
if (x >= b) x -= b;
}
using namespace std;
template <typename T>
ostream &operator<<(ostream &cout, vector<T> vec) {
cout << "{";
for (int i = 0; i < vec.size(); i++) {
cout << vec[i];
if (i != (int)vec.size() - 1) cout << ',';
}
cout << "}";
return cout;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &cout, pair<T1, T2> p) {
cout << "(" << p.first << ',' << p.second << ")";
return cout;
}
template <typename T>
ostream &operator<<(ostream &cout, set<T> s) {
vector<T> t;
for (auto x : s) t.push_back(x);
cout << t;
return cout;
}
template <typename T>
ostream &operator<<(ostream &cout, multiset<T> s) {
vector<T> t;
for (auto x : s) t.push_back(x);
cout << t;
return cout;
}
template <typename T>
ostream &operator<<(ostream &cout, queue<T> q) {
vector<T> t;
while (q.size()) {
t.push_back(q.front());
q.pop();
}
cout << t;
return cout;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &cout, map<T1, T2> m) {
for (auto &x : m) {
cout << "Key: " << x.first << ' ' << "Value: " << x.second << endl;
}
return cout;
}
template <typename T>
T operator*(vector<T> v1, vector<T> v2) {
assert(v1.size() == v2.size());
int n = v1.size();
T res = 0;
for (int i = 0; i < n; i++) {
res += v1[i] * v2[i];
}
return res;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(pair<T1, T2> x, pair<T1, T2> y) {
return make_pair(x.first + y.first, x.second + y.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(pair<T1, T2> x) {
return make_pair(-x.first, -x.second);
}
template <typename T>
vector<vector<T> > operator~(vector<vector<T> > vec) {
vector<vector<T> > v;
int n = vec.size(), m = vec[0].size();
v.resize(m);
for (int i = 0; i < m; i++) {
v[i].resize(n);
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
v[i][j] = vec[j][i];
}
}
return v;
}
void print0x(int x) {
std::vector<int> vec;
while (x) {
vec.push_back(x & 1);
x >>= 1;
}
std::reverse(vec.begin(), vec.end());
for (int i = 0; i < vec.size(); i++) {
std::cout << vec[i];
}
std::cout << ' ';
}
template <typename T>
void print0x(T x, int len) {
std::vector<int> vec;
while (x) {
vec.push_back(x & 1);
x >>= 1;
}
reverse(vec.begin(), vec.end());
for (int i = vec.size(); i < len; i++) {
putchar('0');
}
for (int i = 0; i < vec.size(); i++) {
std::cout << vec[i];
}
std::cout << ' ';
}
using namespace std;
inline long long exgcd(long long a, long long b, long long &x, long long &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long gcd = exgcd(b % a, a, x, y);
swap(x, y);
x -= (b / a) * y;
return gcd;
}
int n;
int a[100005];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
if (n == 1) {
cout << "1 1\n" << -a[0] << endl << "1 1\n0\n1 1\n0\n";
return 0;
}
cout << "1 1\n" << -a[0] << endl;
cout << 2 << ' ' << n << endl;
long long x, y;
for (int i = 1; i < n; i++) {
exgcd(n - 1, n, x, y);
x *= -a[i];
y *= -a[i];
cout << x * (n - 1) << ' ';
}
cout << endl;
cout << 1 << ' ' << n << endl;
for (int i = 0; i < n; i++) {
if (i == 0) {
cout << 0 << ' ';
continue;
}
exgcd(n - 1, n, x, y);
x *= -a[i];
y *= -a[i];
cout << y * (n) << ' ';
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
long long n, k, a[N];
map<long long, long long> cnt;
long long w[N], ans;
long long qpow(long long a, long long b) {
long long r = 1;
while (b) {
if (b & 1) r = r * a;
b >>= 1;
a = a * a;
}
return r;
}
int32_t main() {
cin >> n >> k;
for (long long i = 1; i <= n; ++i) cin >> a[i];
long long LIM = 0;
if (k > 40)
LIM = 1;
else {
while (qpow(LIM, k) <= 1e10) ++LIM;
}
if (k > 2) {
for (long long i = 1; i <= LIM; ++i) w[i] = qpow(i, k);
for (long long i = 1; i <= n; ++i) {
for (long long j = 1; j <= LIM; ++j)
if (w[j] % a[i] == 0) ans += cnt[w[j] / a[i]];
cnt[a[i]]++;
}
} else {
for (long long i = 1; i <= n; ++i) {
long long x = a[i], w = 1;
for (long long j = 2; j * j <= x; ++j)
if (x % j == 0) {
long long c = 0;
while (x % j == 0) x /= j, c++;
if (c & 1) w *= j;
}
if (x > 1) w *= x;
ans += cnt[w];
cnt[w]++;
}
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long getSum(long long BITree[], long long index) {
long long sum = 0;
while (index > 0) {
sum += BITree[index];
index -= index & (-index);
}
return sum;
}
void updateBIT(long long BITree[], long long n, long long index,
long long val) {
while (index <= n) {
BITree[index] += val;
index += index & (-index);
}
}
long long getInvCount(vector<long long>& arr) {
long long n = arr.size();
long long invcount = 0;
long long maxElement = 0;
for (long long i = 0; i < n; i++)
if (maxElement < arr[i]) maxElement = arr[i];
long long BIT[maxElement + 1];
for (long long i = 1; i <= maxElement; i++) BIT[i] = 0;
for (long long i = n - 1; i >= 0; i--) {
invcount += getSum(BIT, arr[i] - 1);
updateBIT(BIT, maxElement, arr[i], 1);
}
return invcount;
}
const long long mod = 998244353;
inline long long md(long long x) { return x < mod ? x : x % mod; }
long long power(long long x, long long y) {
if (y == 0) {
return 1;
}
long long x_ = power(x, y / 2);
if (y & 1) {
return md(md(x_ * x_) * md(x));
} else {
return md(x_ * x_);
}
}
long long mod_inverse(long long x) { return power(x, mod - 2); }
template <long long MOD = 998244353>
struct mint {
long long x;
long long mod = MOD;
mint(long long x = 0) : x(x % MOD) {}
mint& operator+=(const mint a) {
if ((x += a.x) >= MOD) x -= MOD;
return *this;
}
mint& operator-=(const mint a) {
if ((x += MOD - a.x) >= MOD) x -= MOD;
return *this;
}
mint& operator*=(const mint a) {
(x *= a.x) %= MOD;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint power(long long t) const {
if (!t) return 1;
mint a = power(t >> 1);
a *= a;
if (t & 1) a *= *this;
return a;
}
mint inv() const { return power(MOD - 2); }
mint& operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
template <long long mod>
ostream& operator<<(ostream& output, const mint<mod>& a) {
output << a.x;
return output;
}
template <long long mod>
istream& operator>>(istream& input, mint<mod>& a) {
input >> a.x;
return input;
}
using mll = mint<>;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
vector<long long> arr(n);
set<long long> chosen;
for (long long i = 0; i < (n); i++) {
cin >> arr[i];
}
vector<long long> aux;
for (long long i = 0; i < (n); i++) {
if (arr[i] != -1) {
aux.push_back(arr[i]);
chosen.insert(arr[i]);
}
}
vector<long long> comp;
for (long long i = 0; i < (n); i++) {
if (!chosen.count(i + 1)) {
comp.push_back(i + 1);
}
}
long long m = comp.size();
long long x = getInvCount(aux);
vector<long long> pre(n), suff(n);
for (long long i = 0; i < (n); i++) {
if (arr[i] == -1) {
pre[i] = 1;
suff[i] = 1;
}
}
for (long long i = 1; i < n; i++) {
pre[i] += pre[i - 1];
}
for (long long i = n - 2; i >= 0; i--) {
suff[i] += suff[i + 1];
}
mll ans = 0;
ans += x;
long long last = pre.back();
mll temp = last * (last - 1);
temp /= 4;
ans += temp;
for (long long i = 0; i < n; i++) {
if (arr[i] == -1) continue;
long long num_greater =
m - (lower_bound(comp.begin(), comp.end(), arr[i]) - comp.begin());
long long num_smaller =
lower_bound(comp.begin(), comp.end(), arr[i]) - comp.begin();
long long pos_smaller = pre[i];
long long pos_greater = suff[i];
mll temp = pos_greater;
temp /= m;
temp *= num_smaller;
ans += temp;
temp = pos_smaller;
temp /= m;
temp *= num_greater;
ans += temp;
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void ask(int l, int r) { cout << '?' << ' ' << l << ' ' << r << endl; }
int n, ans[101];
void guess() {
cout << "! ";
for (int i = 1; i <= n; i++) cout << char(ans[i]);
cout << endl;
}
int cnt[2][105];
int sum[2][105];
vector<pair<int, int> > e[105];
void dfs(int x, int p) {
for (auto it : e[x]) {
if (it.first == p) continue;
ans[it.first] = it.second - ans[x];
dfs(it.first, x);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
if (n == 1) {
ask(1, 1);
string s;
cin >> s;
cout << "! " << s << endl;
} else {
ask(1, n);
for (int i = 0; i < n * (n + 1) / 2; i++) {
string s;
cin >> s;
for (char it : s) {
cnt[0][s.size()] += (int)(it);
}
}
int len = n;
int root;
for (int i = 1; i <= (n + 1) / 2; i++) {
if (i == n - i + 1) {
root = i;
ans[i] = cnt[0][len] - cnt[0][len + 1];
} else {
int w =
(cnt[0][len] - cnt[0][len + 1]) - (cnt[0][len - 1] - cnt[0][len]);
e[i].emplace_back(n - i + 1, w);
e[n - i + 1].emplace_back(i, w);
}
len--;
}
ask(2, n);
for (int i = 0; i < n * (n - 1) / 2; i++) {
string s;
cin >> s;
for (char it : s) {
cnt[1][s.size()] += (int)(it);
}
}
len = n - 1;
for (int i = 2; i <= n / 2 + 1; i++) {
if (i == n - i + 2) {
root = i;
ans[i] = cnt[1][len] - cnt[1][len + 1];
} else {
int w =
(cnt[1][len] - cnt[1][len + 1]) - (cnt[1][len - 1] - cnt[1][len]);
e[i].emplace_back(n - i + 2, w);
e[n - i + 2].emplace_back(i, w);
}
len--;
}
dfs(root, 0);
guess();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 10000;
int a[nmax], b[nmax];
int main() {
int n, i, j, a, b;
cin >> n;
if (n == 3) cout << 1 << endl;
if (n == 1) cout << 2 << endl;
if (n == 2) cout << 3 << endl;
if (n == 4) cout << 2 << endl;
if (n == 5) cout << 1 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, l = 0, z, k = 0;
cin >> n >> m;
long long a[n];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
while (a[i] > 0) {
z = a[i] % 10;
a[i] = a[i] / 10;
if (z == 4 || z == 7) k++;
}
if (k <= m) l++;
k = 0;
}
cout << l << " ";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
signed main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
int l = 0, ans = 0;
for (int r = 0; r < n; r++) {
while (a[r] - a[l] > 5) {
l++;
}
ans = max(ans, r - l + 1);
}
cout << ans << "\n";
return false;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T, class U>
inline void print(T first, U second) {
printsp(first);
println(second);
}
template <class T, class U, class V>
inline void print(T first, U second, V z) {
printsp(first);
printsp(second);
println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
const int N = 1000100;
int B[10][N];
void update(int r, int u) {
for (; u < N; u += u & -u) B[r][u]++;
}
int calc(int r, int u) {
int ans = 0;
for (; u > 0; u -= u & -u) ans += B[r][u];
return ans;
}
int gra[N], lft[N], rgt[N];
void pre() {
for (int i = 1; i * i < N; i++) rgt[i * i] = i;
for (int i = 1; i * i * i * i < N; i++) lft[i * i * i * i] = i;
int pre = 1;
for (int i = 2; i < N; i++) {
if (rgt[i])
pre = rgt[i];
else
rgt[i] = pre;
}
pre = 1;
for (int i = 2; i < N; i++) {
if (lft[i])
pre = lft[i];
else
lft[i] = pre + 1;
}
update(0, 1);
update(0, 2);
update(0, 3);
for (int i = 4; i < N; i++) {
int R = rgt[i], L = lft[i];
for (int j = 0;; j++)
if (calc(j, R) == calc(j, L - 1)) {
gra[i] = j;
break;
}
update(gra[i], i);
}
}
int grandy(long long n) {
if (n < N) return gra[(int)n];
int L = (int)sqrtl(sqrtl(n)), R = (int)sqrtl(n);
while ((long long)L * L * L * L < n) L++;
while ((long long)R * R <= n) R++;
R--;
for (int i = 0;; i++)
if (calc(i, R) == calc(i, L - 1)) return i;
}
int main() {
pre();
int n;
gn(n);
int ans = 0;
for (int i = 0; i < n; i++) {
long long m;
gn(m);
ans ^= grandy(m);
}
if (ans)
puts("Furlo");
else
puts("Rublo");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int K, N, B, T, a[100005], p[100005], *f[100005], *q[100005];
int calc() {
memset(p, 0, sizeof(p));
for (int i = 1; i <= B; i++) f[1][i] = 1e9;
for (int i = 1; i <= N; i++) scanf("%d", &a[i]);
for (int i = 1; i <= N; i++)
if (!p[a[i]]) p[a[i]] = N + i, f[1][a[i]] = i;
for (int i = N; i >= 0; i--) {
for (int j = 1; j <= B; j++) q[i][j] = p[j];
p[a[i]] = i;
}
for (int i = 2; i <= N; i++)
for (int j = 1, m = 1e9, mm; j <= B; j++)
mm = (m - 1) % N + 1, f[i][j] = q[mm][j] ? m + q[mm][j] - mm : 1e9,
m = min(m, f[i - 1][j]);
for (int i = N; i; i--)
for (int j = 1; j <= B; j++)
if (f[i][j] <= N * T) return i;
}
void doit() {
scanf("%d%d%d%d", &K, &N, &B, &T), T = min(T, B);
for (int i = 0; i <= N; i++) f[i] = new int[B + 5], q[i] = new int[B + 5];
for (int i = 1; i <= K; i++) printf("%d\n", calc());
}
int main() {
doit();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int getnumber(char c) {
if (c >= '0' && c <= '9') return (int)c - (int)'0';
if (c >= 'A' && c <= 'Z') return c - 'A' + 10;
}
char getchr(int i) {
if (i < 10)
return i + '0';
else
return i - 10 + 'A';
}
int getsys(string s) {
int max1 = 0;
for (int i = 0; i < s.length(); i++) {
max1 = max(max1, getnumber(s[i]) + 1);
}
if (max1 < 2) max1 = 2;
return max1;
}
int fromsto10(string s, int st) {
int mult = 1;
int res = 0;
for (int i = s.length() - 1; i >= 0; i--) {
res += getnumber(s[i]) * mult;
mult *= st;
}
return res;
}
string from10tos(int res, int sys) {
string result = "";
while (res > 0) {
int mod = res % sys;
result.push_back(getchr(mod));
res /= sys;
}
reverse(result.begin(), result.end());
return result;
}
int main() {
string s1, s2;
cin >> s1 >> s2;
int syst1 = getsys(s1);
int syst2 = getsys(s2);
int sysr = max(syst1, syst2);
int add1 = fromsto10(s1, sysr);
int add2 = fromsto10(s2, sysr);
int sum = add1 + add2;
string answ = from10tos(sum, sysr);
printf("%d\n", answ.length());
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.