solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, x, a[1000005];
int mp[5];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
while (cin >> n) {
for (int i = 0; i < n; i++) {
cin >> a[i];
}
mp[0] = 0;
mp[1] = 0;
set<int> st;
for (int i = 0; i < n; i++) {
if (i == 0) {
mp[a[i]]++;
} else {
mp[a[i]]++;
if (a[i] != a[i - 1]) {
st.insert(mp[a[i - 1]]);
mp[a[i - 1]] = 0;
}
if (i == n - 1) {
st.insert(mp[a[i]]);
}
}
}
if (st.size() <= 1) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
const int M = 1000005;
const int md = 1000000007;
long long n, i, r, ans, a[N], dp[N];
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
cin >> n;
for (i = 1; i <= n; ++i) cin >> a[i];
if (a[1] > 0) dp[1] = 1;
r = a[1];
ans = a[1] - 1;
for (i = 2; i <= n; ++i) {
if (a[i - 1] < a[i]) {
dp[i] = (dp[i - 1] * (r - 1) + a[i - 1] - r) % md;
r = a[i - 1];
ans = (ans + (dp[i] * (r - 1)) % md + a[i] - 1) % md;
++dp[i];
dp[i] %= md;
} else {
if (r >= a[i]) {
dp[i] = (dp[i - 1] * (a[i] - 1)) % md;
r = a[i];
ans = (ans + (dp[i] * (r - 1)) % md + a[i] - 1) % md;
++dp[i];
dp[i] %= md;
} else {
dp[i] = (dp[i - 1] * (r - 1) + a[i] - r) % md;
r = a[i];
ans = (ans + (dp[i] * (r - 1)) % md + a[i] - 1) % md;
++dp[i];
dp[i] %= md;
}
}
}
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
ios_base::sync_with_stdio(false);
cout << fixed;
cout.precision(10);
int t = 1;
for (int i = 1; i <= t; ++i) {
solve();
}
return 0;
}
vector<int> a;
vector<int> used;
void go(int v) {
used[v] = 1;
if (v == a.size()) return;
int to = v + a[v];
if (!used[to]) {
go(to);
}
}
void solve() {
int n;
cin >> n;
used.resize(n, 0);
int t;
cin >> t;
--t;
a.resize(n - 1);
for (int i = 0; i < n - 1; ++i) {
cin >> a[i];
}
go(0);
if (used[t]) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10, M = 2 * N;
int read() {
int a = 0;
int f = 0;
char p = getchar();
while (!isdigit(p)) {
f |= p == '-';
p = getchar();
}
while (isdigit(p)) {
a = (a << 3) + (a << 1) + (p ^ 48);
p = getchar();
}
return f ? -a : a;
}
int h[N], e[M], ne[M], idx;
int n;
bool st[N];
int a, b;
int dist[N], dist1[N];
int bfs(int u) {
memset(st, 0, sizeof(st));
memset(dist, 0x3f, sizeof(dist));
queue<int> q;
q.push(u);
st[u] = true;
dist[u] = 0;
int t;
while (q.size()) {
t = q.front();
q.pop();
for (int i = h[t]; i != -1; i = ne[i]) {
int j = e[i];
if ((dist[j] > dist[t] + 1) && !st[j]) {
dist[j] = dist[t] + 1;
st[j] = true;
q.push(j);
}
}
}
return t;
}
void add(int a, int b) {
e[idx] = b, ne[idx] = h[a];
h[a] = idx++;
}
int main() {
scanf("%d", &n);
int t = n;
t--;
memset(h, -1, sizeof(h));
while (t--) {
cin >> a >> b;
add(a, b), add(b, a);
}
int p1 = bfs(1);
int p2 = bfs(p1);
for (int i = 1; i <= n; i++) {
dist1[i] = dist[i];
}
bfs(p2);
int c = 0, maxn = 0;
for (int i = 1; i <= n; i++) {
if (i == p1 || i == p2) continue;
int num = dist[i] + dist1[i] + dist[p1];
if (maxn < num) {
maxn = num;
c = i;
}
}
cout << maxn / 2 << endl;
cout << p1 << " " << p2 << " " << c << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, Ans;
int main() {
cin >> n;
if (n == 1)
Ans = 2;
else if (n == 2)
Ans = 3;
else if (n == 3)
Ans = 1;
else if (n == 4)
Ans = 2;
else
Ans = 1;
cout << Ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7;
int T, n, res;
string STR;
void Solve() {
bool ok = 1;
for (int i = 1; i < n; i++) {
if (STR[i] != STR[i - 1]) {
ok = 0;
break;
}
}
if (ok) {
cout << (n + 2) / 3 << "\n";
return;
}
while (STR.front() == STR.back()) {
char ch = STR.back();
string luu = "";
while (STR.back() == ch) {
STR.pop_back();
luu += ch;
}
STR = luu + STR;
break;
}
int luu = 1;
res = 0;
for (int i = 1; i <= n - 1; i++) {
if (STR[i] == STR[i - 1]) {
luu++;
} else {
res += luu / 3;
luu = 1;
}
}
res += luu / 3;
cout << res << "\n";
}
int main() {
cin >> T;
while (T--) {
cin >> n;
cin >> STR;
Solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e6;
long long t[4 * N];
long long fl[4 * N];
void push(long long ind, long long l, long long r) {
if (fl[ind] == 1) {
t[ind] = r - l + 1;
if (l != r) {
fl[ind * 2] = 1;
fl[ind * 2 + 1] = 1;
}
}
if (fl[ind] == -1) {
t[ind] = 0;
if (l != r) {
fl[ind * 2] = -1;
fl[ind * 2 + 1] = -1;
}
}
if (fl[ind] == -2) {
t[ind] = r - l + 1 - t[ind];
if (l != r) {
if (fl[ind * 2] == 0)
fl[ind * 2] = -2;
else if (fl[ind * 2] == 1)
fl[ind * 2] = -1;
else if (fl[ind * 2] == -2)
fl[ind * 2] = 0;
else
fl[ind * 2] = 1;
if (fl[ind * 2 + 1] == 0)
fl[ind * 2 + 1] = -2;
else if (fl[ind * 2 + 1] == 1)
fl[ind * 2 + 1] = -1;
else if (fl[ind * 2 + 1] == -2)
fl[ind * 2 + 1] = 0;
else
fl[ind * 2 + 1] = 1;
}
}
fl[ind] = 0;
}
void update(long long ind, long long l, long long r, long long i, long long j,
long long ps) {
if (fl[ind] != 0) push(ind, l, r);
if (l == i && r == j) {
fl[ind] = ps;
return;
}
long long d = (r + l) / 2;
if (j <= d)
update(ind * 2, l, d, i, j, ps);
else if (i >= d + 1)
update(ind * 2 + 1, d + 1, r, i, j, ps);
else {
update(ind * 2, l, d, i, d, ps);
update(ind * 2 + 1, d + 1, r, d + 1, j, ps);
}
push(ind * 2, l, d);
push(ind * 2 + 1, d + 1, r);
t[ind] = t[ind * 2] + t[ind * 2 + 1];
}
long long get(long long ind, long long l, long long r) {
push(ind, l, r);
if (l == r) {
return l;
}
long long d = (r + l) / 2;
push(ind * 2, l, d);
push(ind * 2 + 1, d + 1, r);
if (t[ind * 2] != d - l + 1)
return get(ind * 2, l, d);
else
return get(ind * 2 + 1, d + 1, r);
}
void solve(vector<tuple<long long, long long, long long>> &a) {
long long otv = 0, n = a.size();
for (long long i = 0; i < n; i++) {
auto [u, v, c] = a[i];
for (long long j = 0; j < n; j++) {
if (i == j) continue;
auto [u1, v1, c1] = a[j];
if (u1 > u && v1 > v && c1 > c) {
otv++;
break;
}
}
}
cout << otv << '\n';
exit(0);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long n;
cin >> n;
vector<tuple<long long, long long, long long>> a(n);
vector<long long> b(1, -1);
;
b.push_back(1);
for (long long i = 0; i < n; i++) {
long long q, l, r;
cin >> q >> l >> r;
a[i] = {q, l, r};
b.push_back(l);
if (l != 1) b.push_back(l - 1);
b.push_back(l + 1);
b.push_back(r);
if (r != 1) b.push_back(r - 1);
b.push_back(r + 1);
}
sort(b.begin(), b.end());
unordered_map<long long, long long> b2;
unordered_map<long long, long long> b3;
long long j = 1;
for (long long i = 1; i < b.size(); i++) {
if (b[i] == b[i - 1]) continue;
b2[b[i]] = j;
b3[j] = b[i];
j++;
}
for (auto [q, l1, r1] : a) {
long long l = b2[l1];
long long r = b2[r1];
if (q == 1) {
update(1, 1, N, l, r, 1);
}
if (q == 2) {
update(1, 1, N, l, r, -1);
}
if (q == 3) {
update(1, 1, N, l, r, -2);
}
long long y = get(1, 1, N);
cout << b3[y] << '\n';
}
}
| 7 |
#include <bits/stdc++.h>
using std::cerr;
using std::endl;
inline int read() {
int 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;
}
const int MAXN = 300005;
int n, a[MAXN], vis[MAXN], cnt;
std::vector<int> one;
std::multiset<int> st;
inline void appear(int x) {
++vis[x];
if (vis[x] == 2) ++cnt;
st.insert(x);
}
inline void disappear(int x) {
--vis[x];
if (vis[x] == 1) --cnt;
st.erase(st.lower_bound(x));
}
int solve(int l, int mid, int r) {
appear(a[mid]);
int ret = 1, ptr = mid, maxn = 1;
for (int i = (mid - 1); i >= (l); --i) {
appear(a[i]);
maxn = std::max(maxn, a[i]);
while (ptr < r && ptr - i + 1 < maxn) appear(a[++ptr]);
while (ptr > mid && ptr - i + 1 > maxn) disappear(a[ptr--]);
if (ptr - i + 1 == maxn && cnt == 0 && *(--st.end()) == maxn) {
++ret;
}
}
cnt = 0;
for (int i = (l); i <= (r); ++i) vis[a[i]] = 0;
st.clear();
appear(a[mid]);
ptr = mid, maxn = 1;
for (int i = (mid + 1); i <= (r); ++i) {
appear(a[i]);
maxn = std::max(maxn, a[i]);
while (ptr > l && i - ptr + 1 < maxn) appear(a[--ptr]);
while (ptr < mid && i - ptr + 1 > maxn) disappear(a[ptr++]);
if (i - ptr + 1 == maxn && cnt == 0 && *(--st.end()) == maxn) {
++ret;
}
}
cnt = 0;
for (int i = (l); i <= (r); ++i) vis[a[i]] = 0;
st.clear();
return ret;
}
int main() {
n = read();
for (int i = (1); i <= (n); ++i) {
a[i] = read();
if (a[i] == 1) one.push_back(i);
}
int ans = 0;
for (int i = (0); i <= ((int)one.size() - 1); ++i) {
if (i == 0 && i == (int)one.size() - 1)
ans += solve(1, one[i], n);
else if (i == 0)
ans += solve(1, one[i], one[i + 1] - 1);
else if (i == (int)one.size() - 1)
ans += solve(one[i - 1] + 1, one[i], n);
else
ans += solve(one[i - 1] + 1, one[i], one[i + 1] - 1);
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 50, INF = 0, MOD = 0;
int n, a[N];
set<pair<int, pair<int, int> > > s;
set<pair<int, int> > z;
pair<int, pair<int, int> > bf, nx, no;
bool upd() {
auto x = *z.begin();
z.erase(x);
auto it = s.lower_bound(make_pair(x.second, make_pair(0, 0)));
no = *it;
bf = make_pair(0, make_pair(0, 0)), nx = make_pair(0, make_pair(0, 0));
if (it != s.begin()) {
it--;
bf = *it;
it++;
}
it++;
if (it != s.end()) nx = *it;
if (nx.second.second > bf.second.second && bf.second.second > 0)
nx = make_pair(0, make_pair(0, 0));
else if (nx.second.second < bf.second.second && nx.second.second > 0)
bf = make_pair(0, make_pair(0, 0));
s.erase(bf);
s.erase(nx);
s.erase(no);
z.erase(make_pair(nx.second.second, nx.first));
z.erase(make_pair(bf.second.second, bf.first));
int cnt = bf.second.first + no.second.first + nx.second.first;
int H = max(bf.second.second, nx.second.second);
if (H < x.first) return false;
s.insert(make_pair(x.second, make_pair(cnt, H)));
if (cnt % 2 == 0) z.insert(make_pair(H, x.second));
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
int cur = 0, last = 0, cnt = 0;
while (cur < n) {
if (cur != n - 1 && a[cur + 1] == a[last]) {
cur++;
continue;
}
cnt++;
int x = cur - last + 1;
s.insert(make_pair(cnt, make_pair(x, a[last])));
if (x % 2 == 0) z.insert(make_pair(a[last], cnt));
last = cur + 1;
cur++;
}
while ((int)s.size() > 1) {
if (z.empty()) return cout << "NO", 0;
if (!upd()) return cout << "NO", 0;
}
cout << "YES" << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000005;
int a[maxn];
int dp1[maxn], dp2[maxn];
int main() {
int n, m;
while (~scanf("%d%d", &n, &m)) {
int flag = 0;
memset(dp1, 0, sizeof(dp1));
memset(dp2, 0, sizeof(dp2));
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] == m) flag = 1;
}
if (flag) {
printf("YES\n");
continue;
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < m; j++) {
if (dp1[j]) dp2[(a[i] + j) % m] = 1;
}
dp2[a[i] % m] = 1;
for (int j = 0; j < m; j++) dp1[j] = dp2[j];
if (dp1[0]) {
flag = 1;
break;
}
}
if (flag)
printf("YES\n");
else
printf("NO\n");
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
stack<int> sta;
map<pair<int, int>, bool>::iterator it;
map<pair<int, int>, bool> MAP;
const int KUAI = 450;
int N, M;
int OP[2010], U[2010], V[2010];
struct EDGE {
int u, v;
} queding[400010];
int qd_cnt;
int fa[200010], sz[200010];
int fin(int u) {
if (fa[u] == u) return u;
return fin(fa[u]);
}
int lasans = 0;
int lianjie(int u, int v) {
u = fin(u);
v = fin(v);
if (u == v) return -1;
if (sz[u] > sz[v]) {
fa[v] = u;
sz[u] += sz[v];
return v;
}
fa[u] = v;
sz[v] += sz[u];
return u;
}
pair<int, int> mp(int u, int v, int la) {
u = (u + la - 1) % N + 1;
v = (v + la - 1) % N + 1;
return make_pair(min(u, v), max(u, v));
}
int main() {
scanf("%d%d", &N, &M);
int jishu = 0;
for (int i = 1; i <= M; ++i) {
++jishu;
scanf("%d%d%d", &OP[jishu], &U[jishu], &V[jishu]);
if (jishu == KUAI || i == M) {
MAP.clear();
for (int j = 1; j <= jishu; ++j) {
if (OP[j] == 1) {
MAP[mp(U[j], V[j], 0)] = 0;
MAP[mp(U[j], V[j], 1)] = 0;
}
}
while (!sta.empty()) sta.pop();
for (int j = 1; j <= N; ++j) {
fa[j] = j;
sz[j] = 1;
}
for (int j = 1; j <= qd_cnt; ++j) {
if (queding[j].u == 0) continue;
it = MAP.find(make_pair(queding[j].u, queding[j].v));
if (it == MAP.end())
lianjie(queding[j].u, queding[j].v);
else {
it->second = 1;
queding[j].u = 0;
}
}
for (int j = 1; j <= jishu; ++j) {
if (OP[j] == 1)
MAP[mp(U[j], V[j], lasans)] ^= 1;
else {
while (!sta.empty()) {
sz[fa[sta.top()]] -= sz[sta.top()];
fa[sta.top()] = sta.top();
sta.pop();
}
for (it = MAP.begin(); it != MAP.end(); it++) {
if (it->second == 1) {
int t = lianjie(it->first.first, it->first.second);
if (t != -1) {
sta.push(t);
}
}
}
lasans = (fin((U[j] + lasans - 1) % N + 1) ==
fin((V[j] + lasans - 1) % N + 1));
printf("%d", lasans);
}
}
for (it = MAP.begin(); it != MAP.end(); it++) {
if (it->second == 1) {
queding[++qd_cnt].u = min(it->first.first, it->first.second);
queding[qd_cnt].v = max(it->first.first, it->first.second);
}
}
jishu = 0;
}
}
puts("");
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
constexpr int N = 3e3;
uint16_t a[N], lst[N], nxt[N], cnxt[19], dp[N][N];
int main() {
cin.tie(0), ios::sync_with_stdio(0);
int t, n;
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i], --a[i];
}
memset(lst, 0, n * sizeof *lst);
for (int i = 0; i < n; ++i) {
++lst[a[i]];
}
int w = -1, r = 0, purged = 0;
while (r < n) {
if (w >= 0 && a[w] == a[r]) {
if (--lst[a[r++]] == 1) {
--w;
++purged;
}
} else if (lst[a[r]] == 1) {
++r;
++purged;
} else {
a[++w] = a[r++];
}
}
memset(lst, -1, n * sizeof *lst);
n = w + 1;
memset(nxt, 127, n * sizeof *nxt);
for (int i = 0; i < n; ++i) {
if (lst[a[i]] != (uint16_t)-1) {
nxt[lst[a[i]]] = i;
}
lst[a[i]] = i;
}
for (int i = n - 1; i > -1; --i) {
{
auto* cnxte = cnxt;
for (int z = nxt[i]; z < n; z = nxt[z]) {
*cnxte++ = z;
}
cnxte = cnxt;
}
int cs = sizeof cnxt / sizeof *cnxt;
for (int j = i + 1; j < n; ++j) {
if (a[j] == a[i]) {
--cs;
}
int t = dp[i + 1][j] - 1;
const auto* z = cnxt;
switch (cs) {
case 0:
t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
case 1:
t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
case 2:
t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
case 3:
t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
case 4:
t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
case 5:
t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
case 6:
t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
case 7:
t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
case 8:
t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
case 9:
t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
case 10:
t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
case 11:
t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
case 12:
t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
case 13:
t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
case 14:
t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
case 15:
t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
case 16:
t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
case 17:
t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
case 18:
t = max(t, dp[i + 1][*z - 1] + dp[*z][j]), ++z;
[[fallthrough]];
[[unlikely]] default:;
}
dp[i][j] = t + 1;
}
}
cout << (n ? n - dp[0][n - 1] : 0) - 1 + purged << '\n';
;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, hh, mm;
cin >> s;
int h, m, x;
h = stoi(s.substr(0, 2));
m = stoi(s.substr(3, 2));
x = (h - (h / 10) * 10) * 10 + (h / 10);
if (x > m && x < 60) {
printf("%02d:%02d", h, x);
return 0;
}
for (int i = h + 1; i < 24; i++) {
for (int j = 0; j < 60; j++) {
x = (j - (j / 10) * 10) * 10 + (j / 10);
if (i == j && x < 60) {
printf("%02d:%02d", i, x);
return 0;
}
}
}
cout << "00:00" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long Q = 2e5 + 3;
const long long T = 1 << 16;
long long k, q, sz;
vector<array<long long, 3>> sweepline;
vector<array<long long, 3>> qu;
vector<long long> st[16 * 4 * T];
bool st_ans[16 * 4 * T];
bool ans[16 * 2 * T];
bool check(long long i, long long l, long long r) {
if (l == r) {
for (long long j = 0; j < 16; ++j) {
if (st_ans[i + j]) {
for (long long x : st[i + j]) {
if (ans[x]) {
return false;
}
}
}
}
return true;
}
long long mid = (l + r) >> 1;
if (!check(2 * i + 16, l, mid)) return false;
if (!check(2 * i + 32, mid + 1, r)) return false;
for (long long j = 0; j < 16; ++j) {
st_ans[i + j] =
st_ans[i + j] || st_ans[2 * i + 16 + j] || st_ans[2 * i + 32 + j];
if (st_ans[i + j]) {
for (long long x : st[i + j]) {
if (ans[x]) {
return false;
}
}
}
}
return true;
}
void build(long long i, long long l, long long r) {
if (l == r) {
for (long long j = 0; j < 16; ++j) ans[l * 16 + j] = st_ans[i + j];
return;
}
for (long long j = 0; j < 16; ++j) {
if (st_ans[i + j]) {
st_ans[2 * i + 16 + j] = true;
st_ans[2 * i + 32 + j] = true;
}
}
long long mid = (l + r) >> 1;
build(2 * i + 16, l, mid);
build(2 * i + 32, mid + 1, r);
}
void update(long long i, long long l, long long r, long long sl, long long sr,
long long big, long long v) {
if (l > sr || r < sl) return;
if (sl <= l && r <= sr) {
for (long long j = 0; j < 16; ++j) {
if ((v >> j) & 1)
st_ans[i + j] = true;
else
st[i + j].push_back(big * 16 + j + 16 * sz);
}
return;
}
long long mid = (l + r) >> 1;
update(2 * i + 16, l, mid, sl, sr, big, v);
update(2 * i + 32, mid + 1, r, sl, sr, big, v);
}
void add_edges(long long l, long long r, long long v) {
long long big = l / sz;
l %= sz;
r %= sz;
for (long long i = 0; i < 16; ++i)
if ((v >> i) & 1) ans[big * 16 + i + 16 * sz] = true;
update(0, 0, sz - 1, l, r, big, v);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> k >> q;
for (long long i = 0; i < q; ++i) {
long long l, r, v;
cin >> l >> r >> v;
sweepline.push_back({l, -1, v});
sweepline.push_back({r, 1, v});
}
sort(sweepline.begin(), sweepline.end());
long long curr = -1, cnt_ = 0, start = -1;
for (long long i = 0; i < 2 * q; ++i) {
auto arr = sweepline[i];
if (arr[1] == -1) {
if (curr != -1 && arr[2] != curr) {
cout << "impossible\n";
return 0;
}
curr = arr[2];
if (!cnt_) start = arr[0];
cnt_++;
} else {
if (cnt_ == 1) qu.push_back({start, arr[0], curr});
cnt_--;
if (!cnt_) curr = -1;
}
}
sz = (1 << k);
for (long long i = 0; i < qu.size(); ++i) {
auto [l, r, v] = qu[i];
if (l / sz == r / sz)
add_edges(l, r, v);
else {
add_edges(l, (l / sz) * sz + sz - 1, v);
add_edges((r / sz) * sz, r, v);
for (long long j = (l / sz) * sz + sz; j < (r / sz) * sz; j += sz)
add_edges(j, j + sz - 1, v);
}
}
build(0, 0, sz - 1);
if (!check(0, 0, sz - 1)) {
cout << "impossible\n";
return 0;
}
cout << "possible\n";
for (long long i = 0; i < 32 * sz; i += 16) {
long long x = 0;
for (long long j = 0; j < 16; ++j)
if (ans[i + j]) x += (1 << j);
cout << x << "\n";
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long inv[100005], actual[100005], arr[100005];
int N, Q;
int main() {
cin >> N;
long long sumInv = 0;
for (int i = 0; i < N; ++i) {
cin >> arr[i];
if (i > 0) {
inv[i - 1] = max(arr[i - 1] - arr[i], 0ll);
actual[i - 1] = arr[i - 1] - arr[i];
sumInv += inv[i - 1];
}
}
if (arr[N - 1] + sumInv + 1 < 0) {
cout << (arr[N - 1] + sumInv) / 2 << endl;
} else {
cout << (arr[N - 1] + sumInv + 1) / 2 << endl;
}
cin >> Q;
for (int i = 0; i < Q; ++i) {
int a, b;
long long c;
cin >> a >> b >> c;
a--;
b--;
long long pre = inv[a - 1] + inv[b];
if (a != 0) {
actual[a - 1] = (actual[a - 1] - c);
inv[a - 1] = max(actual[a - 1], 0ll);
}
if (b != N - 1) {
actual[b] = (actual[b] + c);
inv[b] = max(actual[b], 0ll);
} else {
arr[N - 1] += c;
}
sumInv += inv[a - 1] + inv[b] - pre;
if (arr[N - 1] + sumInv + 1 < 0) {
cout << (arr[N - 1] + sumInv) / 2 << endl;
} else {
cout << (arr[N - 1] + sumInv + 1) / 2 << endl;
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve() {}
int main() {
cin.tie(0)->sync_with_stdio(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int x = n / 3;
int rem = n - 3 * x;
if (rem == 0) {
cout << x << " " << x << "\n";
} else if (rem == 1) {
cout << x + 1 << " " << x << "\n";
} else {
cout << x << " " << x + 1 << "\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const double eps = 1e-8;
const int INF = 0x3f3f3f3f;
const int maxn = 1e5 + 5;
const int maxm = 1e6 + 5;
int n, k, a[maxn];
long long A[maxn + 5], AA[maxn + 5], sum[maxn + 5], pw10[maxn + 5];
long long QP(long long a, long long n) {
long long ans = 1, tmp = a;
while (n) {
if (n & 1) ans = ans * tmp % mod;
tmp = tmp * tmp % mod;
n >>= 1;
}
return ans;
}
void init() {
A[0] = 1;
for (int i = 1; i <= maxn; ++i) A[i] = A[i - 1] * i % mod;
AA[maxn] = QP(A[maxn], mod - 2);
for (int i = maxn; i >= 1; --i) AA[i - 1] = AA[i] * i % mod;
pw10[0] = 1;
for (int i = 1; i <= maxn; ++i) pw10[i] = pw10[i - 1] * 10 % mod;
}
long long C(int n, int m) {
if (n < m) return 0;
return A[n] * AA[n - m] % mod * AA[m] % mod;
}
int main() {
init();
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%1d", &a[i]);
for (int i = 1; i <= n; ++i) sum[i] = sum[i - 1] + a[i];
long long ans = 0;
for (int i = 1; i <= n - k; ++i) {
ans = (ans + C(n - 1 - i, k - 1) * pw10[i - 1] % mod * sum[n - i] % mod) %
mod;
ans = (ans + C(n - i, k) * a[n - i + 1] % mod * pw10[i - 1] % mod) % mod;
}
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k, pos_t, i, j, cnt = 0;
cin >> n >> m;
char s[n], t[m];
cin >> s;
cin >> t;
for (j = 0; j < n; j++) {
if (s[j] != t[j]) cnt++;
}
k = cnt;
pos_t = 0;
if (k == 0) {
cout << k << "\n";
return 0;
}
int len = m - n + 1;
for (i = 1; i < len; i++) {
cnt = 0;
for (j = 0; j < n; j++) {
if (s[j] != t[i + j]) cnt++;
if (cnt >= k) break;
}
if (cnt < k) {
k = cnt;
pos_t = i;
}
}
cout << k << "\n";
if (k == 0) return 0;
for (i = 0; i < n; i++) {
if (s[i] != t[pos_t + i]) cout << i + 1 << ' ';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:2000000")
#pragma comment(linker, "/HEAP:2000000")
using namespace std;
void print_width(long long x) {
std::cout << std::fixed;
std::cout << std::setprecision(x);
}
long long power(long long x, long long y, long long p = 1000000007) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
void printArr(long long a[], long long n) {
for (long long i = 0; i < n; i++) cout << a[i] << " ";
cout << '\n';
}
void printVector(std::vector<long long> v) {
for (long long i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << '\n';
}
void printVectorPair(std::vector<pair<long long, long long>> v) {
for (long long i = 0; i < v.size(); i++)
cout << v[i].first << " " << v[i].second << '\n';
;
cout << '\n';
}
void initialize(long long arr[], long long n) {
for (long long i = 0; i <= n; i++) arr[i] = i;
}
long long root(long long arr[], long long i) {
while (arr[i] != i) {
arr[i] = arr[arr[i]];
i = arr[i];
}
return i;
}
void Union(long long arr[], long long a, long long b) {
long long root_a = root(arr, a);
long long root_b = root(arr, b);
arr[root_a] = root_b;
}
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long power_wm(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
std::vector<long long> vsum(std::vector<long long> a) {
std::vector<long long> s(a.size());
s[0] = a[0];
for (long long i = 1; i <= a.size() - 1; i++) {
s[i] = s[i - 1] + a[i];
}
return s;
}
void time() {}
long long sti(string s) {
long long ans = 0;
long long p = 1;
for (long long i = s.size() - 1; i >= 0; i--) {
ans = (ans + ((long long)(s[i] - '0') * p) % 1000000007) % 1000000007;
p = (p * 10) % 1000000007;
}
return ans;
}
long long bfs(long long x, long long y, vector<vector<long long>> &g) {
std::vector<long long> vis(100001, 0);
vis[x] = 1;
queue<long long> q;
q.push(x);
std::vector<long long> level(100001, (long long)1e18);
level[x] = 0;
while (!q.empty()) {
long long p = q.front();
q.pop();
for (long long i = 0; i < g[p].size(); i++) {
long long p2 = g[p][i];
if (vis[p2] == 0) {
if (x == p and y == p2) {
continue;
} else {
q.push(p2);
vis[p2] = 1;
level[p2] = level[p] + 1;
}
}
}
}
return level[y];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
std::vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
long long bit = 1;
for (long long i = 0; i < 63; i++) {
long long c = 0;
for (long long j = 0; j < n; j++)
if ((a[j] & bit) > 0) c++;
if (c >= 3) {
cout << "3";
return 0;
}
bit = bit << 1;
}
vector<vector<long long>> g(n + 1, vector<long long>(0));
;
set<pair<long long, long long>> edge;
bit = 1;
for (long long i = 0; i < 63; i++) {
long long c = 0;
long long p1 = -1, p2 = -1;
for (long long j = 0; j < n; j++)
if ((a[j] & bit) > 0) {
c++;
if (p1 == -1) {
p1 = j;
} else {
p2 = j;
}
}
if (c == 2) {
edge.insert(make_pair(p1, p2));
edge.insert(make_pair(p2, p1));
g[p1].push_back(p2);
g[p2].push_back(p1);
}
bit = bit << 1;
}
long long ans = (long long)1e18;
for (auto x : edge) {
long long a = x.first;
long long b = x.second;
long long le = bfs(a, b, g);
ans = min(ans, le + 1);
}
if (ans < (long long)1e18) {
cout << ans;
} else {
cout << -1;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct lhy {
int x, y, next, f;
} edge[200020];
struct lnm {
int x, y, id;
} Ans[200020], ANS[200020];
pair<int, int> Tree[1010], Fans[200020];
int ans, n, Max, tot, st, ed, Etot, all, Tcnt, S, Aans;
int sum[10][10], root[10], val[10], cnt[10], su[1010], sv[1010];
int son[10010], now[10010], back[10010], pre[10010], dis[10010], sumd[10010];
char s1[110], s2[110];
inline void add(int x, int y, int f) {
edge[++tot].x = x;
edge[tot].y = y;
edge[tot].f = f;
edge[tot].next = son[x];
son[x] = tot;
edge[++tot].x = y;
edge[tot].y = x;
edge[tot].f = 0;
edge[tot].next = son[y];
son[y] = tot;
}
void SAP() {
int i = st, j, t, tmp, flow = 0x3f3f3f3f, flag, minn;
while (dis[st] < ed) {
back[i] = flow;
flag = 0;
t = now[i];
while (t != -1) {
j = edge[t].y;
if (edge[t].f > 0 && dis[j] + 1 == dis[i]) {
flag = 1;
now[i] = t;
pre[j] = t;
if (edge[t].f < flow) flow = edge[t].f;
i = j;
if (i == ed) {
ans += flow;
while (i != st) {
edge[pre[i]].f -= flow;
edge[pre[i] ^ 1].f += flow;
i = edge[pre[i]].x;
}
flow = 0x3f3f3f3f;
}
break;
}
t = edge[t].next;
}
if (flag) continue;
minn = ed - 1;
t = son[i];
while (t != -1) {
if (edge[t].f > 0 && dis[edge[t].y] < minn)
minn = dis[edge[t].y], tmp = t;
t = edge[t].next;
}
now[i] = tmp;
if (!(--sumd[dis[i]])) break;
sumd[dis[i] = minn + 1]++;
if (i != st) flow = back[i = edge[pre[i]].x];
}
}
inline int cmp1(const lnm &a, const lnm &b) {
if (a.x == b.x) return a.y < b.y;
return a.x < b.x;
}
void print(int x) {
if (!x) return;
print(x / 10);
putchar(x % 10 + '0');
}
void doit() {
st = 1, ed = 1 + Max + Etot + 1;
tot = -1;
for (int i = 1; i <= ed; i++) son[i] = -1;
for (int i = 1; i <= Etot; i++) {
add(st, 1 + Max + i, sum[su[i]][sv[i]]);
add(1 + Max + i, su[i] + 1, 0x3f3f3f3f);
add(1 + Max + i, sv[i] + 1, 0x3f3f3f3f);
}
for (int i = 1; i <= Max; i++) add(1 + i, ed, cnt[i]);
ans = 0;
for (int i = 1; i <= ed; i++) now[i] = son[i], dis[i] = 0, sumd[i] = 0;
sumd[0] = ed;
SAP();
if (ans != all) return;
for (int i = 1, now = 1; i <= Max; i++, now *= 10) root[i] = val[i] = now;
for (int i = 1; i <= Tcnt; i++)
ANS[++Aans] = (lnm){root[Tree[i].first], root[Tree[i].second], 0};
int u, v;
for (int i = 1; i <= Etot; i++) {
for (int j = son[i + 1 + Max]; j != -1; j = edge[j].next) {
v = edge[j].y - 1;
if (v < 1 || v > Max) continue;
u = su[i] + sv[i] - v;
for (int k = edge[j ^ 1].f; k; k--)
ANS[++Aans] = (lnm){root[u], ++val[v], 0};
}
}
sort(ANS + 1, ANS + n, cmp1);
for (int i = 1; i < n; i++) Fans[Ans[i].id] = make_pair(ANS[i].x, ANS[i].y);
for (int i = 1; i < n; i++) {
print(Fans[i].first);
putchar(' ');
print(Fans[i].second);
putchar('\n');
}
exit(0);
}
void dfs(int can, int now) {
if (now == ((1 << Max) - 1)) {
doit();
return;
}
if (!can) return;
int j, u, v, flag;
for (j = 0; j < Max; j++)
if (can & (1 << j)) break;
dfs(can ^ (1 << j), now);
for (int s = S ^ now; s; s = (s - 1) & (S ^ now)) {
flag = 1;
for (int i = 0; i < Max; i++)
if (s & (1 << i)) {
u = i + 1, v = j + 1;
if (u > v) swap(u, v);
sum[u][v]--;
if (sum[u][v] < 0) flag = 0;
Tree[++Tcnt] = make_pair(u, v);
}
if (flag) dfs((can ^ (1 << j)) | s, now | s);
for (int i = 0; i < Max; i++)
if (s & (1 << i)) {
u = i + 1, v = j + 1;
if (u > v) swap(u, v);
sum[u][v]++;
Tcnt--;
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1, now = 1; now <= n; i++, now *= 10)
cnt[i] = min(now * 10, n + 1) - now - 1, all += cnt[i], Max = i;
S = (1 << Max) - 1;
int l1, l2;
for (int i = 1; i < n; i++) {
l1 = l2 = 0;
char ch = getchar();
while (ch != '?') ch = getchar();
while (ch == '?') l1++, ch = getchar();
while (ch != '?') ch = getchar();
while (ch == '?') l2++, ch = getchar();
sum[l1][l2]++;
Ans[i] = (lnm){l1, l2, i};
}
sort(Ans + 1, Ans + n, cmp1);
for (int i = 1; i <= Max; i++)
for (int j = i; j <= Max; j++) {
if (i != j) sum[i][j] += sum[j][i], sum[j][i] = 0;
Etot++;
su[Etot] = i;
sv[Etot] = j;
}
dfs(1, 1);
puts("-1");
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t, temp, res;
cin >> s >> t;
reverse(s.begin(), s.end());
if (s == t)
cout << "YES";
else
cout << "NO";
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
using namespace std;
long long MOD = 998244353;
double eps = 1e-12;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
for (int it = 1; it <= t; it++) {
int n;
cin >> n;
bool ans = false;
if (!(n & 1)) {
cout << (n / 2) << " " << (n / 2) << "\n";
ans = true;
} else {
int i = 2;
while (i * i <= n) {
if (n % i == 0) {
cout << (n / i) << " " << (n - (n / i)) << "\n";
ans = true;
break;
}
i++;
}
}
if (!ans) cout << 1 << " " << n - 1 << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
const double eps = 1e-8;
const int MAXN = 4e5 + 10;
const int mod = 1e9 + 7;
using namespace std;
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;
}
int n;
long long T, sum[MAXN];
int a[MAXN];
int p[MAXN], sz;
typedef struct node {
int id;
long long n, m;
} node;
node d[MAXN * 2];
bool cmp(node x, node y) {
if (p[x.n] == p[y.n])
return x.m < y.m;
else
return p[x.n] < p[y.n];
}
long long vip[MAXN], fvip[MAXN];
long long ksm(long long x, long long y) {
long long ans = 1;
while (y) {
if (y & 1) ans = ans * x % mod;
x = x * x % mod;
y = y >> 1;
}
return ans;
}
long long ipv[MAXN], fipv[MAXN];
void init() {
vip[0] = fvip[0] = 1;
ipv[0] = fipv[0] = 1;
for (int i = 1; i <= n; i++)
vip[i] = vip[i - 1] * i % mod, fvip[i] = ksm(vip[i], mod - 2);
for (int i = 1; i <= n; i++)
ipv[i] = ipv[i - 1] * 2 % mod, fipv[i] = ksm(ipv[i], mod - 2);
}
long long ans1[MAXN], Vip;
long long C(long long x, long long y) {
if (y < 0) return 0;
assert(x >= y);
return vip[x] * fvip[y] % mod * fvip[x - y] % mod;
}
int main() {
n = read();
T = read();
sz = sqrt(n);
Vip = ksm(2, mod - 2);
init();
for (int i = 1; i <= n; i++) a[i] = read(), sum[i] = sum[i - 1] + a[i];
for (int i = 1; i <= n; i++) p[i] = (i - 1) / sz + 1;
int cnt = 0;
for (int i = 1; i <= n; i++) {
d[++cnt].id = i;
d[cnt].n = i - 1;
d[cnt].m = min((i - 1) * 1ll, T - sum[i - 1]);
d[++cnt].id = -i;
d[cnt].n = i;
d[cnt].m = min(i * 1ll, T - sum[i]);
}
d[++cnt].id = n + 1;
d[cnt].n = n;
d[cnt].m = min(n * 1ll, T - sum[n]);
sort(d + 1, d + cnt + 1, cmp);
int L = 1;
int R = 0;
long long ans = 1;
for (int i = 1; i <= cnt; i++) {
if (d[i].m < 0) continue;
while (L < d[i].n) {
ans = (2ll * ans - C(L, R) + mod) % mod;
L++;
}
while (L > d[i].n) {
L--;
ans = (ans + C(L, R)) % mod * Vip % mod;
}
while (R < d[i].m) {
R++;
ans = (ans + C(L, R)) % mod;
}
while (R > d[i].m) {
ans = (ans - C(L, R) + mod) % mod;
R--;
}
if (d[i].id < 0)
ans1[-d[i].id] -= (ans * fipv[-d[i].id] % mod);
else
ans1[d[i].id] += (ans * fipv[d[i].id - 1] % mod);
}
for (int i = 1; i <= n + 1; i++) ans1[i] = (ans1[i] + mod) % mod;
ans = 0;
for (int i = 1; i <= n + 1; i++) ans += ans1[i] * (i - 1) % mod, ans %= mod;
printf("%lld\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char a[15];
struct point {
int x, y;
};
point b[12];
int main() {
int n;
cin >> n;
while (n--) {
cin >> a;
int i, j;
int mak = 0;
for (i = 0; i < 12; i++) {
if (a[i] == 'X') {
mak = 1;
break;
}
}
int cnt = 0;
if (mak == 0) {
cout << "0" << endl;
continue;
} else {
cnt = 0;
b[0].x = 1;
b[0].y = 12;
}
int kk = 0;
for (i = 0; i < 6; i++)
if (a[i] == 'X' && a[i + 6] == 'X') {
cnt++;
b[cnt].x = 2;
b[cnt].y = 6;
break;
}
for (i = 0; i < 4; i++) {
if (a[i] == 'X' && a[i + 4] == 'X' && a[i + 8] == 'X') {
cnt++;
b[cnt].x = 3;
b[cnt].y = 4;
break;
}
}
for (i = 0; i < 3; i++) {
if (a[i] == 'X' && a[i + 3] == 'X' && a[i + 6] == 'X' &&
a[i + 9] == 'X') {
cnt++;
b[cnt].x = 4;
b[cnt].y = 3;
break;
}
}
for (i = 0; i < 2; i++) {
if (a[i] == 'X' && a[i + 2] == 'X' && a[i + 4] == 'X' &&
a[i + 6] == 'X' && a[i + 8] == 'X' && a[i + 10] == 'X') {
cnt++;
b[cnt].x = 6;
b[cnt].y = 2;
break;
}
}
int mak1 = 0;
for (i = 0; i < 12; i++) {
if (a[i] == 'O') {
mak1 = 1;
break;
}
}
if (mak1 == 0) {
cnt++;
b[cnt].x = 12;
b[cnt].y = 1;
}
cout << cnt + 1;
for (i = 0; i <= cnt; i++) cout << " " << b[i].x << "x" << b[i].y;
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> d;
string s;
int main() {
cin >> n;
cin >> s;
for (int i = 1; i <= n; ++i) {
if (n % i == 0) d.push_back(i);
}
for (int i = 0; i < d.size(); ++i) {
reverse(s.begin(), s.begin() + d[i]);
}
cout << s << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10, MUD = 1e9 + 7;
int p, k, m;
long long ans = 1;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> p >> k;
if (k == 0 || k == 1) {
int t = p - 1;
if (k == 1) t++;
while (t) {
ans *= p;
t--;
ans = ans % MUD;
}
cout << ans << '\n';
return 0;
}
long long tmp = k;
while (1) {
m++;
if (tmp == 1) break;
tmp *= k;
tmp = tmp % p;
}
int t = (p - 1) / m;
while (t) {
ans *= p;
t--;
ans = ans % MUD;
}
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[20][20];
bool b[20][20];
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
if (a[i][j] == 'W') b[i][j] = true;
}
}
int cnt = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j] == 'P') {
if (a[i + 1][j] == 'W' && b[i + 1][j]) {
cnt++;
b[i + 1][j] = false;
}
if (a[i - 1][j] == 'W' && b[i - 1][j]) {
cnt++;
b[i - 1][j] = false;
}
if (a[i][j + 1] == 'W' && b[i][j + 1]) {
cnt++;
b[i][j + 1] = false;
}
if (a[i][j - 1] == 'W' && b[i][j - 1]) {
cnt++;
b[i][j - 1] = false;
}
}
}
}
cout << cnt;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int mod = 1e9 + 7;
const int inf = (1 << 30) - 1;
const ll infll = (1LL << 61) - 1;
int N, g;
template <typename T>
T gcd(T a, T b) {
return (b ? gcd(b, a % b) : a);
}
template <typename T>
T lcm(T a, T b) {
return a / (gcd(a, b)) * b;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> N;
vector<int> a(N);
for (int i = 0; i < N; i++) {
cin >> a[i];
g = gcd(a[i], g);
}
if (g > 1) {
cout << "YES\n0\n";
} else {
int res = 0;
for (int i = 0; i + 1 < N; i++) {
if (a[i] % 2 == 1) {
if (a[i + 1] % 2 == 0)
res += 2, a[i]++;
else
res++, a[i]++, a[i + 1]++;
}
}
if (a[N - 1] % 2 == 1) res += 2;
cout << "YES\n" << res << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5000006;
const int MOD = 1E9 + 7;
const int inv2 = 500000004;
int ans[N];
int pwr(int b, int e) {
int ans = 1;
while (e) {
if (e & 1) ans = (1LL * ans * b) % MOD;
e >>= 1;
b = (1LL * b * b) % MOD;
}
return ans;
}
void pre() {
for (int i = 0; i < N; ++i) {
ans[i] = i;
}
for (int i = 2; i < N; i += 2) {
ans[i] = 2;
}
for (int i = 3; i * i < N; i += 2) {
if (ans[i] != i) continue;
for (int j = i * i; j < N; j += i) {
if (ans[j] == j) ans[j] = i;
}
}
}
int cal(int x) {
if (x == 1) return 0;
int ret = ((1LL * ans[x] * (ans[x] - 1))) % MOD;
ret = (1LL * ret * inv2) % MOD;
ret = (1LL * ret * (x / ans[x])) % MOD;
ret = (1LL * ret + 1LL * cal(x / ans[x])) % MOD;
return ret;
}
int32_t main(int32_t argc, char const *argv[]) {
pre();
int t, l, r;
cin >> t >> l >> r;
int sum = 0;
int pv = 1;
for (int i = l; i <= r; ++i) {
sum = (1LL * sum + (1LL * pv * cal(i)) % MOD) % MOD;
pv = (1LL * pv * t) % MOD;
}
cout << sum;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void printl(T a, char c = '\n') {
cout << a << c;
}
template <typename T>
inline void print(T a, char c = ' ') {
cout << a << c;
}
template <typename T1, typename T2>
inline void print(T1 a, T2 b) {
cout << a << " " << b << endl;
}
inline void solve() {
long long n, s, k;
cin >> n >> s;
k = s;
if (n * 2 < s) {
printl("YES");
for (long long i = 1; i < n; i++) {
cout << 2 << " ";
s -= 2;
}
cout << s << '\n';
printl(k - 1);
} else if (n * 2 == s) {
printl("YES");
for (long long i = 1; i < n; i++) {
cout << 1 << " ";
s -= 1;
}
cout << s << '\n';
printl(k - n);
} else
printl("NO");
}
signed main() {
long long n = 1;
while (n--) solve();
;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int last[100005];
int main() {
int n;
for (n = 1; n <= 100000; n++) last[n] = -1;
scanf("%d", &n);
int q, x, y;
for (q = 1; q <= n; q++) {
scanf("%d%d", &x, &y);
int ans = 0;
int j;
for (j = 1; j * j <= x; j++) {
if (x % j == 0) {
if (last[j] < q - y) ans++;
last[j] = q;
int u = x / j;
if (u != j) {
if (last[u] < q - y) ans++;
last[u] = q;
}
}
}
printf("%d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, d, n, t;
int main() {
cin >> t;
while (t--) {
cin >> n >> a >> b >> c >> d;
if (((a - b) * n > (c + d)) || ((a + b) * n < (c - d)))
cout << "NO" << endl;
else
cout << "YES" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int k2, k3, k5, k6, ans256, ans32, ans, i, j, n, k;
cin >> k2 >> k3 >> k5 >> k6;
k = min(k5, k6);
ans256 = min(k2, k);
k2 -= ans256;
k5 -= ans256;
k6 -= ans256;
ans32 = min(k2, k3);
cout << (ans256 * 256) + (ans32 * 32) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[3];
cin >> a[0] >> a[1] >> a[2];
sort(a, a + 3);
int cnt = 0;
while (a[0] + a[1] <= a[2]) {
cnt++, a[0]++;
}
cout << cnt << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, a[N], b[N], l[N], r[N];
int main() {
int t;
scanf("%d", &t);
while (t--) {
bool flag = false;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d%d", l + i, r + i), a[i] = i;
sort(a + 1, a + 1 + n,
[](int x, int y) { return l[x] == l[y] ? r[x] < r[y] : l[x] < l[y]; });
for (int i = 1, R = 0; i <= n; ++i)
if (i == 1)
R = r[a[i]];
else if (l[a[i]] > R) {
for (int j = 1; j <= n; ++j) b[a[j]] = j < i ? 1 : 2;
flag = true;
break;
} else
R = max(R, r[a[i]]);
if (flag) {
for (int i = 1; i <= n; ++i) printf("%d ", b[i]);
puts("");
} else
puts("-1");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const long long ooo = 9223372036854775807ll;
const int _cnt = 1000 * 1000 + 7;
const int _p = 1000 * 1000 * 1000 + 7;
const int N = 100005;
const double PI = acos(-1.0);
const double eps = 1e-9;
int o(int x) { return x % _p; }
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
void file_put() {
freopen("filename.in", "r", stdin);
freopen("filename.out", "w", stdout);
}
long long Pow(long long x, long long k, long long p) {
long long ans = 1;
for (; k; k >>= 1, (x *= x) %= _p)
if (k & 1) (ans *= x) %= _p;
return ans;
}
const int _M = 100;
template <class V = long long, long long _p = (long long)1e9 + 7>
struct L_B {
V base[_M + 5][_M + 5], a[_M + 5], b[_M + 5], t;
int D, cnt;
long long pp = 13331;
inline void Init(int _D) {
D = _D, memset(base, 0, sizeof(base));
cnt = 0;
}
inline bool I(V a[]) {
memset(b, 0, sizeof(b));
for (int i = (0); i <= (D - 1); ++i)
if (a[i]) {
if (!base[i][i]) {
t = Pow(a[i], _p - 2, _p);
for (int j = (i); j <= (D - 1); ++j)
base[i][j] = a[j] = (long long)a[j] * t % _p;
cnt++;
return 1;
}
b[i] = a[i];
for (int j = (D - 1); j >= (i); --j)
a[j] = (a[j] - (long long)a[i] * base[i][j] % _p) % _p;
}
return 0;
}
inline bool Insert(V _a[], V _b[] = NULL) {
memcpy(a, _a, D * sizeof(V));
bool tt = I(a);
if (!tt && _b) memcpy(_b, b, D * sizeof(V));
return tt;
}
inline void Normalize() {
for (int i = (0); i <= (D - 1); ++i)
if (base[i][i])
for (int j = (0); j <= (i - 1); ++j)
if (base[j][i])
for (int k = (D - 1); k >= (i); --k)
base[j][k] =
(base[j][k] - (long long)base[i][k] * base[j][i] % _p) % _p;
for (int i = (0); i <= (D - 1); ++i)
for (int j = (0); j <= (D - 1); ++j)
if (base[i][j] < 0) base[i][j] += _p;
}
inline L_B &Clone() const {
L_B p;
for (int i = (0); i <= (D - 1); ++i)
for (int j = (0); j <= (D - 1); ++j) p.base[i][j] = base[i][j];
p.D = D, p.cnt = cnt;
return p;
}
friend L_B &Merge(const L_B &a, const L_B &b) {
L_B c = a.Clone();
for (int i = (0); i <= (b.D - 1); ++i) c.Insert(b.base[i]);
return c;
}
inline V Get_Hash_Code() const {
V ans = D ^ cnt % _p;
for (int i = (0); i <= (D - 1); ++i)
for (int j = (0); j <= (D - 1); ++j)
ans = ((long long)ans * pp + base[i][j]) % _p;
return ans;
}
friend bool operator==(const L_B &_a, const L_B &_b) {
L_B a = _a.Clone(), b = _b.Clone();
a.Normalize(), b.Normalize();
return a.Get_Hash_Code() == b.Get_Hash_Code();
}
inline void Print() const {
puts("\n_______________\n\n");
cout << "D"
<< " => " << (D) << endl;
puts("\n_______________\n\n");
cout << "cnt"
<< " => " << (cnt) << endl;
puts("\n_______________\n\n");
cout << "base"
<< ":\n";
for (int i = (0); i <= (D - 1); ++i)
for (int j = (0); j <= (D - 1); ++j)
cout << "base"
<< "[" << (i) << "][" << (j) << "]= " << base[i][j]
<< ((j == D - 1) ? "\n\n" : " ");
}
};
int m, d, k, id = 0;
L_B<> B;
long long a[15], ret;
map<long long, int> M;
int main() {
scanf("%d%d", &m, &d);
while (m--) {
scanf("%d", &k), B.Init(d);
for (int i = (1); i <= (k); ++i) {
for (int j = (0); j <= (d - 1); ++j) scanf("%I64d", &a[j]);
B.Insert(a);
}
B.Normalize();
ret = B.Get_Hash_Code();
if (!M.count(ret)) M[ret] = ++id;
printf("%d ", M[ret]);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
void solve() {
int n;
cin >> n;
vector<int> diff(n);
for (auto &x : diff) cin >> x;
int curr = 1;
reverse(diff.begin(), diff.end());
int sum = 0;
int add = 1;
for (auto x : diff) {
sum += 1ll * curr * x % MOD;
sum %= MOD;
curr = (2ll * curr + add) % MOD;
add = 2ll * add % MOD;
}
cout << sum << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize "trapv"
using namespace std;
vector<string> split(const string& s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) v.push_back(x);
return move(v);
}
template <typename T, typename... Args>
inline string arrStr(T arr, int n) {
stringstream s;
s << "[";
for (int i = 0; i < n - 1; i++) s << arr[i] << ",";
s << arr[n - 1] << "]";
return s.str();
}
inline void __evars_begin(int line) { cerr << "#" << line << ": "; }
template <typename T>
inline void __evars_out_var(vector<T> val) {
cerr << arrStr(val, val.size());
}
template <typename T>
inline void __evars_out_var(T* val) {
cerr << arrStr(val, 10);
}
template <typename T>
inline void __evars_out_var(T val) {
cerr << val;
}
inline void __evars(vector<string>::iterator it) { cerr << endl; }
template <typename T, typename... Args>
inline void __evars(vector<string>::iterator it, T a, Args... args) {
cerr << it->substr((*it)[0] == ' ', it->length()) << "=";
__evars_out_var(a);
cerr << "; ";
__evars(++it, args...);
}
const long long MaxN = 1e2 + 5;
long long st[4 * MaxN];
long long f(long long x, long long y) { return x + y; }
void build(long long a[], long long node, long long start, long long end) {
if (start == end) {
st[node] = a[end];
} else {
long long mid = (start + end) / 2;
build(a, 2 * node + 1, start, mid);
build(a, 2 * node + 2, mid + 1, end);
st[node] = f(st[2 * node + 1], st[2 * node + 2]);
}
}
void update(long long node, long long start, long long end, long long pos,
long long val) {
if (pos < start || pos > end)
return;
else if (start == end && pos == start) {
st[node] = val;
return;
}
long long mid = (start + end) / 2;
update(2 * node + 1, start, mid, pos, val);
update(2 * node + 2, mid + 1, end, pos, val);
st[node] = f(st[2 * node + 1], st[2 * node + 2]);
}
long long query(long long start, long long end, long long l, long long r,
long long node) {
if (r < start || l > end)
return 0;
else if (start >= l && end <= r)
return st[node];
long long mid = (start + end) / 2;
return f(query(start, mid, l, r, 2 * node + 1),
query(mid + 1, end, l, r, 2 * node + 2));
}
long long find(long long k, long long node, long long l, long long r) {
if (l == r) return l;
long long mid = (l + r) / 2;
long long t = st[node * 2 + 1];
if (k < t) {
return find(k, node * 2 + 1, l, mid);
} else {
return find(k - t, node * 2 + 2, mid + 1, r);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
clock_t clk = clock();
int t = 1;
while (t--) {
long long n;
cin >> n;
long long a[n];
for (int i = 0; i < n; i++) cin >> a[i];
memset(st, 0, sizeof(st));
build(a, 0, 0, n - 1);
long long qry1 = 0, qry2 = 0, qry3 = 0, ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
qry1 = 0, qry2 = 0, qry3 = 0;
if (i > 0) qry1 = query(0, n - 1, 0, i - 1, 0);
if (j < n - 1) qry2 = query(0, n - 1, j + 1, n - 1, 0);
qry3 = query(0, n - 1, i, j, 0);
ans = max(ans, qry1 + qry2 + (j - i + 1) - qry3);
}
}
cout << ans << endl;
}
cerr << '\n'
<< "Time (in s): " << double(clock() - clk) * 1.0 / CLOCKS_PER_SEC
<< '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int cnt[100];
string ans, t;
int main() {
int T, n, k;
cin >> T;
while (T--) {
cin >> n >> k;
t.clear();
cin >> t;
memset(cnt, 0, sizeof(cnt));
sort(t.begin(), t.end());
ans.clear();
for (int i = 0; i < n; i++) cnt[t[i] - 'a']++;
int it = 0;
while (cnt[it] == 0) it++;
if (n == k) {
printf("%c\n", t[n - 1]);
continue;
}
if (cnt[it] < k) {
it++;
while (cnt[it] == 0) it++;
printf("%c\n", t[k - 1]);
} else {
ans += (char)(it + 'a');
cnt[it] -= k;
while (cnt[it] == 0) it++;
if (cnt[it] != n - k) {
for (int i = k; i < n; i++) ans += t[i];
cout << ans << endl;
continue;
} else {
for (int i = 1; i <= (n - k - 1) / k + 1; i++) ans += (char)(it + 'a');
cout << ans << endl;
continue;
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, mod;
const int N = 1e6 + 7;
vector<int> v[N];
int sz[N];
int dfs(int x) {
sz[x]++;
for (int i : v[x])
if (!sz[i]) sz[x] += dfs(i);
return sz[x];
}
long long pw(int x, int y) {
if (!y) return 1;
long long cnt = pw(x, y / 2);
return (((cnt * cnt) % mod) * (y & 1 ? x : 1)) % mod;
}
int main() {
cin >> n >> m >> mod;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
long long zarb = 1, cnt = 0;
for (int i = 1; i <= n; i++)
if (!sz[i]) zarb = (zarb * dfs(i)) % mod, cnt++;
if (!(cnt - 1))
cout << 1 % mod;
else
cout << (zarb * pw(n, cnt - 2)) % mod;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100500;
bool F[N];
int n;
bool check(int q) {
if (n / q <= 2) return false;
for (int i = 0; i < q; i++) {
int t;
for (t = i; t < n; t += q)
if (!F[t]) break;
if (t >= n) return true;
}
return false;
}
int main(int argc, char **argv) {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> F[i];
}
for (int t = 1; t <= (int)sqrt((double)n); t++) {
if (n % t) continue;
if (check(t) || check(n / t)) {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct Tpoint {
double x, y;
Tpoint() {}
Tpoint(double _x, double _y) {
x = _x;
y = _y;
}
inline void read() { scanf("%lf%lf", &x, &y); }
inline void show() { printf("%lf %lf\n", x, y); }
inline double norm() { return sqrt(((x) * (x)) + ((y) * (y))); }
};
inline Tpoint operator+(const Tpoint &a, const Tpoint &b) {
return Tpoint(a.x + b.x, a.y + b.y);
}
inline Tpoint operator-(const Tpoint &a, const Tpoint &b) {
return Tpoint(a.x - b.x, a.y - b.y);
}
inline Tpoint operator*(const Tpoint &a, const double &b) {
return Tpoint(a.x * b, a.y * b);
}
inline Tpoint operator/(const Tpoint &a, const double &b) {
return Tpoint(a.x / b, a.y / b);
}
inline double det(const Tpoint &a, const Tpoint &b) {
return a.x * b.y - a.y * b.x;
}
inline double dot(const Tpoint &a, const Tpoint &b) {
return a.x * b.x + a.y * b.y;
}
const int limit = 12;
int nf, ne, ns;
int rf, re, rs;
double lf, le, ls;
int df, de, sel[limit + 1];
double f[limit + 1][21][21], damageF[limit + 1], damageE[limit + 1];
inline double dfs(int x, int s) {
if (s == ns) {
memset(f, 0, sizeof(f));
for (int i = 0; i < limit; ++i) {
for (int j = 0; j <= nf; ++j)
for (int k = 0; k <= ne; ++k) {
for (int dj = 0; dj + sel[i] <= 2 && j + dj <= nf; ++dj)
for (int dk = 0; dk + dj + sel[i] <= 2 && k + dk <= ne; ++dk) {
f[i + 1][j + dj][k + dk] =
max(f[i + 1][j + dj][k + dk],
f[i][j][k] + dj * (damageF[i] + 2 * lf) * df +
dk * (damageE[i] + 2 * le) * de);
}
}
}
return f[limit][nf][ne];
}
if (x == limit) return 0;
double res = 0;
for (int i = 0; i <= 2 && s + i <= ns; ++i) {
for (int x0 = 0; x0 < limit; ++x0) {
damageF[x0] += i * max(0.0, min(x + ls, x0 + lf) - max(x - ls, x0 - lf));
damageE[x0] += i * max(0.0, min(x + ls, x0 + le) - max(x - ls, x0 - le));
}
sel[x] = i;
res = max(dfs(x + 1, s + i), res);
sel[x] = 0;
for (int x0 = 0; x0 < limit; ++x0) {
damageF[x0] -= i * max(0.0, min(x + ls, x0 + lf) - max(x - ls, x0 - lf));
damageE[x0] -= i * max(0.0, min(x + ls, x0 + le) - max(x - ls, x0 - le));
}
}
return res;
}
int main() {
scanf("%d%d%d", &nf, &ne, &ns);
scanf("%d%d%d", &rf, &re, &rs);
lf = sqrt(rf * rf - 1.0), le = sqrt(re * re - 1.0), ls = sqrt(rs * rs - 1.0);
scanf("%d%d", &df, &de);
memset(sel, 0, sizeof(sel));
printf("%.10f\n", dfs(0, 0));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long MODD = 1e9 + 7;
int q;
long long a, b, u, v, k;
long long calc(long long u, long long v, long long k, long long o = 0) {
if (u > v) swap(u, v);
if (u < 1 || k <= 0) return 0;
long long p = 1, res = 0;
while (p * 2LL <= v) p *= 2LL;
long long tmp = min(p, k);
if (u <= p) {
res = (tmp * (tmp + 1) / 2 % MODD) * u % MODD;
res += (o * tmp % MODD) * u % MODD + calc(u, v - p, k - p, o + p);
res %= MODD;
} else {
res = (tmp * (tmp + 1) / 2 % MODD) * p % MODD;
res += (o * tmp % MODD) * p % MODD;
res += calc(u - p, v - p, k, o) + calc(p, v - p, k - p, o + p) +
calc(u - p, p, k - p, o + p);
}
return res;
}
int main() {
scanf("%d", &q);
while (q-- > 0) {
scanf("%I64d %I64d %I64d %I64d %I64d", &a, &b, &u, &v, &k);
long long res = (calc(u, v, k) + calc(a - 1, b - 1, k)) % MODD;
res = (res - calc(a - 1, v, k) - calc(u, b - 1, k) + MODD * MODD) % MODD;
printf("%lld\n", res);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int MAXN = 1e6 + 10;
long long inv[MAXN];
long long fact[MAXN];
long long esp(long long x, long long e) {
if (e == 0) return 1;
if (e % 2 == 0) return esp((x * x) % mod, e / 2);
return (esp((x * x) % mod, e / 2) * x) % mod;
}
long long g[MAXN];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, k;
cin >> n >> k;
for (long long x = 1; x <= n; x++) inv[x] = esp(x, mod - 2);
long long sum = 0;
for (long long i = 1; i <= k; i++) g[i] = 1, sum = (sum + g[i]) % mod;
for (long long i = k + 1; i <= n; i++) {
g[i] = (sum * inv[i - 1]) % mod;
sum = (sum + g[i] - g[i - k]) % mod;
sum = (sum + mod) % mod;
}
fact[0] = 1;
for (long long i = 1; i <= n; i++) fact[i] = (fact[i - 1] * i) % mod;
long long cres = 0;
for (long long i = 1; i <= n; i++) cres = (cres + g[i]) % mod;
cres = (cres * fact[n - 1]) % mod;
cout << (fact[n] + mod - cres) % mod << "\n";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int C = 26;
void add(int &x, int y) {
x += y;
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
}
int fix(int x) {
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
return x;
}
int pw(int a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret = 1ll * ret * a % MOD;
b >>= 1;
a = 1ll * a * a % MOD;
}
return ret;
}
const int MAXN = 1e6 + 10;
void solve() {
int n, m, k;
cin >> n >> m >> k;
if (n % 2 == 0) {
cout << "Marsel\n";
return;
}
int mx = 1;
for (int i = 2; i * i <= m; i++) {
if (m % i == 0) {
mx = max(mx, m / i);
}
}
cout << (mx >= k && mx < m ? "Timur\n" : "Marsel\n");
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int te = 1;
for (int w = 1; w <= te; w++) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, answer = 0;
cin >> n;
int arr[n][2], range[n];
for (int r = 0; r < n; r++) {
cin >> arr[r][0] >> arr[r][1];
}
for (int r = 0; r < n; r++) {
range[r] = arr[r][0] + arr[r][1];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (arr[j][0] == range[i]) {
if (arr[i][0] == range[j]) {
answer++;
}
}
}
}
if (answer > 0) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void mycode();
const long long int mod = 998244353;
long long int ceil(long long int a, long long int b) { return (a + b - 1) / b; }
long long int min(long long int a, long long int b) {
if (a > b)
return b;
else
return a;
}
bool bit_check(long long int a, int i) {
if ((a & ((long long)1 << (i - 1)))) return 1;
return 0;
}
long long int bit_toggle(long long int a, int i) {
return (a ^ ((long long)1 << (i - 1)));
}
long long int bit_sum(long long int a, int i) {
return a + ((long long)1 << (i - 1));
}
long long int bit_sub(long long int a, int i) {
return a - ((long long)1 << (i - 1));
}
long long int mod_power(long long int x, long long int y) {
long long int p = mod;
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int power_of(long long int a, int b) {
if (a == 0) return -1;
return 1 + power_of(a / b, b);
}
long long int power(long long int a, int b) {
long long int c = 1;
if (b > 0)
while (b--) c = c * a;
return c;
}
double T, c, h;
double fx(long long int x) {
if (x & 1) {
} else
return 999999999;
double xx = (x - 1.0) / 2.0;
return abs(T - (h + c * xx + h * xx) / (2.0 * xx + 1.0));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
mycode();
return 0;
}
void mycode() {
int t, f = 0;
cin >> t;
bool flag = 0;
while (t--) {
f++;
cin >> h >> c >> T;
double value = (1LL << 60) + 5;
long long int mi, k = 30;
long long int left = 1, right = (1LL << 31), shift = (1LL << 30);
upside:
for (long long int i = left; i <= right; i += shift) {
if (value > fx(i)) {
mi = i;
value = fx(i);
} else if (i < mi && value + 0.0000001 > fx(i)) {
mi = i;
value = fx(i);
}
}
if (shift != 1) {
left = max(mi - shift, left);
right = min(mi + shift, right);
shift = (1LL << k);
k--;
goto upside;
}
if (abs(T - (h + c + 0.0) / 2.0) < value) {
mi = 2;
}
cout << mi << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
const int maxn = 120;
vector<pair<int, int> > e[maxn];
int ans, vis[maxn], flag, book[maxn];
void dfs(int second, int t, int cur) {
if (flag) return;
if (second == t) {
ans++;
flag = 1;
return;
}
for (auto i : e[second]) {
if (vis[i.first] || i.second != cur) continue;
vis[i.first] = 1;
dfs(i.first, t, cur);
vis[i.first] = 0;
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int x, y, z;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> x >> y >> z;
e[x].push_back({y, z});
e[y].push_back({x, z});
}
int q;
cin >> q;
while (q--) {
ans = 0;
cin >> x >> y;
memset(book, 0, sizeof(book));
for (auto i : e[x]) {
if (book[i.second]) continue;
book[i.second] = 1;
flag = 0;
memset(vis, 0, sizeof(vis));
vis[x] = 1;
dfs(x, y, i.second);
}
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
inline long long read() {
bool f = false;
char ch = getchar();
long long res = 0;
while (ch < '0' || '9' < ch) f |= (ch == '-'), ch = getchar();
while ('0' <= ch && ch <= '9') res = 10 * res + ch - '0', ch = getchar();
return f ? -res : res;
}
const int N = 1e5 + 10;
int a[N], n;
int fa[N];
int get(int x) {
if (x == fa[x]) return x;
return fa[x] = get(fa[x]);
}
void join(int x, int y) {
x = get(x), y = get(y);
if (x == y) return;
if (y < x) swap(x, y);
if (y > n)
fa[x] = y;
else
fa[y] = x;
}
int pos[N];
struct node {
int l, r;
} tree[N << 2];
int maxn[N << 2], add[N << 2];
void push_up(int p) { maxn[p] = max(maxn[p << 1], maxn[p << 1 | 1]); }
void build(int p, int l, int r) {
tree[p].l = l, tree[p].r = r;
add[p] = 0;
maxn[p] = 1;
if (l == r) {
return;
}
int mid = (l + r) >> 1;
build(p << 1, l, mid);
build(p << 1 | 1, mid + 1, r);
}
void spread(int p) {
if (add[p] != 0) {
maxn[p << 1] = add[p];
maxn[p << 1 | 1] = add[p];
add[p << 1] = add[p];
add[p << 1 | 1] = add[p];
add[p] = 0;
}
}
void change(int p, int l, int r, int v) {
if (l <= tree[p].l && r >= tree[p].r) {
maxn[p] = v;
add[p] = v;
return;
}
spread(p);
int mid = (tree[p].l + tree[p].r) >> 1;
if (l <= mid) change(p << 1, l, r, v);
if (r > mid) change(p << 1 | 1, l, r, v);
push_up(p);
}
long long query(int p, int l, int r) {
if (l <= tree[p].l && r >= tree[p].r) {
return maxn[p];
}
spread(p);
int mid = (tree[p].l + tree[p].r) >> 1;
long long ans = 0;
if (l <= mid) ans = max(ans, query(p << 1, l, r));
if (r > mid) ans = max(ans, query(p << 1 | 1, l, r));
return ans;
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
n = read();
build(1, 1, n);
for (int i = 1; i <= n + 1; i++) fa[i] = i;
for (int i = 1; i <= n; i++) {
a[i] = read();
pos[a[i]] = i;
}
bool flag = true;
for (int i = 1; i <= n; i++) {
int maxnum = query(1, 1, n);
if (maxnum != query(1, get(pos[i]), get(pos[i]))) {
flag = false;
break;
} else {
if (get(pos[i] + 1) > n)
change(1, get(pos[i]), get(pos[i] + 1), 0);
else
change(1, get(pos[i]), get(pos[i] + 1), maxnum + 1);
join(pos[i], pos[i] + 1);
}
}
if (flag)
puts("Yes");
else
puts("No");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int sz[(30 * 300009)], l[(30 * 300009)], r[(30 * 300009)], cnt = 0;
int newnode() {
l[cnt] = r[cnt] = -1;
sz[cnt] = 0;
cnt++;
return cnt - 1;
}
int root;
void insert(int N) {
int u = root;
sz[u]++;
for (int i = 30 - 1; i >= 0; i--) {
if (N & (1 << i)) {
if (r[u] == -1) r[u] = newnode();
u = r[u];
} else {
if (l[u] == -1) l[u] = newnode();
u = l[u];
}
sz[u]++;
}
}
int ans;
bool search(int u, int h, int num, int N) {
if (u == -1 || sz[u] <= 0) return false;
sz[u]--;
if (h == -1) {
ans = num;
return true;
}
if (N & (1 << h)) {
return search(r[u], h - 1, num, N) ||
search(l[u], h - 1, num | (1 << h), N);
} else {
return search(l[u], h - 1, num, N) ||
search(r[u], h - 1, num | (1 << h), N);
}
}
int A[300009], P[300009], N;
int main() {
root = newnode();
scanf("%d", &N);
for (int i = 0; (i) < (N); (i)++) scanf("%d", &A[i]);
for (int i = 0; (i) < (N); (i)++) {
scanf("%d", &P[i]);
insert(P[i]);
}
for (int i = 0; (i) < (N); (i)++) {
search(root, 30 - 1, 0, A[i]);
printf("%d ", ans);
}
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char s[200020];
const unsigned long long base = 37;
unsigned long long expmod(unsigned long long a, unsigned long long b) {
unsigned long long rlt = 1;
for (; b; a = a * a, b >>= 1)
if (b & 1) rlt = rlt * a;
return rlt;
}
unsigned long long pw[200020];
unsigned long long calc(int l, int r) {
if ((r - l) & 1) {
unsigned long long rlt = 0;
for (int i = l; i < r; i++) rlt = rlt * base + s[i];
return rlt;
}
int m = l + r >> 1;
unsigned long long L = calc(l, m);
unsigned long long R = calc(m, r);
if (L > R) swap(L, R);
return L * pw[r - m] + R;
}
int main() {
pw[0] = 1;
for (int i = 1; i < 200020; i++) pw[i] = pw[i - 1] * base;
scanf("%s", s);
int n = strlen(s);
unsigned long long fir = calc(0, n);
scanf("%s", s);
unsigned long long sec = calc(0, n);
puts(fir == sec ? "YES" : "NO");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int mas[16];
int perm[16];
int matr[4][4];
int main() {
int n;
cin >> n;
for (int i = 0; i < n * n; i++) {
cin >> mas[i];
perm[i] = i;
}
if (n == 1) {
cout << mas[0] << endl;
cout << mas[0] << endl;
return 0;
}
while (next_permutation(perm, perm + n * n)) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
matr[i][j] = mas[perm[i * n + j]];
}
}
int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0, h = 0;
for (int i = 0; i < n; i++) {
a += matr[0][i];
b += matr[min(1, n - 1)][i];
c += matr[min(2, n - 1)][i];
d += matr[i][0];
e += matr[i][min(1, n - 1)];
f += matr[i][min(2, n - 1)];
g += matr[i][i];
h += matr[i][n - 1 - i];
}
if (a == b && a == c && a == d && a == e && a == f && a == g && a == h) {
cout << a << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cout << matr[i][j] << " ";
}
cout << endl;
}
return 0;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long a[501][501], ma[501], mi[501];
signed main() {
long long n, m;
cin >> n >> m;
long long t = sqrt((signed)n);
memset(mi, 0x7f, sizeof(mi));
memset(ma, 0x80, sizeof(ma));
while (t * (t + 1) < n) t++;
for (long long x = 1; x <= t + 1; x++)
for (long long y = 1; y <= t && (x - 1) * t + y <= n; y++) cin >> a[x][y];
for (long long x = 1; x <= t + 1; x++, a[x][0] = a[x - 1][t])
for (long long y = 1, z; y <= t && (x - 1) * t + y <= n; y++)
cin >> z, a[x][y] -= z, a[x][y] = -a[x][y], a[x][y] += a[x][y - 1],
ma[x] = max(ma[x], a[x][y]),
mi[x] = min(mi[x], a[x][y]);
while (m--) {
long long l, r;
cin >> l >> r;
long long x1 = (l - 1) / t + 1, x2 = (r - 1) / t + 1;
long long y1 = l - (x1 - 1) * t, y2 = r - (x2 - 1) * t;
if (a[x2][y2] - a[x1][y1 - 1] != 0)
cout << -1 << endl;
else if (x1 != x2) {
long long ans = -10000000000000000, mni = 10000000000000000;
for (long long x = y1; x <= t; x++)
ans = max(ans, a[x1][x]), mni = min(mni, a[x1][x]);
for (long long x = 1; x <= y2; x++)
ans = max(ans, a[x2][x]), mni = min(mni, a[x2][x]);
for (long long x = x1 + 1; x <= x2 - 1; x++)
ans = max(ans, ma[x]), mni = min(mni, mi[x]);
if (mni - a[x1][y1 - 1] < 0)
cout << -1 << endl;
else
cout << ans - a[x1][y1 - 1] << endl;
} else {
long long ans = -10000000000000000, mni = 10000000000000000;
for (long long x = y1; x <= y2; x++)
ans = max(ans, a[x1][x]), mni = min(mni, a[x1][x]);
if (mni - a[x1][y1 - 1] < 0)
cout << -1 << endl;
else
cout << ans - a[x1][y1 - 1] << endl;
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void trace(T a) {
cout << a << "\n";
}
template <typename T, typename... Args>
void trace(T a, Args... args) {
cout << a << " ";
trace(args...);
}
int recNum = 0;
void prTabs() {
for (int i = 0; i < recNum; i++) cout << " ";
}
template <typename... Args>
void recInit(Args... args) {
prTabs();
trace("rec(", args..., ")");
recNum++;
}
template <typename T>
void recEnd(T a) {
prTabs();
trace("->", a);
recNum--;
}
int n, m, a, b, c;
int op[300010];
vector<int> g[300010];
pair<int, int> dfs(int v) {
if ((int)g[v].size() == 0) {
return {1, 1};
} else {
pair<int, int> res;
if (op[v]) {
res = {300010, 0};
} else {
res = {0, 0};
}
for (int child : g[v]) {
pair<int, int> df = dfs(child);
res.second += df.second;
if (op[v]) {
res.first = min(df.first, res.first);
} else {
res.first += df.first;
}
}
return res;
}
}
int main() {
scanf("%d\n", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", op + i);
}
for (int i = 2; i <= n; i++) {
scanf("%d", &a);
g[a].push_back(i);
}
pair<int, int> res = dfs(1);
printf("%d\n", res.second - res.first + 1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
const int oo = 0x3f3f3f3f;
const int maxn = 2100;
int n, m;
double f[maxn + 5][maxn + 5];
int main() {
scanf("%d%d", &n, &m);
f[0][0] = 1;
for (int ipj = (1), ipj_end_ = (n + m + 1); ipj < ipj_end_; ++ipj) {
for (int i = (0), i_end_ = (ipj + 1); i < i_end_; ++i) {
int j = ipj - i;
if (!i)
f[i][j] = 1. / (j + 1);
else if (!j)
f[i][j] = 1;
else {
double &u = f[j][i - 1], &v = f[j - 1][i];
double invnj = 1. / (j + 1);
double a = u + invnj, b = (1 - u - (1 + j - j * v) * invnj), c = -invnj,
d = (1 + j - j * v) * invnj;
f[i][j] = invnj;
double mid = -c / a;
if (mid > 0) {
if (a + b < 0)
chkmax(f[i][j], c + d);
else
chkmax(f[i][j], (a + b) * mid + c + d);
}
if (mid < 1) {
if (b < 0)
chkmax(f[i][j], b * mid + d);
else
chkmax(f[i][j], b + d);
}
}
}
}
printf("%.15f %.15f\n", f[n][m], 1 - f[n][m]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
stack<pair<long long int, long long int> > s;
long long int prod = 1;
long long int totalAdds = 0;
int flag = 0;
int overflow = 0;
for (int i = 0; i < t; i++) {
string str;
cin >> str;
if (flag == 1) continue;
if (str == "add") {
if (overflow || totalAdds + prod >= (1LL << 32)) {
flag = 1;
} else {
totalAdds += prod;
}
continue;
}
if (str == "for") {
long long int n;
scanf("%lld", &n);
if (!overflow && ((1LL << 32) - 1LL) / n >= prod) {
prod = prod * n;
} else {
overflow = 1;
}
s.push(make_pair(n, overflow));
continue;
}
if (str == "end") {
if (s.top().second == 0) {
prod = prod / s.top().first;
s.pop();
} else {
s.pop();
if (s.empty()) {
overflow = 0;
} else {
overflow = s.top().second;
}
}
}
}
if (flag || totalAdds >= (1LL << 32)) {
printf("OVERFLOW!!!\n");
} else {
printf("%lld\n", totalAdds);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool prefix(string s, string t) {
if (min(s.length(), t.length()) == t.length()) return false;
for (long long i = 0; i < s.length(); i++) {
if (s[i] != t[i]) return false;
}
return true;
}
int32_t main() {
ios_base ::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
string s, t;
cin >> s >> t;
string ans = "---";
char minn = 'Z';
vector<long long> v;
char b;
long long i;
long long n, k = 0;
string f = s;
long long g = 1;
set<char> sq;
vector<char> vx;
long long d, m;
for (long long i = 0; i < s.length(); i++) sq.insert(f[i]);
for (set<char>::iterator i = sq.begin(); i != sq.end(); i++)
vx.push_back(*i);
for (long long i = 0; i < min(s.length(), t.length()); i++) {
if (s[i] < t[i]) {
cout << s << "\n";
goto x;
} else if (t[i] < s[i])
break;
}
for (long long i = 0; i < s.length(); i++) {
if (s[i] < minn) minn = s[i];
}
for (long long i = 0; i < s.length(); i++) {
if (s[i] == minn) v.push_back(i);
}
for (i = 0; i < s.length(); i++) {
if (s[i] != minn) break;
}
n = v.size();
if (i < v[n - 1])
swap(s[i], s[v[n - 1]]);
else {
while (g < vx.size()) {
b = vx[g];
for (i = 0; i < s.length(); i++) {
if (s[i] > b) break;
}
m = i;
for (long long i = s.length() - 1; i >= 0; i--) {
if (s[i] == b) {
d = i;
break;
}
}
if (d > m) {
swap(s[d], s[m]);
break;
} else {
g++;
}
}
}
k = 0;
for (long long i = 0; i < min(s.length(), t.length()); i++) {
if (t[i] < s[i]) {
ans = "---";
break;
} else if (s[i] < t[i]) {
ans = s;
break;
} else
ans = "---";
}
if (prefix(s, t))
cout << s << "\n";
else if (k == 1)
cout << "---\n";
else
cout << ans << "\n";
x:;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4010;
const int inf = 2147483647;
long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') x = x * 10ll + ch - '0', ch = getchar();
return x * f;
}
int n, m, sz[N];
long long a[N], f[N][N];
int solve(int l, int r) {
if (l > r) return 0;
int p = l;
for (int i = l + 1; i <= r; i++)
if (a[i] < a[p]) p = i;
sz[p] = r - l + 1;
int L = solve(l, p - 1), R = solve(p + 1, r);
for (int i = 0; i <= sz[L]; i++)
for (int j = 0; j <= sz[R]; j++)
f[p][i + j] = max(f[p][i + j], f[L][i] + f[R][j] - 2ll * i * j * a[p]),
f[p][i + j + 1] = max(f[p][i + j + 1],
f[L][i] + f[R][j] + (long long)m * a[p] -
2ll * (i + 1) * (j + 1) * a[p] + a[p]);
return p;
}
int main() {
n = read(), m = read();
for (int i = 1; i <= n; i++) a[i] = read();
printf("%lld\n", f[solve(1, n)][m]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, ret = 0;
cin >> n;
ret = n;
for (int i = 2; i * i <= n; i++)
while (n % i == 0) {
ret += n / i, n /= i;
}
ret += (n > 1);
cout << ret << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
int a[n];
map<int, int> f;
for (int i = 0; i < n; i++) {
cin >> a[i];
f[a[i]]++;
}
map<int, int>::iterator it;
int c = 0, d = 0;
for (it = f.begin(); it != f.end(); it++) {
c = c + (d + (it->second)) / (it->first);
d = ((it->second) + d) % (it->first);
}
cout << c << endl;
}
int main() {
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
int dblcmp(double d) {
if (fabs(d) < eps) return 0;
return (d > 0) ? 1 : -1;
}
int n, m, T, r;
const int N = 1000100;
struct Me {
int s[N][2];
int cnt;
int errorr, all;
void clear() {
cnt = 0;
errorr = 0;
all = 0;
}
void counterrorr() {
errorr = 0;
for (int i = 0; i < cnt; ++i) errorr += s[i][1] - 1;
}
bool operator<(const Me& A) const { return errorr < A.errorr; }
bool gao(int f, int g) {
cnt = 0;
errorr = 0;
all = 0;
while (f && g) {
if (f > g) {
s[cnt][0] = 0;
s[cnt][1] = f / g;
if (f % g == 0) {
s[cnt][1]--;
f = g;
} else
f %= g;
all += s[cnt++][1];
if (all > n) return false;
} else if (f < g) {
s[cnt][0] = 1;
s[cnt][1] = g / f;
if (g % f == 0) {
s[cnt][1]--;
g = f;
} else
g %= f;
all += s[cnt++][1];
if (all > n) return false;
} else {
if (f * g != 1) return false;
if (cnt == 0 || s[cnt - 1][0] == 0) {
s[cnt][0] = 1;
s[cnt][1] = g / f;
g %= f;
all += s[cnt++][1];
if (all > n) return false;
} else {
s[cnt][0] = 0;
s[cnt][1] = f / g;
f %= g;
all += s[cnt++][1];
if (all > n) return false;
}
}
}
return all == n;
}
} ans[2];
void solve() {
ans[0].errorr = 99999999;
int dt = 1;
for (int i = 0; i <= r; ++i) {
if (!ans[dt].gao(i, r)) continue;
ans[dt].counterrorr();
if (ans[dt] < ans[1 - dt]) dt = 1 - dt;
}
dt = 1 - dt;
if (ans[dt].errorr == 99999999)
printf("IMPOSSIBLE\n");
else {
printf("%d\n", ans[dt].errorr);
int pre = ans[dt].s[0][0];
for (int i = 0; i < ans[dt].cnt; ++i)
for (int j = 0; j < ans[dt].s[i][1]; ++j)
if (ans[dt].s[i][0] == pre)
printf("T");
else
printf("B");
printf("\n");
}
}
int main() {
while (cin >> n >> r) solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
struct pt {
double x, y;
} a, b, c;
int T;
bool zero(double a) { return fabs(a) < eps; }
double sqr(double a) { return a * a; }
pt operator+(pt a, pt b) { return (pt){a.x + b.x, a.y + b.y}; }
pt operator-(pt a, pt b) { return (pt){a.x - b.x, a.y - b.y}; }
pt operator*(pt a, double k) { return (pt){a.x * k, a.y * k}; }
double cross(pt a, pt b) { return a.x * b.y - a.y * b.x; }
double sqr(pt a) { return sqr(a.x) + sqr(a.y); }
double dis(pt a) { return sqrt(sqr(a)); }
void print(pt a) { printf("%.9lf %.9lf ", a.x, a.y); }
bool check(pt *p) {
if (cross(p[1] - p[0], p[2] - p[1]) * cross(p[3] - p[0], p[2] - p[3]) > -eps)
return 0;
if (cross(p[0] - p[1], p[3] - p[0]) * cross(p[2] - p[1], p[3] - p[2]) > -eps)
return 0;
return 1;
}
void gauss(double mat[5][6], double *X) {
int Ct = 4;
for (int i = 1; i < Ct; i++) {
if (zero(mat[i][i])) {
int k;
for (int j = i + 1; j <= Ct; j++)
if (!zero(mat[j][i])) k = j;
for (int j = 1; j <= Ct + 1; j++) swap(mat[k][j], mat[i][j]);
}
if (!zero(mat[i][i]))
for (int j = i + 1; j <= Ct; j++) {
double mul = mat[j][i] / mat[i][i];
for (int k = 1; k <= Ct + 1; k++) mat[j][k] -= mul * mat[i][k];
}
}
X[Ct] = mat[Ct][Ct + 1] / mat[Ct][Ct];
for (int i = Ct - 1; i >= 1; i--) {
X[i] = mat[i][Ct + 1];
for (int j = i + 1; j <= Ct; j++) X[i] -= mat[i][j] * X[j];
if (!zero(mat[i][i])) X[i] /= mat[i][i];
}
}
bool solve(pt a, pt b, pt c) {
pt p[4];
double t0 = sqr(a) - sqr(b), t1 = sqr(a) - sqr(c);
double t2 = (a.x - b.x) * 2.0, t3 = (a.y - b.y) * 2.0;
double t4 = (a.x - c.x) * 2.0, t5 = (a.y - c.y) * 2.0;
double X[5], mat[5][6] = {{0, 0, 0, 0, 0, 0},
{0, t2, t3, 0, 0, t0},
{0, 0, 0, t4, t5, t1},
{0, 1, 0, 1, 0, 2 * a.x},
{0, 0, 1, 0, 1, 2 * a.y}};
gauss(mat, X);
p[0].x = X[1], p[0].y = X[2];
p[1].x = X[3], p[1].y = X[4];
p[3] = b * 2 - p[0];
p[2] = c * 2 - p[1];
if (check(p)) {
printf("YES\n");
for (int i = 0; i < 4; i++) print(p[i]);
puts("");
return 0;
}
return 1;
}
void error() { printf("NO\n\n"); }
int main() {
scanf("%d", &T);
while (T--) {
cin >> a.x >> a.y >> b.x >> b.y >> c.x >> c.y;
if (zero(cross(a - b, a - c)))
error();
else if (solve(a, b, c) && solve(b, a, c) && solve(c, a, b))
error();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
str = " " + str;
set<long long int> s[26];
for (long long int i = 1; i < str.size(); i++) s[str[i] - 'a'].insert(i);
long long int t;
cin >> t;
while (t--) {
long long int type;
cin >> type;
if (type == 1) {
long long int x;
char z;
cin >> x >> z;
s[str[x] - 'a'].erase(x);
s[z - 'a'].insert(x);
str[x] = z;
}
if (type == 2) {
long long int m, n;
cin >> m >> n;
long long int ans = 0;
for (long long int i = 0; i < 26; i++) {
auto it = s[i].lower_bound(m);
if (it != s[i].end() && *it <= n) {
ans++;
}
}
cout << ans << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
if (n % 2 == 1)
cout << "Ehab\n";
else
cout << "Mahmoud\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char M[40][30];
char C[30];
int n;
int substr(int l) {
for (int i = 0; i < n; i++) {
for (int j = 0; j + l - 1 < strlen(M[i]); j++) {
int f = 0;
for (int k = 0; k < l; k++) {
if (C[k] != M[i][j + k]) f = 1;
}
if (f == 0) return (1);
}
}
return (0);
}
int push(int l) {
for (int i = l - 1; i >= 0; i--) {
if (C[i] < 'z') {
C[i] = C[i] + 1;
for (int j = i + 1; j < l; j++) {
C[j] = 'a';
}
return (1);
}
}
return (0);
}
void length(int l) {
for (int i = 0; i < l; i++) {
C[i] = 'a';
}
while (true) {
if (!substr(l)) {
for (int i = 0; i < l; i++) {
printf("%c", C[i]);
}
printf("\n");
exit(0);
}
if (!push(l)) return;
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s", M[i]);
}
for (int i = 1; i < 20; i++) {
length(i);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100010;
const int MOD = 1000000007;
struct Vector {
int v[2];
};
struct Matrix {
int matrix[2][2];
};
void Print(const Matrix &A) {
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 2; ++j) {
cout << A.matrix[i][j] << " ";
}
cout << endl;
}
cout << endl;
}
Matrix operator*(const Matrix &left, const Matrix &right) {
Matrix result;
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 2; ++j) {
result.matrix[i][j] = 0;
for (int c = 0; c < 2; ++c) {
result.matrix[i][j] =
(result.matrix[i][j] +
(long long)left.matrix[i][c] * right.matrix[c][j]) %
MOD;
}
}
}
return result;
}
Vector operator*(const Vector &left, const Matrix &right) {
Vector result;
for (int i = 0; i < 2; ++i) {
result.v[i] = 0;
for (int c = 0; c < 2; ++c) {
result.v[i] =
(result.v[i] + (long long)left.v[c] * right.matrix[c][i]) % MOD;
}
}
return result;
}
Vector operator+(const Vector &left, const Vector &right) {
Vector result;
for (int i = 0; i < 2; ++i) {
result.v[i] = (left.v[i] + right.v[i]) % MOD;
}
return result;
}
Matrix BinPow(int n) {
Matrix result;
result.matrix[0][0] = 1;
result.matrix[0][1] = 0;
result.matrix[1][0] = 0;
result.matrix[1][1] = 1;
Matrix a;
a.matrix[0][0] = 0;
a.matrix[0][1] = 1;
a.matrix[1][0] = 1;
a.matrix[1][1] = 1;
while (n > 0) {
if (n % 2 == 1) {
result = result * a;
--n;
} else {
a = a * a;
n /= 2;
}
}
return result;
}
Vector Fib(int n) {
Vector fib;
fib.v[0] = 0;
fib.v[1] = 1;
return fib * BinPow(n - 1);
}
struct Node {
Vector sum_fib;
Matrix add;
Node() {
add.matrix[0][0] = 1;
add.matrix[0][1] = 0;
add.matrix[1][0] = 0;
add.matrix[1][1] = 1;
}
Node(int _add, int x) { add = BinPow(_add), sum_fib = Fib(x); }
};
int a[MAX_N];
Node tree[4 * MAX_N];
Node Combine(const Node &left, const Node &right, const Matrix &add) {
Node answer;
answer.add = add;
answer.sum_fib = (left.sum_fib + right.sum_fib) * add;
return answer;
}
void Build(int v, int tl, int tr) {
if (tl == tr) {
tree[v] = Node(0, a[tl]);
} else {
int tm = (tl + tr) / 2;
Build(v * 2, tl, tm);
Build(v * 2 + 1, tm + 1, tr);
tree[v] = Combine(tree[v * 2], tree[v * 2 + 1], tree[v].add);
}
}
void Update(int v, int tl, int tr, int l, int r, const Matrix &delta) {
if (tl == l && tr == r) {
tree[v].sum_fib = tree[v].sum_fib * delta;
tree[v].add = tree[v].add * delta;
} else {
int tm = (tl + tr) / 2;
if (tm < l) {
Update(v * 2 + 1, tm + 1, tr, l, r, delta);
} else if (tm >= r) {
Update(v * 2, tl, tm, l, r, delta);
} else {
Update(v * 2, tl, tm, l, tm, delta);
Update(v * 2 + 1, tm + 1, tr, tm + 1, r, delta);
}
tree[v] = Combine(tree[v * 2], tree[v * 2 + 1], tree[v].add);
}
}
Vector GetSum(int v, int tl, int tr, int l, int r) {
if (tl == l && tr == r) {
return tree[v].sum_fib;
} else {
int tm = (tl + tr) / 2;
if (tm < l) {
return GetSum(v * 2 + 1, tm + 1, tr, l, r) * tree[v].add;
} else if (tm >= r) {
return GetSum(v * 2, tl, tm, l, r) * tree[v].add;
} else {
return (GetSum(v * 2, tl, tm, l, tm) +
GetSum(v * 2 + 1, tm + 1, tr, tm + 1, r)) *
tree[v].add;
}
}
}
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
Build(1, 0, n - 1);
for (int i = 0; i < m; ++i) {
int tp;
cin >> tp;
if (tp == 1) {
int l, r, x;
cin >> l >> r >> x;
--l;
--r;
Update(1, 0, n - 1, l, r, BinPow(x));
} else {
int l, r;
cin >> l >> r;
--l;
--r;
cout << ((GetSum(1, 0, n - 1, l, r).v[1] % MOD) + MOD) % MOD << endl;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 50;
const int MAXS = (1 << 20) + 5;
template <typename T>
inline void read(T &AKNOI) {
T x = 0, flag = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') flag = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
AKNOI = flag * x;
}
template <typename T>
inline void cmax(T &x, T y) {
if (x < y) x = y;
}
double k;
int n, m1, m2, S1, S2;
int g1[N], g2[N];
int bit[MAXS], dp1[MAXS], ok[MAXS], dp2[MAXS];
void init() {
read(n);
scanf("%lf", &k);
m1 = n / 2, S1 = (1 << m1);
m2 = n - m1, S2 = (1 << m2);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
int x;
read(x);
if (!x) continue;
if (j < m1) {
g1[i] |= (1 << j);
} else {
g2[i] |= (1 << (j - m1));
}
if (i < m1) {
g1[j] |= (1 << i);
} else {
g2[j] |= (1 << (i - m1));
}
}
}
}
void solve() {
for (int s = 1; s < S2; ++s) {
bit[s] = bit[s >> 1] + (s & 1);
}
for (int s = 1; s < S1; ++s) {
for (int i = 0; i < m1; ++i) {
if ((s >> i) & 1) {
cmax(dp1[s], dp1[s & g1[i]] + 1);
}
}
}
int ans = dp1[S1 - 1];
ok[0] = 1;
dp2[0] = S1 - 1;
for (int s = 1; s < S2; ++s) {
for (int i = 0; i < m2; ++i) {
if ((s >> i) & 1) {
if (!ok[s ^ (1 << i)]) continue;
if (s & g2[i + m1] ^ s ^ (1 << i)) continue;
ok[s] = 1;
dp2[s] = (dp2[s ^ (1 << i)] & g1[i + m1]);
}
}
if (ok[s]) {
cmax(ans, dp1[dp2[s]] + bit[s]);
}
}
printf("%.10lf\n", k * k * (ans - 1) / ans / 2);
}
int main() {
init();
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long x, now, N, M, K;
long long pow(long long A, long long K) {
long long ans = 1ll;
while (K) {
if (K & 1) ans = (long long)ans * A % 1000000009;
A = (long long)A * A % 1000000009;
K >>= 1;
}
return ans % 1000000009;
}
int main() {
cin >> N >> M >> K;
if (M == 0) {
cout << 0 << endl;
return 0;
}
if ((K - 1) * (N - M + 1) + N - M >= N) {
cout << M % 1000000009 << endl;
return 0;
}
x = 0;
now = N - (N - M) * K;
x = (pow(2ll, now / K) * x % 1000000009 +
(pow(2ll, now / K + 1) - 2 + 1000000009) * K % 1000000009 + now % K) %
1000000009;
x += (N - M) * (K - 1) % 1000000009;
x %= 1000000009;
cout << x % 1000000009 << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 501011;
int a[MAXN];
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
if (a[1] + a[2] > a[n])
printf("-1\n");
else
printf("1 2 %d\n", n);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int M, ALen, BLen;
char D, A[2010], B[2010];
long long ans = 0, F[2010][2010];
long long dfs(char* arr, int pos, long long sum, bool islim) {
if (arr[pos] < '0' || arr[pos] > '9') return sum == 0;
if (!islim && F[pos][sum] != -1) return F[pos][sum];
int lim = islim ? (arr[pos] - '0') : 9;
long long ret = 0, nsum = 0;
for (int i = 0; i <= lim; ++i) {
nsum = (sum * 10 + i) % M;
if (pos % 2 == 1 && i == D - '0') continue;
if (pos % 2 == 0 && i != D - '0') continue;
ret = (ret + dfs(arr, pos + 1, nsum, islim && i == lim)) % mod;
}
if (!islim) F[pos][sum] = ret;
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
memset(F, -1, sizeof(F));
cin >> M >> D;
cin >> A + 1;
cin >> B + 1;
ALen = strlen(A + 1);
BLen = strlen(B + 1);
int isAMagic = 1;
long long sum = 0;
for (int i = 1; i <= ALen; ++i) {
sum = (sum * 10 + A[i] - '0') % M;
if (i % 2 == 1 && A[i] == D) {
isAMagic = 0;
break;
} else if (i % 2 == 0 && A[i] != D) {
isAMagic = 0;
break;
}
}
if (sum) isAMagic = 0;
ans = (dfs(B, 1, 0, 1) + mod - dfs(A, 1, 0, 1) + isAMagic) % mod;
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int sum_of_digits(int x) {
int sum = 0;
while (x) {
sum += x % 10;
x /= 10;
}
return sum;
}
int main() {
long long int n, ans = 0;
cin >> n;
int a[10000] = {0}, j = 0;
long long int digits = 0, m = n;
while (m) {
digits++;
m /= 10;
}
if (digits == 1) {
for (int i = 1; i <= 10; i++) {
if (i + sum_of_digits(i) == n) {
ans++;
a[j++] = i;
}
}
} else {
for (int i = n; i >= n - (9 * digits); i--) {
if (i + sum_of_digits(i) == n) {
ans++;
a[j++] = i;
}
}
}
cout << ans << "\n";
for (int i = ans - 1; i >= 0; i--) {
cout << a[i] << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int x;
cin >> x;
while (x % 10 == 0) x /= 10;
string s = to_string(x);
int n = s.length();
for (int i = 0; i < n / 2; i++) {
if (s[i] != s[n - i - 1]) {
cout << "NO" << endl;
return;
}
}
cout << "YES" << endl;
return;
}
int main() {
int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long max_n = 1e5 + 5;
map<pair<long long, long long>, bool> wn, ls;
vector<bool> w, l;
bool win(long long s, long long e) {
if (s > e) return true;
if (wn.count({s, e}) > 0) return wn[{s, e}];
if (e & 1) {
if (s & 1)
return wn[{s, e}] = false;
else
return wn[{s, e}] = true;
} else {
if (s > (e / 2)) {
if (s & 1)
return wn[{s, e}] = true;
else
return wn[{s, e}] = false;
} else if (s > (e / 4))
return wn[{s, e}] = true;
else
return wn[{s, e}] = win(s, (e / 4));
}
}
bool lose(long long s, long long e) {
if (ls.count({s, e}) > 0) return ls[{s, e}];
if (e < (s * 2)) return ls[{s, e}] = true;
return ls[{s, e}] = win(s, (e / 2));
}
long long res(long long pos, bool win) {
if (pos) {
if (win) {
if (w[pos])
return res(pos - 1, false);
else
return res(pos - 1, true);
} else {
if (l[pos])
return res(pos - 1, false);
else
return res(pos - 1, true);
}
}
if (win and w[pos]) return true;
if (!win and l[pos]) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
w.resize(t);
l.resize(t);
for (long long i = 0; (1 > 0 and i <= t - 1) or (1 < 0 and i >= t - 1);
i += 1) {
long long s, e;
cin >> s >> e;
w[i] = win(s, e);
l[i] = lose(s, e);
}
cout << res(t - 1, true) << " " << res(t - 1, false) << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
char inp[5];
void try_catch(long long int l, long long int r) {
long long int mid = l + rand() % (r - l + 1);
printf("%lld %lld\n", mid, mid);
fflush(stdout);
scanf("%s", inp);
if (inp[0] == 'Y') exit(0);
}
int main() {
srand(time(NULL));
long long int n, k;
cin >> n >> k;
long long int l = 1, r = n;
while (1) {
while (r - l < 100) {
try_catch(max(1LL, l - k), min(n, r + k));
l = max(1LL, l - 2 * k);
r = min(n, r + 2 * k);
}
long long int mid = (l + r) / 2;
printf("%lld %lld\n", l, mid);
fflush(stdout);
scanf("%s", inp);
if (inp[0] == 'Y') {
if (l == mid) exit(0);
r = min(n, mid + k);
l = max(1LL, l - k);
} else {
l = max(1LL, mid - k);
r = min(n, r + k);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long s, n, m;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) s += (m + i % 5) / 5;
cout << s;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int32_t t, n, a;
cin >> t;
while (t--) {
cin >> n;
vector<int32_t> v;
for (int i = 0; i < (n); i++) {
cin >> a;
v.push_back(a);
}
int32_t first = -1;
int32_t last = -1;
for (int i = 0; i < (n); i++) {
if (v[i] == 1) {
first = i;
break;
}
}
for (int i = n - 1; i >= 0; i--) {
if (v[i] == 1) {
last = i;
break;
}
}
int32_t answ = 0;
if (first == last) {
answ = 0;
} else {
for (int i = first; i < last; i++) {
if (v[i] == 0) {
answ++;
}
}
}
cout << answ << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
long long N, C1, C2, adults = 0, ans = INFINITY;
string s;
cin >> N >> C1 >> C2 >> s;
for (int i = 0; i < N; i++) adults += s[i] == '1';
for (int i = 1; i <= adults; i++) {
long long cost = i * (C1 + C2) - 2 * C2 * N +
C2 * ((N % i) * (N / i + 1) * (N / i + 1) +
(i - (N % i)) * (N / i) * (N / i));
ans = min(ans, cost);
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 60;
const long double EPS = 1e-12;
const long double PI = acos(-1);
int n;
int x[9], y[9];
bool isUpper(char c) { return c >= 'A' && c <= 'Z'; }
bool isLower(char c) { return c >= 'a' && c <= 'z'; }
bool isLetter(char c) { return c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z'; }
bool isDigit(char c) { return c >= '0' && c <= '9'; }
char toLower(char c) { return (isUpper(c)) ? (c + 32) : c; }
char toUpper(char c) { return (isLower(c)) ? (c - 32) : c; }
bool isPowOf2(int i) { return (i & i - 1) == 0; }
bool srtDes(long long x, long long y) { return (x > y); }
long long gcd(long long a, long long b) {
while (b) {
long long temp = a % b;
a = b, b = temp;
}
return a;
}
long long lcm(long long x, long long y) { return x * y / gcd(x, y); }
long long extended_euclid(long long a, long long b, long long& x,
long long& y) {
long long xx = y = 0;
long long yy = x = 1;
while (b) {
long long q = a / b;
long long t = b;
b = a % b;
a = t;
t = xx;
xx = x - q * xx;
x = t;
t = yy;
yy = y - q * yy;
y = t;
}
return a;
}
long double pow(long double num, long long n) {
long double res = 1;
while (n) {
if (n % 2 == 1) res *= num;
num *= num;
n /= 2;
}
return res;
}
bool isPrime(unsigned long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (unsigned long long i = 5; i <= sqrt(n); i = i + 6) {
if (n % i == 0 || n % (i + 2) == 0) return false;
}
return true;
}
void buildTable(string& w, vector<int>& t) {
t = vector<int>(w.length());
int i = 2, j = 0;
t[0] = -1;
t[1] = 0;
while (i < w.length()) {
if (w[i - 1] == w[j]) {
t[i] = j + 1;
i++;
j++;
} else if (j > 0)
j = t[j];
else {
t[i] = 0;
i++;
}
}
return;
}
int kmp(string& s, string& w) {
int m = 0, i = 0;
vector<int> t;
buildTable(w, t);
while (m + i < s.length()) {
if (w[i] == s[m + i]) {
i++;
if (i == w.length()) return m;
} else {
m += i - t[i];
if (i > 0) i = t[i];
}
}
return s.length();
}
void input();
void solve();
void output();
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
input();
solve();
output();
return 0;
}
void input() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> x[i] >> y[i];
return;
}
void solve() {
if (n == 1) {
cout << -1 << endl;
return;
}
if (n == 2) {
if (x[1] == x[2] || y[1] == y[2]) {
cout << -1 << endl;
return;
}
cout << abs((x[2] - x[1]) * (y[2] - y[1])) << endl;
return;
}
int x_max = *max_element(x + 1, x + 1 + n);
int x_min = *min_element(x + 1, x + 1 + n);
int y_max = *max_element(y + 1, y + 1 + n);
int y_min = *min_element(y + 1, y + 1 + n);
cout << (x_max - x_min) * (y_max - y_min) << endl;
return;
}
void output() { return; }
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int a[6];
for (int i = 0; i < 6; i++) cin >> a[i];
cout << (a[0] + a[1] + a[2]) * (a[0] + a[1] + a[2]) - a[0] * a[0] -
a[2] * a[2] - a[4] * a[4];
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
unsigned int T;
cin >> T;
while (T--) {
unsigned int s, i, e;
cin >> s >> i >> e;
unsigned int a = (s + i + e - 1) / 2;
cout << (i <= a ? min(a - i, e) + 1U : 0U) << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
while (cin >> n >> m) {
int a[1000], sum = 0, cnt = 0;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = n - 1; i >= 0; i--) {
sum += a[i], cnt++;
if (sum >= m) {
cout << cnt << endl;
break;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, k;
string t, s;
vector<int> be;
vector<int> en;
vector<int> res;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> a >> b >> k;
cin >> t;
s = "1" + t + "1";
for (int i = 1; i < s.length(); ++i) {
if (s[i] == '0' && s[i - 1] == '1') be.push_back(i);
}
en.resize(be.size());
for (int i = 0; i < be.size(); ++i) {
int j = be[i];
while (s[j] == '0') ++j;
en[i] = j - 1;
}
int num = 0;
for (int i = 0; i < be.size(); ++i) num += ((en[i] - be[i] + 1) / b);
bool fl = true;
for (int i = 0; fl && i < be.size(); ++i) {
int ii = be[i];
int jj = en[i];
while (fl && jj - ii + 1 >= b) {
res.push_back(ii + b - 1);
ii += b;
--num;
if (num < a) fl = false;
}
}
cout << res.size() << endl;
for (int i = 0; i < res.size(); ++i) cout << res[i] << " ";
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int power(int x, int y) {
int result = 1;
for (int counter = 0; counter < y; counter++) result *= x;
return result;
}
int main() {
int N, b, p;
cin >> N >> b >> p;
int resultBottles = 0, resultP = p * N;
int maxPower = 0;
while (N > 1) {
for (int counter = 0; counter < 30; counter++) {
if (pow(2, counter) <= N && pow(2, counter + 1) > N) {
maxPower = counter;
break;
}
}
resultBottles += (2 * b + 1) * power(2, maxPower) / 2;
N = power(2, maxPower) / 2 + (N - power(2, maxPower));
}
cout << resultBottles << " " << resultP << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
class BinTree : vector<int> {
public:
explicit BinTree(int k = 0) { assign(k + 1, 0); }
int lowbit(int k) { return k & -k; }
int sum(int k) { return k > 0 ? sum(k - lowbit(k)) + (*this)[k] : 0; }
int last() { return size() - 1; }
void add(int k, int w) {
if (k > last()) return;
(*this)[k] += w;
add(k + lowbit(k), w);
}
};
int N, M;
int A[300005];
int idxs[300005];
BinTree bt(600010);
int minidx[300005], maxidx[300005];
void solve() {
int head = 300000;
for (int i = 0; i < M; i++) {
int a = A[i];
int idx = idxs[a];
int v = bt.sum(idx);
maxidx[a] = max(maxidx[a], v);
minidx[a] = min(minidx[a], 1);
bt.add(idx, -1);
bt.add(head, 1);
idxs[a] = head;
head--;
}
for (int a = 1; a <= N; a++) {
int idx = idxs[a];
maxidx[a] = max(maxidx[a], bt.sum(idx));
}
for (int i = 1; i <= N; i++) {
cout << minidx[i] << " " << maxidx[i] << endl;
}
}
int main() {
cin >> N >> M;
for (int i = 0; i < M; i++) {
cin >> A[i];
}
for (int a = 1; a <= N; a++) {
int idx = 300005 + a;
idxs[a] = idx;
bt.add(idx, 1);
minidx[a] = a;
maxidx[a] = a;
}
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int P;
int ksm(int a, int b, int P) {
int c = 1, d = a;
while (b) {
if (b & 1) c = (long long)c * d % P;
d = (long long)d * d % P;
b >>= 1;
}
return c;
}
vector<int> ans;
int main() {
int n, m, a, q, now, i, C;
cin >> n >> m >> a >> q;
now = a % q;
for (i = 1;; i++) {
if (now == 1) break;
now = (long long)now * a % q;
}
P = i;
now = 1;
C = 1;
for (i = 1; i <= n; i++) {
ans.push_back(ksm(a, now, q));
if (i <= m)
C = (long long)C * (m - i + 1) % P * ksm(i, P - 2, P) % P;
else
C = 0;
now = (now + C) % P;
}
reverse(ans.begin(), ans.end());
for (auto it : ans) printf("%d ", it);
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int Max = 2001;
const int def = 0x3f3f3f3f;
long long a[Max], b[Max], aa[Max], bb[Max], aaa[Max], bbb[Max];
int main() {
long long i, j, h;
int n, m;
while (scanf("%d %d", &n, &m) != EOF) {
for (i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
aaa[i] = aa[i] = aaa[i - 1] + a[i];
for (j = i - 1; j >= 1; j--) {
aaa[j] = aaa[j] + a[i] - a[i - j];
aa[j] = min(aa[j], aaa[j]);
}
}
for (i = 1; i <= m; i++) {
scanf("%lld", &b[i]);
bbb[i] = bb[i] = bbb[i - 1] + b[i];
for (j = i - 1; j >= 1; j--) {
bbb[j] += b[i] - b[i - j];
bb[j] = min(bb[j], bbb[j]);
}
}
long long s;
long long shuchu = -1;
scanf("%lld", &s);
for (i = 0; i <= n; i++)
for (j = 0; j <= m; j++) {
if (aa[i] * bb[j] <= s) shuchu = max(shuchu, i * j);
}
printf("%lld\n", shuchu);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100100;
const int MAX_M = 500100;
vector<int> A[MAX_N];
pair<int, int> mu[MAX_M];
bool mviz[MAX_M];
vector<int> ans;
void euler(int nod) {
while (A[nod].size() && mviz[A[nod][A[nod].size() - 1]]) {
A[nod].pop_back();
}
while (A[nod].size()) {
int it = A[nod][A[nod].size() - 1];
mviz[it] = true;
int v = ((mu[it].first == nod) ? (mu[it].second) : (mu[it].first));
A[nod].pop_back();
euler(v);
while (A[nod].size() && mviz[A[nod][A[nod].size() - 1]]) {
A[nod].pop_back();
}
}
ans.push_back(nod);
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> mu[i].first >> mu[i].second;
A[mu[i].first].push_back(i);
A[mu[i].second].push_back(i);
}
int nod = 0;
for (int i = 1; i <= n; i++) {
if (A[i].size() & 1) {
if (!nod) {
nod = i;
} else {
mu[++m] = make_pair(nod, i);
A[nod].push_back(m);
A[i].push_back(m);
nod = 0;
}
}
}
euler(1);
if (ans.size() % 2 == 0) {
ans.push_back(1);
}
cout << ans.size() - 1 << '\n';
for (int i = 0; i < (int)ans.size() - 1; i++) {
if (i % 2 == 0) {
cout << ans[i] << ' ' << ans[i + 1] << '\n';
} else {
cout << ans[i + 1] << ' ' << ans[i] << '\n';
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000 + 10;
struct Graph {
int id, next, num;
bool flag;
} g[MAXN * 2];
int tot, n, N, cd[MAXN], st[MAXN];
bool flag;
void Add(int first, int second, int z) {
++cd[first], g[++tot].id = second, g[tot].num = z, g[tot].flag = true,
g[tot].next = st[first], st[first] = tot;
}
vector<int> w, v;
void DFS(int first) {
if (!cd[first]) return;
for (int i = st[first]; i != -1; i = g[i].next)
if (g[i].flag) {
--cd[first];
g[i].flag = false;
DFS(g[i].id);
w.push_back(g[i].num);
}
}
int main() {
cin >> n;
if (n & 1) puts("-1"), exit(0);
if (n == 2) puts("0 1 0"), exit(0);
if (n == 4) puts("0 1 3 2 0"), exit(0);
N = (n - 4) / 2;
memset(st, -1, sizeof(st));
for (int i = 2; i < n - 2; ++i) {
if (i == n / 2)
Add(i / 2, 1, i);
else if (i == n / 2 - 1)
Add(i / 2, N, i);
else
Add(i / 2, (i * 2 % n) / 2, i);
}
DFS(1);
reverse(w.begin(), w.end());
for (int i = 0; i < (int)w.size(); ++i) {
if (w[i] == n / 2)
v.push_back(n / 2), v.push_back(0), v.push_back(1);
else if (w[i] == n / 2 - 1)
v.push_back(n / 2 - 1), v.push_back(n - 1), v.push_back(n - 2);
else
v.push_back(w[i]);
}
int p = 0;
for (; v[p]; ++p)
;
rotate(v.begin(), v.begin() + p, v.end());
for (int i = 0; i < (int)v.size(); ++i) printf("%d ", v[i]);
puts("0");
fclose(stdin);
fclose(stdout);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 200 + 5;
int n, K;
int d[MX];
int dis[MX][MX];
vector<int> G[MX];
int dp[MX][MX], ans[MX], path[MX];
void dfs(int u, int fa) {
for (int i = 1; i <= n; i++) dp[u][i] = d[dis[u][i]] + K;
for (auto v : G[u]) {
if (v == fa) continue;
dfs(v, u);
for (int i = 1; i <= n; i++) dp[u][i] += min(dp[v][ans[v]], dp[v][i] - K);
}
ans[u] = 1;
for (int i = 2; i <= n; i++) {
if (dp[u][i] < dp[u][ans[u]]) ans[u] = i;
}
}
void get_ans(int u, int fa, int i) {
path[u] = i;
for (auto v : G[u]) {
if (v == fa) continue;
if (dp[v][ans[v]] < dp[v][i] - K)
get_ans(v, u, ans[v]);
else
get_ans(v, u, i);
}
}
int main() {
scanf("%d%d", &n, &K);
for (int i = 1; i < n; i++) scanf("%d", &d[i]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) dis[i][j] = i == j ? 0 : 1e9;
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
dis[u][v] = dis[v][u] = 1;
}
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
}
}
dfs(1, 0);
get_ans(1, 0, ans[1]);
printf("%d\n", dp[1][ans[1]]);
for (int i = 1; i <= n; i++) printf("%d%c", path[i], " \n"[i == n]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
using ll = long long;
const char E = '\n';
const int N = 105;
const int mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll x, y = 0, n, ans = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x;
if (x >= y) {
ans += (x - y) * (n - x + 1);
} else {
ans += (y - x) * x;
}
y = x;
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int T, N, i, j;
string S, R;
vector<string> V;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> T;
for (i = 1; i <= T; i++) {
cin >> S;
if (S == "pwd") {
cout << "/";
for (j = 0; j < V.size(); j++) {
cout << V[j] << "/";
}
cout << endl;
} else {
cin >> S;
if (S[0] == '/') {
while (!V.empty()) {
V.pop_back();
}
}
R = "";
for (j = 0; j < S.length(); j++) {
if (S[j] == '/') {
if (R == "..") {
V.erase(V.end());
R = "";
} else if (R != "") {
V.push_back(R);
R = "";
}
} else
R = R + S[j];
}
if (R == "..") {
V.erase(V.end());
R = "";
} else if (R != "") {
V.push_back(R);
R = "";
}
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long getAns(long long b, long long c) {
if (b > c) swap(b, c);
if (b == 0)
return 0;
else if (b == 1)
return c;
else {
if (b % 2 == 0)
return b;
else
return c;
}
}
int main(int argc, char* argv[]) {
long long a, b, c;
while (scanf("%I64d%I64d%I64d", &a, &b, &c) >= 1) {
if (a > b) swap(a, b);
if (b > c) swap(b, c);
if (a > b) swap(a, b);
long long ans = 1e18;
ans = min(ans, getAns(b - a, c + a) + a);
ans = min(ans, getAns(c - a, b + a) + a);
ans = min(ans, getAns(a + b, c - b) + b);
printf("%I64d\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
std::cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
long long hell = round(1e18);
signed solve() {
long long n, d, l;
cin >> n >> d >> l;
vector<long long> v;
vector<long long> w;
if (n % 2) {
long long p = n / 2;
long long q = p + 1;
if (q - p * l <= d & q * l - p >= d) {
if (d <= 0) {
long long k = q - d;
for (long long i = 0; i < k % p; i++) {
v.push_back(k / p + 1);
}
for (long long i = k % p; i < p; i++) {
v.push_back(k / p);
}
for (long long i = 0; i < q; i++) w.push_back(1);
} else {
long long k = q * l - d;
__f("k, p, q", k, p, q);
for (long long i = 0; i < p; i++) v.push_back(1);
long long j = p + d;
for (long long i = 0; i < j % q; i++) w.push_back(j / q + 1);
for (long long i = j % q; i < q; i++) w.push_back(j / q);
}
for (long long i = 0; i < p; i++) cout << w[i] << " " << v[i] << " ";
cout << w[p];
} else {
cout << -1;
}
} else {
long long p = n / 2;
if (p - p * l <= d & p * l - p >= d) {
if (d <= 0) {
long long k = p - d;
for (long long i = 0; i < k % p; i++) {
v.push_back(k / p + 1);
}
for (long long i = k % p; i < p; i++) {
v.push_back(k / p);
}
for (long long i = 0; i < p; i++) w.push_back(1);
} else {
long long q = p;
long long k = q * l - d;
for (long long i = 0; i < p; i++) v.push_back(1);
long long j = p + d;
for (long long i = 0; i < j % q; i++) w.push_back(j / q + 1);
for (long long i = j % q; i < q; i++) w.push_back(j / q);
}
for (long long i = 0; i < p; i++) cout << w[i] << " " << v[i] << " ";
} else {
cout << -1;
}
}
return 0;
}
signed main() {
long long t = 1;
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
while (t--) {
solve();
}
return 0;
}
| 3 |
// F_Copy_or_Prefix_Sum_AC.cpp
// Created by RainCurtain on 2021/3/8.
//
#include <iostream>
#include <map>
using namespace std;
typedef long long ll;
const ll M = 1e9 + 7;
const int MAXN = 2e5 + 5;
ll b[MAXN];
inline void solve() {
int n;
map<ll, ll> num;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> b[i];
num [0] = 1;
ll ans = 1, bias = 0;
for (int i = 1; i <= n; ++i) {
ll t = num[0 - bias];
bias += b[i];
num[b[i] - bias] = ans;
ans = ((ans * 2 - t) % M + M) % M;
}
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) solve();
return 0;
} | 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 5;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
long long n, k, a, b;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> a >> b;
long long mx = 0, mn = 1ll << 60;
for (int i = 0; i < 2; ++i) {
long long s = i ? a : k - a;
for (int j = 0; j < n; ++j) {
for (int o = 0; o < 2; ++o) {
long long t = o ? j * k + b : (j + 1) * k - b;
t = t < s ? t + n * k : t;
long long l = t - s;
long long ret = n * k / gcd(n * k, l);
mn = min(mn, ret);
mx = max(mx, ret);
}
}
}
cout << mn << " " << mx << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
char map[505][505];
int n, m, k, vis[505][505];
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int ok(int x, int y) {
int i;
if (map[x][y] != '.') return 0;
int f = 0;
for (i = 0; i < 4; i++) {
int xx = x + dx[i];
int yy = y + dy[i];
if (xx >= n || xx < 0 || yy >= m || yy < 0) continue;
if (map[xx][yy] == '.') {
f = 1;
break;
}
}
return f;
}
void dfs(int x, int y) {
int i;
for (i = 0; i < 4; i++) {
int xx = x + dx[i];
int yy = y + dy[i];
if (xx >= n || xx < 0 || yy >= m || yy < 0) continue;
if (map[xx][yy] == '.' && !vis[xx][yy]) {
vis[xx][yy] = 1;
dfs(xx, yy);
}
}
if (k <= 0) return;
map[x][y] = 'X';
k--;
return;
}
int main(void) {
while (~scanf("%d %d %d", &n, &m, &k)) {
int i, j;
for (i = 0; i < n; i++) {
scanf("%s", map[i]);
}
if (k == 500 * 500 - 1) {
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) map[i][j] = 'X';
}
map[0][0] = '.';
k = 0;
}
while (k) {
memset(vis, 0, sizeof(vis));
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (ok(i, j)) {
memset(vis, 0, sizeof(vis));
vis[i][j] = 1;
dfs(i, j);
}
if (k <= 0) break;
}
if (k <= 0) break;
}
}
for (i = 0; i < n; i++) puts(map[i]);
}
return 0;
}
| 4 |
#include <iostream>
#include<bits/stdc++.h>
using namespace std;
int main()
{
long long c1,c2,c3,a1,a2,a3,a4,a5,e;
cin>>e;
while(e--)
{
cin>>c1>>c2>>c3;
cin>>a1>>a2>>a3>>a4>>a5;
if(c1>=a1)
{
c1=c1-a1;
}
else
{
cout<<"NO"<<endl;
continue;
}
if(c2>=a2)
{
c2=c2-a2;
}
else
{
cout<<"NO"<<endl;
continue;
}
if(c3>=a3)
{
c3=c3-a3;
}
else
{
cout<<"NO"<<endl;
continue;
}
if(a4<=c1)
{
c1=0;
}
else
{
c1=c1-a4;
}
if(a5<=c2)
{
c2=0;
}
else
{
c2=c2-a5;
}
c3=c3+c1+c2;
if(c3>=0)
{
cout<<"YES"<<endl;
}
else
{
cout<<"NO"<<endl;
continue;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
map<int64_t, int> dorms;
int64_t cumulative = 0;
for (int i = 1; i <= n; i++) {
int64_t count;
cin >> count;
cumulative += count;
dorms[cumulative] = i;
}
for (int i = 1; i <= m; i++) {
int64_t room;
cin >> room;
auto it = dorms.lower_bound(room);
if (it != dorms.begin()) {
auto it2 = std::prev(it);
room -= it2->first;
}
cout << it->second << " " << room << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a = 0, b, c = 0, d, i, j, k = 0, l = 0, n, m = 10, digit = 0;
char str[100000];
cin >> n;
while (true) {
l++;
if (n / m == 0)
break;
else
m *= 10;
}
for (i = 0; i < l; i++) str[i] = '1';
d = atoi(str);
cout << l * (n + 1) - d << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int i, j, k;
cin >> n >> s;
for (i = 0; i < n; i++) {
for (j = 1; j <= (n - i) / 3; j++) {
for (k = 0; k < 5; k++) {
if (s[i + k * j] != '*') k = 100;
}
if (k == 5) {
cout << "yes";
return 0;
}
}
}
cout << "no";
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.