solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
struct CHT {
vector<long long> m, b;
long long ptr = 0;
bool bad(long long l1, long long l2, long long l3) {
return 1.0 * (b[l3] - b[l1]) * (m[l1] - m[l2]) <=
1.0 * (b[l2] - b[l1]) * (m[l1] - m[l3]);
}
void add(long long _m, long long _b) {
m.push_back(_m);
b.push_back(_b);
long long s = m.size();
while (s >= 3 && bad(s - 3, s - 2, s - 1)) {
s--;
m.erase(m.end() - 2);
b.erase(b.end() - 2);
}
}
long long f(long long i, long long x) { return m[i] * x + b[i]; }
long long query(long long x) {
if (ptr >= m.size()) ptr = m.size() - 1;
while (ptr < m.size() - 1 && f(ptr + 1, x) < f(ptr, x)) ptr++;
return f(ptr, x);
}
};
const long long N = 1e5 + 7;
long long a[N], A[N];
vector<pair<long long, long long> > lines[4 * N];
vector<pair<long long, long long> > queries[4 * N];
long long ans[N];
long long ex[N];
void AddLine(long long u, long long st, long long en, long long idx,
pair<long long, long long> line) {
lines[u].push_back(line);
if (st == en) return;
long long mid = (st + en) / 2;
if (idx <= mid)
AddLine(2 * u, st, mid, idx, line);
else
AddLine(2 * u + 1, mid + 1, en, idx, line);
}
void AddQuery(long long u, long long st, long long en, long long l, long long r,
pair<long long, long long> q) {
if (r < st || en < l)
return;
else if (l <= st && en <= r) {
queries[u].push_back(q);
} else {
long long mid = (st + en) / 2;
AddQuery(2 * u, st, mid, l, r, q);
AddQuery(2 * u + 1, mid + 1, en, l, r, q);
}
}
void push(long long u, long long st, long long en) {
sort(lines[u].rbegin(), lines[u].rend());
sort(queries[u].begin(), queries[u].end());
CHT cht;
for (pair<long long, long long> pr : lines[u]) cht.add(pr.first, pr.second);
for (pair<long long, long long> pr : queries[u])
ans[pr.second] = min(ans[pr.second], (long long)cht.query(pr.first));
if (st == en) return;
long long mid = (st + en) / 2;
push(2 * u, st, mid);
push(2 * u + 1, mid + 1, en);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
A[i] = A[i - 1] + a[i];
pair<long long, long long> l = {-a[i], i * a[i] - A[i]};
AddLine(1, 1, n, i, l);
}
long long q;
cin >> q;
for (long long i = 1; i <= q; i++) {
long long x, y;
cin >> x >> y;
AddQuery(1, 1, n, y - x + 1, y, {y - x, i});
ex[i] = A[y];
}
for (long long i = 1; i <= q; i++) ans[i] = 2e18;
push(1, 1, n);
for (long long i = 1; i <= q; i++) cout << ans[i] + ex[i] << "\n";
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, m = -10000000;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
if (a < 0) {
if (a > m) m = a;
continue;
}
if (a > m && (int)sqrt(a) != (double)sqrt(a)) m = a;
}
cout << m;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
if (b % a == 0) {
int x = b / a;
int cnt = 0;
while (x % 2 == 0) x /= 2, cnt++;
while (x % 3 == 0) x /= 3, cnt++;
if (x != 1)
cout << "-1" << endl;
else
cout << cnt << endl;
} else
cout << "-1" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sq(T x) {
return x * x;
}
const long long inf = 2147383647;
const double pi = 2 * acos(0.0);
const double eps = 1e-9;
const long long maxint = 2147483647;
const long long minint = -2147483648;
long long gcd(long long a, long long b) {
while (b) {
a = a % b;
swap(a, b);
}
return a;
}
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
long long power(long long a, long long p) {
long long res = 1, x = a;
while (p) {
if (p & 1) res = res * x;
x = x * x;
p >>= 1;
}
return res;
}
long long bigmod(long long a, long long p, long long mod) {
long long res = 1, x = a;
while (p) {
if (p & 1) res = (res * x) % mod;
x = (x * x) % mod;
p >>= 1;
}
return res;
}
char text[100010], pat[1010];
int pre[1010], pre2[100010], first[100010], second[100010];
void compute() {
int plen = strlen(pat + 1), k = 0;
pre[1] = 0;
for (int i = 2; i <= plen; i++) {
while (k && pat[k + 1] != pat[i]) k = pre[k];
if (pat[k + 1] == pat[i]) k++;
pre[i] = k;
}
}
void match() {
int tlen = strlen(text + 1), plen = strlen(pat + 1);
int q = 0;
int i;
for (i = 1; i <= tlen; i++) {
while (q && pat[q + 1] != text[i]) q = pre[q];
if (pat[q + 1] == text[i]) q++;
pre2[i] = q;
if (q == plen) {
q = pre[q];
}
}
}
int n, m;
int early[1010], late[1010];
int process() {
int i;
for (i = 1; i <= m; i++) {
early[i] = inf;
late[i] = -inf;
}
for (i = 1; i <= n; i++) {
int f = first[i];
early[f] = min(early[f], i);
int s = second[i];
late[s] = max(late[s], i);
}
for (i = 1; i < m; i++) {
int a = early[i];
int b = late[m - i];
if (a < b) return 1;
}
return 0;
}
int main() {
scanf("%s", text + 1);
int q;
int res = 0;
scanf("%d", &q);
while (q--) {
scanf("%s", pat + 1);
compute();
match();
int i, len = strlen(text + 1);
for (i = 1; i <= len; i++) first[i] = pre2[i];
reverse(text + 1, text + 1 + len);
reverse(pat + 1, pat + 1 + strlen(pat + 1));
compute();
match();
for (i = 1; i <= len; i++) second[i] = pre2[len - i + 1];
n = len;
m = strlen(pat + 1);
int r = process();
res += r;
reverse(text + 1, text + 1 + len);
}
printf("%d\n", res);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
int fa[maxn][19];
int dep[maxn];
int getdis(int u, int v) {
int ret = 0;
if (dep[u] < dep[v]) swap(u, v);
for (int i = 18; i >= 0; i--)
if (dep[u] - (1 << i) >= dep[v]) {
u = fa[u][i];
ret += 1 << i;
}
if (u == v) return ret;
for (int i = 18; i >= 0; i--)
if (fa[u][i] != fa[v][i]) {
u = fa[u][i];
v = fa[v][i];
ret += 1 << i + 1;
}
return ret + 2;
}
int main() {
int n;
scanf("%d", &n);
set<int> s1{1}, s2;
dep[1] = 1;
int mx = 1;
for (int v = 2; v <= n + 1; v++) {
int u;
scanf("%d", &u);
fa[v][0] = u;
dep[v] = dep[u] + 1;
for (int i = 1; (1 << i) < dep[v]; i++) fa[v][i] = fa[fa[v][i - 1]][i - 1];
int dist1 = s1.empty() ? 0 : getdis(v, *s1.begin());
int dist2 = s2.empty() ? 0 : getdis(v, *s2.begin());
if (max(dist1, dist2) > mx) {
mx = max(dist1, dist2);
if (dist1 == mx) {
for (int u : s2) {
if (getdis(u, v) == mx) s1.insert(u);
}
s2.clear();
s2.insert(v);
} else {
for (int u : s1) {
if (getdis(u, v) == mx) s2.insert(u);
}
s1.clear();
s1.insert(v);
}
} else if (max(dist1, dist2) == mx) {
if (dist1 >= dist2)
s2.insert(v);
else
s1.insert(v);
}
printf("%d\n", s1.size() + s2.size());
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, t;
int parent[250250];
vector<int> edge[250250];
vector<int> leave;
int dept[250250];
void print_path(int u) {
vector<int> res;
while (parent[u] != u) {
res.push_back(u);
u = parent[u];
}
res.push_back(u);
cout << "PATH\n" << res.size() << endl;
for (int i = res.size() - 1; i >= 0; i--) cout << res[i] << " ";
cout << endl;
}
void print_cycle() {
cout << "CYCLES" << endl;
for (int i = 0; i < k; i++) {
int u = leave[i];
for (int j = 0; j < 3; j++) {
vector<int> res[2];
for (int jj = 0, kk = 0; jj < 3; jj++) {
if (jj != j) res[kk++].push_back(edge[u][jj]);
}
if (dept[res[0].back()] < dept[res[1].back()]) {
swap(res[0], res[1]);
}
while (dept[res[0].back()] > dept[res[1][0]]) {
res[0].push_back(parent[res[0].back()]);
}
while (res[0].back() != res[1].back()) {
res[0].push_back(parent[res[0].back()]);
res[1].push_back(parent[res[1].back()]);
}
int sum = res[0].size() + res[1].size();
if (sum % 3) {
cout << sum << endl;
cout << u;
res[0].pop_back();
for (int xx : res[0]) cout << " " << xx;
for (auto it = res[1].rbegin(); it != res[1].rend(); it++) {
cout << " " << *it;
}
cout << endl;
break;
}
}
}
}
void dfs(int u) {
if (dept[u] >= t) {
print_path(u);
exit(0);
}
bool leaf = true;
for (int x : edge[u]) {
if (dept[x]) continue;
dept[x] = dept[u] + 1;
parent[x] = u;
dfs(x);
leaf = false;
}
if (leaf) leave.push_back(u);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
edge[u].push_back(v);
edge[v].push_back(u);
}
t = n / k + (n % k > 0);
dept[1] = 1;
parent[1] = 1;
dfs(1);
print_cycle();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long c = 100002, sok = 1e15;
long long t[c], p[c], kom[c], n, k, sum, o = 0, m1 = sok, m2 = sok, ans;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> t[i];
kom[i] = kom[i - 1] + t[i];
}
for (int i = 1; i <= n; i++) {
cin >> p[i];
m2 = min(m2, p[i]);
if (i < n && m2 < m1) swap(m2, m1);
}
sum = kom[n];
if (k >= 2) {
cout << max({o, sum - m1, t[n] - p[n]}) << "\n";
return 0;
}
for (int i = 2; i <= n; i++) {
ans = max(ans, sum - kom[i - 1] - p[i]);
}
if (k == 0) {
ans = max(ans, sum - p[1]);
cout << ans << "\n";
return 0;
}
ans = max(ans, sum - m1 - m2);
for (int i = 2; i <= n; i++) {
ans = max(ans, sum - t[i] - p[1]);
}
ans = max(ans, sum - t[n] - m1);
cout << ans << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int dx[8] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy[8] = {1, -1, -1, 0, 1, -1, 0, 1};
long long bit[1000005], bit1[1000005];
long long sum(long long x) {
long long s = 0;
while (x > 0) {
s += bit[x];
x -= (x & (-x));
}
return s;
}
void update(long long x, long long val) {
while (x < 1000005) {
bit[x] += val;
x += (x & (-x));
}
}
long long cnt(long long x) {
long long s = 0;
while (x > 0) {
s += bit1[x];
x -= (x & (-x));
}
return s;
}
void updatecnt(long long x) {
while (x < 1000005) {
bit1[x] += 1;
x += (x & (-x));
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
long long pos[n + 1], vel[n + 1];
vector<long long> v;
map<long long, long long> h, h1;
for (long long i = 1; i < n + 1; i++) cin >> pos[i];
for (long long i = 1; i < n + 1; i++) {
cin >> vel[i];
if (!h[vel[i]]) v.push_back(vel[i]);
h[vel[i]] = 1;
}
v.push_back(-1000000000);
sort(v.begin(), v.end());
for (long long i = 1; i < v.size(); i++) {
if (!h1[v[i]]) h1[v[i]] = i;
}
vector<pair<long long, long long> > v1;
for (long long i = 1; i < n + 1; i++) {
vel[i] = h1[vel[i]];
v1.push_back({pos[i], vel[i]});
}
sort(v1.begin(), v1.end());
long long ans = 0;
for (long long i = 0; i < v1.size(); i++) {
long long s = sum(v1[i].second);
long long c = cnt(v1[i].second);
ans += c * v1[i].first - s;
update(v1[i].second, v1[i].first);
updatecnt(v1[i].second);
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[10101];
int ans[101][2];
int last[101];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n * k; i++) scanf("%d", &a[i]);
deque<int> DQ;
int cnt = 0;
for (int l = 1, r = 1; r <= n * k; r++) {
if (last[a[r]] == 0 || last[a[r]] < l || ans[a[r]][0] != 0)
last[a[r]] = r;
else {
ans[a[r]][0] = last[a[r]];
ans[a[r]][1] = r;
cnt++;
DQ.push_back(r);
}
while (cnt >= (n + k - 2) / (k - 1)) {
while (DQ.size() > 0 && DQ.front() <= l) {
cnt--;
DQ.pop_front();
}
l++;
}
}
for (int i = 1; i <= n; i++) printf("%d %d\n", ans[i][0], ans[i][1]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main() {
int w, h, n;
std::cin >> w >> h >> n;
std::set<long long> hor, vert;
std::multiset<long long> hDis, vDis;
hor.insert(0);
hor.insert(w);
vert.insert(0);
vert.insert(h);
hDis.insert(w);
vDis.insert(h);
while (n--) {
char ch;
int p;
std::cin >> ch >> p;
if (ch == 'V') {
int hi = *hor.lower_bound(p);
int lo = *(--hor.lower_bound(p));
hor.insert(p);
hDis.erase(hDis.lower_bound(hi - lo));
hDis.insert(hi - p);
hDis.insert(p - lo);
} else {
int hi = *vert.lower_bound(p);
int lo = *(--vert.lower_bound(p));
vert.insert(p);
vDis.erase(vDis.lower_bound(hi - lo));
vDis.insert(hi - p);
vDis.insert(p - lo);
}
std::cout << *((--hDis.end())) * (*(--vDis.end())) << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
stringstream ss;
int main() {
int n, m;
long long mod = 10000LL * 100000LL + 9, res = 1;
cin >> n >> m;
long long p = 1;
while (m--) p = (p * 2) % mod;
p--;
while (n--) res = (res * p--) % mod;
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
template <class T>
bool umin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool umax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
using namespace std;
int main(int argc, char **argv) {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed;
string a, b, tmp;
int n;
cin >> a >> b >> n;
int alphaBetS = 'z' - 'a' + 1;
vector<vector<string>> v(alphaBetS);
for (int i = 0; i < (int)(n); ++i) {
cin >> tmp;
int pos = tmp[0] - 'a';
v[pos].push_back(tmp.substr(3));
}
vector<vector<vector<bool>>> pA(
a.size(), vector<vector<bool>>(a.size() + 1, vector<bool>(alphaBetS)));
vector<vector<vector<bool>>> pB(
b.size(), vector<vector<bool>>(b.size() + 1, vector<bool>(alphaBetS)));
for (int i = 0; i < (int)(a.size()); ++i) pA[i][i + 1][a[i] - 'a'] = true;
for (int i = 0; i < (int)(b.size()); ++i) pB[i][i + 1][b[i] - 'a'] = true;
for (int len = (int)(2); len <= (int)(a.size()); ++len) {
for (int start = 0; start < (int)(a.size()); ++start) {
int end = start + len;
if (end > a.size()) break;
for (int i = 0; i < (int)(alphaBetS); ++i) {
for (int j = (int)(start + 1); j <= (int)(end - 1); ++j) {
for (int k = 0; k < (int)(v[i].size()); ++k) {
if (pA[start][j][v[i][k][0] - 'a'] &&
pA[j][end][v[i][k][1] - 'a']) {
pA[start][end][i] = true;
}
}
}
}
}
}
for (int len = (int)(2); len <= (int)(b.size()); ++len) {
for (int start = 0; start < (int)(b.size()); ++start) {
int end = start + len;
if (end > b.size()) break;
for (int i = 0; i < (int)(alphaBetS); ++i) {
for (int j = (int)(start + 1); j <= (int)(end - 1); ++j) {
for (int k = 0; k < (int)(v[i].size()); ++k) {
if (pB[start][j][v[i][k][0] - 'a'] &&
pB[j][end][v[i][k][1] - 'a']) {
pB[start][end][i] = true;
}
}
}
}
}
}
const int INF = 1000;
vector<vector<vector<vector<int>>>> dp(
a.size(),
vector<vector<vector<int>>>(
a.size() + 1,
vector<vector<int>>(b.size(), vector<int>(b.size() + 1, INF))));
for (int ai = 0; ai < (int)(a.size()); ++ai) {
for (int aj = (int)(ai + 1); aj <= (int)(a.size()); ++aj) {
for (int bi = 0; bi < (int)(b.size()); ++bi) {
for (int bj = (int)(bi + 1); bj <= (int)(b.size()); ++bj) {
for (int i = 0; i < (int)(alphaBetS); ++i) {
if (pA[ai][aj][i] && pB[bi][bj][i]) {
dp[ai][aj][bi][bj] = 1;
}
}
}
}
}
}
for (int lena = (int)(1); lena <= (int)(a.size()); ++lena)
for (int lenb = (int)(1); lenb <= (int)(b.size()); ++lenb)
for (int as = 0; as < (int)(a.size() - lena + 1); ++as)
for (int bs = 0; bs < (int)(b.size() - lenb + 1); ++bs) {
int ae = as + lena;
int be = bs + lenb;
for (int am = (int)(as + 1); am <= (int)(ae - 1); ++am)
for (int bm = (int)(bs + 1); bm <= (int)(be - 1); ++bm) {
if (dp[as][am][bs][bm] + dp[am][ae][bm][be] <
dp[as][ae][bs][be]) {
dp[as][ae][bs][be] = dp[as][am][bs][bm] + dp[am][ae][bm][be];
}
}
}
if (dp[0][a.size()][0][b.size()] >= INF)
cout << -1 << endl;
else
cout << dp[0][a.size()][0][b.size()] << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
long long const inf = 1e18, linf = 2e9, mod = 1e9 + 7;
int const mxn = 5e3 + 10;
long long poww(long long a, long long b, long long md) {
return (!b ? 1
: (b & 1 ? a * poww(a * a % md, b / 2, md) % md
: poww(a * a % md, b / 2, md) % md));
}
long long dp[mxn][mxn], ans;
string s, t;
int main() {
cin >> s >> t;
int ss = s.size(), ts = t.size();
s = "#" + s, t = "#" + t;
for (int i = 1; i <= ss; i++) {
for (int j = 1; j <= ts; j++) {
dp[i][j] += (dp[i - 1][j - 1] + 1) * (s[i] == t[j]) + dp[i][j - 1];
dp[i][j] %= mod;
}
}
for (int i = 1; i <= ss; i++) {
ans += dp[i][ts];
ans %= mod;
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
int L, R;
long long lazy[N * 4], a[N];
void update(int pos, int l, int r, long long c) {
int mid = (l + r) >> 1;
if (r < L || R < l) return;
if (L <= l && r <= R) {
lazy[pos] += c;
return;
}
update(pos * 2, l, mid, c);
update(pos * 2 + 1, mid + 1, r, c);
}
inline long long get(int pos, int l, int r) {
int mid = (l + r) >> 1;
if (lazy[pos] > 0) {
long long temp = lazy[pos];
if (l != r) {
lazy[pos * 2] += temp;
lazy[pos * 2 + 1] += temp;
lazy[pos] = 0;
}
}
if (r < L || R < l) assert(0);
if (L <= l && r <= R) return lazy[pos];
if (l <= L && R <= mid) return get(pos * 2, l, mid);
return get(pos * 2 + 1, mid + 1, r);
}
int v[N], n;
struct val {
int x[7];
val() { memset(x, 0, sizeof(x)); }
} tree[N * 4];
inline int comp(int x) {
int l = L, r = R;
L = x, R = x;
long long u = a[x] + get(1, 1, n), v;
L = x + 1, R = x + 1;
v = a[x + 1] + get(1, 1, n);
L = l, R = r;
if (u < v) return 1;
if (u > v) return 2;
return 0;
}
void update(int pos, int l, int r, int k) {
int mid = (l + r) >> 1;
if (r < L || R < l) return;
if (L <= l && r <= R) {
memset(tree[pos].x, 0, sizeof(tree[pos].x));
if (k == 1) tree[pos].x[0] = tree[pos].x[3] = tree[pos].x[6] = 1;
if (k == 2) tree[pos].x[2] = tree[pos].x[5] = tree[pos].x[6] = 1;
return;
}
update(pos * 2, l, mid, k);
update(pos * 2 + 1, mid + 1, r, k);
int i, u = pos * 2, v = pos * 2 + 1, len1 = mid - l + 1, len2 = r - mid,
maxi = max(tree[u].x[6], tree[v].x[6]);
for (i = 0; i < 3; ++i) tree[pos].x[i] = tree[u].x[i];
for (i = 3; i < 6; ++i) tree[pos].x[i] = tree[v].x[i];
if (len1 == tree[u].x[0]) {
tree[pos].x[0] += tree[v].x[0];
if (max(tree[v].x[1], tree[v].x[2]) > 0)
tree[pos].x[1] =
max(tree[pos].x[1], tree[u].x[0] + max(tree[v].x[1], tree[v].x[2]));
}
if (len1 == tree[u].x[1])
tree[pos].x[1] = max(tree[pos].x[1], tree[u].x[1] + tree[v].x[2]);
if (len1 == tree[u].x[2]) tree[pos].x[2] += tree[v].x[2];
if (len2 == tree[v].x[3]) {
tree[pos].x[3] += tree[u].x[3];
}
if (len2 == tree[v].x[4]) tree[pos].x[4] += tree[u].x[3];
if (len2 == tree[v].x[5]) {
tree[pos].x[5] += tree[u].x[5];
if (max(tree[u].x[4], tree[u].x[3]) > 0)
tree[pos].x[4] =
max(tree[pos].x[4], max(tree[u].x[4], tree[u].x[3]) + tree[v].x[5]);
}
maxi = max(maxi,
max(tree[v].x[2], max(tree[v].x[0], tree[v].x[1])) + tree[u].x[3]);
maxi = max(maxi, max(tree[u].x[4], tree[u].x[5]) + tree[v].x[2]);
for (i = 0; i < 6; ++i) maxi = max(maxi, tree[pos].x[i]);
tree[pos].x[6] = maxi;
}
int main() {
cin >> n;
int i, j, m, l, r, x;
for (i = 1; i <= n; ++i) scanf("%d", &x), a[i] = x;
for (i = 1; i < n; ++i) L = R = i, update(1, 1, n - 1, comp(i));
cin >> m;
long long C;
while (m--) {
scanf("%d%d%d", &l, &r, &x);
L = l, R = r, C = x;
update(1, 1, n, C);
l = L - 1, r = R;
if (l > 0) L = l, R = l, update(1, 1, n - 1, comp(l));
if (r < n) L = r, R = r, update(1, 1, n - 1, comp(r));
cout << 1 + tree[1].x[6] << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int N = 1e2 + 5, M = 1e5 + 5;
int lim = (1 << 10) - 1;
bool vis[M];
vector<int> primes;
int idx[M];
void pre() {
for (int i = 2; primes.size() < 110; ++i) {
if (vis[i]) continue;
primes.emplace_back(i);
for (int j = i; j < M; j += i) vis[j] = true;
}
for (int i = 0; i < 110; ++i) idx[primes[i]] = i;
}
vector<int> tmp;
void fac(int x) {
tmp.clear();
for (int i = 2; i * i <= x; ++i) {
if (x % i) continue;
tmp.emplace_back(idx[i]);
while (x % i == 0) x /= i;
}
if (x > 1) tmp.emplace_back(idx[x]);
}
int n, a[N];
int dp[N][1 << 10][N + 10];
int solve(int i, int msk, int j) {
if (i == n) return 0;
if (msk == lim && j == 110) return (int)1e7;
int &ret = dp[i][msk][j];
if (~ret) return ret;
ret = (int)1e7;
if (j < 110 && a[i] > primes[j])
cout << "yala n2fl ya 3mna kda mb2tsh nf3a" << endl;
if (j < 110) ret = min(ret, solve(i + 1, msk, j + 1) - a[i] + primes[j]);
for (int f = 0; f < 10; ++f) {
if ((msk & (1 << f))) continue;
int nw = primes[f];
for (int k = 0; k <= 15 && (int)1e7 / nw >= primes[f]; ++k, nw *= primes[f])
ret = min(ret, solve(i + 1, (msk | (1 << f)), j) + abs(a[i] - nw));
}
for (int hna = 1; hna <= 30; ++hna) {
bool baz = false;
int nmsk = msk;
fac(hna);
for (auto f : tmp) {
nmsk |= (1 << f);
baz |= ((msk & (1 << f)) > 0);
}
if (baz) continue;
ret = min(ret, solve(i + 1, nmsk, j) + abs(a[i] - hna));
}
return ret;
}
vector<int> out;
void build(int i, int msk, int j) {
if (i == n) {
for (auto x : out) printf("%d%c", x, " \n"[&x == &out.back()]);
exit(0);
}
if (msk == lim && j == 110) return;
int m3lsh = solve(i, msk, j);
if (j < 110 && m3lsh == solve(i + 1, msk, j + 1) - a[i] + primes[j]) {
out.emplace_back(primes[j]);
build(i + 1, msk, j + 1);
return;
}
for (int f = 0; f < 10; ++f) {
if ((msk & (1 << f))) continue;
int nw = primes[f];
for (int k = 0; k <= 15 && (int)1e7 / nw >= primes[f];
++k, nw *= primes[f]) {
if (m3lsh == solve(i + 1, (msk | (1 << f)), j) + abs(a[i] - nw)) {
out.emplace_back(nw);
build(i + 1, (msk | (1 << f)), j);
return;
}
}
}
for (int hna = 1; hna <= 30; ++hna) {
bool baz = false;
int nmsk = msk;
fac(hna);
for (auto f : tmp) {
nmsk |= (1 << f);
baz |= (msk & (1 << f));
}
if (baz) continue;
if (m3lsh == solve(i + 1, nmsk, j) + abs(a[i] - hna)) {
out.emplace_back(hna);
build(i + 1, nmsk, j);
return;
}
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
pre();
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", a + i);
memset(dp, -1, sizeof dp);
solve(0, 0, 10);
build(0, 0, 10);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << ": " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << ": " << arg1 << " | ";
__f(comma + 1, args...);
}
long long rem(long long n) {
long long ans = 0, val = 1;
while (n) {
long long d = n % 10;
n /= 10;
if (d) {
ans += d * val;
val *= 10;
}
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long a, b, c;
cin >> a >> b;
c = a + b;
a = rem(a);
b = rem(b);
c = rem(c);
if (a + b == c)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long a[26][131073];
map<pair<long long, pair<long long, long long>>, long long> memo;
long long findans(long long st, long long en, long long req, long long n,
string &s) {
if (st > en) {
return 0;
}
if (st == en) {
if (s[st] == (req + 'a')) {
return 0;
} else {
return 1;
}
}
if (memo.find(make_pair(st, make_pair(en, req))) != memo.end()) {
return memo[make_pair(st, make_pair(en, req))];
}
long long tn = (en - st + 1);
long long reqc = (en - st + 1) / 2;
long long op1 = 0;
if (st - 1 >= 0) {
op1 = a[req][st + reqc - 1] - a[req][st - 1];
op1 = reqc - op1;
} else {
op1 = a[req][st + reqc - 1];
op1 = reqc - op1;
}
long long choice1 = op1 + findans(st + (reqc), en, req + 1, n, s);
long long ts = st + (tn) / 2;
if (ts - 1 >= 0) {
op1 = a[req][en] - a[req][ts - 1];
op1 = reqc - op1;
} else {
op1 = a[req][en];
op1 = reqc - op1;
}
long long choice2 = op1 + findans(st, en - (reqc), req + 1, n, s);
return memo[make_pair(st, make_pair(en, req))] = min(choice1, choice2);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
long long t1;
cin >> t1;
while (t1--) {
long long n;
cin >> n;
string s;
cin >> s;
for (long long i = 0; i < 26; i++) {
for (long long j = 0; j < n; j++) {
a[i][j] = 0;
}
}
for (long long i = 0; i < n; i++) {
a[s[i] - 'a'][i] = 1;
}
for (long long i = 0; i < 26; i++) {
for (long long j = 1; j < n; j++) {
a[i][j] = a[i][j - 1] + a[i][j];
}
}
memo.clear();
long long ans = findans(0, n - 1, 0, n, s);
cout << ans << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int t;
std::cin >> t;
while (t--) {
int n;
std::cin >> n;
std::cout << n << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e5 + 5;
vector<pair<int, int>> graph[mx];
int MOD, n, PHI;
long long bigmod(long long x, long long n) {
long long res = 1;
while (n > 0) {
if (n % 2) res = (res * x) % MOD;
n /= 2;
x = (x * x) % MOD;
}
return res;
}
long long inv(int n) { return bigmod(n, PHI - 1); }
bool flag[mx];
vector<int> primes;
void sieve() {
primes.push_back(2);
for (int i = 3; i < mx; i += 2)
if (!flag[i]) {
primes.push_back(i);
for (long long j = (long long)i * i; j < mx; j += i) flag[j] = true;
}
}
int phi(int n) {
int ans = n;
for (int i = 0; (long long)primes[i] * primes[i] <= n; i++) {
if (n % primes[i] == 0) {
while (n % primes[i] == 0) n /= primes[i];
ans -= ans / primes[i];
}
}
if (n != 1) ans -= ans / n;
return ans;
}
vector<int> nodes;
int treesize, sz[mx];
bool vis[mx];
int dfs(int u, int p) {
if (p == -1) nodes.clear();
nodes.push_back(u);
sz[u] = 1;
for (auto it : graph[u]) {
int v = it.first;
if (!vis[v] && v != p) {
sz[u] += dfs(v, u);
}
}
if (p == -1) treesize = sz[u];
return sz[u];
}
int findCent(int u, int p) {
for (auto it : graph[u]) {
int v = it.first;
if (!vis[v] && v != p) {
if (sz[v] * 2 > treesize) return findCent(v, u);
}
}
return u;
}
int parts = 0, dppart[mx], hi[mx];
long long down[mx], up[mx];
void prep(int u, int p, int cent) {
if (p == cent) {
dppart[u] = parts;
parts++;
} else if (p != -1) {
dppart[u] = dppart[p];
}
for (auto it : graph[u]) {
int v = it.first;
int w = it.second;
if (!vis[v] && v != p) {
hi[v] = hi[u] + 1;
down[v] = (10 * down[u] + w) % MOD;
up[v] = (bigmod(10, hi[u]) * w + up[u]) % MOD;
prep(v, u, cent);
}
}
}
long long solve(int cent) {
for (int v : nodes) {
up[v] = down[v] = hi[v] = 0;
}
parts = 0;
prep(cent, -1, cent);
dppart[cent] = -1;
map<long long, long long> cnt;
vector<map<long long, long long>> vec;
vec.resize(parts + 1);
cnt[0]++;
for (int v : nodes) {
if (v == cent) continue;
cnt[up[v]]++;
vec[dppart[v]][up[v]]++;
}
long long ans = 0;
for (int v : nodes) {
int pt = dppart[v];
if (v == cent)
ans += (cnt[0] - 1);
else {
long long val = (-down[v] % MOD + MOD) % MOD;
val = (val * inv(bigmod(10, hi[v]))) % MOD;
ans += (cnt[val] - vec[pt][val]);
}
}
return ans;
}
long long comsolve(int u) {
dfs(u, -1);
int cent = findCent(u, -1);
long long ans = solve(cent);
vis[cent] = true;
for (auto it : graph[cent]) {
int v = it.first;
if (!vis[v]) ans += comsolve(v);
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> MOD;
sieve();
PHI = phi(MOD);
if (MOD == 1) {
cout << (long long)n * (n - 1) << endl;
return 0;
}
for (int i = 1; i < n; i++) {
int u, v, w;
cin >> u >> v >> w;
graph[u].push_back(make_pair(v, w));
graph[v].push_back(make_pair(u, w));
}
cout << comsolve(0) << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MOD1 = 1e9 + 7;
const int MOD2 = 998244353;
const long long INF = 2 * 1e18;
const long double PI = 3.14159265358979323846;
long long a[200005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
;
bool x = 0;
map<pair<long long, long long>, long long> ans;
map<long long, long long> m;
vector<pair<long long, long long> > v;
long long n, k;
cin >> n >> k;
for (long long i = 0; i < n; i++) {
cin >> a[i];
v.push_back(make_pair(a[i], i));
m[a[i]]++;
if (m[a[i]] > k) x = 1;
}
if (x) {
cout << "NO";
return 0;
}
sort(v.begin(), v.end());
long long cnt = 1;
for (long long i = 0; i < n; i++) {
ans[v[i]] = cnt;
cnt++;
if (cnt > k) cnt = 1;
}
cout << "YES\n";
for (long long i = 0; i < n; i++) {
cout << ans[make_pair(a[i], i)] << " ";
}
}
| 3 |
#include <bits/stdc++.h>
int main() {
char b[100], c[100];
int i, j;
gets(b);
j = 0;
for (i = 0; b[i] != '\0'; i++) {
if (b[i] == '1' || b[i] == '2' || b[i] == '3') {
c[j] = b[i];
j++;
}
}
c[j] = '\0';
int d = j - 1;
int k, l;
char temp;
for (k = 0; k < j - 1; k++) {
for (l = 0; l < j - 1 - k; l++) {
if (c[l] > c[l + 1]) {
temp = c[l + 1];
c[l + 1] = c[l];
c[l] = temp;
}
}
}
for (j = 0; j <= d; j++) {
if (j > 0) printf("+");
printf("%c", c[j]);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
double n, m, k;
cin >> n >> m >> k;
if (m == 0)
cout << 0 << endl;
else if (n / k >= m) {
cout << (int)m << endl;
} else {
double zz = (m - (n / k));
int tt;
tt = ceil(zz / (k - 1));
cout << "" << (int)(n / k) - tt << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int main() {
long long n, k, p, x;
vector<long long> O;
vector<long long> E;
vector<long long> ans;
cin >> n >> k >> p;
for (int i = 0; i < n; ++i) {
cin >> x;
if (x % 2 == 0) {
E.push_back(x);
} else {
O.push_back(x);
}
}
long long odd = k - p;
long long even = p;
long long rem = (int)(O).size() - (odd);
if ((int)(O).size() < odd || rem % 2 != 0 ||
(int)(E).size() + (rem / 2) < p) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
int i = 0;
for (i = 0; i < odd && i < k - 1; ++i) {
cout << 1 << " " << O.back() << endl;
O.pop_back();
}
while (i < k - 1 && (int)(O).size()) {
cout << 2 << " " << O.back() << " ";
O.pop_back();
cout << O.back() << endl;
O.pop_back();
i++;
}
if (i == k - 1) {
cout << (int)(O).size() + (int)(E).size() << " ";
while ((int)(O).size()) {
cout << O.back() << " ";
O.pop_back();
}
while ((int)(E).size()) {
cout << E.back() << " ";
E.pop_back();
}
i++;
}
while (i < k - 1 && (int)(E).size()) {
cout << 1 << " " << E.back() << " " << endl;
E.pop_back();
i++;
}
if (i == k - 1) {
cout << (int)(O).size() + (int)(E).size() << " ";
while ((int)(O).size()) {
cout << O.back() << " ";
O.pop_back();
cout << O.back() << " ";
O.pop_back();
}
while ((int)(E).size()) {
cout << E.back() << " ";
E.pop_back();
}
i++;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int arr[100010];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) scanf("%d", &arr[i]);
sort(arr, arr + n);
int j = n - 1;
long long int ans = 0, target = arr[n - 1];
if (n == 1) {
printf("0\n");
return 0;
}
while (1) {
if (target == 0 || j < 0) break;
if (arr[j] >= target) {
ans += (arr[j] - 1);
} else {
long long int dif = abs(target - (long long int)arr[j]);
ans += (arr[j] - 1);
ans -= dif;
target = arr[j];
}
target--;
j--;
}
for (; j >= 0; j--) {
ans += (arr[j] - 1);
}
if (target) ans -= target;
printf("%lld\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i;
cin >> n >> k;
vector<string> s(n);
for (i = 0; i < n; i++) {
cin >> s[i];
}
map<string, int> m;
for (i = 0; i < n; i++) {
m[s[i]] = 1;
}
int ans = 0;
for (i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
string str = "";
for (int len = 0; len < k; len++) {
if (s[i][len] == s[j][len]) {
str.push_back(s[i][len]);
} else {
str.push_back('S' + 'T' + 'E' - s[i][len] - s[j][len]);
}
}
if (m[str] == 1) {
ans++;
}
}
}
cout << ans / 3 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int countteams(int n, int m, int& t) {
if (n == 1 || m == 0) return 0;
t += 1;
n -= 2;
m -= 1;
if (n > m) {
countteams(n, m, t);
} else
countteams(m, n, t);
return 0;
}
int main() {
int n, m;
int t = 0;
cin >> n >> m;
if (n > m) {
countteams(n, m, t);
} else
countteams(m, n, t);
cout << t << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200100;
int n, m;
vector<int> clause[maxn];
int pos[maxn][2], sze[maxn];
int ans[maxn];
int sgn(int x) { return x < 0 ? -1 : x > 0 ? 1 : 0; }
bool vis[maxn];
void del(int i, int x) {
if (sze[i] == 0)
return;
else if (sze[i] == 1) {
if (abs(pos[i][0]) == x) sze[i] = 0;
} else if (sze[i] == 2) {
if (abs(pos[i][1]) == x)
sze[i] = 1;
else if (abs(pos[i][0]) == x) {
pos[i][0] = pos[i][1];
sze[i] = 1;
}
}
}
void process(int);
void dfs(int x) {
if (vis[x]) return;
vis[x] = 1;
for (int i : clause[x]) {
del(abs(i), x);
process(abs(i));
}
}
void process(int i) {
if (sze[i] == 0)
return;
else if (sze[i] == 1) {
ans[i] = sgn(pos[i][0]);
sze[i] = 0;
dfs(abs(pos[i][0]));
} else if (sze[i] == 2) {
if (sgn(pos[i][0]) == sgn(pos[i][1])) {
ans[i] = sgn(pos[i][0]);
sze[i] = 0;
dfs(abs(pos[i][0]));
dfs(abs(pos[i][1]));
}
}
}
int other(int a, int x) {
assert(sze[a] == 2);
if (abs(pos[a][0]) == x)
return abs(pos[a][1]);
else if (abs(pos[a][1]) == x)
return abs(pos[a][0]);
else
assert(0);
}
bool dfs2(int x, int p = 0) {
vis[x] = 1;
bool ret = 0;
int s;
for (int i : clause[x]) {
int a = abs(i);
if (a == p) {
s = sgn(i);
continue;
}
int y = other(a, x);
if (ret) {
if (!vis[y]) dfs2(y, a);
ans[a] = -sgn(i);
} else if (vis[y]) {
ret = 1;
ans[a] = sgn(i);
} else {
if (dfs2(y, a)) ret = 1, ans[a] = sgn(i);
}
}
if (!ret) {
if (!p) {
cout << "NO";
exit(0);
}
ans[p] = s;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
int k;
cin >> k;
clause[i].resize(k);
for (int j = 0; j < k; j++) {
int x;
cin >> x;
clause[i][j] = x;
pos[abs(x)][sze[abs(x)]++] = sgn(x) * i;
}
}
for (int i = 1; i <= m; i++) process(i);
for (int i = 1; i <= n; i++) {
vector<int> v;
for (int j : clause[i]) {
assert(sze[abs(j)] != 1);
if (sze[abs(j)]) v.push_back(j);
}
clause[i] = v;
}
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) {
if (clause[i].size() == 0) continue;
if (!vis[i]) dfs2(i);
}
cout << "YES\n";
for (int i = 1; i <= m; i++) {
if (ans[i] >= 0)
cout << 1;
else
cout << 0;
}
cout << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, flag = 1;
char ch = getchar();
while (!isdigit(ch) && ch != '-') ch = getchar();
if (ch == '-') flag = -1, ch = getchar();
while (isdigit(ch)) x = (x << 3) + (x << 1) + (ch - '0'), ch = getchar();
return x * flag;
}
bitset<7009> a[100100], b[7009], c[7009];
int vis[7009], pri[7009], mu[7009], cnt, n, m;
int main() {
mu[1] = 1;
for (int i = 2; i < 7009; ++i) {
if (!vis[i]) mu[i] = 1, pri[++cnt] = i;
for (int j = 1; j <= cnt && i * pri[j] < 7009; ++j) {
vis[i * pri[j]] = 1;
if (i % pri[j])
mu[i * pri[j]] = mu[i];
else {
mu[i * pri[j]] = 0;
break;
}
}
}
for (int i = 1; i < 7009; ++i)
for (int j = 1; i * j < 7009; ++j)
if (mu[j]) b[i][i * j] = 1;
for (int i = 1; i < 7009; ++i)
for (int j = 1; j <= i; ++j) c[i][j] = (i % j == 0);
n = read(), m = read();
int opt, x, y, z;
while (m--) {
opt = read();
if (opt == 1) {
x = read();
y = read();
a[x] = c[y];
} else if (opt == 2) {
x = read();
y = read();
z = read();
a[x] = a[y] ^ a[z];
} else if (opt == 3) {
x = read();
y = read();
z = read();
a[x] = a[y] & a[z];
} else if (opt == 4) {
x = read();
y = read();
putchar('0' + ((a[x] & b[y]).count() & 1));
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int tot = 0;
while (n--) {
int l, r;
cin >> l >> r;
tot += r - l + 1;
}
cout << (k - tot % k) % k << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[2000], i = 0;
void lucky(long long x = 0) {
if (x > 1000000000) return;
a[i++] = x;
lucky(x * 10 + 4);
lucky(x * 10 + 7);
}
int main() {
int n = 0;
cin >> n;
lucky();
for (int i = 0; i <= 1022; i++) {
int item = a[i];
int j = i;
while (j > 0 && a[j - 1] > item) {
a[j] = a[j - 1];
j--;
a[j] = item;
}
}
int ans = 0;
for (int i = 0; i <= 1022; i++) {
if (a[i] == n) {
ans = i;
break;
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int Max = 1e5 + 5;
int vis[100001], prime[100001], tot = 0;
bitset<2200> B, C;
vector<int> bud[Max];
int beg = 1, siz[Max], dfn[Max], rak[Max], last[Max], a[Max];
int n, m;
void phi() {
for (int i = 2; i <= 1000; i++) {
if (!vis[i]) prime[tot++] = i;
for (int j = 0; j < tot && prime[j] <= 1000 / i; j++) {
vis[i * prime[j]] = 1;
if (i % prime[j] == 0) break;
}
}
for (int i = 0; i < tot && prime[i] < m; i++) {
B.set(prime[i]);
}
}
void dfs(int fa, int u) {
rak[beg] = u;
dfn[u] = beg++;
last[u] = u;
siz[u] = 1;
for (int i = 0; i < bud[u].size(); i++) {
int v = bud[u][i];
if (v == fa) continue;
dfs(u, v);
siz[u] += siz[v];
last[u] = last[v];
}
}
struct node {
int l, r, w;
bitset<2200> f;
} tree[4 * Max];
void build(int l, int r, int k) {
tree[k].l = l;
tree[k].r = r;
if (l == r) {
tree[k].f.set(a[rak[l]]);
return;
}
int mid = (l + r) / 2;
build(l, mid, 2 * k);
build(mid + 1, r, 2 * k + 1);
tree[k].f = tree[2 * k].f | tree[2 * k + 1].f;
}
void down(int k) {
bitset<2200> ex;
ex.reset();
tree[2 * k].f <<= tree[k].w;
tree[2 * k].w += tree[k].w;
tree[2 * k].w %= m;
ex = tree[2 * k].f >> m;
tree[2 * k].f |= ex;
tree[2 * k].f &= C;
ex.reset();
tree[2 * k + 1].f <<= tree[k].w;
tree[2 * k + 1].w += tree[k].w;
tree[2 * k + 1].w %= m;
ex = tree[2 * k + 1].f >> m;
tree[2 * k + 1].f |= ex;
tree[2 * k + 1].f &= C;
tree[k].w = 0;
}
void change_interval(int l, int r, int k, int x) {
if (tree[k].l >= l && tree[k].r <= r) {
tree[k].f <<= x;
tree[k].w += x;
tree[k].w %= m;
bitset<2200> ex;
ex = tree[k].f >> m;
tree[k].f |= ex;
tree[k].f &= C;
return;
}
if (tree[k].w) down(k);
int mid = (tree[k].l + tree[k].r) / 2;
if (l <= mid) change_interval(l, r, 2 * k, x);
if (r > mid) change_interval(l, r, 2 * k + 1, x);
tree[k].f = tree[2 * k].f | tree[2 * k + 1].f;
}
bitset<2200> cou;
void ask_interval(int l, int r, int k) {
if (tree[k].l >= l && tree[k].r <= r) {
cou |= tree[k].f;
return;
}
if (tree[k].w) down(k);
int mid = (tree[k].l + tree[k].r) / 2;
if (l <= mid) ask_interval(l, r, 2 * k);
if (r > mid) ask_interval(l, r, 2 * k + 1);
}
int main() {
scanf("%d", &n);
;
scanf("%d", &m);
;
phi();
for (int i = 0; i <= m - 1; ++i) C.set(i);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
;
a[i] %= m;
}
for (int i = 1; i <= n - 1; ++i) {
int u, v;
scanf("%d", &u);
;
scanf("%d", &v);
;
bud[u].push_back(v);
bud[v].push_back(u);
}
dfs(0, 1);
build(1, n, 1);
int q;
scanf("%d", &q);
;
while (q--) {
int u;
scanf("%d", &u);
;
if (u == 1) {
int v, x;
scanf("%d", &v);
;
scanf("%d", &x);
;
x %= m;
change_interval(dfn[v], dfn[last[v]], 1, x);
} else {
cou.reset();
int v;
scanf("%d", &v);
;
ask_interval(dfn[v], dfn[last[v]], 1);
cou &= B;
printf("%d\n", cou.count());
}
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, f = 0;
cin >> n;
string a[] = {"Sheldon", "Leonard", "Penny", "Rajesh", "Howard"};
while (n > 5) {
n = n / 2 - 2;
}
cout << a[n - 1] << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int dx[4]{-1, 1, 0, 0};
int dy[4]{0, 0, -1, 1};
const int N = 1000;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.precision(10);
cout << fixed;
int n, m;
cin >> n >> m;
vector<string> board(n + 2, string(m + 2, '*'));
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
board[i + 1].replace(1, m, s);
}
vector<int> cnt(N * N, 0);
int cc[N + 2][N + 2];
memset(cc, 0, sizeof(cc));
int pos = 1;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (board[i][j] == '.' && cc[i][j] == 0) {
int cur = pos;
++pos;
int c = 1;
vector<int> s;
s.push_back(i);
s.push_back(j);
cc[i][j] = cur;
while (!s.empty()) {
int j_ = s.back();
s.pop_back();
int i_ = s.back();
s.pop_back();
for (int k = 0; k < 4; ++k) {
int ii = i_ + dx[k];
int jj = j_ + dy[k];
if (board[ii][jj] == '.' && cc[ii][jj] == 0) {
s.push_back(ii);
s.push_back(jj);
cc[ii][jj] = cur;
++c;
}
}
cnt[cur] = c;
}
}
vector<string> ans(n, string(m, '.'));
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (board[i][j] == '*') {
int tot = 1;
set<int> si;
for (int k = 0; k < 4; ++k) {
si.insert(cc[i + dx[k]][j + dy[k]]);
}
for (int k : si) {
tot += cnt[k];
}
tot %= 10;
ans[i - 1][j - 1] = (char)tot + '0';
}
for (string& s : ans) {
cout << s << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool prime(int m) {
int u = sqrt(m);
for (int i = 2; i <= u + 1; i++) {
if (m % i == 0) {
return false;
}
}
return true;
}
long long max(long long a, long long b) {
if (a > b) {
return a;
} else {
return b;
}
}
long long min(long long a, long long b) {
if (a < b) {
return a;
} else {
return b;
}
}
bool file = false;
int main() {
if (file) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
int n, b[4001];
cin >> n;
int ttt = 0;
int m[1000001];
for (int i = 1; i <= n; i++) {
cin >> b[i];
m[b[i]] = i;
ttt = max(ttt, b[i]);
}
int maxer = min(2, n);
for (int i = 1; i <= n; i++) {
int fix = b[i];
int q = 1;
int u[4001], v[4001];
for (int k = 1; k <= n; k++) {
u[k] = 1;
v[k] = 0;
}
int t = i;
for (int j = i + 1; j <= n; j++) {
v[m[b[j]]] = 2;
if (b[j] == fix) {
q++;
for (int k = t + 1; k <= j - 1; k++) {
u[m[b[k]]] += v[m[b[k]]];
v[m[b[k]]] = 0;
}
t = j;
}
}
int qqq[4001];
for (int k = 1; k <= n; k++) {
qqq[k] = 1;
}
for (int k = t + 1; k <= n; k++) {
u[m[b[k]]] += qqq[m[b[k]]];
qqq[m[b[k]]] = 0;
}
for (int k = 1; k <= n; k++) {
q = max(q, u[k]);
}
maxer = max(q, maxer);
}
cout << maxer << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class A>
void read(vector<A>& v);
template <class A, size_t S>
void read(array<A, S>& a);
template <class T>
void read(T& x) {
cin >> x;
}
void read(double& d) {
string t;
read(t);
d = stod(t);
}
void read(long double& d) {
string t;
read(t);
d = stold(t);
}
template <class H, class... T>
void read(H& h, T&... t) {
read(h);
read(t...);
}
template <class A>
void read(vector<A>& x) {
for (auto& a : x) read(a);
}
template <class A, size_t S>
void read(array<A, S>& x) {
for (auto& a : x) read(a);
}
const int mod = 1e9 + 7;
long long int primeLimit = 1e5;
const double PI = acos(-1);
bool prime[100000];
string LongestPalindromicPrefix(string str) {
string temp = str + '?';
reverse(str.begin(), str.end());
temp += str;
long long int n = temp.length();
long long int lps[n];
fill(lps, lps + n, 0);
for (long long int i = 1; i < n; i++) {
long long int len = lps[i - 1];
while (len > 0 && temp[len] != temp[i]) {
len = lps[len - 1];
}
if (temp[i] == temp[len]) {
len++;
}
lps[i] = len;
}
return temp.substr(0, lps[n - 1]);
}
bool binarySearchFloat(float lower, float higher, float maxErrorAllowed,
long long int numberOfTimesWanttoRunCode) {
float l = lower, r = higher;
float eps = maxErrorAllowed;
long long int iteration_count = numberOfTimesWanttoRunCode;
for (long long int i = 0; i < iteration_count && l + eps < r; ++i) {
}
}
void primefinder() {
memset(prime, true, sizeof(prime));
prime[1] = false;
prime[0] = false;
for (long long int i = 2; i < primeLimit; i++) {
if (prime[i]) {
for (long long int j = i * i; j < primeLimit; j += i) {
prime[j] = false;
}
}
}
}
long long fast_pow(long long int x, long long int y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = res * x;
y = y >> 1;
x = x * x;
}
return res;
}
long long Fast_pow(long long int x, long long int y, long long int p) {
long long res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int nCr(long long int n, long long int r) {
long long int res = 1;
if (n - r < r) r = n - r;
for (long long int i = 0; i < r; i++) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, k;
cin >> n >> k;
long long int ans = 1;
if (k > 1) ans += nCr(n, 2);
if (k > 2) ans += nCr(n, 3) * 2;
if (k > 3) ans += nCr(n, 4) * 9;
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e3 + 2;
const long long mod = 1e9 + 7;
const long long INF = 1e18 + 1;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> a(n);
long long s = 0;
for (long long i = 0; i < n; i++) {
cin >> a[i];
s += a[i];
}
if (n == 2) {
if (a[0] != a[1])
cout << "T\n";
else
cout << "HL\n";
continue;
}
sort((a).begin(), (a).end());
long long as = s - a.back();
if (a.back() > as)
cout << "T\n";
else {
if (s % 2 == 0)
cout << "HL\n";
else
cout << "T\n";
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
class uftree {
public:
int n;
vector<int> val;
uftree(int n_) : n(n_), val(n_, -1) {}
int root(int x) { return (val[x] < 0) ? x : (val[x] = root(val[x])); }
void merge(int x, int y) {
x = root(x);
y = root(y);
if (x == y) return;
val[x] += val[y];
val[y] = x;
}
bool same(int x, int y) { return root(x) == root(y); }
int independent(int nn) {
int ret = 0;
for (int i = 0; i < nn; i++)
if (val[i] < 0) ret++;
return ret;
}
};
struct task {
int s, t, d;
};
vector<task> ans;
int n, e, v, from, to;
int a[301];
int b[301];
long long sum[301];
int tube[301][301];
bool used[301];
int prevv[301];
bool dfs(int s, int t, vector<int>& path) {
if (s == t) {
path.push_back(s);
return true;
}
used[s] = true;
for (int i = 0; i < n; i++) {
if (!used[i] && tube[s][i] == 1) {
if (dfs(i, t, path)) {
path.push_back(s);
return true;
}
}
}
return false;
}
void pour(int i, int j, int d, vector<int>& path) {
if (i == j) return;
int s = path[j - 1];
int t = path[j];
int cap = min(d, a[s]);
if (cap > 0) {
a[s] -= cap;
a[t] += cap;
task tsk = {s, t, cap};
ans.push_back(tsk);
}
pour(i, j - 1, d, path);
int rest = d - cap;
if (rest > 0) {
a[s] -= rest;
a[t] += rest;
task tsk = {s, t, rest};
ans.push_back(tsk);
}
}
bool solve() {
ans.clear();
uftree uf(n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j) continue;
if (tube[i][j] == 1) {
uf.merge(i, j);
}
}
}
memset(sum, 0, sizeof(sum));
for (int i = 0; i < n; i++) {
sum[uf.root(i)] += a[i] - b[i];
}
for (int i = 0; i < n; i++) {
if (sum[i] != 0) return false;
}
vector<int> path;
bool update = true;
while (update) {
update = false;
for (int i = 0; i < n; i++) {
if (a[i] == b[i]) continue;
for (int j = 0; j < n; j++) {
if (!uf.same(i, j) || a[j] == b[j]) continue;
if ((a[i] < b[i]) ^ (a[j] < b[j])) {
int s, t, d;
if (a[i] < b[i]) {
s = j;
t = i;
d = min(b[i] - a[i], a[j] - b[j]);
} else {
s = i;
t = j;
d = min(a[i] - b[i], b[j] - a[j]);
}
memset(used, 0, sizeof(used));
path.clear();
dfs(s, t, path);
reverse((path).begin(), (path).end());
int len = path.size();
pour(0, len - 1, d, path);
update = true;
goto ex;
}
}
}
ex:;
}
return true;
}
void coding() {
while (scanf("%d%d%d", &n, &v, &e) != EOF) {
int sum = 0;
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
for (int i = 0; i < n; i++) {
scanf("%d", b + i);
}
memset(tube, 0, sizeof(tube));
for (int i = 0; i < e; i++) {
scanf("%d%d", &from, &to);
from--;
to--;
tube[from][to] = 1;
tube[to][from] = 1;
}
if (!solve()) {
printf("NO\n");
} else {
int sz = (int)(ans).size();
printf("%d\n", sz);
for (int i = 0; i < sz; i++) {
printf("%d %d %d\n", ans[i].s + 1, ans[i].t + 1, ans[i].d);
}
}
}
}
int main() { coding(); }
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, f[N], as = 1, a[N];
inline int read() {
register char ch = getchar();
register int x = 0;
register bool y = 1;
while (ch != '-' && (ch > '9' || ch < '0')) ch = getchar();
if (ch == '-') ch = getchar(), y = 0;
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + (ch ^ '0'), ch = getchar();
return y ? x : -x;
}
int main() {
n = read();
while (n--) {
int x = read(), mx = f[x];
for (register int i = 2; i * i <= x; i++)
if (x % i == 0) mx = max(max(mx, f[i]), f[x / i]);
for (register int i = 2; i * i <= x; i++)
if (x % i == 0) f[i] = f[x / i] = mx + 1;
f[x] = mx + 1;
as = max(as, mx + 1);
}
printf("%d\n", as);
return 0;
}
| 3 |
#include<cstdio>
typedef long long ll;
const int N = 1e6 + 50;
ll k, l, r, t, x, y;
bool vis[N];
int main(){
scanf("%lld%lld%lld%lld%lld%lld", &k, &l, &r, &t, &x, &y);
r -= l, k -= l, l = 0;
if(k < 0 || k > r){
puts("No");
return 0;
}
if(x >= y){
if(k + y <= r) k += y;
if(k < x){
puts("No");
}
else{
if(x == y){
puts("Yes");
}
else{
k -= x, --t;
t -= k / (x - y);
printf("%s", t > 0 ? "No" : "Yes");
}
}
return 0;
}
while(1){
if(k + y <= r) k += y;
if(k < x){
//printf("%d %d\n", t, k);
puts("No");
return 0;
}
t -= k / x;
k %= x;
if(t <= 0 || vis[k]){
puts("Yes");
return 0;
}
vis[k] = 1;
}
return 0;
} | 7 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 500005;
struct Node {
long long x, y;
} p[N];
map<long long, map<long long, long long> > H;
map<long long, map<long long, long long> > D;
long long n, m, k, up[N], dn[N], a[N], b[N];
long long r[N], c[N], ordr[N], ordc[N];
long long x[N], y[N], cntr[N], cntc[N];
map<long long, long long> Mapr, Mapc;
vector<long long> vecr[N], vecc[N];
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline void solve() {
Mapr.clear(), Mapc.clear();
for (long long i = 0; i <= n; ++i) ordr[i] = 0, cntr[i] = 0;
assert(true);
for (long long i = 0; i <= m; ++i) ordc[i] = 0, cntc[i] = 0;
assert(true);
for (long long i = 0; i <= max(n, m); ++i) up[i] = dn[i] = 0;
assert(true);
for (long long i = 0; i < n; ++i) vecc[i].clear();
for (long long i = 0; i < m; ++i) vecr[i].clear();
assert(true);
for (long long i = 1; i <= n; ++i) r[i] = read(), ordr[r[i]] = i;
for (long long i = 1; i <= m; ++i) c[i] = read(), ordc[c[i]] = i;
assert(true);
for (long long i = 1; i <= n; ++i) Mapr[r[i]] = i;
for (long long i = 1; i <= m; ++i) Mapc[c[i]] = i;
assert(true);
for (long long i = 1; i <= k; ++i) {
x[i] = read(), y[i] = read();
if ((ordr[x[i]]) && (ordc[y[i]])) continue;
if (ordr[x[i]]) {
up[i] = (*(Mapc.lower_bound(y[i]))).second, dn[i] = up[i] - 1;
++cntc[dn[i]];
vecc[dn[i]].push_back(x[i]);
} else {
up[i] = (*(Mapr.lower_bound(x[i]))).second, dn[i] = up[i] - 1;
++cntr[dn[i]];
vecr[dn[i]].push_back(y[i]);
}
}
assert(true);
H.clear(), D.clear();
for (long long i = 1; i <= n; ++i) a[i] = r[i];
assert(true);
for (long long i = 1; i <= m; ++i) b[i] = c[i];
assert(true);
for (long long i = 1; i <= k; ++i) p[i] = (Node){x[i], y[i]};
assert(true);
long long res = 0;
for (long long i = 1; i <= k; ++i) {
long long x = p[i].x, y = p[i].y;
long long Up = lower_bound(a + 1, a + n + 1, x) - a;
long long Rig = lower_bound(b + 1, b + m + 1, y) - b;
if (x == a[Up] && b[Rig] == y) continue;
if (x == a[Up])
++H[Rig][Up];
else if (y == b[Rig])
++D[Up][Rig];
}
assert(true);
long long ans = 0;
assert(true);
assert(true);
for (auto x : H) {
long long sum = 0;
for (auto y : x.second) sum += y.second;
for (auto y : x.second) res += y.second * (sum - y.second);
}
assert(true);
for (long long i = 0; i < m; ++i) {
sort(vecc[i].begin(), vecc[i].end());
long long cnt = 1;
for (long long j = 1; j < vecc[i].size(); ++j) {
if (vecc[i][j] == vecc[i][j - 1])
++cnt;
else {
ans = ans + (cntc[i] - cnt) * cnt;
cnt = 1;
}
}
ans = ans + (cntc[i] - cnt) * cnt;
}
assert(true);
for (auto x : D) {
long long sum = 0;
for (auto y : x.second) sum += y.second;
for (auto y : x.second) res += y.second * (sum - y.second);
}
printf("%lld\n", res / 2);
}
signed main() {
long long T = read();
while (T--) {
n = read(), m = read(), k = read();
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1009;
int n, a[N], bin[N], c[N], ansx[N], ansy[N], cnt;
void Assert(int flag) {
if (!flag) {
puts("NO");
exit(0);
}
}
void init() {
scanf("%d", &n);
for (int i = 1, x, y; i < n; i++) {
scanf("%d %d", &x, &y);
if (x < y) swap(x, y);
Assert(y != n && x == n);
a[i] = y, bin[a[i]]++;
}
}
void add(int x, int y) { cnt++, ansx[cnt] = x, ansy[cnt] = y; }
void work() {
for (int i = 1; i < n; i++)
if (!bin[i]) c[++*c] = i;
sort(a + 1, a + n);
int now = 0;
for (int i = 1; i < n; i++) {
if (!bin[a[i]]) continue;
if (bin[a[i]] == 1)
add(n, a[i]);
else {
add(n, c[++now]);
for (int j = 1; j < bin[a[i]] - 1; j++) add(c[now], c[now + 1]), now++;
add(c[now], a[i]);
Assert(c[now] < a[i]);
}
i += bin[a[i]] - 1;
}
printf("YES\n");
for (int i = 1; i <= cnt; i++) printf("%d %d\n", ansx[i], ansy[i]);
}
int main() {
init();
work();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int getint() {
int _x = 0, _tmp = 1;
char _tc = getchar();
while ((_tc < '0' || _tc > '9') && _tc != '-') _tc = getchar();
if (_tc == '-') _tc = getchar(), _tmp = -1;
while (_tc >= '0' && _tc <= '9') _x *= 10, _x += (_tc - '0'), _tc = getchar();
return _x * _tmp;
}
bool equal(double _x, double _y) { return _x > _y - 1e-7 && _x < _y + 1e-7; }
int __ = 1, cs;
char c[500010];
int len;
double ans, dp[500010], cnt[500010];
double BIT[500010];
int lb(int x) { return x & (-x); }
void insert(int no, double dlt) {
while (no <= len) {
BIT[no] += dlt;
no += lb(no);
}
}
double query(int no) {
double sum = 0;
while (no) {
sum += BIT[no];
no -= lb(no);
}
return sum;
}
bool vowel(char ctmp) {
return ctmp == 'I' || ctmp == 'E' || ctmp == 'A' || ctmp == 'O' ||
ctmp == 'U' || ctmp == 'Y';
}
void build() {}
void init() {
scanf("%s", c + 1);
len = strlen(c + 1);
}
void solve() {
for (int i = 1; i <= len; i++)
if (vowel(c[i])) {
int lft = i, rgt = len - i + 1;
int tmp = min(lft, rgt);
ans += (double)tmp;
int low = tmp + 1, high = len + 1 - tmp;
if (low <= high) {
insert(low, tmp);
insert(high + 1, -tmp);
}
int st = len + 2 - tmp;
dp[st] += tmp - 1.0;
cnt[st] += 1.0;
}
for (int i = 1; i <= len; i++) {
double tsum = query(i);
ans += tsum / (double)i;
}
for (int i = 1; i <= len; i++) {
ans += dp[i] / (double)i;
dp[i + 1] += dp[i] - cnt[i];
cnt[i + 1] += cnt[i];
}
printf("%.20f\n", ans);
}
int main() {
build();
while (__--) {
init();
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.1415926535897923846;
const long long int MOD = 1000000007;
const long long int N = 998244353;
long long int power(long long int x, long long int n) {
long long int res = 1;
while (n > 0) {
if (n & 1) res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
long long int modinverse(long long int a) { return power(a, MOD - 2); }
void solve() {
long long int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
cout << (((y2 - y1) / 2 + 1) * (x2 - x1 + 1) - (x2 - x1) / 2) << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int test = 1;
while (test--) {
solve();
}
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC
<< "ms\n";
}
| 5 |
/*
Creater :
ANSHUMAN MISHRA
"All Losses In this World Are Due To Lack Of Ability.
If You Want To Curse Someone , Curse Your Own Weakness"
*/
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair<int,int>
#define yes cout<<"YES\n"
#define no cout<<"NO\n"
const int N=1e5+5;
int cnt[26][N];
signed main(){
ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("in.txt","r",stdin);
#endif
int t=1;cin>>t;
while(t--){
int n,m;
cin>>n>>m;
for (int i=0;i<m;++i) for (int j=0;j<26;++j) cnt[j][i]=0;
string s;
for (int i=0;i<n;++i){
cin>>s;
for (int j=0;j<m;++j)
cnt[s[j]-'a'][j]++;
}
/*
for (int i=0;i<m;++i){
for (int j=0;j<26;++j){
/*
if (cnt[j][i]==1){
ans+= (j+'a');
break;
}
cout<<cnt[j][i]<<' ';
}
cout<<'\n';
}*/
for (int i=0;i<n-1;++i){
cin>>s;
for (int j=0;j<m;++j)
cnt[s[j]-'a'][j]--;
}
string ans="";
for (int i=0;i<m;++i){
for (int j=0;j<26;++j){
if (cnt[j][i]==1){
ans+= (j+'a');
break;
}
//cout<<cnt[j][i]<<' ';
}
//cout<<'\n';
}
cout<<ans<<endl;
cout.flush();
}
return 0;
} | 2 |
#include <bits/stdc++.h>
using namespace std;
struct disjoint_sets {
vector<int> data;
disjoint_sets() = default;
explicit disjoint_sets(size_t n) : data(n, -1) {}
bool is_root(int i) { return data[i] < 0; }
int find_root(int i) {
return is_root(i) ? i : (data[i] = find_root(data[i]));
}
int set_size(int i) { return -data[find_root(i)]; }
int union_sets(int i, int j) {
i = find_root(i);
j = find_root(j);
if (i != j) {
if (set_size(i) < set_size(j)) swap(i, j);
data[i] += data[j];
data[j] = i;
}
return i;
}
bool is_same(int i, int j) { return find_root(i) == find_root(j); }
};
struct wrapped_disjoint_sets {
vector<int> a_data;
stack<pair<int, int> > modified;
explicit wrapped_disjoint_sets(disjoint_sets const& a_original)
: a_data(a_original.data) {}
void reset() {
while (not modified.empty()) {
int i, value;
tie(i, value) = modified.top();
modified.pop();
a_data[i] = value;
}
}
int data(int i) { return a_data[i]; }
void data_set(int i, int j) {
if (data(i) != j) {
modified.emplace(i, a_data[i]);
a_data[i] = j;
}
}
bool is_root(int i) { return data(i) < 0; }
int find_root(int i) { return is_root(i) ? i : find_root(data(i)); }
int set_size(int i) { return -data(find_root(i)); }
int union_sets(int i, int j) {
i = find_root(i);
j = find_root(j);
if (i != j) {
if (set_size(i) < set_size(j)) swap(i, j);
data_set(i, data(i) + data(j));
data_set(j, i);
}
return i;
}
bool is_same(int i, int j) { return find_root(i) == find_root(j); }
};
int main() {
int n, k, m;
scanf("%d%d%d", &n, &k, &m);
disjoint_sets splitted_ds(n);
constexpr int bucket_width = 512;
int bucket_count = ceil(n / (double)bucket_width);
vector<vector<int> > edges(n);
for (int i = 0; (i) < int(m); ++(i)) {
int u, v;
scanf("%d%d", &u, &v);
--u;
--v;
if (u > v) swap(u, v);
edges[u].push_back(v);
int uj = u / bucket_width;
int vj = v / bucket_width;
if (uj == vj) {
splitted_ds.union_sets(u, v);
}
}
vector<int> cnts(bucket_count);
for (int i = 0; (i) < int(n); ++(i)) {
splitted_ds.find_root(i);
if (splitted_ds.is_root(i)) {
int j = i / bucket_width;
++cnts[j];
}
}
wrapped_disjoint_sets wrapped_ds(splitted_ds);
int q;
scanf("%d", &q);
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
--l;
int lj = l / bucket_width;
int rj = r / bucket_width;
wrapped_ds.reset();
int cnt = 0;
{
int i = l;
for (; i < r and i / bucket_width == lj; ++i) {
wrapped_ds.data_set(i, -1);
++cnt;
}
for (; i / bucket_width < rj; i += bucket_width) {
cnt += cnts[i / bucket_width];
}
for (; i < r; ++i) {
wrapped_ds.data_set(i, -1);
++cnt;
}
}
{
int i = l;
for (; i < r and i / bucket_width == lj; ++i) {
for (int j : edges[i])
if (j < r) {
if (not wrapped_ds.is_same(i, j)) {
wrapped_ds.union_sets(i, j);
--cnt;
}
}
}
for (; i / bucket_width < rj; i += bucket_width) {
for (int di = bucket_width - k; di < bucket_width; ++di) {
for (int j : edges[i + di])
if (j < r) {
if (not wrapped_ds.is_same(i + di, j)) {
wrapped_ds.union_sets(i + di, j);
--cnt;
}
}
}
}
for (; i < r; ++i) {
for (int j : edges[i])
if (j < r) {
if (not wrapped_ds.is_same(i, j)) {
wrapped_ds.union_sets(i, j);
--cnt;
}
}
}
}
printf("%d\n", cnt);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int N, M, K;
int inroom[20005][15];
int sent[20005][15];
int cnt[15];
int main() {
cin >> N >> M >> K;
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
cin >> inroom[i][j];
sent[i][j] = 0;
}
}
for (int i = 0; i < M; i++) cnt[i] = 0;
for (int i = 0; i < K; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
cnt[b]++;
sent[a][b]++;
}
for (int i = 0; i < N; i++) {
int ans = 0;
for (int j = 0; j < M; j++) {
ans += inroom[i][j] * cnt[j] - sent[i][j];
}
if (i != 0) cout << " ";
cout << ans;
}
cout << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<pair<int, int> > v;
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int a;
scanf("%d", &a);
v.push_back(make_pair(a, i));
}
for (int i = 0; i < n; ++i) {
int b;
scanf("%d", &b);
v.push_back(make_pair(b, i));
}
int m;
scanf("%d", &m);
sort(v.begin(), v.end());
int ans = 1;
for (int i = 0; i < (int)v.size(); ++i) {
int j = i;
while (j < 2 * n && v[j].first == v[i].first) {
++j;
}
int len = j - i;
for (int k = i; k < j; ++k) {
if (k + 1 < j && v[k + 1].second == v[k].second) {
ans = (long long)len * (len - 1) / 2 % m * ans % m;
++k;
len -= 2;
} else {
ans = (long long)ans * len % m;
len--;
}
}
i = j - 1;
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1e5 + 5;
char a[MAX_N];
int main() {
int N;
cin >> N;
scanf("%s", a + 1);
int cnt = 0;
for (int i = 1; i <= N; i++) {
if (a[i] == 'S' && a[i] >= 2 && a[i - 1] == 'G') {
cnt++;
}
}
if (a[N] == 'G') cnt++;
int len = 0, prelen = (cnt >= 2), ans = 0;
for (int i = 1; i <= N; i++) {
if (a[i] == 'G') {
len++;
ans = max(ans, len + prelen);
}
if (a[i] == 'S') {
if (2 <= i && i <= N - 1 && a[i - 1] == 'G' && a[i + 1] == 'G') {
if (cnt == 2) {
prelen = len;
} else if (cnt >= 3) {
prelen = len + 1;
}
} else {
prelen = (cnt >= 2);
}
len = 0;
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MX = (1 << 7) + 100, MD = 1e9 + 7;
long long a[MX], tmp, w[10];
struct mat {
long long val[MX][MX], n, m;
mat() { memset(val, 0, sizeof val); }
long long* operator[](long long x) { return val[x]; }
};
mat f[10];
mat operator*(mat A, mat B) {
mat res;
res.n = A.n;
res.m = B.m;
for (int i = 0; i < res.n; i++) {
for (int j = 0; j < res.m; j++) {
tmp = 0;
for (int k = 0; k < A.m; k++) tmp += A[i][k] * B[k][j], tmp %= MD;
res[i][j] = tmp;
}
}
return res;
}
mat Pow(mat A, int x) {
mat res;
res.n = A.n;
res.m = A.m;
for (int i = 0; i < A.n; i++) {
for (int j = 0; j < A.m; j++) {
if (i != j)
res[i][j] = 0;
else
res[i][j] = 1;
}
}
for (; x > 0; x /= 2) {
if (x % 2 == 1) res = res * A;
A = A * A;
}
return res;
}
int main() {
for (int i = 1; i <= 7; i++) cin >> w[i];
for (int i = 1; i <= 7; i++) {
f[i].n = (1 << i);
f[i].m = (1 << i);
for (int j = 0; j < (1 << i); j++) {
for (int k = 0; k < (1 << i); k++) {
for (int g = 0; g < (1 << (i - 1)); g++) {
bool flag = 0;
for (int check = 1; check <= i; check++) {
bool top, bot, left, right;
if (check == 1)
top = 1;
else
top = g & (1 << (check - 2));
if (check == i)
bot = 1;
else
bot = g & (1 << (check - 1));
left = j & (1 << (check - 1));
right = k & (1 << (check - 1));
if (bot && top && left && right) {
flag = 1;
break;
}
}
if (!flag) f[i][j][k]++;
}
}
}
}
mat ans;
ans.n = 2;
ans.m = 1;
ans[1][0] = 1;
for (int i = 1; i <= 7; i++) {
ans = Pow(f[i], w[i]) * ans;
if (i == 7) continue;
for (int j = 0; j < (1 << i); j++) {
ans[j + (1 << i)][0] = ans[j][0];
ans[j][0] = 0;
}
}
cout << ans[(1 << 7) - 1][0];
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 8010, M = 1000010, P = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const int INF = 0xcfcfcfcf;
const double eps = 1e-9, pi = asin(1) * 2;
inline long long read();
inline int ADD(int a, int b) { return a + b >= P ? a + b - P : a + b; }
inline int MINUS(int a, int b) { return a - b < 0 ? a - b + P : a - b; }
inline int sqr(int x) { return x * x; }
inline int dis(int x, int y) { return x * x + y * y; }
int ID[210][210], num = 0;
inline int quickmi(int x, int n) {
int res = 1;
for (; n; n >>= 1) {
if (n & 1) res = 1ll * res * x % P;
x = 1ll * x * x % P;
}
return res;
}
int r, _2r, tot;
int a[N][N];
int p[5], sp = 0;
const int dx[] = {0, 1, 0, -1, 0};
const int dy[] = {0, 0, 1, 0, -1};
inline void gauss(int n) {
for (int i = 1; i <= n; ++i) {
int R = min(n, i + _2r + 1);
for (int j = i; j <= R; ++j) {
if (a[j][i]) {
if (i == j) break;
for (int k = i; k <= R; k++) swap(a[i][k], a[j][k]);
break;
}
}
int inv = quickmi(a[i][i], P - 2);
a[i][n + 1] = (1ll * a[i][n + 1] * (inv)) % P;
for (int j = R; j >= i; --j) a[i][j] = (1ll * a[i][j] * (inv)) % P;
for (int j = i + 1; j <= R; ++j) {
if (!a[j][i]) continue;
a[j][n + 1] = MINUS(a[j][n + 1], 1ll * a[j][i] * a[i][n + 1] % P);
for (int k = R; k >= i; --k)
a[j][k] = MINUS(a[j][k], 1ll * a[j][i] * a[i][k] % P);
}
}
for (int i = n; i; --i) {
int L = max(i - _2r - 1, 1), R = min(n, i + _2r + 1);
for (int j = L; j < i; ++j) {
if (!a[j][i]) continue;
a[j][n + 1] = MINUS(a[j][n + 1], 1ll * a[j][i] * a[i][n + 1] % P);
for (int k = i; k <= R; ++k)
a[j][k] = MINUS(a[j][k], 1ll * a[j][i] * a[i][k] % P);
}
}
}
inline long long read() {
long long s = 0;
bool flag = false;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') flag = true;
for (; '0' <= ch && ch <= '9'; ch = getchar())
s = (s << 3) + (s << 1) + (ch ^ '0');
if (flag) return -s;
return s;
}
int main() {
r = read(), tot = sqr(2 * r + 1), _2r = 2 * r;
for (int i = 1; i <= 4; ++i) sp += (p[i] = read());
int invp = quickmi(sp, P - 2);
for (int i = 1; i <= 4; ++i) p[i] = (1ll * p[i] * (invp)) % P;
for (int x = -r; x <= r; x++)
for (int y = -r; y <= r; y++) {
if (dis(x, y) > r * r) continue;
ID[x + r][y + r] = ++num;
}
for (int x = -r; x <= r; ++x) {
for (int y = -r; y <= r; ++y) {
if (dis(x, y) > r * r) continue;
int idn = (ID[(x) + r][(y) + r]);
a[idn][idn] = P - 1;
for (int i = 1; i <= 4; ++i) {
int xx = x + dx[i], yy = y + dy[i];
if (dis(xx, yy) > r * r) continue;
int id = (ID[(xx) + r][(yy) + r]);
a[idn][id] = p[i];
}
}
}
for (int i = 1; i <= num; i++) a[i][num + 1] = P - 1;
gauss(num);
printf("%d\n", a[(ID[(0) + r][(0) + r])][num + 1]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long a[18];
long long cal(long long n) {
if (n == 0) return 0;
int i;
for (i = 1; i <= 16; i++)
if (a[i] > n) break;
long long ta = n / a[i - 1] * (i - 1) + cal(n % a[i - 1]);
if (a[i] - n >= n) return ta;
long long tb = i + cal(a[i] - n);
return (ta > tb ? tb : ta);
}
int main() {
long long n;
cin >> n;
for (int i = 1; i <= 16; i++) a[i] = a[i - 1] * 10 + 1;
cout << cal(n) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
int main() {
ios_base::sync_with_stdio(0);
long long r, h;
cin >> r >> h;
r *= 2;
h *= 2;
long long res = (h + r / 2) / r;
long long y = res * r - r / 2;
long long L = h + r - y - r / 2;
long long R = r * r * 3 / 4;
res *= 2;
if (L >= 0 && L * L >= R) res++;
cout << res;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int r, g, b, w, t;
int check(int a, int b, int c, int d) {
int ans;
ans = a % 2;
ans += b % 2;
ans += c % 2;
ans += d % 2;
return ans;
}
int main() {
cin >> t;
while (t--) {
cin >> r >> g >> b >> w;
if (check(r, g, b, w) <= 1) {
cout << "Yes" << endl;
} else if (r > 0 && g > 0 && b > 0 &&
check(r - 1, g - 1, b - 1, w + 1) <= 1) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long a[1505][1505];
long long dp[1505][1505];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= m; j++) cin >> a[i][j];
for (long long i = 1; i <= m; i++) dp[1][i] = dp[1][i - 1] + a[1][i];
for (long long i = 2; i <= n; i++) {
if (i & 1) {
long long mx = dp[i - 1][1];
long long cur = a[i][1];
for (long long j = 2; j <= m; j++) {
cur += a[i][j];
dp[i][j] = cur + mx;
mx = max(mx, dp[i - 1][j]);
}
} else {
long long mx = dp[i - 1][m];
long long cur = 0;
for (long long j = 1; j <= m; j++) cur += a[i][j];
for (long long j = m - 1; j >= 1; j--) {
cur -= a[i][j + 1];
dp[i][j] = cur + mx;
mx = max(mx, dp[i - 1][j]);
}
}
}
long long ans = -1e18;
if (n & 1) {
for (long long i = 2; i <= m; i++) ans = max(ans, dp[n][i]);
} else {
for (long long i = 1; i < m; i++) ans = max(ans, dp[n][i]);
}
cout << ans << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
multiset<int> s;
multiset<int>::iterator it;
int n, i, x;
int a[505];
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int main() {
s.clear();
scanf("%d", &n);
for (i = 1; i <= n * n; i++) scanf("%d", &x), s.insert(x);
for (i = 1; i <= n; i++) {
it = s.end();
it--;
x = *it;
s.erase(it);
a[i] = x;
printf("%d ", x);
for (int j = 1; j < i; j++) {
int g = gcd(a[j], x);
it = s.find(g);
s.erase(it);
it = s.find(g);
s.erase(it);
}
}
}
| 4 |
#include<bits/stdc++.h>
#define ll long long int
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll tc,n,c,ans,remain,days,x;
cin>>tc;
while(tc--){
cin>>n>>c;
vector<ll>a(n),b(n-1);
for(int i=0;i<n;i++){
cin>>a[i];
}
for(int i=0;i<n-1;i++){
cin>>b[i];
}
ans = INT_MAX;
remain = 0;
days = 0;
for(int i=0;i<n;i++){
ans = min( ans , max( 0ll , days + ( c - remain + a[i] - 1 )/a[i] ) );
if(i==n-1){
break;
}
x = ( b[i] - remain + a[i] - 1 ) / a[i];
remain += x*a[i] - b[i];
days += x + 1;
}
cout<<ans<<endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int max = 0;
int count = 0;
char c;
cin >> noskipws >> c;
for (int i = 0; i < n; i++) {
cin >> noskipws >> c;
if (c >= 65 && c <= 90)
count++;
else if (c == 32)
count = 0;
if (count > max) max = count;
}
cout << max;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void dbg() { std::cout << " #\n"; }
template <typename T, typename... Args>
void dbg(T a, Args... args) {
std::cout << a << ' ';
dbg(args...);
}
const int maxn = 1e6 + 10;
const int MAX = 1000;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
int n, m;
vector<int> a[maxn];
vector<pair<int, int> > ans;
int ru[maxn];
int maxx;
void dfs(int now, int fa, int pastpoint) {
int remain = a[now].size() - 1;
int nextpoint = pastpoint;
for (auto to : a[now])
if (to != fa) {
if (nextpoint == maxx) {
nextpoint = pastpoint - remain - 1;
ans.push_back(make_pair(now, nextpoint));
}
remain--;
nextpoint++;
ans.push_back(make_pair(to, nextpoint));
dfs(to, now, nextpoint);
}
if (nextpoint + 1 != pastpoint) {
ans.push_back(make_pair(now, pastpoint - 1));
nextpoint = pastpoint - 1;
}
if (now != 1) ans.push_back(make_pair(fa, nextpoint + 1));
}
void solve() {
cin >> n;
for (int i = (1); i <= (n - 1); ++i) {
int x, y;
scanf("%d%d", &x, &y);
a[x].push_back(y);
a[y].push_back(x);
ru[x]++;
ru[y]++;
}
maxx = *max_element(ru + 1, ru + 1 + n);
ans.push_back(make_pair(1, 0));
dfs(1, -1, 0);
int len = ans.size() - 1;
printf("%d\n", len);
for (int i = (0); i <= (len - 1); ++i) {
printf("%d %d\n", ans[i].first, ans[i].second);
}
}
signed main() {
int T = 1;
while (T--) {
solve();
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long int sum[700];
long long int a[700][700];
long long int b[700], n;
void floyd() {
for (int k = 1; k < n + 1; k++) {
for (int i = 1; i < n + 1; i++)
for (int j = 1; j < n + 1; j++)
a[i][j] = min(a[i][j], a[i][b[k]] + a[b[k]][j]);
for (int i = 1; i < k + 1; i++)
for (int j = 1; j < k + 1; j++) sum[k] += a[b[i]][b[j]];
}
for (int i = n; i >= 1; i--) cout << sum[i] << " ";
cout << endl;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) a[i][j] = 1e9;
a[i][i] = 0, b[i] = 0, sum[i] = 0;
}
for (int i = 1; i < n + 1; i++)
for (int j = 1; j < n + 1; j++) cin >> a[i][j];
int t;
for (int i = 1; i < n + 1; i++) cin >> t, b[n - i + 1] = t;
floyd();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int ans[100005];
int main() {
int n, k;
cin >> n >> k;
long long nn = (n - 1ll * k * (k + 1) / 2);
if (nn < 0) {
cout << "NO" << endl;
exit(0);
}
int x = 1 + nn / k;
if (x == 1 && nn % k == k - 1 && (k == 2 || k == 3)) {
cout << "NO" << endl;
exit(0);
}
if (x == 1 && nn % k == k - 1 && k > 3) {
ans[k]++;
nn--;
}
for (int i = 1; i <= k; i++) {
ans[i] += i + nn / k;
}
for (int i = k; i >= k - nn % k + 1; i--) {
ans[i]++;
}
cout << "YES" << endl;
for (int i = 1; i <= k; i++) {
cout << ans[i] << " ";
}
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int todx[] = {-2, -2, -1, -1, 1, 1, 2, 2};
const int tody[] = {-1, 1, -2, 2, -2, 2, -1, 1};
bool sortbysec(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.second < b.second);
}
void func(void) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
void printStack(stack<string> s) {
if (s.empty()) return;
string x = s.top();
s.pop();
printStack(s);
cout << x;
s.push(x);
}
long long binaryexp(long long n, long long p) {
if (p == 0) return 1;
if (p % 2 == 0)
return binaryexp((n % 1000000007) * (n % 1000000007), p / 2);
else
return ((n % 1000000007) *
binaryexp(((n % 1000000007) * (n % 1000000007)) % 1000000007,
(p - 1) / 2) %
1000000007);
}
vector<long long> spf(10000001, 0);
void siv() {
spf[1] = 1;
for (long long i = 2; i < 10000001; i++) spf[i] = i;
for (long long i = 4; i < 10000001; i += 2) {
spf[i] = 2;
}
for (long long i = 3; i * i < 10000001; i++) {
if (spf[i] == i) {
for (long long j = i * i; j < 10000001; j += i) {
if (spf[j] == j) {
spf[j] = i;
}
}
}
}
}
int main() {
string n;
long long k;
cin >> n >> k;
long long ans = 0;
long long in2 = binaryexp(2, (k)*n.size());
long long in3 = binaryexp(2, n.size());
in3 = ((1 % 1000000007 - in3 % 1000000007) + 1000000007) % 1000000007;
in3 = binaryexp(in3, 1000000007 - 2);
in2 = ((1 % 1000000007 - in2 % 1000000007) + 1000000007) % 1000000007;
in2 = (in2 * in3) % 1000000007;
for (int i = 0; i < n.size(); i++) {
if (n[i] == '0' or n[i] == '5') {
long long in = binaryexp(2, i);
in = in % 1000000007 * in2 % 1000000007;
in %= 1000000007;
ans = (ans % 1000000007 + in % 1000000007) % 1000000007;
}
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, s;
getline(cin, a);
getline(cin, s);
sort(s.rbegin(), s.rend());
for (int i = 0, j = 0; i < a.length() && j < s.length(); i++)
if (a[i] < s[j]) a[i] = s[j++];
cout << a;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, x;
cin >> n >> m;
vector<int> v(n), v1;
for (int i = 0; i < n; i++) cin >> v[i];
for (int i = 0; i < m; i++) {
cin >> x;
for (int j = 0; j < n; j++) {
if (x == v[j]) {
v1.push_back(j);
break;
}
}
}
sort(v1.begin(), v1.end());
for (int i = 0; i < v1.size(); i++) {
cout << v[v1[i]] << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <int n, class... T>
typename enable_if<(n >= sizeof...(T))>::type _ot(ostream &,
tuple<T...> const &) {}
template <int n, class... T>
typename enable_if<(n < sizeof...(T))>::type _ot(ostream &os,
tuple<T...> const &t) {
os << (n == 0 ? "" : ", ") << get<n>(t);
_ot<n + 1>(os, t);
}
template <class... T>
ostream &operator<<(ostream &o, tuple<T...> const &t) {
o << "(";
_ot<0>(o, t);
o << ")";
return o;
}
template <class T, class U>
ostream &operator<<(ostream &o, pair<T, U> const &p) {
o << "(" << p.first << ", " << p.second << ")";
return o;
}
template <class T>
ostream &operator<<(ostream &o, const stack<T> &a) {
o << "{";
for (auto tmp = a; tmp.size(); tmp.pop())
o << (a.size() == tmp.size() ? "" : ", ") << tmp.top();
o << "}";
return o;
}
template <class T,
class = typename iterator_traits<typename T::iterator>::value_type,
class = typename enable_if<!is_same<T, string>::value>::type>
ostream &operator<<(ostream &o, const T &a) {
for (auto ite = a.begin(); ite != a.end(); ++ite)
o << (ite == a.begin() ? "" : " ") << *ite;
return o;
}
int main() {
std::ios::sync_with_stdio(false), std::cin.tie(0);
int n;
string s;
cin >> n;
cin >> s;
map<char, int> mp;
for (char c : s) mp[c]++;
string ans;
priority_queue<pair<int, char>> v;
for (auto p : mp) {
ans += string(p.second, p.first);
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
void QS(int l, int r, long* vecx, long* vecc);
int main() {
using namespace std;
int n, i, j;
long x[3000], c[3000];
long long d[3000], min = LLONG_MAX;
cin >> n;
for (i = 0; i < n; ++i) cin >> x[i] >> c[i];
QS(0, n - 1, x, c);
for (int t = c[0], i = 0; i < n; ++i) d[i] = t;
for (j = 1; j < n; ++j) {
min = LLONG_MAX;
for (i = 0; i < j; ++i) {
d[i] += x[j] - x[i];
if (d[i] < min) min = d[i];
}
d[j] += c[j];
if (d[j] < min) min = d[j];
for (i = j + 1; i < n; ++i) d[i] = min;
}
if (n == 1)
cout << c[0] << endl;
else
cout << min << endl;
return 0;
}
void QS(int l, int r, long* vecx, long* vecc) {
int i, j;
long tmp, m;
m = vecx[l + rand() % (r - l + 1)];
i = l;
j = r;
do {
while (vecx[i] < m) ++i;
while (vecx[j] > m) --j;
if (i <= j) {
tmp = vecx[i];
vecx[i] = vecx[j];
vecx[j] = tmp;
tmp = vecc[i];
vecc[i] = vecc[j];
vecc[j] = tmp;
++i;
--j;
}
} while (i <= j);
if (i < r) QS(i, r, vecx, vecc);
if (j > l) QS(l, j, vecx, vecc);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 100005;
int a[mx], pos[mx];
long long cost[mx];
bool cmp(int i, int j) { return a[i] < a[j]; }
int main() {
int i, j, k, n, A, cf, cm;
long long m;
while (scanf("%d", &n) == 1) {
scanf("%d%d%d%I64d", &A, &cf, &cm, &m);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
pos[i] = i;
}
sort(pos, pos + n, cmp);
cost[0] = 0;
for (i = 1; i < n; i++) {
cost[i] = cost[i - 1] + (a[pos[i]] - a[pos[i - 1]]) * 1LL * i;
}
long long mn = -1;
long long total = 0, ans = -1;
int cnt = 0;
pos[n] = n;
a[n] = A;
int id;
for (j = n; j >= 0; j--) {
i = pos[j];
if (A - a[i] > m) break;
m -= A - a[i];
long long tmp = cf * 1LL * (n - j);
int p = (int)(lower_bound(cost, cost + j, m + 1) - cost);
long long t = -1;
if (p > 0) {
long long val = a[pos[p - 1]] + (m - cost[p - 1]) / p;
if (val > A) val = A;
t = val;
tmp += val * 1LL * cm;
} else if (j == 0) {
tmp += A * 1LL * cm;
t = A;
}
if (ans < tmp) {
ans = tmp;
id = j;
mn = t;
}
}
cout << ans << endl;
for (i = 0; i < id; i++) {
if (a[pos[i]] < mn) a[pos[i]] = mn;
}
for (i = id; i < n; i++) a[pos[i]] = A;
for (i = 0; i < n; i++) printf("%d ", a[i]);
puts("");
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1001;
const int mod = 1e9 + 7;
long double ans, dp[N][N], all, cnk[N][N];
int n, a[N], m, h;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> h;
for (int i = 0; i <= 1000; i++) {
cnk[i][i] = cnk[i][0] = 1;
for (int j = 1; j < i; j++) cnk[i][j] = cnk[i - 1][j] + cnk[i - 1][j - 1];
}
int sum = 0;
for (int i = 1; i <= m; i++) {
cin >> a[i];
sum += a[i];
}
if (sum < n) {
cout << -1;
return 0;
}
n--;
swap(a[h], a[m]);
a[m]--;
dp[0][0] = 1;
for (int i = 1; i <= m; i++) {
for (int j = 0; j <= n; j++) {
for (int x = 0; x <= a[i]; x++) {
if (j + x > n) break;
dp[i][j + x] += cnk[a[i]][x] * dp[i - 1][j];
}
}
}
all = dp[m][n];
memset(dp, 0, sizeof dp);
dp[0][0] = 1;
m--;
for (int i = 1; i <= m; i++) {
for (int j = 0; j <= n; j++) {
for (int x = 0; x <= a[i]; x++) {
if (j + x > n) break;
dp[i][j + x] += cnk[a[i]][x] * dp[i - 1][j];
}
}
}
for (int i = 1; i <= a[m + 1]; i++)
if (n - i >= 0) ans += cnk[a[m + 1]][i] * dp[m][n - i];
ans /= all;
cout << fixed << setprecision(10) << ans;
return 0;
}
| 4 |
// #pragma GCC target ("avx2")
#pragma GCC optimization ("O3")
// #pragma GCC optimization ("unroll-loops")
#include<bits/stdc++.h>
using namespace std;
#define crap ios::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
typedef long long int ll;
typedef unsigned long long ull;
#define int ll
typedef std::vector<int> vi;
typedef std::vector<ll> vll;
typedef std::vector<vi > vvi;
typedef std::vector<vll > vvll;
typedef std::pair<int,int> ii;
typedef std::pair<int, ii > iii;
typedef std::pair< ll, ll > lp;
typedef std::vector<ii> vii;
typedef std::vector<vii > vvii;
#define pb push_back
#define PB pop_back
#define pf push_front
#define PF pop_front
#define mp make_pair
#define ub(a,b) upper_bound(all(a),b)
#define lb(a,b) lower_bound(all(a),b)
#define bs(a,b) binary_search(all(a),b)
#define mem(a,b) memset(a,b,sizeof(a))
#define in(a,n) F(i,0,n-1)cin>>a[i]
#define in1(a,n) F(i,1,n)cin>>a[i]
#define out(a,n) F(i,0,n-1)cout<<a[i]<<" ";cout<<endl
#define ff first
#define ss second
#define F(i,a,b) for (ll i=a;i<=b;i++)
#define RF(i,a,b) for(ll i=a;i>=b;i--)
#define rep(i,n) F(i,0,n-1)
#define clr(a) (a).clear()
#define rz resize
#define sqr(a) ((a) * (a))
#define sz(a) int((a).size())
#define len(a) int((a).length())
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin() ,(a).rend()
#define endl '\n'
#define flush cout.flush()
int mod;
// #define mod (int)1e9+123
// #define mod LLONG_MAX
// #define mod 998244353
// ################################## Debugging statements ##################################
string to_string(string s) {return '"' + s + '"';}
string to_string(const char* s) {return to_string((string) s);}
string to_string(bool b) {return (b ? "true" : "false");}
template <typename A, typename B>
string to_string(pair<A, B> p) {return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";}
template <typename A>
string to_string(A v) {bool first = true; string res = "{";for (const auto &x : v) {if (!first) { res += ", "; }first = false; res += to_string(x);}res += "}";return res;}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {cerr << " " << to_string(H);debug_out(T...);}
#define TRACE // comment this out for submission
#ifdef TRACE
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...)
#endif
// ###########################################################################################
inline int add(int a, int b){a += b; if(a >= mod)a -= mod; return a;}
inline int sub(int a, int b){a -= b; if(a < 0)a += mod; return a;}
inline int mul(int a, int b){return (int)((long long) a * b %mod);}
inline int poww(int a, int b){int res = 1; while(b > 0){ if(b & 1)res = mul(res, a); a = mul(a, a);b /= 2;} return res;}
inline int inv(int a){return poww(a, mod - 2);}
int gcd(int a, int b, int &x, int &y){if(a == 0){x = 0, y = 1; return b;} int x1, y1; int d = gcd(b%a, a, x1, y1); x = y1 - (b/a) * x1; y = x1; return d;}
// #################################### matrix operations ####################################
inline vvi matmul(vvi A, vvi B) {int p = A.size(), q = A[0].size();int r = B.size(), s = B[0].size();assert(q == r);vvi C(p, vi(s, 0LL));
rep(i, p){rep(j, s){rep(k, q){
// C[i][j] += A[i][k] * B[k][j];
C[i][j] = add(C[i][j], mul(A[i][k], B[k][j]));
}}}return C;}
inline vvi matpow(vvi A, int n){int p = A.size(), q = A[0].size();assert(p == q);vvi res(p, vi(p, 0));rep(i, p)res[i][i] = 1;while (n){if (n&1)res = matmul(res, A);A = matmul(A, A);n >>= 1;}return res;}
// ###########################################################################################
// #################################### Combinatorics template ###############################
struct factorial{
int N;int *fac;int *ifac; int *der; int MOD;
factorial(int n, int m = 998244353){N = n;MOD = m;fac = new int[1+N];ifac = new int[1+N];der= new int[N+1];pre_calc(); calc_derangement();}
int add(int a, int b){a += b; if(a >= MOD)a -= MOD; return a;}
int subtract(int a, int b){a -= b; if(a < 0)a += MOD; return a;}
int multiply(int a, int b){return (int)((long long) a * b %MOD);}
int binpow(int a, int b){int res = 1; while(b > 0){ if(b & 1)res = multiply(res, a); a = multiply(a, a);b /= 2;} return res;}
int inverse(int a){return binpow(a, MOD - 2);}
void pre_calc(){fac[0] = ifac[0] = 1;for (int i = 1 ; i <= N ; i++){fac[i] = multiply(fac[i-1], i);ifac[i] = multiply(ifac[i-1], inverse(i));}}
int ncr(int n , int r){return multiply(fac[n], multiply(ifac[r], ifac[n-r]));}
void calc_derangement(){
der[1] = 0;der[2] = 1;
for (int i = 3; i <= N; i++){
der[i] = multiply(i-1, add(der[i-1], der[i-2]));
}
}
int derangement(int n){
if (n == 1) return 1;
return der[n];
}
};
vi factors_n(int n){std::vector<int> fac;for (int i = 1; i * i <= n ; i++){if (n % i == 0){fac.push_back(i);if (i * i != n){fac.push_back(n/i);}}}return fac;}
// ###########################################################################################
// ##################################### Fenwick Tree template ###############################
struct fenwick_tree{
int *bit;int n;
fenwick_tree(){this->n = 200005;this->bit = new int[200005+1]; init_bit();}
fenwick_tree(int n){this->n = n;this->bit = new int[n+1]; init_bit();}
void init_bit(){for (int i=0; i <= this->n; i++)this->bit[i]=0;}
void add(int i, int v){for (; i<=this->n; i+= i&-i){this->bit[i] = (this->bit[i] + v);}}
int get(int i){int s = 0;for (; i; i -= i&-i){s = (this->bit[i] + s);}return s;}
};
struct suffix_fenwick_tree{
int *bit;int n;
suffix_fenwick_tree(){this->n = 200005;this->bit = new int[200005+1]; init_bit();}
suffix_fenwick_tree(int n){this->n = n;this->bit = new int[n+1]; init_bit();}
void init_bit(){for (int i=0; i <= this->n; i++)this->bit[i]=0;}
void add(int i, int v){for (; i; i-= i&-i){this->bit[i] = (this->bit[i] + v);}}
int get(int i){int s = 0;for (; i <= this->n; i += i&-i){s = (this->bit[i] + s);}return s;}
};
// ###########################################################################################
// ######################################## Policy-based DS ##################################
// #include<ext/pb_ds/assoc_container.hpp>
// using namespace __gnu_pbds;
// template<class key, class value = null_type, class cmp = std::less<key>>
// using ordered_tree = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
// order_of_key (val): returns the no. of values less than val
// find_by_order (k): returns the iterator to kth largest element.(0-based)
// ###########################################################################################
// ######################################## Bit manipulations ##################################
int no_of_ones(int n){return __builtin_popcount(n);}
int setmask(int mask, int i){return mask | (1 << i);}
int unsetmask(int mask, int i){return (mask & !(1 << i));}
// ###########################################################################################
// ###################################### Convex Hull Trick ##################################
// struct Line {
// mutable ll k, m, p;
// bool operator<(const Line& o) const { return k < o.k; }
// bool operator<(ll x) const { return p < x; }
// };
// struct LineContainer : multiset<Line, less<>> {
// // (for doubles, use inf = 1/.0, div(a,b) = a/b)
// const ll inf = LLONG_MAX;
// ll div(ll a, ll b) { // floored division
// return a / b - ((a ^ b) < 0 && a % b); }
// bool isect(iterator x, iterator y) {
// if (y == end()) { x->p = inf; return false; }
// if (x->k == y->k) x->p = x->m > y->m ? inf : -inf;
// else x->p = div(y->m - x->m, x->k - y->k);
// return x->p >= y->p;
// }
// void add(ll k, ll m) { // y = k * x + m
// auto z = insert({k, m, 0}), y = z++, x = y;
// while (isect(y, z)) z = erase(z);
// if (x != begin() && isect(--x, y)) isect(x, y = erase(y));
// while ((y = x) != begin() && (--x)->p >= y->p)
// isect(x, erase(y));
// }
// ll query(ll x) {
// assert(!empty());
// auto l = *lower_bound(x);
// return l.k * x + l.m;
// }
// };
// ###########################################################################################
// ######################################## Disjoint Set ##################################
// struct disjoint_sets{
// int n;
// vector<int> par;
// vector<int> ranks;
// disjoint_sets(int _n):n(_n){
// for (int i = 0; i <= n; i++){
// par.emplace_back(i);
// ranks.emplace_back(1);
// }
// }
// int find_root(int u){// path compression
// return (par[u] == u) ? u : (par[u] = find_root(par[u]));
// }
// void merge_node(int u, int v){
// u = find_root(u), v = find_root(v);
// if (u == v)
// return;
// if (ranks[u] < ranks[v])
// swap(u, v);
// par[v] = u;
// ranks[u] += ranks[v];
// }
// };
// ###########################################################################################
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
// ################################### Template ends here ####################################
void solve(){
int n;
cin >> n;
int a[1+n];
in1(a, n);
fenwick_tree ft(6+n);
F(i, 1, n){
if (a[i] == 0) continue;
int l = max(1ll, i - a[i] + 1), r = i;
ft.add(l, 1);
ft.add(r+1, -1);
}
F(i, 1, n){
int val = 0;
if (ft.get(i) > 0) val = 1;
cout << val << " \n"[i==n];
}
}
void init(){
}
void pre(){
}
signed main(){
crap;
int tt = 1;
cin >> tt;
int t0 = 1;
pre();
while (tt--){
// cout<<"Case "<< t0++ <<": ";
init();
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
unordered_set<char> r;
for (int i = 0; i < k; i++) {
char x;
cin >> x;
r.insert(x);
}
long long cnt = 0;
long long ans = 0;
for (int i = 0; i < s.size(); i++) {
if (r.find(s[i]) != r.end())
cnt++;
else {
ans += cnt * (cnt + 1) / 2;
cnt = 0;
}
}
if (cnt > 0) ans += cnt * (cnt + 1) / 2;
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, sum = 0;
cin >> n;
sum = 2 * (n / 3);
if (n % 3 > 0) {
sum++;
}
cout << sum;
return 0;
}
| 0 |
#include <bits/stdc++.h>
int abs(int xx) { return xx > 0 ? xx : -xx; }
int a, b, c, i, j, t, u, s, d[200023], ans[200023];
bool ch[200023];
std::vector<int> G[200022], H[200022];
struct A {
int how, num;
};
bool operator<(A aa, A bb) { return aa.how < bb.how; }
std::multiset<A> S;
std::multiset<A>::iterator it;
int main() {
scanf("%d%d", &a, &b);
for (i = 1; i <= a; i++) {
scanf("%d", &c);
d[i] = c;
for (j = 0; j < c; j++) {
scanf("%d", &t);
G[i].push_back(t);
if (t < 0)
H[-t].push_back(i);
else
H[t].push_back(i);
}
}
for (i = 1; i <= a; i++) S.insert({d[i], i});
int check, p;
while (!S.empty()) {
it = S.begin();
A s = *it;
S.erase(it);
if (ch[s.num]) continue;
ch[s.num] = 1;
check = 0;
for (i = 0; i < G[s.num].size(); i++) {
if ((G[s.num][i] < 0 && ans[-G[s.num][i]] == -1) ||
(G[s.num][i] > 0 && ans[G[s.num][i]] == 1)) {
break;
} else if ((G[s.num][i] < 0 && ans[-G[s.num][i]] == 1) ||
(G[s.num][i] > 0 && ans[G[s.num][i]] == -1)) {
check++;
}
}
if (i != G[s.num].size()) continue;
if (check == G[s.num].size()) {
printf("NO");
return 0;
}
for (i = 0; i < G[s.num].size(); i++) {
if (ans[abs(G[s.num][i])] == 0) break;
}
p = abs(G[s.num][i]);
ans[p] = G[s.num][i] / p;
d[s.num]--;
for (i = 0; i < H[p].size(); i++) {
if (H[p][i] != s.num) {
d[H[p][i]]--;
S.insert({d[H[p][i]], H[p][i]});
}
}
}
puts("YES");
for (i = 1; i <= b; i++) {
if (ans[i] == 1)
printf("1");
else
printf("0");
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[4];
for (int i = 0; i < 4; i++) cin >> a[i];
sort(a, a + 4);
if (a[0] + a[1] > a[2] || a[2] + a[1] > a[3])
cout << "TRIANGLE" << endl;
else if (a[0] + a[1] == a[2] || a[2] + a[1] == a[3])
cout << "SEGMENT" << endl;
else
cout << "IMPOSSIBLE" << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int x, int y) {
if (y < 0 || y > 0)
return gcd(y, x % y);
else
return x;
}
int main() {
int n;
cin >> n;
int ans = 0;
for (int i = 2; i <= n - 1; i++) {
int x = n;
while (x >= i) {
ans = ans + x % i;
x = x / i;
}
ans = ans + x;
}
cout << ans / gcd(ans, n - 2) << "/" << (n - 2) / gcd(ans, n - 2);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, n, p, q, s = 0;
scanf("%lld", &n);
for (i = 0; i < n; i++) {
scanf("%lld%lld", &p, &q);
if (q - p >= 2) s++;
}
printf("%lld\n", s);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, mn = 0, i, sum = 0, index = 0;
cin >> n >> k;
int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
if (i < k) mn += a[i];
}
sum = mn;
for (i = 1; i <= n - k; i++) {
sum = sum - a[i - 1] + a[i + k - 1];
if (sum < mn) {
mn = sum;
index = i;
}
}
cout << index + 1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, time, ans = 0, i = 1;
cin >> n >> time;
time = 240 - time;
while (time >= 0) {
ans++;
if (ans == n + 1) break;
time = time - 5 * i;
i++;
}
cout << ans - 1 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, ans = 0, a, b;
cin >> n;
ans = 1;
for (int i = sqrt(n); i >= 1; i--) {
if (n % i == 0) {
k = i;
break;
}
}
cout << k << " " << n / k << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int Set(int N, int pos) { return N = N | (1 << pos); }
int reset(int N, int pos) { return N = N & ~(1 << pos); }
bool check(int N, int pos) { return (bool)(N & (1 << pos)); }
void CI(int &_x) { scanf("%d", &_x); }
void CO(int &_x) { cout << _x; }
template <typename T>
void getarray(T a[], int n) {
for (int i = 0; i < n; i++) cin >> a[i];
}
template <typename T>
void printarray(T a[], int n) {
for (int i = 0; i < n - 1; i++) cout << a[i] << " ";
cout << a[n - 1] << endl;
}
const double EPS = 1e-9;
const int INF = 0x7f7f7f7f;
int dr8[8] = {1, -1, 0, 0, 1, -1, -1, 1};
int dc8[8] = {0, 0, -1, 1, 1, 1, -1, -1};
int dr4[4] = {0, 0, 1, -1};
int dc4[4] = {-1, 1, 0, 0};
int kn8r[8] = {1, 2, 2, 1, -1, -2, -2, -1};
int kn8c[8] = {2, 1, -1, -2, -2, -1, 1, 2};
int w, m;
int rec(int num) {
if (num == 1) return 1;
if (num % w == 0) {
return rec(num / w);
} else if ((num - 1) % w == 0) {
return rec((num - 1) / w);
} else if ((num + 1) % w == 0) {
return rec((num + 1) / w);
} else
return 0;
}
int main() {
cin >> w >> m;
int ans = rec(m);
if (ans)
puts("YES");
else
puts("NO");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long comb(long long n, long long m) {
long long r = 1;
for (int i = 1; i <= m; ++i) {
r = r * n-- / i;
}
return r;
}
bool judge(long long n, long long m, long long k) {
long long tot = 0;
for (int i = 0; i <= k; ++i) {
long long c = comb(k, i);
if (c < n) {
n -= c;
tot += i * c;
} else {
tot += i * n;
n = 0;
break;
}
}
return n == 0 && tot <= k * m;
}
long long solve(long long n, long long m) {
if (m > n / 2) m = n / 2;
long long low = 0, high = n - 1, ans;
while (low <= high) {
long long mid = (low + high) / 2;
if (judge(n, m, mid)) {
ans = mid;
high = mid - 1;
} else {
low = mid + 1;
}
}
return ans;
}
int main() {
int re;
cin >> re;
while (re--) {
long long n, m;
cin >> n >> m;
cout << solve(n, m) << endl;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long rec(int x) {
if (x == 1) return 2;
return ((pow(2, x)) + rec(x - 1));
}
int main() {
int n;
long long x;
cin >> n;
x = rec(n);
cout << x << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 5;
struct segtree {
vector<int> tree;
vector<int> lfend;
vector<int> rgend;
int length;
void update(int vertex) {
if (vertex == 0) return;
tree[vertex] = min(tree[2 * vertex], tree[2 * vertex + 1]);
update(vertex / 2);
}
public:
segtree(int _length, int init) {
length = 1;
while (length < _length) {
length *= 2;
}
tree = vector<int>(2 * length, init);
lfend = vector<int>(2 * length);
rgend = vector<int>(2 * length);
for (int i = length; i < 2 * length; i++) {
lfend[i] = i - length;
rgend[i] = i - length;
}
for (int i = length - 1; i > 0; i--) {
lfend[i] = lfend[2 * i];
rgend[i] = rgend[2 * i + 1];
}
}
void set(int idx, int val) {
tree[length + idx] = val;
update((length + idx) / 2);
}
int get(int ql, int qr, int vertex = 1) {
ql = max(ql, lfend[vertex]);
qr = min(qr, rgend[vertex]);
if (ql > qr) return INF;
if (ql == lfend[vertex] && qr == rgend[vertex]) return tree[vertex];
return min(get(ql, qr, 2 * vertex), get(ql, qr, 2 * vertex + 1));
}
};
const int MAX_N = 3e5 + 5;
int arr[MAX_N];
int rangel[MAX_N], ranger[MAX_N];
void solve() {
int length;
cin >> length;
map<int, int> compr;
for (int i = 0; i < length; i++) {
cin >> arr[i];
compr[arr[i]] = 0;
}
int colorc = 0;
for (auto it = compr.begin(); it != compr.end(); it++) {
it->second = colorc;
colorc++;
}
for (int i = 0; i < length; i++) {
arr[i] = compr[arr[i]];
}
for (int i = 0; i < colorc; i++) {
rangel[i] = length + 5;
ranger[i] = -1;
}
for (int i = 0; i < length; i++) {
rangel[arr[i]] = min(rangel[arr[i]], i);
ranger[arr[i]] = max(ranger[arr[i]], i);
}
segtree st(length + 5, INF);
segtree forb(length + 5, INF);
for (int i = colorc - 1; i >= 0; i--) {
int forbi = st.get(0, ranger[i]);
st.set(rangel[i], i);
forb.set(i, forbi);
}
int ans = INF;
for (int i = 0; i < colorc; i++) {
int right_cut = forb.get(i, colorc - 1);
if (right_cut == INF) {
ans = min(ans, i);
} else {
ans = min(ans, i + colorc - right_cut);
}
}
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(false);
int testc;
cin >> testc;
for (int i = 0; i < testc; i++) {
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
const int N = (int)1e5 + 1;
void TimeExecution() {
cout << "\n\n===>> Time Execution: " << clock() / (double)1000 << " sec(s).";
}
inline long long fpow(long long n, long long k) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n;
n = n * n;
}
return r;
}
long long sqr(long long a) { return a * a; }
long long msqr(long long a) { return ((a % MOD) * (a % MOD)) % MOD; }
long long msub(long long a, long long b) { return ((a - b) % MOD + MOD) % MOD; }
long long madd(long long a, long long b) { return (a + b) % MOD; }
long long mmul(long long a, long long b) {
return ((a % MOD) * (b % MOD)) % MOD;
}
int cal(int x, int s) {
int cnt = 0;
int len = (1 << s);
return (x / len + 1) * (len / 2) -
max(0, ((x / len) * len + (len / 2) - 1 - x));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int l, r;
cin >> l >> r;
int ans = INF;
int len = floor(log2(r)) + 1;
while (len) {
int v1 = cal(r, len);
int v2 = cal(l - 1, len);
ans = min(ans, cal(r, len) - cal(l - 1, len));
len--;
}
cout << ans << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string s;
vector<bool> ve(50001, 0);
int main() {
getline(cin, s);
int l = 0, r = 0, g = 0, cnt = 0;
for (int i = 0; i < s.length();) {
if (s[i] == 'b' && s[i + 1] == 'e' && s[i + 2] == 'a' && s[i + 3] == 'r') {
l = i + 1;
r = i + 4;
i += 4;
for (int k = 1; k <= l; ++k) {
g = r;
while (g <= s.length() && !ve[k]) {
++cnt;
++g;
}
ve[k] = 1;
}
} else
++i;
}
cout << cnt;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 2005;
const int mod = 1000000007;
int n;
int a[maxn];
bool vis[maxn];
bool in[maxn];
unsigned long long f[maxn][maxn];
bool g[maxn][maxn];
unsigned long long A[maxn];
void init() {
A[0] = A[1] = 1;
for (int i = 2; i < maxn; i++) {
A[i] = (A[i - 1] * i) % mod;
}
}
unsigned long long dfs(int x, int y) {
if (g[x][y]) return f[x][y];
if (y == 0) {
g[x][y] = 1;
return f[x][y] = A[x];
}
if (y == 1) {
g[x][y] = 1;
return f[x][y] = (x * dfs(x, y - 1)) % mod;
}
g[x][y] = 1;
return f[x][y] = (x * dfs(x, y - 1) + (y - 1) * dfs(x + 1, y - 2)) % mod;
}
int main() {
init();
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] != -1) {
in[i] = 1;
vis[a[i]] = 1;
}
}
int cnt1 = 0, cnt2 = 0;
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
if (in[i])
cnt1++;
else
cnt2++;
}
printf("%I64d\n", dfs(cnt1, cnt2));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
void print_array(int arr[], int n) {
for (int i = 0; i < n; i++) cout << arr[i] << ' ';
cout << endl;
}
void print_vector(const vector<int> &a) {
for (int i = 0; i < (int)a.size(); i++) cout << a[i] << ' ';
}
int main() {
int n, m;
cin >> n >> m;
int sum = n * (n + 1) / 2;
while (m > sum) {
m = m - sum;
}
for (int i = 1; i <= n; i++) {
if (m - i < 0) break;
m = m - i;
}
cout << m << endl;
}
| 0 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
int main() {
int n;
int w = 1;
int temp;
cin >> n;
int* x;
x = new int[n];
for (int i = 0; i < n; i++) cin >> x[i];
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (x[j] > x[j + 1]) {
temp = x[j];
x[j] = x[j + 1];
x[j + 1] = temp;
}
}
}
for (int i = 1; i < n; i++)
if (x[i] != x[i - 1] && x[i - 1] != 0 && x[i] != 0) w++;
cout << w;
delete x;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i;
long long int n;
cin >> n;
if (n % 2 == 0) {
while (n % 2 == 0 && (n / 2) % 2 == 0) {
n = n / 2;
}
}
for (i = 3; i <= sqrt(n); i += 2) {
if (n % i == 0) {
while (n % i == 0 && (n / i) % i == 0) {
n = n / i;
}
}
}
cout << n << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int mark[MAXN] = {0};
int m[MAXN] = {0};
int gen_primes(int maxn) {
for (int p = 2; p < maxn; p++)
if (!mark[p]) {
mark[p] = p;
long long int t = p;
t *= p;
for (; t < maxn; t += p) mark[t] = p;
}
return 0;
}
vector<pair<int, int> > fact(int x) {
vector<pair<int, int> > f;
while (x > 1) {
int k = 0;
int p = mark[x];
while (x % p == 0) {
x /= p;
k++;
}
if (k) f.push_back(make_pair(p, k));
}
return f;
}
vector<int> divs(int x) {
vector<pair<int, int> > f = fact(x);
vector<int> d(1, 1);
for (int i = 0; i < f.size(); i++) {
int p = f[i].first;
int k = f[i].second;
int size = d.size();
int t = 1;
for (int ki = 1; ki < k + 1; ki++) {
t *= p;
for (int i = 0; i < size; i++) {
int nw = d[i] * t;
d.push_back(nw);
}
}
}
return d;
}
int main() {
gen_primes(MAXN);
int n;
cin >> n;
for (int i = 1; i < n + 1; i++) {
int x, y;
cin >> x >> y;
vector<int> d = divs(x);
if (y == 0) {
cout << d.size() << endl;
} else {
int ans = 0;
for (int j = 0; j < d.size(); j++) {
int dj = d[j];
int index = m[dj];
if (index < i - y) ans++;
}
cout << ans << endl;
}
for (int j = 0; j < d.size(); j++) m[d[j]] = i;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = (long long)2e18;
const double eps = 1e-9;
const double pi = acos(-1.0);
int n, m, b;
pair<int, pair<int, int> > a[110];
long long dp[2][1 << 21];
int cur = 0, nxt = 0;
int main() {
cin >> n >> m >> b;
for (int i = 0; i < n; i++) {
int k;
cin >> a[i].second.first >> a[i].first >> k;
a[i].second.second = 0;
while (k--) {
int x;
cin >> x;
a[i].second.second |= (1 << (x - 1));
}
}
sort(a, a + n);
for (int i = 0; i < (1 << m); i++) dp[0][i] = inf;
dp[0][0] = 0;
long long ans = inf;
for (int iter = 0; iter < n; iter++) {
nxt = (cur ^ 1);
for (int i = 0; i < (1 << m); i++) dp[nxt][i] = dp[cur][i];
int x = a[iter].second.first, k = a[iter].first;
int mask = a[iter].second.second;
for (int i = 0; i < (1 << m); i++)
dp[nxt][i | mask] = min(dp[nxt][i | mask], x + dp[cur][i]);
ans = min(ans, dp[nxt][(1 << m) - 1] + b * 1ll * k);
cur ^= 1;
}
if (ans == inf) ans = -1;
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long>> graph;
set<long long> a;
vector<long long> ans;
long long visited[100004];
int main() {
long long n, m;
cin >> n >> m;
graph.resize(n + 1);
for (int i = 1; i <= m; i++) {
long long x, y;
cin >> x >> y;
graph[x].push_back(y);
graph[y].push_back(x);
}
long long vertex = 1;
visited[1] = 1;
ans.push_back(1);
while (ans.size() != n) {
visited[vertex] = 1;
for (auto i : graph[vertex]) {
if (visited[i] == 0) a.insert(i);
}
ans.push_back(*(a.begin()));
vertex = *(a.begin());
a.erase(*(a.begin()));
}
for (auto i : ans) {
cout << i << ' ';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct ASDF {
ASDF& operator,(int& a) {
scanf("%d", &a);
return *this;
}
ASDF& operator,(long int& a) {
scanf("%ld", &a);
return *this;
}
ASDF& operator,(long long int& a) {
scanf("%lld", &a);
return *this;
}
ASDF& operator,(char& c) {
scanf("%c", &c);
return *this;
}
ASDF& operator,(double& d) {
scanf("%lf", &d);
return *this;
}
template <typename T>
ASDF& operator,(T& a) {
cin >> a;
return *this;
}
} asdf;
struct ASDFG {
template <typename T>
ASDFG& operator,(vector<T>& v) {
printf("[");
cout << v[0];
for (int i = 1; i < int(v.size()); i++) {
cout << ", " << v[i];
}
printf("]");
return *this;
}
template <typename T>
ASDFG& operator,(T x) {
cout << x << " ";
return *this;
}
} asdfg;
bool cnt[8][8];
string board[8];
int dist[8][8];
int x[] = {2, 2, -2, -2};
int y[] = {2, -2, 2, -2};
bool isValid(int i, int j) { return -1 < i && i < 8 && -1 < j && j < 8; }
bool search(int i, int j) {
cnt[i][j] = true;
if (board[i][j] == 'K') {
return dist[i][j] % 2 == 0;
} else {
bool res = false;
for (int k = 0; k < 4; k++) {
int xx, yy;
xx = i + x[k];
yy = j + y[k];
if (isValid(xx, yy) && cnt[xx][yy] == false) {
dist[xx][yy] = dist[i][j] + 1;
res = res | search(xx, yy);
}
}
return res;
}
}
int main() {
int kases;
scanf("%d", &kases);
bool result;
while (kases--) {
for (int i = 0; i < 8; i++) {
cin >> board[i];
}
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
if (board[i][j] == 'K') {
dist[i][j] = 0;
board[i][j] = '.';
result = search(i, j);
goto hell;
}
}
}
hell:
if (result) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, a, b;
int main() {
cin >> n >> m >> x >> y >> a >> b;
int res = INT_MAX;
if ((x - 1) % a == 0 && (y - 1) % b == 0) {
if ((x - 1) / a == (y - 1) / b) {
res = min(res, (x - 1) / a);
} else {
if (((x - 1) / a) % 2 == ((y - 1) / b) % 2) {
int aa = (x - 1) / a;
int bb = (y - 1) / b;
if (aa > bb) {
if ((y + b) <= m || (y - b) >= 1) {
res = min(res, aa);
}
} else if (aa < bb) {
if ((x + a) <= n || (x - a) >= 1) {
res = min(res, bb);
}
}
}
}
}
if ((x - 1) % a == 0 && (m - y) % b == 0) {
if ((x - 1) / a == (m - y) / b) {
res = min(res, (x - 1) / a);
} else {
if (((x - 1) / a) % 2 == ((m - y) / b) % 2) {
int aa = (x - 1) / a;
int bb = (m - y) / b;
if (aa > bb) {
if ((y + b) <= m || (y - b) >= 1) {
res = min(res, aa);
}
} else if (aa < bb) {
if ((x + a) <= n || (x - a) >= 1) {
res = min(res, bb);
}
}
}
}
}
if ((n - x) % a == 0 && (y - 1) % b == 0) {
if ((n - x) / a == (y - 1) / b) {
res = min(res, (n - x) / a);
} else {
if (((n - x) / a) % 2 == ((y - 1) / b) % 2) {
int aa = (n - x) / a;
int bb = (y - 1) / b;
if (aa > bb) {
if ((y + b) <= m || (y - b) >= 1) {
res = min(res, aa);
}
} else if (aa < bb) {
if ((x + a) <= n || (x - a) >= 1) {
res = min(res, bb);
}
}
}
}
}
if ((n - x) % a == 0 && (m - y) % b == 0) {
if ((n - x) / a == (m - y) / b) {
res = min(res, (n - x) / a);
} else {
if (((n - x) / a) % 2 == ((m - y) / b) % 2) {
int aa = (n - x) / a;
int bb = (m - y) / b;
if (aa > bb) {
if ((y + b) <= m || (y - b) >= 1) {
res = min(res, aa);
}
} else if (aa < bb) {
if ((x + a) <= n || (x - a) >= 1) {
res = min(res, bb);
}
}
}
}
}
if (res == INT_MAX) {
cout << "Poor Inna and pony!" << endl;
} else {
cout << res << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double PI = atan(1) * 4;
const long long MAX = 1e9;
string s, w, B = "QWERTYUIOPASDFGHJKLZXCVBNM", S = "qwertyuiopasdfghjklzxcvbnm";
int n;
map<string, bool> u;
int main() {
cin >> s >> n;
while (n--) {
cin >> w;
if (w.size() == s.size()) {
int c = 0, c1 = 0;
for (int i = 0; i < s.size(); i++) {
if ((B.find(s[i]) != string::npos || S.find(s[i]) != string::npos) &&
(B.find(w[i]) != string::npos || S.find(w[i]) != string::npos) &&
toupper(s[i]) == toupper(w[i]))
c++;
else if ((s[i] == '0' && (w[i] == 'o' || w[i] == 'O')) ||
(w[i] == '0' && (s[i] == 'o' || s[i] == 'O')))
c++;
else if ((s[i] == '1' && ((w[i] == 'L' || w[i] == 'l') ||
(w[i] == 'i' || w[i] == 'I'))) ||
(w[i] == '1' && ((s[i] == 'L' || s[i] == 'l') ||
(s[i] == 'i' || s[i] == 'I'))) ||
(((w[i] == 'L' || w[i] == 'l') &&
(s[i] == 'i' || s[i] == 'I'))) ||
(((s[i] == 'L' || s[i] == 'l') &&
(w[i] == 'i' || w[i] == 'I'))))
c++;
else if (s[i] == w[i])
c++, c1++;
else
break;
}
if (c == w.size() && c1 != w.size()) {
cout << "No";
return 0;
}
} else
continue;
}
cout << "Yes";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) {
if (a > b) return a;
return b;
}
long long min(long long a, long long b) {
if (a < b) return a;
return b;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++, printf("\n"))
for (int j = 0; j < n; j++) {
int now = 0;
if (i != j)
if (i == n - 1 && j)
now = j * 2;
else if (j == n - 1 && i)
now = i * 2;
else
now = i + j;
if (now >= n) now = (now + 1) % n;
printf("%d ", now);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T abs(T t) {
return t < 0 ? -t : t;
}
const long long modn = 1000000007;
inline long long mod(long long x) { return x % modn; }
const int MAXN = 2123456;
const long long INF = 300000000000LL;
int n, m, k;
long long s[MAXN];
multiset<long long> bef[MAXN], aft[MAXN];
int ind[MAXN];
int d[MAXN], ini[MAXN], fim[MAXN];
vector<pair<int, long long> > in[MAXN], out[MAXN];
bool cmp(int a, int b) { return d[a] < d[b]; }
long long sum;
void add(int i, int j, long long x) {
if (i == 0) {
sum -= *aft[j].begin();
aft[j].insert(x);
sum += *aft[j].begin();
} else {
sum -= *bef[i].begin();
bef[i].insert(x);
sum += *bef[i].begin();
}
}
void rmv(int i, int j, long long x) {
if (i == 0) {
sum -= *aft[j].begin();
aft[j].erase(aft[j].find(x));
sum += *aft[j].begin();
} else {
sum -= *bef[i].begin();
bef[i].erase(bef[i].find(x));
sum += *bef[i].begin();
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int a = 1; a <= n; a++) {
bef[a].insert(INF);
aft[a].insert(INF);
sum += 2ll * INF;
}
for (int a = 0; a < m; a++) {
scanf("%d%d%d%lld", &d[a], ini + a, fim + a, s + a);
if (ini[a] == 0)
out[d[a]].push_back(pair<int, long long>(fim[a], s[a]));
else
in[d[a]].push_back(pair<int, long long>(ini[a], s[a]));
}
for (int dia = 1000000; dia >= k; dia--) {
for (int i = 0; i < out[dia].size(); i++) {
pair<int, long long> voo = out[dia][i];
add(0, voo.first, voo.second);
}
}
long long res = LLONG_MAX;
for (int dia = 0; dia <= 1000000 - k; dia++) {
res = min(res, sum);
for (pair<int, long long> voo : in[dia]) add(voo.first, 0, voo.second);
for (pair<int, long long> voo : out[dia + k]) rmv(0, voo.first, voo.second);
}
if (res >= INF)
puts("-1");
else
printf("%lld\n", res);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll x, y, z;
cin >> x >> y >> z;
if (x > y + z) {
cout << "+" << endl;
return 0;
}
if (y > x + z) {
cout << "-" << endl;
return 0;
}
if (x == y && !z) {
cout << 0 << endl;
return 0;
}
cout << "?" << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, t[204], i, m;
bool b = true;
int main() {
cin >> n;
for (i = 0; i < 2 * n; i++) {
cin >> t[i];
}
sort(t, t + (n * 2));
m = n * 2 - 1;
for (i = 0; i < n; i++) {
if (t[i] >= t[m]) {
b = false;
break;
}
m--;
}
if (b == true)
cout << "YES";
else
cout << "NO";
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize "-O3"
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using namespace std;
const ll MOD = 998244353;
ll pw(ll a, ll b) {
ll ans = 1;
while (b) {
while (!(b & 1)) b >>= 1, a = (a * a) % MOD;
ans = (ans * a) % MOD, --b;
}
return ans;
}
int n;
int m;
int lst[1000];
ll dp[1000][1000];
ll solve(vector<int> vv) {
dp[vv.size()][vv.size()] = 1;
for (int i = vv.size() - 1; i >= 0; --i) {
dp[i][i] = 1;
for (int j = i + 1; j <= vv.size(); ++j) {
int x = i;
for (int k = i; k < j; ++k)
if (vv[k] < vv[x]) x = k;
ll al = 0;
for (int l = i; l <= x; ++l) al = (al + dp[i][l] * dp[l][x]) % MOD;
ll ar = 0;
for (int r = x + 1; r <= j; ++r)
ar = (ar + dp[x + 1][r] * dp[r][j]) % MOD;
dp[i][j] = (al * ar) % MOD;
}
}
return dp[0][vv.size()];
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cout.setf(ios::fixed), cout.precision(20);
cin >> n >> m;
vector<int> vv;
for (int i = 0; i < m; ++i) {
int c;
cin >> c;
if (vv.empty() || vv.back() != c) vv.push_back(c);
}
m = vv.size();
if (2 * n < m + 1) {
cout << 0 << "\n";
return 0;
}
for (int i = 0; i < m; ++i) {
int fl = 0;
for (int j = i + 1; j < m; ++j) {
if (vv[j] < vv[i]) fl = 1;
if (fl && vv[j] == vv[i]) {
cout << 0 << "\n";
return 0;
}
}
}
for (int i = 0; i <= n; ++i) lst[i] = -1;
vector<int> st;
ll ans = 1;
for (int i = 0; i < vv.size(); ++i) {
int c = vv[i];
if (lst[c] != -1) {
vector<int> tmp;
while (st.size() != lst[c] + 1) {
tmp.push_back(st.back());
st.pop_back();
}
ans = (ans * solve(tmp)) % MOD;
} else {
lst[c] = st.size();
st.push_back(c);
}
}
ans = (ans * solve(st)) % MOD;
cout << ans << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const double eps = 1e-9;
const double INF = inf;
const double EPS = eps;
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
int N[2][1100 * 1100 * 4];
long long T[110000];
int V[110000];
int main() {
int x, y, n, q, a, b, c, d, bb, it;
int i, j, k, nx, ny;
char ch;
scanf("%d%d", &n, &b);
for (i = 0; i <= b; i++)
for (j = 0; j <= b; j++)
for (k = 0; k < 4; k++) {
nx = i + dx[k], ny = j + dy[k];
nx = max(nx, 0), nx = min(nx, b);
ny = max(ny, 0), ny = min(ny, b);
N[0][(i * (b + 1) + j) * 4 + k] = (nx * (b + 1) + ny) * 4 + k;
}
for (i = 0; i < n; i++) {
scanf("%d%d%d%d", &a, &bb, &c, &d);
assert(a != c || bb != d);
int len = abs(a - c) + abs(bb - d);
for (it = 0; it < 4; it++)
if (c == a + len * dx[it] && d == bb + len * dy[it]) {
for (j = 0; j <= len; j++) {
x = a + j * dx[it], y = bb + j * dy[it];
int id = (x * (b + 1) + y) * 4;
for (k = 0; k < 4; k++) {
N[0][id + k] = N[0][id + it];
}
}
break;
}
}
scanf("%d", &q);
for (i = 0; i < q; i++) {
scanf("%d%d %c %I64d", &x, &y, &ch, &T[i]);
V[i] = (x * (b + 1) + y) * 4;
if (ch == 'L') V[i]++;
if (ch == 'U') V[i] += 2;
if (ch == 'D') V[i] += 3;
}
for (it = 0; it < 55; it++) {
for (i = 0; i < q; i++)
if (T[i] & (1ll << it)) V[i] = N[0][V[i]];
for (j = 0; j < (b + 1) * (b + 1) * 4; j++) N[1][j] = N[0][N[0][j]];
memcpy(N[0], N[1], sizeof(N[0]));
}
for (i = 0; i < q; i++)
printf("%d %d\n", V[i] / (4 * (b + 1)), (V[i] / 4) % (b + 1));
;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
string str1, str2;
cin >> str1 >> str2;
int k = 0;
string::size_type loc;
char ch;
vector<bool> f(8, true);
for (int i = 0; i != str1.size(); ++i) {
if (str2[i] != str1[i]) {
if (str2[i] == '4')
ch = '7';
else
ch = '4';
if ((loc = str2.find(ch, i + 1)) == string::npos) f[ch - '0'] = false;
if ((loc = str2.find(ch, i + 1)) == string::npos) f[ch - '0'] = false;
while (loc != string::npos) {
if (str2[i] != str2[loc] && str2[loc] != str1[loc]) {
swap(str2[i], str2[loc]);
break;
}
loc = str2.find(ch, loc + 1);
}
++k;
if (f[ch - '0'] == false) {
for (int j = i + 1; j != str1.size(); ++j) {
if (str1[j] != str2[i]) ++k;
}
break;
}
}
}
cout << k;
return 0;
}
| 2 |
Subsets and Splits