solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
int s = (a + b);
int k = 0, t = 0;
while (1) {
if (t >= s) {
break;
}
t += (k + 1);
k++;
}
if (t != s) {
k--;
}
set<int> seti;
set<int> two;
int c = min(a, b), x = 0;
for (int i = k; i >= 1; i--) {
if (x + i <= c) {
x += i;
seti.insert(i);
} else {
two.insert(i);
}
}
if (a < b) {
cout << seti.size() << "\n";
for (int i : seti) {
cout << i << " ";
}
cout << "\n" << two.size() << "\n";
for (int i : two) {
cout << i << " ";
}
} else {
cout << two.size() << "\n";
for (int i : two) {
cout << i << " ";
}
cout << "\n" << seti.size() << "\n";
for (int i : seti) {
cout << i << " ";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y, long long int p) {
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;
}
int main() {
string s;
cin >> s;
vector<long long int> ind1, ind2;
long long int i = 0, j = s.size() - 1;
while (1) {
if (i > j)
break;
else {
if ((s[i] == '(') && (s[j] == ')')) {
ind2.push_back(j + 1);
ind1.push_back(i + 1);
i++;
j--;
} else if ((s[i] == '(') && (s[j] != ')'))
j--;
else if ((s[i] != '(') && (s[j] == ')'))
i++;
else {
i++;
j--;
}
}
}
long long int z = min(2 * ind1.size(), 2 * ind2.size());
if (z != 0) cout << "1" << endl;
cout << z << endl;
;
if (z != 0)
for (long long int k = 0; k < min(ind1.size(), ind2.size()); k++)
cout << ind1[k] << " ";
if (z != 0)
for (long long int k = min(ind1.size(), ind2.size()) - 1; k >= 0; k--)
cout << ind2[k] << " ";
if (z != 0) cout << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[3000][3000];
bool used[3000][3000];
int s, per, maxx, maxy, minx;
const int dx[4] = {-1, 1, 0, 0}, dy[4] = {0, 0, -1, 1};
inline bool check(int i, int j) {
if (i < 0 || j < 0 || i >= n || j >= n) return 0;
return 1;
}
void dfs(int i, int j) {
if (!check(i, j)) return;
if (used[i][j]) return;
if (a[i][j] == 0) return;
used[i][j] = 1;
if (i > maxx) maxx = i;
if (i < minx) minx = i;
if (j > maxy) maxy = j;
s++;
int toadd = 1;
for (int k = 0; k < 4; k++) {
dfs(i + dx[k], j + dy[k]);
if (!check(i + dx[k], j + dy[k]) || a[i + dx[k]][j + dy[k]] == 0)
per += toadd, toadd = 0;
}
}
int main(void) {
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
scanf("%d ", &a[i][j]);
}
}
int c = 0, sq = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[i][j] == 0) continue;
if (used[i][j]) continue;
s = per = maxx = maxy = 0;
minx = n;
dfs(i, j);
double r = (maxx * 1.0 - minx) / 2;
r = per * 1.0 / r / 2;
if (fabs(r - 2.75) < 0.2) {
c++;
} else {
sq++;
}
}
}
cout << c << " " << sq;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const double eps = 1e-9;
const int INF = 0x3f3f3f3f;
long long a[200050];
long long x[200050];
long long b[200050];
int main(void) {
int n;
long long t;
while (~scanf("%d%lld", &n, &t)) {
int flag = 1;
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++) {
scanf("%lld", &x[i]);
x[0] = x[1];
if ((x[i] != x[i - 1]) && (x[i - 1] != i - 1)) flag = 0;
}
if (x[n] != n) flag = 0;
if (!flag)
puts("No");
else {
int cnt = 0;
for (int i = 2; i <= n; i++) {
if (x[i] != x[i - 1]) {
while (++cnt < i - 1) {
b[cnt] = max(b[cnt - 1] + 1, a[cnt + 1] + t);
}
b[cnt] = max(b[cnt - 1] + 1, a[i - 1] + t);
}
}
while (++cnt < n) {
b[cnt] = max(b[cnt - 1] + 1, a[cnt + 1] + t);
}
b[cnt] = max(b[cnt - 1] + 1, a[n] + t);
for (int i = 2; i <= n; i++) {
if (x[i] != x[i - 1] && a[i] + t <= b[i - 1]) {
return puts("No"), 0;
}
}
puts("Yes");
for (int i = 1; i <= n; i++) printf("%lld%c", b[i], i == n ? '\n' : ' ');
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
long N, M;
int main(void) {
long i, j, u, v, Icase, k = 0;
scanf("%ld%ld", &N, &M);
set<pair<long, long> > s;
for (i = 1; i <= M; i++) {
scanf("%ld%ld", &u, &v);
s.insert(make_pair(u, v));
s.insert(make_pair(v, u));
}
vector<long> Vec;
for (i = 1; i <= N; i++) {
Vec.push_back(i);
}
long Cnt = 50;
do {
random_shuffle(Vec.begin(), Vec.end());
for (i = 0; i < M; i++) {
u = Vec[i];
v = Vec[(i + 1) % N];
if (s.find(make_pair(u, v)) != s.end()) break;
}
if (i == M) {
for (i = 0; i < M; i++) {
u = Vec[i];
v = Vec[(i + 1) % N];
printf("%ld %ld\n", u, v);
}
return 0;
}
Cnt--;
if (!Cnt) break;
} while (Cnt);
printf("-1\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const int INF = 1e9;
struct UnionFind {
vector<int> par;
vector<int> rank;
vector<long long> Size;
UnionFind(int n = 1) { init(n); }
void init(int n = 1) {
par.resize(n + 1);
rank.resize(n + 1);
Size.resize(n + 1);
for (int i = 0; i <= n; ++i) par[i] = i, rank[i] = 0, Size[i] = 1;
}
int root(int x) {
if (par[x] == x) {
return x;
} else {
int r = root(par[x]);
return par[x] = r;
}
}
bool issame(int x, int y) { return root(x) == root(y); }
bool merge(int x, int y) {
x = root(x);
y = root(y);
if (x == y) return false;
if (rank[x] == rank[y]) ++rank[x];
par[y] = x;
Size[x] += Size[y];
return true;
}
long long size(int x) { return Size[root(x)]; }
};
long long N, Q;
long long node[150000][27];
long long subtree[150000][27];
int p[150000];
int tmpp[150000];
vector<int> children[150000];
int val[150000];
int tmpval[150000];
void f(int now) {
if (children[now].size() == 0) {
for (int i = 0; i < 27; i++) {
subtree[now][i] = node[now][i];
}
}
if (children[now].size() == 1) {
for (int i = 0; i < 27; i++) {
subtree[now][i] = node[now][i] + subtree[children[now][0]][i];
}
}
if (children[now].size() == 2) {
int num[2] = {0, 0};
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 27; j++) {
num[i] += subtree[children[now][i]][j];
}
}
if (num[0] != num[1]) {
for (int i = 0; i < 27; i++) subtree[now][i] = -INF;
} else {
int tmpnum = num[0];
for (int i = 0; i < 26; i++) {
subtree[now][i] =
max(subtree[children[now][0]][i], subtree[children[now][1]][i]);
tmpnum -= subtree[now][i];
}
if (tmpnum < 0) {
for (int i = 0; i < 27; i++) subtree[now][i] = -INF;
} else {
subtree[now][26] = tmpnum;
for (int i = 0; i < 27; i++) {
subtree[now][i] += node[now][i];
}
}
}
}
}
void dfs(int now) {
cerr << "---dfs: " << now << endl;
cerr << "children: ";
for (auto tmp : children[now]) {
cerr << tmp << " ";
}
cerr << endl;
for (auto tmp : children[now]) dfs(tmp);
}
UnionFind uni;
void print() {
for (int i = 0; i < N; i++) {
if (uni.root(i) != i) continue;
cerr << "-------------" << i << "-------------" << endl;
for (int j = 0; j < 27; j++) {
cerr << subtree[i][j] << " ";
}
cerr << endl;
}
}
int main() {
cin >> N >> Q;
p[0] = -1;
for (int i = 1; i < N; i++) {
cin >> p[i];
p[i]--;
char tmp;
cin >> tmp;
if (tmp == '?')
tmpval[i] = 26;
else
tmpval[i] = (int)(tmp - 'a');
val[i] = 26;
children[p[i]].push_back(i);
}
uni.init(N);
for (int i = 0; i < N; i++) {
if (children[i].size() == 1) {
uni.merge(i, children[i][0]);
}
}
for (int i = 1; i < N; i++) {
node[uni.root(i)][val[i]]++;
}
for (int i = 0; i < N; i++) {
tmpp[i] = p[i];
p[i] = -1;
}
for (int i = 0; i < N; i++) {
if (children[i].size() == 2) {
p[children[i][0]] = uni.root(i);
p[children[i][1]] = uni.root(i);
}
}
for (int i = 0; i < N; i++) children[i].clear();
for (int i = 0; i < N; i++) {
if (p[i] != -1) {
children[p[i]].push_back(i);
}
}
for (int i = N - 1; i >= 0; i--) {
if (uni.root(i) == i) f(i);
}
if (subtree[0][0] < 0) {
for (int q = 0; q < Q; q++) {
cout << "Fou" << endl;
}
return 0;
}
for (int i = 1; i < N; i++) {
val[i] = tmpval[i];
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < 27; j++) {
subtree[i][j] = 0;
node[i][j] = 0;
}
}
for (int i = 1; i < N; i++) {
node[uni.root(i)][val[i]]++;
}
for (int i = N - 1; i >= 0; i--) {
if (uni.root(i) == i) f(i);
}
for (int q = 0; q < Q; q++) {
int v;
char tmp;
cin >> v >> tmp;
v--;
int c;
if (tmp == '?')
c = 26;
else
c = (int)(tmp - 'a');
int now = uni.root(v);
node[now][val[v]]--;
val[v] = c;
node[now][val[v]]++;
int nownode = now;
while (true) {
f(nownode);
if (p[nownode] == -1) break;
nownode = p[nownode];
}
if (subtree[0][0] < 0) {
cout << "Fou" << endl;
} else {
cout << "Shi ";
long long ans = 0;
for (long long i = 0; i < 26; i++) {
ans += (i + 1) * (subtree[0][i] + subtree[0][26]);
}
cout << ans << endl;
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
void solve(int n) {
vector<int> arr(n);
int totalMoves = 0;
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < n - 1; i++) {
int t = floor(log2(n - i - 1));
int opp = i + (int)pow(2, t);
arr[opp] += arr[i];
totalMoves += arr[i];
arr[i] = 0;
cout << totalMoves << endl;
}
}
int main() {
int n;
scanf("%d\n", &n);
solve(n);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 100010;
const long long MOD = 1e9 + 7;
const long long MOD2 = 998244353;
const long long INF = 1e9;
const long long LINF = 1e18;
long long n, m, x, y, l, r, k, a[maxn], b[maxn];
map<long long, long long> M, N;
string s, ss;
set<long long> S;
void solve() {
cin >> n >> m >> k;
for (long long i = 0; i < m; i++) cin >> a[i];
long long i = 0, pos = 0, cnt = 0;
while (i < m) {
long long p = i;
while (i < m - 1 and
(a[i] + k - 1 - pos) / k == (a[i + 1] + k - 1 - pos) / k)
i++;
pos += i - p + 1, cnt++, i++;
}
cout << cnt;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long t = 1;
while (t--) solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > M;
vector<int> A, B;
map<char, char> PLOT;
string str;
vector<pair<int, int> > Range, Qual;
int main() {
int n, k, i, j;
cin >> n >> k;
Range.resize(2 * n);
Qual.resize(n);
for (i = 0; i < n; i++) {
scanf("%d %d\n", &Range[2 * i].first, &Range[2 * i + 1].first);
Range[2 * i].second = 0;
Range[2 * i + 1].second = 1;
}
sort(Range.begin(), Range.end());
int ctr;
ctr = i = 0;
for (j = 0; j < 2 * n; j++) {
if (!Range[j].second) {
ctr++;
if (ctr == k) Qual[i].first = Range[j].first;
} else {
ctr--;
if (ctr == k - 1) Qual[i++].second = Range[j].first;
}
}
printf("%d\n", i);
for (j = 0; j < i; j++) {
printf("%d %d\n", Qual[j].first, Qual[j].second);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
vector<long long> gr[100005];
long long ans[100005], add[100005], sub[100005], tour[100005];
map<long long, vector<long long>> mp;
void dfs(long long ch, long long par, long long lvl) {
mp[lvl].push_back(ch);
sub[ch] = 1;
for (auto it : gr[ch]) {
if (it != par) {
dfs(it, ch, lvl + 1);
sub[ch] += sub[it];
}
}
}
bool comp(const long long a, const long long b) { return sub[a] > sub[b]; }
void dfs2(long long ch, long long par) {
if (tour[ch] != 1) add[ch]++;
for (auto it : gr[ch]) {
if (it != par) {
dfs2(it, ch);
add[ch] += add[it];
}
}
for (auto it : gr[ch]) {
if (it != par) {
if (tour[ch] == 1) {
cout << ch << " " << it << " " << add[it] << '\n';
ans[ch] = (add[it] * (add[it] + 1)) / 2 + (tour[it] != 1);
} else
ans[ch] = 0;
}
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long p, q, r;
cin >> p >> q >> r;
long long a[p], b[q], c[r];
for (long long i = 0; i < p; i++) cin >> a[i];
for (long long i = 0; i < q; i++) cin >> b[i];
for (long long i = 0; i < r; i++) cin >> c[i];
sort(a, a + p);
sort(b, b + q);
sort(c, c + r);
long long ans = (long long)(3e18 + 10);
for (long long i = 0; i < p; i++) {
long long j = upper_bound(b, b + q, a[i]) - b;
long long k = lower_bound(c, c + r, a[i]) - c;
if (j == 0 or k == r) continue;
j--;
long long temp = (a[i] - b[j]) * (a[i] - b[j]);
temp += (c[k] - b[j]) * (c[k] - b[j]);
temp += (a[i] - c[k]) * (a[i] - c[k]);
ans = min(ans, temp);
}
for (long long j = 0; j < q; j++) {
long long i = upper_bound(a, a + p, b[j]) - a;
long long k = lower_bound(c, c + r, b[j]) - c;
if (i == 0 or k == r) continue;
i--;
long long temp = (a[i] - b[j]) * (a[i] - b[j]);
temp += (c[k] - b[j]) * (c[k] - b[j]);
temp += (a[i] - c[k]) * (a[i] - c[k]);
ans = min(ans, temp);
}
for (long long k = 0; k < r; k++) {
long long j = upper_bound(b, b + q, c[k]) - b;
long long i = lower_bound(a, a + p, c[k]) - a;
if (j == 0 or i == p) continue;
j--;
long long temp = (a[i] - b[j]) * (a[i] - b[j]);
temp += (c[k] - b[j]) * (c[k] - b[j]);
temp += (a[i] - c[k]) * (a[i] - c[k]);
ans = min(ans, temp);
}
for (long long i = 0; i < p; i++) {
long long j = lower_bound(b, b + q, a[i]) - b;
long long k = upper_bound(c, c + r, a[i]) - c;
if (j == q or k == 0) continue;
k--;
long long temp = (a[i] - b[j]) * (a[i] - b[j]);
temp += (c[k] - b[j]) * (c[k] - b[j]);
temp += (a[i] - c[k]) * (a[i] - c[k]);
ans = min(ans, temp);
}
for (long long j = 0; j < q; j++) {
long long i = lower_bound(a, a + p, b[j]) - a;
long long k = upper_bound(c, c + r, b[j]) - c;
if (i == p or k == 0) continue;
k--;
long long temp = (a[i] - b[j]) * (a[i] - b[j]);
temp += (c[k] - b[j]) * (c[k] - b[j]);
temp += (a[i] - c[k]) * (a[i] - c[k]);
ans = min(ans, temp);
}
for (long long k = 0; k < r; k++) {
long long j = lower_bound(b, b + q, c[k]) - b;
long long i = upper_bound(a, a + p, c[k]) - a;
if (j == q or i == 0) continue;
i--;
long long temp = (a[i] - b[j]) * (a[i] - b[j]);
temp += (c[k] - b[j]) * (c[k] - b[j]);
temp += (a[i] - c[k]) * (a[i] - c[k]);
ans = min(ans, temp);
}
cout << ans << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000101;
int n, pt;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long e[maxn], a[maxn], p[100], d, k, cur[1 << 13 | 10],
ans[13][1 << 13 | 10];
map<long long, vector<long long> > mp;
int main() {
scanf("%d%lld", &n, &k);
for (int i = (1); i <= (n); ++i) scanf("%lld", &a[i]), d = gcd(d, a[i]);
for (int i = (1); i <= (n); ++i) scanf("%lld", &e[i]);
long long dd = d;
for (long long i = 2; i * i <= dd; i++) {
if (dd % i == 0) {
p[++pt] = i;
while (dd % i == 0) dd /= i;
}
}
if (dd != 1) p[++pt] = dd;
for (int i = (1); i <= (n); ++i) {
long long ai = a[i], t = 1;
for (int j = (1); j <= (pt); ++j) {
while (ai % p[j] == 0) t *= p[j], ai /= p[j];
}
mp[t].push_back(e[i]);
}
memset(ans, 0x3f, sizeof ans);
ans[0][(1 << pt) - 1] = 0;
long long Ans = 0x3f3f3f3f3f3f3f3f, inf = Ans;
for (map<long long, vector<long long> >::iterator it = mp.begin();
it != mp.end(); ++it) {
sort(it->second.begin(), it->second.end());
int len = min((int)it->second.size(), pt);
vector<long long> th = it->second;
th.resize(len);
long long x = it->first;
for (int i = (0); i <= ((1 << pt) - 1); ++i) {
long long t = x, q = 1;
for (int j = (1); j <= (pt); ++j) {
if (i & (1 << j - 1))
while (t % p[j] == 0) t /= p[j], q *= p[j];
}
cur[i] = q;
}
for (int t = (0); t <= (len - 1); ++t) {
int bj = 1;
for (int st = pt; st; st--)
for (int i = (0); i <= ((1 << pt) - 1); ++i) {
if (ans[st - 1][i] < inf)
for (int j = i; j; j = (j - 1) & i) {
if (cur[j] <= k) {
if (ans[st][i - j] > ans[st - 1][i] + th[t])
ans[st][i - j] = ans[st - 1][i] + th[t], bj = 1;
}
}
}
if (!bj) break;
}
}
for (int i = (0); i <= (pt); ++i)
if (ans[i][0] < inf) Ans = min(Ans, i * ans[i][0]);
if (Ans < inf)
cout << Ans;
else
cout << -1;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a, b, c;
cin >> a >> b >> c;
cout << min(a, max(1, b + c - a + 1)) << " " << min(a, b + c - 1) << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const long long MX = 1e3;
const long long MX1 = 2e2 + 10;
const long long INF = 1e9;
int n, a[MX1], mem[MX1][MX];
void dp(int i, int j) {
if (i == n) {
mem[i][j] = 0;
return;
}
if (j == MX) {
mem[i][j] = INF;
return;
}
if (mem[i][j + 1] == -1) dp(i, j + 1);
if (mem[i + 1][j + 1] == -1) dp(i + 1, j + 1);
mem[i][j] = mem[i][j + 1];
mem[i][j] = min(mem[i][j], mem[i + 1][j + 1] + abs(a[i] - j));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
sort(a, a + n);
memset(mem, -1, sizeof(mem));
dp(0, 1);
cout << mem[0][1] << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int ara[5002][5002];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> ara[1][i];
int len = n;
for (int i = 2; i <= n; i++) {
for (int j = 1; j < len; j++) ara[i][j] = ara[i - 1][j] ^ ara[i - 1][j + 1];
len--;
}
len = n;
for (int i = 2; i <= n; i++) {
for (int j = 1; j < len; j++)
ara[i][j] = max(ara[i][j], max(ara[i - 1][j], ara[i - 1][j + 1]));
len--;
}
int q;
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
len = (r - l + 1);
cout << ara[len][l] << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
long long n, q;
vector<long long> G[N], vec, sub(N), idx(N);
void dfs(long long node, long long par) {
vec.push_back(node);
sub[node] = 1;
for (auto nb : G[node]) {
if (nb == par) continue;
dfs(nb, node);
}
for (auto nb : G[node]) {
if (nb == par) continue;
sub[node] += sub[nb];
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
for (long long i = 2; i <= n; i++) {
long long a, b = i;
cin >> a;
G[a].push_back(b);
G[b].push_back(a);
}
for (long long i = 1; i < n + 1; i++) {
sort(G[i].begin(), G[i].end());
}
dfs(1, 0);
for (long long i = 0; i < n; i++) {
long long node = vec[i];
idx[node] = i;
}
while (q--) {
long long node, k;
cin >> node >> k;
if (k > sub[node])
cout << "-1\n";
else
cout << vec[idx[node] + k - 1] << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, st, dr, m, c1, c2, c3, c4, x11, x12, x21, x22, y11, y12, y21, y22, nr,
aux;
int main() {
scanf("%d", &n);
st = 1;
dr = n;
while (st <= dr) {
m = (st + dr) / 2;
printf("? %d %d %d %d\n", 1, 1, n, m);
fflush(stdout);
scanf("%d", &nr);
if (nr == 0)
st = m + 1;
else
dr = m - 1;
}
c1 = st;
st = 1;
dr = n;
while (st <= dr) {
m = (st + dr) / 2;
printf("? %d %d %d %d\n", 1, 1, n, m);
fflush(stdout);
scanf("%d", &nr);
if (nr == 0 || nr == 1)
st = m + 1;
else
dr = m - 1;
}
c2 = st;
st = 1;
dr = n;
while (st <= dr) {
m = (st + dr) / 2;
printf("? %d %d %d %d\n", 1, m, n, n);
fflush(stdout);
scanf("%d", &nr);
if (nr == 0)
dr = m - 1;
else
st = m + 1;
}
c3 = dr;
st = 1;
dr = n;
while (st <= dr) {
m = (st + dr) / 2;
printf("? %d %d %d %d\n", 1, m, n, n);
fflush(stdout);
scanf("%d", &nr);
if (nr == 0 || nr == 1)
dr = m - 1;
else
st = m + 1;
}
c4 = dr;
if (c3 > c1)
nr = 0;
else {
printf("? %d %d %d %d\n", 1, c3, n, c1);
fflush(stdout);
scanf("%d", &nr);
}
if (nr > 0) {
y11 = c3;
y12 = c1;
y21 = c4;
y22 = c2;
} else {
y11 = c4;
y12 = c1;
y21 = c3;
y22 = c2;
}
st = 1;
dr = n;
while (st <= dr) {
m = (st + dr) / 2;
printf("? %d %d %d %d\n", 1, 1, m, n);
fflush(stdout);
scanf("%d", &nr);
if (nr == 0)
st = m + 1;
else
dr = m - 1;
}
c1 = st;
st = 1;
dr = n;
while (st <= dr) {
m = (st + dr) / 2;
printf("? %d %d %d %d\n", 1, 1, m, n);
fflush(stdout);
scanf("%d", &nr);
if (nr == 0 || nr == 1)
st = m + 1;
else
dr = m - 1;
}
c2 = st;
st = 1;
dr = n;
while (st <= dr) {
m = (st + dr) / 2;
printf("? %d %d %d %d\n", m, 1, n, n);
fflush(stdout);
scanf("%d", &nr);
if (nr == 0)
dr = m - 1;
else
st = m + 1;
}
c3 = dr;
st = 1;
dr = n;
while (st <= dr) {
m = (st + dr) / 2;
printf("? %d %d %d %d\n", m, 1, n, n);
fflush(stdout);
scanf("%d", &nr);
if (nr == 0 || nr == 1)
dr = m - 1;
else
st = m + 1;
}
c4 = dr;
if (c3 > c1)
nr = 0;
else {
printf("? %d %d %d %d\n", c3, 1, c1, n);
fflush(stdout);
scanf("%d", &nr);
}
if (nr > 0) {
x11 = c3;
x12 = c1;
x21 = c4;
x22 = c2;
} else {
x11 = c4;
x12 = c1;
x21 = c3;
x22 = c2;
}
printf("? %d %d %d %d\n", x11, y11, x12, y12);
fflush(stdout);
scanf("%d", &nr);
if (nr == 0) {
aux = y11;
y11 = y21;
y21 = aux;
aux = y12;
y12 = y22;
y22 = aux;
}
printf("! %d %d %d %d %d %d %d %d", x11, y11, x12, y12, x21, y21, x22, y22);
fflush(stdout);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 100000007;
const int M = 100005;
const double pi = acos(-1);
struct pt {
long long x, y, EWGDFGdfgfsdhfdshfdhf;
bool operator<(const pt &a) const { return (x < a.x); }
bool operator>(const pt &a) const { return (x > a.x); }
};
long long CAlASFSAF[100050], n, m, k;
set<pt> u[200050];
set<pt> d[200050];
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
cin >> m;
cin >> k;
for (int i = 1; i <= k; i++) {
pt p;
cin >> p.x;
cin >> p.y;
p.EWGDFGdfgfsdhfdshfdhf = i;
u[p.y - p.x + 100000].insert(p);
d[p.y + p.x].insert(p);
}
pt now, lst;
now.x = 0;
now.y = 0;
now.EWGDFGdfgfsdhfdshfdhf = 0;
long long xPXPXPPXXPXP = 1, nowdy = 1;
for (int i = 1; i <= k; i++) CAlASFSAF[i] = -1;
CAlASFSAF[0] = 0;
long long NTNTNFN = 0, PLOPLO = 0;
set<pt>::iterator ite;
while (true) {
lst = now;
if (nowdy == 1) {
if (xPXPXPPXXPXP == 1) {
while (!u[now.y - now.x + 100000].empty()) {
lst = now;
NTNTNFN = PLOPLO;
now = *(u[now.y - now.x + 100000].begin());
PLOPLO = NTNTNFN + abs(now.x - lst.x);
if (CAlASFSAF[now.EWGDFGdfgfsdhfdshfdhf] == -1)
CAlASFSAF[now.EWGDFGdfgfsdhfdshfdhf] = PLOPLO;
u[now.y - now.x + 100000].erase(u[now.y - now.x + 100000].begin());
}
} else {
while (!d[now.y + now.x].empty()) {
lst = now;
NTNTNFN = PLOPLO;
ite = d[now.y + now.x].end();
ite--;
now = *ite;
PLOPLO = NTNTNFN + abs(now.x - lst.x);
if (CAlASFSAF[now.EWGDFGdfgfsdhfdshfdhf] == -1)
CAlASFSAF[now.EWGDFGdfgfsdhfdshfdhf] = PLOPLO;
d[now.y + now.x].erase(ite);
}
}
} else {
if (xPXPXPPXXPXP == 1) {
while (!d[now.y + now.x].empty()) {
lst = now;
NTNTNFN = PLOPLO;
now = *(d[now.y + now.x].begin());
PLOPLO = NTNTNFN + abs(now.x - lst.x);
if (CAlASFSAF[now.EWGDFGdfgfsdhfdshfdhf] == -1)
CAlASFSAF[now.EWGDFGdfgfsdhfdshfdhf] = PLOPLO;
d[now.y + now.x].erase(d[now.y + now.x].begin());
}
} else {
while (!u[now.y - now.x + 100000].empty()) {
lst = now;
NTNTNFN = PLOPLO;
ite = u[now.y - now.x + 100000].end();
ite--;
now = *ite;
PLOPLO = NTNTNFN + abs(now.x - lst.x);
if (CAlASFSAF[now.EWGDFGdfgfsdhfdshfdhf] == -1)
CAlASFSAF[now.EWGDFGdfgfsdhfdshfdhf] = PLOPLO;
u[now.y - now.x + 100000].erase(ite);
}
}
}
pt tr = now;
tr.x += (xPXPXPPXXPXP * min(abs(now.x - (xPXPXPPXXPXP == 1 ? n : 0)),
abs(now.y - (nowdy == 1 ? m : 0))));
tr.y += (nowdy * min(abs(now.x - (xPXPXPPXXPXP == 1 ? n : 0)),
abs(now.y - (nowdy == 1 ? m : 0))));
tr.EWGDFGdfgfsdhfdshfdhf = 0;
PLOPLO = PLOPLO + abs(tr.x - now.x);
if (((tr.x == 0) || (tr.x == n)) && ((tr.y == 0) || (tr.y == m))) break;
if (((xPXPXPPXXPXP == 1) && (tr.x == n)) ||
((xPXPXPPXXPXP == -1) && (tr.x == 0)))
xPXPXPPXXPXP *= (-1);
if (((nowdy == 1) && (tr.y == m)) || ((nowdy == -1) && (tr.y == 0)))
nowdy *= (-1);
now = tr;
}
for (int i = 1; i <= k; i++) {
cout << CAlASFSAF[i] << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int h12, h13, h14, h23, h24, h34;
int alpha, beta, gamma;
int p0, q0, r0;
int p, q, r;
int ksi;
int i;
cin >> h12 >> h13 >> h14 >> h23 >> h24 >> h34;
if (h12 + h23 < h13) {
cout << "-1\n";
return 0;
}
if ((h12 + h23 - h13) % 2) {
cout << "-1\n";
return 0;
}
alpha = (h12 + h23 - h13) / 2;
if (h12 + h13 < h23) {
cout << "-1\n";
return 0;
}
if ((h12 + h13 - h23) % 2) {
cout << "-1\n";
return 0;
}
beta = (h12 + h13 - h23) / 2;
if (h23 + h13 < h12) {
cout << "-1\n";
return 0;
}
if ((h23 + h13 - h12) % 2) {
cout << "-1\n";
return 0;
}
gamma = (h23 + h13 - h12) / 2;
if (h14 + h24 < alpha + beta) {
cout << "-1\n";
return 0;
}
if ((h14 + h24 - alpha - beta) % 2) {
cout << "-1\n";
return 0;
}
r0 = (h14 + h24 - alpha - beta) / 2;
if (h14 + h34 < gamma + beta) {
cout << "-1\n";
return 0;
}
if ((h14 + h34 - gamma - beta) % 2) {
cout << "-1\n";
return 0;
}
p0 = (h14 + h34 - gamma - beta) / 2;
if (h34 + h24 < alpha + gamma) {
cout << "-1\n";
return 0;
}
if ((h34 + h24 - alpha - gamma) % 2) {
cout << "-1\n";
return 0;
}
q0 = (h34 + h24 - alpha - gamma) / 2;
ksi = 0;
if (p0 - alpha > ksi) ksi = p0 - alpha;
if (q0 - beta > ksi) ksi = q0 - beta;
if (r0 - gamma > ksi) ksi = r0 - gamma;
if (p0 < ksi) {
cout << "-1\n";
return 0;
}
if (q0 < ksi) {
cout << "-1\n";
return 0;
}
if (r0 < ksi) {
cout << "-1\n";
return 0;
}
p = p0 - ksi;
q = q0 - ksi;
r = r0 - ksi;
cout << alpha + beta + gamma + ksi << "\n";
for (i = 0; i < alpha; i++) cout << "a";
for (i = 0; i < beta; i++) cout << "a";
for (i = 0; i < gamma; i++) cout << "a";
for (i = 0; i < ksi; i++) cout << "a";
cout << "\n";
for (i = 0; i < alpha; i++) cout << "b";
for (i = 0; i < beta; i++) cout << "b";
for (i = 0; i < gamma; i++) cout << "a";
for (i = 0; i < ksi; i++) cout << "a";
cout << "\n";
for (i = 0; i < alpha; i++) cout << "a";
for (i = 0; i < beta; i++) cout << "b";
for (i = 0; i < gamma; i++) cout << "b";
for (i = 0; i < ksi; i++) cout << "a";
cout << "\n";
for (i = 0; i < p; i++) cout << "b";
for (i = p; i < alpha; i++) cout << "a";
for (i = 0; i < q; i++) cout << "a";
for (i = q; i < beta; i++) cout << "b";
for (i = 0; i < r; i++) cout << "b";
for (i = r; i < gamma; i++) cout << "a";
for (i = 0; i < ksi; i++) cout << "b";
cout << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, last = 1, end = 0, j = 1, d = 0;
cin >> n;
vector<string> book(n + 1);
book[0] = "";
vector<int> cg((int)(2 * 1e6 + 10), 0);
for (int i = 1; i <= n; i++) {
int k, a;
cin >> book[i] >> k;
while (k--) {
cin >> a;
end = max(end, a - 1 + (int)book[i].size());
if (book[cg[a]].size() < book[i].size()) cg[a] = i;
}
}
for (int i = 1; i <= end; i++) {
if ((int)book[cg[i]].size() - 1 >= (int)book[d].size() - j) {
j = 0;
d = cg[i];
}
if (j < book[d].size())
cout << book[d][j];
else
cout << 'a';
j++;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10;
long long res;
long long dp[N][2];
char mde[N];
int n;
inline void dypr() {
for (int i = 1; i <= n; i++) {
dp[i + 1][0] = (mde[i] == 'A') ? dp[i][0] + dp[i][1] : dp[i][1];
if (mde[i + 1] == 'A') {
if (mde[i] == 'B') dp[i + 1][1] = dp[i][0];
} else {
dp[i + 1][1] = dp[i][1];
}
}
}
int main() {
scanf("%s", mde + 1);
for (n = 1; mde[n + 1] != '\0'; n++)
;
mde[n + 1] = mde[1];
dp[1][0] = 1;
dypr();
res += dp[n + 1][0];
for (int i = 1; i <= n + 1; i++) dp[i][0] = dp[i][1] = 0;
dp[1][1] = 1;
dypr();
res += dp[n + 1][1];
printf("%I64d", res);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
enum type { UP, DOWN };
const int MAXN = 2e5 + 5;
const int MOD = 998244353;
int N;
vector<pair<int, int> > adj[MAXN], ch[MAXN];
int dp_dir[MAXN][2], dp_undir[MAXN][2];
int last[MAXN];
void load() {
scanf("%d", &N);
for (int i = 1; i < N; i++) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back({i, v});
adj[v].push_back({i, u});
}
}
void dfs(int x, int p, int id) {
for (auto it : adj[x])
if (it.second != p) {
dfs(it.second, x, it.first);
ch[x].push_back(it);
}
sort(ch[x].begin(), ch[x].end());
for (auto it : ch[x])
if (it.first < id) last[x] = it.first;
}
int dir(int, type);
int undir(int, bool);
inline int add(int x, int y) {
x += y;
if (x >= MOD) return x - MOD;
return x;
}
inline int mul(int x, int y) { return (long long)x * y % MOD; }
int dir(int x, type edge) {
int &ref = dp_dir[x][edge];
if (ref != -1) return ref;
int dp[2] = {1, 0};
for (auto it : ch[x]) {
bool points = edge && (it.first > last[x]);
dp[1] =
add(mul(dp[0], it.first <= last[x] || points ? 0 : dir(it.second, UP)),
mul(dp[1], undir(it.second, true)));
dp[0] = mul(dp[0], add(points ? 0 : dir(it.second, DOWN),
undir(it.second, points)));
}
return ref = add(dp[0], dp[1]);
}
int undir(int x, bool sat) {
int &ref = dp_undir[x][sat];
if (ref != -1) return ref;
int dp[2] = {sat || last[x], 0};
for (auto it : ch[x]) {
dp[1] =
add(mul(dp[0], dir(it.second, UP)), mul(dp[1], undir(it.second, true)));
dp[0] = sat || it.first < last[x]
? mul(dp[0], add(dir(it.second, DOWN), undir(it.second, false)))
: 0;
}
return ref = add(dp[1], dp[0]);
}
int solve() {
memset(dp_dir, -1, sizeof dp_dir);
memset(dp_undir, -1, sizeof dp_undir);
dfs(1, 0, 0);
return undir(1, true);
}
int main() {
load();
printf("%d\n", solve());
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long int hell = 100000000;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
map<long long int, long long int> m;
long long int a[n], b[n];
for (long long int i = 0; i < n; i++) cin >> a[i], m[a[i]]++;
for (long long int i = 0; i < n; i++) cin >> b[i];
long long int ans = 0;
for (long long int i = n - 1; i >= 0; i--) {
m[a[i]]--;
long long int x = b[i] - a[i];
if (x > 0 && m[1] > 0)
continue;
else if (x < 0 && m[-1] > 0)
continue;
else if (x == 0)
continue;
else {
ans = -1;
break;
}
}
if (ans < 0)
cout << "NO";
else
cout << "YES";
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct StVal {
int minV = 0, numMin = 0;
StVal() {}
StVal(const int _v) : minV(_v), numMin(1) {}
StVal(const StVal& v1, const StVal& v2) {
if (v1.minV < v2.minV) {
minV = v1.minV;
numMin = v1.numMin;
} else if (v1.minV > v2.minV) {
minV = v2.minV;
numMin = v2.numMin;
} else {
minV = v1.minV;
numMin = v1.numMin + v2.numMin;
}
}
};
struct StUpdate {
int v = 0;
StUpdate() {}
StUpdate(const int v) : v(v) {}
StUpdate(const StUpdate& u1, const StUpdate& u2) { v = u1.v + u2.v; }
void apply(StVal& sv, const int lo, const int hi) { sv.minV += v; }
};
struct SegTree {
int n;
vector<StVal> st;
vector<StUpdate> lazy;
vector<int> leaves;
SegTree(const int n) : n(n) {
leaves.resize(n);
init(1, 0, n - 1);
lazy.resize(st.size());
}
void init(const int si, const int lo, const int hi) {
if (lo == hi) {
if (si >= (int)st.size()) {
st.resize(si + 1);
}
st[si] = StVal(0);
leaves[lo] = si;
return;
}
int lC = si << 1, rC = (si << 1) | 1, mid = (lo + hi) >> 1;
init(lC, lo, mid);
init(rC, mid + 1, hi);
st[si] = StVal(st[lC], st[rC]);
}
void updateLazy(const int si, const int lo, const int hi) {
lazy[si].apply(st[si], lo, hi);
if (lo != hi) {
lazy[si << 1] = StUpdate(lazy[si << 1], lazy[si]);
lazy[si << 1 | 1] = StUpdate(lazy[si << 1 | 1], lazy[si]);
}
lazy[si] = StUpdate();
}
StVal query(const int l, const int r) {
return (l <= r && l < n && r >= 0) ? query(l, r, 1, 0, n - 1) : StVal();
}
StVal query(const int l, const int r, const int si, const int lo,
const int hi) {
updateLazy(si, lo, hi);
if (l <= lo && hi <= r) return st[si];
const int mid = (lo + hi) >> 1;
if (r <= mid) return query(l, r, si << 1, lo, mid);
if (mid < l) return query(l, r, si << 1 | 1, mid + 1, hi);
return StVal(query(l, r, si << 1, lo, mid),
query(l, r, si << 1 | 1, mid + 1, hi));
}
void update(const int l, const int r, const StUpdate u) {
if (l <= r) update(l, r, u, 1, 0, n - 1);
}
void update(const int l, const int r, const StUpdate& u, const int si,
const int lo, const int hi) {
if (l <= lo && hi <= r) {
lazy[si] = StUpdate(lazy[si], u);
updateLazy(si, lo, hi);
} else {
updateLazy(si, lo, hi);
if (hi < l || r < lo) return;
const int mid = (lo + hi) >> 1;
update(l, r, u, si << 1, lo, mid);
update(l, r, u, si << 1 | 1, mid + 1, hi);
st[si] = StVal(st[si << 1], st[si << 1 | 1]);
}
}
void updateAllLazy() { updateAllLazy(1, 0, n - 1); }
void updateAllLazy(const int si, const int lo, const int hi) {
updateLazy(si, lo, hi);
if (lo != hi) {
const int mid = (lo + hi) >> 1;
updateAllLazy(si << 1, lo, mid);
updateAllLazy(si << 1 | 1, mid + 1, hi);
}
}
};
struct Node {
array<Node*, 2> child{};
Node* splayTreeParent = nullptr;
Node* pathParentPointer = nullptr;
bool reverse = false;
Node() {}
bool getSide() {
return splayTreeParent ? splayTreeParent->child[1] == this : false;
}
void tryReverse() {
if (!reverse) {
return;
}
reverse = false;
swap(child[0], child[1]);
if (child[0]) {
child[0]->reverse = !child[0]->reverse;
}
if (child[1]) {
child[1]->reverse = !child[1]->reverse;
}
}
Node* splay() {
vector<Node*> ancestors;
Node* cur = this;
while (cur) {
ancestors.push_back(cur);
cur = cur->splayTreeParent;
}
for (int i = ancestors.size() - 1; i >= 0; i--) {
if (!ancestors[i]) {
continue;
}
ancestors[i]->tryReverse();
}
while (splayTreeParent) {
if (splayTreeParent->splayTreeParent) {
(getSide() == splayTreeParent->getSide() ? splayTreeParent : this)
->rotate();
}
rotate();
}
return this;
}
Node* rotate() {
bool side = getSide(), parentSide = splayTreeParent->getSide();
auto ancestor = splayTreeParent->splayTreeParent;
pathParentPointer = splayTreeParent->pathParentPointer;
splayTreeParent->pathParentPointer = nullptr;
splayTreeParent->attach(child[!side], side);
attach(splayTreeParent, !side);
if (ancestor)
ancestor->attach(this, parentSide);
else
splayTreeParent = nullptr;
return this;
}
Node* attach(Node* node, int side) {
if (node) node->splayTreeParent = this;
child[side] = node;
return this;
}
};
struct LinkCutTreeGeneral {
void link(Node* parent, Node* child) {
assert(findRoot(child) != findRoot(parent));
access(child);
access(parent);
Node* lChild = child->child[0];
if (lChild) {
lChild->reverse = !lChild->reverse;
detachChild(child, 0);
}
child->attach(parent, 0);
}
void cut(Node* u) {
access(u);
assert(u->child[0]);
u->child[0]->splayTreeParent = nullptr;
u->child[0] = nullptr;
}
void cut(Node* u, Node* v) {
bool b = findRoot(u) != findRoot(v);
access(u);
assert(!(b && u->child[0] && findMax(u->child[0]) == v));
if (u->child[0] && findMax(u->child[0]) == v) {
cut(u);
return;
}
access(v);
assert(!(b && v->child[0] && findMax(v->child[0]) == u));
if (v->child[0] && findMax(v->child[0]) == u) {
cut(v);
}
}
Node* findRoot(Node* u) {
access(u);
while (u->child[0]) {
u = u->child[0];
}
access(u);
return u;
}
private:
Node* access(Node* u) {
u->splay();
detachChild(u, 1);
Node* curPP = u;
while (u->pathParentPointer) {
curPP = u->pathParentPointer;
curPP->splay();
detachChild(curPP, 1);
curPP->attach(u, 1);
u->pathParentPointer = nullptr;
u->splay();
}
return curPP;
}
Node* findMax(Node* u) {
if (!u) {
return nullptr;
}
while (u->child[1]) {
u = u->child[1];
}
return u;
}
void detachChild(Node* u, bool b) {
if (!u->child[b]) {
return;
}
u->child[b]->pathParentPointer = u;
u->child[b]->splayTreeParent = nullptr;
u->child[b] = nullptr;
}
};
struct NodeWithId : Node {
int id;
NodeWithId(int id) : Node(), id(id) {}
};
struct DynamicTreeLCT {
LinkCutTreeGeneral lct;
vector<NodeWithId*> nodes;
int n = 0;
DynamicTreeLCT() {}
int addNode() {
nodes.push_back(new NodeWithId(n));
return n++;
}
void link(int parentId, int childId) {
lct.link(nodes[parentId], nodes[childId]);
}
void cut(int id) { lct.cut(nodes[id]); }
void cut(int u, int v) { lct.cut(nodes[u], nodes[v]); }
int findRoot(int u) {
auto res = (NodeWithId*)lct.findRoot(nodes[u]);
return res->id;
}
bool connected(int u, int v) { return findRoot(u) == findRoot(v); }
};
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
vector<int> numToID;
int n, m;
void cutNeighbors(DynamicTreeLCT& lct, vector<vector<int>>& grid, int l,
int r) {
int i = numToID[l] / m, j = numToID[l] % m;
int idx = numToID[l];
for (int k = 0; k < 4; k++) {
int ni = i + dx[k], nj = j + dy[k];
if (ni < 0 || nj < 0 || ni == n || nj == m) {
continue;
}
if (grid[ni][nj] < l || grid[ni][nj] > r) {
continue;
}
int nIdx = numToID[grid[ni][nj]];
lct.cut(idx, nIdx);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
DynamicTreeLCT lct;
cin >> n >> m;
vector<vector<int>> grid(n, vector<int>(m));
numToID.resize(n * m + 1);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> grid[i][j];
numToID[grid[i][j]] = lct.addNode();
}
}
SegTree st(n * m + 1);
long long ans = 0;
int l = 1;
for (int r = 1; r <= m * n; r++) {
st.update(l, r, StUpdate(1));
int i = numToID[r] / m, j = numToID[r] % m;
int idx = numToID[r];
for (int k = 0; k < 4; k++) {
int ni = i + dx[k], nj = j + dy[k];
if (ni < 0 || nj < 0 || ni == n || nj == m) {
continue;
}
if (grid[ni][nj] < l || grid[ni][nj] > r) {
continue;
}
int nIdx = numToID[grid[ni][nj]];
while (lct.connected(idx, nIdx)) {
cutNeighbors(lct, grid, l, r);
l++;
}
if (l > grid[ni][nj]) {
continue;
}
if (l == r) {
break;
}
lct.link(idx, nIdx);
st.update(l, grid[ni][nj], StUpdate(-1));
}
ans += st.query(l, r).numMin;
}
cout << ans << '\n';
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s;
cin >> s;
long count = 0;
char max = 0;
for (char ch : s) {
if (ch == max) {
count++;
} else if (ch > max) {
max = ch;
count = 1;
}
}
while (count--) {
cout << max;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("-O2")
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
std::cerr << name << " = " << arg1 << std::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...);
}
const long double PI = acos(-1.0);
const int INF = 0x3f3f3f3f;
map<string, int> ma;
void solve() {
int n;
cin >> n;
ma["void"] = 0;
for (int i = 0; i < n; i++) {
string t;
cin >> t;
if (t == "typedef") {
string a, b, tmp = "";
cin >> a >> b;
int amp = 0, ast = 0;
for (auto j : a) {
if (j != '&' and j != '*') tmp += j;
amp += (j == '&'), ast += (j == '*');
}
if (ma.count(tmp)) {
if (ma[tmp] == INF) {
ma[b] = INF;
continue;
}
ma[b] = ma[tmp] + ast - amp;
if (ma[b] < 0) ma[b] = INF;
} else {
ma[b] = INF;
}
} else {
string a;
cin >> a;
string tmp = "";
int amp = 0, ast = 0;
for (auto j : a) {
if (j != '&' and j != '*') tmp += j;
amp += (j == '&'), ast += (j == '*');
}
if (ma.count(tmp)) {
if (ma[tmp] == INF) {
cout << "errtype" << '\n';
continue;
}
if (ma[tmp] + ast - amp < 0) {
cout << "errtype" << '\n';
continue;
}
cout << "void";
for (int j = 0; j < ma[tmp] + ast - amp; j++) cout << "*";
cout << '\n';
} else
cout << "errtype" << '\n';
}
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, b = 0, cnt = 0;
cin >> n;
while (n >= cnt) {
b++;
cnt += (b * (b + 1) / 2);
}
cout << b - 1 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int MAXN = 5000 + 10;
int N, M, Ret;
int F[MAXN][MAXN];
char S[MAXN], T[MAXN];
int main(int argc, char *argv[]) {
scanf("%s", S + 1);
scanf("%s", T + 1);
N = strlen(S + 1);
M = strlen(T + 1);
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
if (S[i] == T[j]) {
F[i][j] = (F[i][j] + F[i - 1][j - 1] + 1) % MOD;
}
F[i][j] = (F[i][j] + F[i][j - 1]) % MOD;
}
Ret = (Ret + F[i][M]) % MOD;
}
printf("%d\n", Ret);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
void faster() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
}
long long par[101];
long long root(long long n) {
return (par[n] < 0) ? n : (par[n] = root(par[n]));
}
void merge(long long u, long long v) {
if ((u = root(u)) == (v = root(v))) return;
if (par[u] < par[v]) swap(u, v);
par[v] += par[u];
par[u] = v;
}
long long count_dis(long long n) {
long long ans = 0;
for (long long i = 0; i < n; i++)
if (par[i] < 0) ans++;
return ans;
}
void solve() {
for (long long i = 0; i < 101; i++) par[i] = -1;
long long n;
cin >> n;
vector<pair<long long, long long> > pts(n);
for (long long i = 0; i < n; i++) cin >> pts[i].first >> pts[i].second;
for (long long i = 0; i < n; i++) {
for (long long j = i + 1; j < n; j++) {
if (pts[i].first == pts[j].first || pts[i].second == pts[j].second)
merge(i, j);
}
}
cout << count_dis(n) - 1 << endl;
}
signed main() {
faster();
long long t = 1;
while (t--) solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double pi = acos(-1.0);
const int K = 1e6 + 7;
const int mod = 1e9 + 7;
int n, m, a = 1e9;
int main(void) {
int x, y;
cin >> n >> m;
for (int i = 1; i <= m; i++) cin >> x >> y, a = min(y - x + 1, a);
printf("%d\n", a);
for (int i = 1; i <= n;)
for (int j = 0; j < a && i <= n; j++, i++) printf("%d ", j);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long x, y;
scanf("%lld %lld", &x, &y);
while (true) {
if (x >= y) {
cout << "YES" << endl;
return;
} else if ((x == 1 && y == 1)) {
cout << "YES" << endl;
return;
} else if (x == 3 || x == 1) {
cout << "NO" << endl;
return;
} else {
if (x % 2 != 0) {
x--;
}
x *= 3;
x /= 2;
}
}
}
int main() {
long long t;
scanf("%lld", &t);
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1009;
const int mod = 998244353;
int a[N], dp[N][N], sum[N];
int n, k;
int ans;
void add(int x, int y) {
for (; x <= n; x += (x & -x)) {
sum[x] = (sum[x] + y);
if (sum[x] >= mod) sum[x] -= mod;
}
}
int query(int x) {
int ans = 0;
while (x) {
ans = (ans + sum[x]);
if (ans >= mod) ans -= mod;
x -= (x & -x);
}
return ans;
}
void solve(int x) {
for (int j = 2; j <= k; j++) {
for (int i = 1; i <= n; i++) {
int l = upper_bound(a + 1, a + n + 1, a[i] - x) - a - 1;
dp[i][j] = sum[l];
}
for (int i = 1; i <= n; i++) {
sum[i] = dp[i][j] + sum[i - 1];
if (sum[i] > mod) sum[i] -= mod;
}
}
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
int limit = a[n] / (k - 1);
for (int x = 1; x <= limit; x++) {
for (int i = 0; i <= n; i++)
for (int j = 0; j <= k; j++) dp[i][j] = 0;
for (int i = 0; i <= n; i++) sum[i] = 0;
for (int i = 1; i <= n; i++) dp[i][1] = 1, sum[i] = i;
solve(x);
for (int i = k; i <= n; i++) {
ans = (ans + dp[i][k]);
if (ans >= mod) ans -= mod;
}
}
if (ans < 0) ans += mod;
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m_end, num, pos, Len;
char s[2000005];
char p[2000005];
int main() {
while (~scanf("%d", &n)) {
Len = 0;
memset(s, '#', sizeof(s));
for (int cnt = 1; cnt <= n; cnt++) {
scanf("%s%d", &p, &num);
int len = strlen(p);
int now = -1;
for (int i = 1; i <= num; i++) {
scanf("%d", &pos);
Len = max(pos + len - 1, Len);
for (int j = max(now, pos); j <= pos + len - 1; j++) s[j] = p[j - pos];
now = pos + len;
}
}
for (int i = 1; i <= Len; i++)
if (s[i] == '#')
putchar('a');
else
putchar(s[i]);
putchar('\n');
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5;
int sum1[maxn], sum2[maxn], a[maxn], b[maxn];
int n, m;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sum1[i] = sum1[i - 1] + a[i];
}
for (int i = 1; i <= m; i++) {
cin >> b[i];
sum2[i] = sum2[i - 1] + b[i];
}
int j = 1, ans = 0;
int res1 = 0, res2 = 0;
int preposa = 0, preposb = 0;
for (int i = 1; i <= n; i++) {
int q = sum1[i] - sum1[preposa], k;
for (; j <= m; j++) {
k = sum2[j] - sum2[preposb];
if (q <= k) break;
}
if (q == k) {
preposa = i;
preposb = j;
ans++;
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
# define Rep(i,a,b) for(int i=a;i<=b;i++)
# define _Rep(i,a,b) for(int i=a;i>=b;i--)
# define RepG(i,u) for(int i=head[u];~i;i=e[i].next)
typedef long long ll;
const int N=3.5e4+5;
const int M=105;
template<typename T> void read(T &x){
x=0;int f=1;
char c=getchar();
for(;!isdigit(c);c=getchar())if(c=='-')f=-1;
for(;isdigit(c);c=getchar())x=(x<<1)+(x<<3)+c-'0';
x*=f;
}
int n,m;
ll f[N];
int a[N],lst[N],pre[N];
struct node{
ll min,tag;
}seg[N<<2];
# define lc (u<<1)
# define rc (u<<1|1)
void pushup(int u){
seg[u].min=min(seg[lc].min,seg[rc].min);
}
void renew(int u,int k){
seg[u].min+=k;
seg[u].tag+=k;
}
void pushdown(int u){
renew(lc,seg[u].tag);
renew(rc,seg[u].tag);
seg[u].tag=0;
}
void build(int u,int l,int r){
seg[u].tag=0;
if(l==r){
seg[u].min=f[l-1];
return;
}
int mid=l+r>>1;
build(lc,l,mid);
build(rc,mid+1,r);
pushup(u);
}
void update(int u,int l,int r,int ql,int qr,int k){
if(l>=ql&&r<=qr){
renew(u,k);
return;
}
if(seg[u].tag)pushdown(u);
int mid=l+r>>1;
if(ql<=mid)update(lc,l,mid,ql,qr,k);
if(qr>mid)update(rc,mid+1,r,ql,qr,k);
pushup(u);
}
int main()
{
# ifdef hibike
freopen("testdata.in","r",stdin);
freopen("test1.out","w",stdout);
# endif
memset(f,0x3f,sizeof(f));
read(n),read(m);
Rep(i,1,n)read(a[i]);
Rep(i,1,n)pre[i]=lst[a[i]],lst[a[i]]=i;
f[0]=0;
Rep(j,1,m){
build(1,1,n);
Rep(i,1,n){
if(pre[i])update(1,1,n,1,pre[i],i-pre[i]);
f[i]=seg[1].min;
}
}
printf("%lld\n",f[n]);
return 0;
} | 8 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
unordered_set<long long> e;
set<long long> s;
vector<vector<long long>> ans;
queue<long long> q;
void bfs(long long node) {
s.erase(node);
q.push(node);
vector<long long> visited;
while (!q.empty()) {
node = q.front();
visited.push_back(node);
q.pop();
vector<long long> to_erase;
for (auto it = s.begin(); it != s.end(); it++) {
if (e.count(n * node + *it)) continue;
to_erase.push_back(*it);
}
for (auto x : to_erase) s.erase(x), q.push(x);
}
ans.push_back(visited);
}
signed main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (long long i = 1; i <= n; i++) s.insert(i);
for (long long i = 1; i <= m; i++) {
long long a, b;
cin >> a >> b;
e.insert(n * a + b);
e.insert(n * b + a);
}
for (long long i = 1; i <= n; i++) {
if (!s.count(i)) continue;
bfs(i);
}
cout << ans.size() << '\n';
for (auto x : ans) {
cout << x.size() << ' ';
for (auto y : x) cout << y << " ";
cout << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int N, a[1001][1001], cnt, b[1001], sum[1001];
int main() {
cin >> N;
for (int i = 1; i <= N; i++) cin >> b[i];
int tot = 0;
for (int k = N; k >= 1; k--)
for (int i = 1; i <= N; i++)
if (b[i] == k) {
int x = tot++;
for (int j = 1; j <= b[i]; j++) {
a[i][x] = 1;
x = (x + 1) % (N + 1);
}
}
for (int j = 0; j <= N; j++) {
for (int i = 1; i <= N; i++) sum[j] += a[i][j];
if (sum[j]) cnt++;
}
cout << cnt << endl;
for (int j = 0; j <= N; j++)
if (sum[j]) {
for (int i = 1; i <= N; i++) cout << a[i][j];
cout << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
struct node {
long long l, r;
long long cover;
long long lazy;
} nodes[N * 4 * 3 * 2];
struct op {
long long t;
long long l, r;
} ops[N];
void build(long long l, long long r, long long u) {
nodes[u].l = l;
nodes[u].r = r;
nodes[u].cover = 0;
nodes[u].lazy = 0;
if (l + 1 == r) return;
build(l, (l + r) >> 1, u << 1);
build((l + r) >> 1, r, u << 1 | 1);
}
void revert(long long u) {
nodes[u].cover = 2 - nodes[u].cover;
nodes[u].lazy = 2 - nodes[u].lazy;
}
void pushDown(long long u) {
if (!nodes[u].lazy) return;
if (nodes[u].lazy == 1) {
nodes[u << 1].cover = nodes[u << 1 | 1].cover = nodes[u].cover;
nodes[u << 1].lazy = nodes[u << 1 | 1].lazy = 1;
nodes[u].lazy = 0;
} else {
revert(u << 1);
revert(u << 1 | 1);
nodes[u].lazy = 0;
}
}
void pushUp(long long u) {
if (nodes[u << 1].cover == nodes[u << 1 | 1].cover &&
nodes[u << 1].cover != 1) {
nodes[u].cover = nodes[u << 1].cover;
} else {
nodes[u].cover = 1;
}
}
void Update(long long l, long long r, long long u, long long c) {
pushDown(u);
if (nodes[u].l == l && nodes[u].r == r) {
nodes[u].cover = c;
nodes[u].lazy = 1;
return;
}
long long m = (nodes[u].l + nodes[u].r) >> 1;
if (r <= m) {
Update(l, r, u << 1, c);
} else if (l >= m) {
Update(l, r, u << 1 | 1, c);
} else {
Update(l, m, u << 1, c);
Update(m, r, u << 1 | 1, c);
}
pushUp(u);
}
void Revert(long long l, long long r, long long u) {
pushDown(u);
if (nodes[u].l == l && nodes[u].r == r) {
nodes[u].cover = 2 - nodes[u].cover;
nodes[u].lazy = 2;
return;
}
long long m = (nodes[u].l + nodes[u].r) >> 1;
if (r <= m) {
Revert(l, r, u << 1);
} else if (l >= m) {
Revert(l, r, u << 1 | 1);
} else {
Revert(l, m, u << 1);
Revert(m, r, u << 1 | 1);
}
pushUp(u);
}
long long query(long long u) {
pushDown(u);
long long ans;
if (nodes[u].cover == 0) {
ans = nodes[u].l;
} else if (nodes[u].cover == 1) {
if (nodes[u << 1].cover == 2) {
ans = query(u << 1 | 1);
} else {
ans = query(u << 1);
}
} else {
ans = nodes[u].r;
}
pushUp(u);
return ans;
}
int main() {
int n;
cin >> n;
vector<long long> all;
all.push_back(1);
for (int i = 0; i < n; i++) {
cin >> ops[i].t >> ops[i].l >> ops[i].r;
all.push_back(ops[i].l);
all.push_back(ops[i].r);
all.push_back(ops[i].r + 1);
}
sort(all.begin(), all.end());
all.resize(unique(all.begin(), all.end()) - all.begin());
build(1, all.size() + 1, 1);
for (int i = 0; i < n; i++) {
int t = ops[i].t;
int l = lower_bound(all.begin(), all.end(), ops[i].l) - all.begin() + 1;
int r = lower_bound(all.begin(), all.end(), ops[i].r) - all.begin() + 1;
if (t == 1) {
Update(l, r + 1, 1, 2);
} else if (t == 2) {
Update(l, r + 1, 1, 0);
} else {
Revert(l, r + 1, 1);
}
long long ans = query(1);
printf("%I64d\n", all[ans - 1]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 201;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, m, num, cnt;
int a[maxn][maxn], b[maxn][maxn], S[maxn], T[maxn];
int ans[maxn], dp[maxn], vis[maxn], p[maxn][maxn];
int dfs(int u, int v) {
if (vis[u] == cnt) return dp[u];
vis[u] = cnt;
int Ans = -1;
for (int i = 1; i <= n; i++)
if (a[u][i] == 1 && a[u][i] + a[i][v] == a[u][v]) Ans = max(Ans, dfs(i, v));
if (Ans < 0) Ans = 1e9;
dp[u] = min(ans[u] + 1, Ans);
return dp[u];
}
int main() {
int u, v;
n = read(), m = read(), S[0] = read(), T[0] = read();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i != j) a[i][j] = 1e9;
for (int i = 1; i <= m; i++) {
u = read(), v = read();
a[u][v] = 1;
}
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) a[i][j] = min(a[i][j], a[i][k] + a[k][j]);
num = read();
for (int i = 1; i <= num; i++) {
S[i] = read(), T[i] = read();
for (int j = 1; j <= n; j++)
if (a[S[i]][j] < 1e9 && a[S[i]][j] + a[j][T[i]] == a[S[i]][T[i]])
b[i][a[S[i]][j]]++;
for (int j = 1; j <= n; j++)
if (a[S[i]][j] < 1e9 && a[S[i]][j] + a[j][T[i]] == a[S[i]][T[i]] &&
b[i][a[S[i]][j]] == 1)
p[i][j] = 1;
}
for (int i = 1; i <= n; i++) ans[i] = 1e9;
ans[T[0]] = 0;
while (1) {
bool find = 0;
for (int i = 1; i <= num; i++)
for (int j = 1; j <= n; j++)
if (p[i][j]) {
cnt++;
int tmp = dfs(j, T[i]);
if (tmp < ans[j]) {
ans[j] = tmp;
find = 1;
}
}
if (!find) break;
}
if (ans[S[0]] < 1e9)
printf("%d\n", ans[S[0]]);
else
printf("-1\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = (1e-8);
const int OO = (int)1e9 + 9;
const int MAX = 200009;
long long n, m, k, a, b, c, d, e, f, x, y, z;
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
z = lcm(n, m);
x = z / n;
y = z / m;
if (x == y - 1 || y == x - 1)
cout << "Equal";
else if (x > y)
cout << "Dasha";
else
cout << "Masha";
cout << endl << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long arr[57][57];
long long rw[57], rb[57];
long long cw[57], cb[57];
long long power[60];
int main() {
power[0] = 1;
long long n, m, i, j, k, l, x, y;
cin >> n >> m;
for (i = 1; i < 60; i++) power[i] = power[i - 1] * 2LL;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> arr[i][j];
}
}
long long cntw = 0, cntb = 0;
for (i = 0; i < n; i++) {
cntw = cntb = 0;
for (j = 0; j < m; j++) {
if (arr[i][j] == 1)
cntb++;
else
cntw++;
}
rw[i] = cntw;
rb[i] = cntb;
}
for (i = 0; i < m; i++) {
cntw = cntb = 0;
for (j = 0; j < n; j++) {
if (arr[j][i] == 1)
cntb++;
else
cntw++;
}
cw[i] = cntw;
cb[i] = cntb;
}
long long ans = n * m;
for (i = 0; i < n; i++) {
if (rw[i] > 1) ans = ans + power[rw[i]] - 1 - rw[i];
if (rb[i] > 1) ans = ans + power[rb[i]] - 1 - rb[i];
}
for (i = 0; i < m; i++) {
if (cw[i] > 1) ans = ans + power[cw[i]] - 1 - cw[i];
if (cb[i] > 1) ans = ans + power[cb[i]] - 1 - cb[i];
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long maxN = 1000 * 200 + 100;
long long a, b;
string s[44] = {
"Washington", "Adams", "Jefferson", "Madison", "Monroe",
"Adams", "Jackson", "Van Buren", "Harrison", "Tyler",
"Polk", "Taylor", "Fillmore", "Pierce", "Buchanan",
"Lincoln", "Johnson", "Grant", "Hayes", "Garfield",
"Arthur", "Cleveland", "Harrison", "Cleveland", "McKinley",
"Roosevelt", "Taft", "Wilson", "Harding", "Coolidge",
"Hoover", "Roosevelt", "Truman", "Eisenhower", "Kennedy",
"Johnson", "Nixon", "Ford", "Carter", "Reagan",
"Bush", "Clinton", "Bush", "Obama"};
int main() {
cin >> a;
cout << s[a - 1] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int dummy;
cin >> dummy;
}
cout << "0?1?<>1" << endl;
cout << "1?1?<>2" << endl;
cout << "2?1?<>3" << endl;
cout << "3?1?<>4" << endl;
cout << "4?1?<>5" << endl;
cout << "5?1?<>6" << endl;
cout << "6?1?<>7" << endl;
cout << "7?1?<>8" << endl;
cout << "8?1?<>9" << endl;
cout << "9?1?>>?1?0" << endl;
cout << "?1?<>1" << endl;
cout << "?0?0>>0?0?" << endl;
cout << "?0?1>>1?0?" << endl;
cout << "?0?2>>2?0?" << endl;
cout << "?0?3>>3?0?" << endl;
cout << "?0?4>>4?0?" << endl;
cout << "?0?5>>5?0?" << endl;
cout << "?0?6>>6?0?" << endl;
cout << "?0?7>>7?0?" << endl;
cout << "?0?8>>8?0?" << endl;
cout << "?0?9>>9?0?" << endl;
cout << "?0?>>?1?" << endl;
cout << "0>>?0?0" << endl;
cout << "1>>?0?1" << endl;
cout << "2>>?0?2" << endl;
cout << "3>>?0?3" << endl;
cout << "4>>?0?4" << endl;
cout << "5>>?0?5" << endl;
cout << "6>>?0?6" << endl;
cout << "7>>?0?7" << endl;
cout << "8>>?0?8" << endl;
cout << "9>>?0?9" << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<int> numbers;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
int ans = 0;
for (int i = 0; i < n; ++i) {
int j = i;
while (j + 1 < n && a[j + 1] <= a[j] * 2) ++j;
ans = max(ans, j - i + 1);
i = j;
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int main() {
cin >> n >> m >> k;
if (n <= m && n <= k)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string s;
vector<long long> v[128];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long a = 0, b = 0, c, d, e, f = 0, l, g, m, n, k, i, j, t, p, q;
cin >> n;
cin >> s;
for (i = 0; i < 127; i++) v[i].push_back(0);
for (i = 0; i < n; i++) {
v[s[i]].push_back(i + 1);
}
cin >> q;
while (q--) {
long long x[150] = {0};
cin >> s;
l = s.size();
for (i = 0; i < l; i++) {
x[s[i]]++;
}
f = 0;
for (i = 'a'; i <= 'z'; i++) {
f = max(f, v[i][x[i]]);
}
cout << f << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, i, j, k, l, pos, r, ans = 0;
cin >> n >> pos >> l >> r;
if (pos < l) {
ans = l - pos + 1;
if (n > r) ans += r - l + 1;
} else if (pos > r) {
ans = pos - r + 1;
if (l > 1) ans += r - l + 1;
} else {
if (l > 1 && r < n) {
ans = min(pos - l, r - pos) + r - l + 2;
} else if (l == 1 && r < n) {
ans = r - pos + 1;
} else if (r == n && l > 1)
ans = pos - l + 1;
else
ans = 0;
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n, k;
scanf("%d %d", &n, &k);
if ((k == 1 && n != 1) || k > n) {
printf("-1\n");
} else {
int i;
char a[n];
for (i = 0; i < n; i++) {
if (i % 2 == 0)
a[i] = 'a';
else
a[i] = 'b';
}
i = n - 1;
if (k == 1) {
printf("a\n");
return 0;
}
k -= 2;
while (k--) {
a[i] = ('c' + k);
i--;
}
for (i = 0; i < n; i++) printf("%c", a[i]);
printf("\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long x, a, b;
long long fun(long long n, long long m) {
long long x = n / m;
return n * n - x * x;
}
void solve() {
cin >> x;
if (x == 0) {
cout << 1 << " " << 1 << "\n";
return;
};
for (__typeof(((long long)sqrt(x + 1e7) + 1)) i = (2);
i < ((long long)sqrt(x + 1e7) + 1); i++) {
long long l = i, r = 1e9, mid;
while (r - l > 1) {
mid = (l + r) / 2;
if (fun(mid, i) >= x)
r = mid;
else
l = mid;
}
if (fun(l, i) == x) {
cout << l << " " << i << "\n";
return;
};
if (fun(r, i) == x) {
cout << r << " " << i << "\n";
return;
};
}
{
cout << -1 << "\n";
return;
};
}
void prep() {}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
cin >> t;
prep();
cout << fixed << setprecision(12);
while (t--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
}
int n, x1, x2, y1, y2, ans = 0;
cin >> n;
while (n--) {
cin >> x1 >> y1 >> x2 >> y2;
ans += (x2 - x1 + 1) * (y2 - y1 + 1);
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
const long long INF = 2e18;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long t;
cin >> t;
while (t--) {
string s;
cin >> s;
vector<char> order;
long long n = s.size();
set<char> used;
map<char, long long> ct;
for (long long i = n - 1; i >= 0; i--) {
if (!used.count(s[i])) order.push_back(s[i]);
used.insert(s[i]);
ct[s[i]]++;
}
bool bad = false;
long long m = order.size();
long long x = 0;
for (long long i = 0; i < m; i++) {
if (ct[order[i]] % (m - i) != 0) {
bad = true;
break;
}
x += ct[order[i]] / (m - i);
}
if (bad)
cout << -1 << "\n";
else {
reverse(order.begin(), order.end());
string a = s.substr(0, x), b = "";
for (auto it : order) {
b += a;
string curr = "";
for (auto& jt : a) {
if (jt == it) continue;
curr += jt;
}
a = curr;
}
if (s != b)
cout << -1 << "\n";
else {
cout << s.substr(0, x) << " ";
for (auto it : order) cout << it;
cout << "\n";
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-9;
const long double PI = atan(1) * 4;
const long long M = 1000000007;
struct PT {
double x, y;
PT() {}
PT(double x, double y) : x(x), y(y) {}
PT(const PT &p) : x(p.x), y(p.y) {}
PT operator+(const PT &p) const { return PT(x + p.x, y + p.y); }
PT operator-(const PT &p) const { return PT(x - p.x, y - p.y); }
PT operator*(double c) const { return PT(x * c, y * c); }
PT operator/(double c) const { return PT(x / c, y / c); }
};
double dot(PT p, PT q) { return p.x * q.x + p.y * q.y; }
double dist2(PT p, PT q) { return dot(p - q, p - q); }
double cross(PT p, PT q) { return p.x * q.y - p.y * q.x; }
double cos_u2v(const PT &u, const PT &v) {
return dot(u, v) / sqrt(dot(u, u) * dot(v, v));
}
double sin_u2v(const PT &u, const PT &v) {
return cross(u, v) / sqrt(dot(u, u) * dot(v, v));
}
ostream &operator<<(ostream &os, const PT &p) {
os << "(" << p.x << "," << p.y << ")";
}
double vector2angle(const PT &v) { return atan2(v.y, v.x); }
struct UnionFind {
vector<long long> C;
UnionFind(long long n) : C(n) {
for (int i = 0; i < n; i++) C[i] = i;
}
long long find(long long x) { return (C[x] == x) ? x : C[x] = find(C[x]); }
void merge(long long x, long long y) { C[find(x)] = find(y); }
};
long long mod(long long x, long long m) { return ((x % m) + m) % m; }
long long gcd(long long a, long long b) {
for (; b > 0; swap(a, b)) a %= b;
return a;
}
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 long mod_inverse(long long a, long long n) {
long long x, y;
long long d = extended_euclid(a, n, x, y);
if (d > 1) return -1;
return mod(x, n);
}
struct LPSolver {
int m, n;
vector<long long> B, N;
vector<vector<long double>> D;
LPSolver(const vector<vector<long double>> &A, const vector<long double> &b,
const vector<long double> &c)
: m(b.size()),
n(c.size()),
N(n + 1),
B(m),
D(m + 2, vector<long double>(n + 2)) {
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++) D[i][j] = A[i][j];
for (int i = 0; i < m; i++) {
B[i] = n + i;
D[i][n] = -1;
D[i][n + 1] = b[i];
}
for (int j = 0; j < n; j++) {
N[j] = j;
D[m][j] = -c[j];
}
N[n] = -1;
D[m + 1][n] = 1;
}
void Pivot(int r, int s) {
for (int i = 0; i < m + 2; i++)
if (i != r)
for (int j = 0; j < n + 2; j++)
if (j != s) D[i][j] -= D[r][j] * D[i][s] / D[r][s];
for (int j = 0; j < n + 2; j++)
if (j != s) D[r][j] /= D[r][s];
for (int i = 0; i < m + 2; i++)
if (i != r) D[i][s] /= -D[r][s];
D[r][s] = 1.0 / D[r][s];
swap(B[r], N[s]);
}
bool Simplex(int phase) {
int x = phase == 1 ? m + 1 : m;
while (true) {
int s = -1;
for (int j = 0; j <= n; j++) {
if (phase == 2 && N[j] == -1) continue;
if (s == -1 || D[x][j] < D[x][s] || D[x][j] == D[x][s] && N[j] < N[s])
s = j;
}
if (D[x][s] > -EPS) return true;
int r = -1;
for (int i = 0; i < m; i++) {
if (D[i][s] < EPS) continue;
if (r == -1 || D[i][n + 1] / D[i][s] < D[r][n + 1] / D[r][s] ||
(D[i][n + 1] / D[i][s]) == (D[r][n + 1] / D[r][s]) && B[i] < B[r])
r = i;
}
if (r == -1) return false;
Pivot(r, s);
}
}
long double solve(vector<long double> &x) {
int r = 0;
for (int i = 1; i < m; i++)
if (D[i][n + 1] < D[r][n + 1]) r = i;
if (D[r][n + 1] < -EPS) {
Pivot(r, n);
if (!Simplex(1) || D[m + 1][n + 1] < -EPS)
return -numeric_limits<long double>::infinity();
for (int i = 0; i < m; i++)
if (B[i] == -1) {
int s = -1;
for (int j = 0; j <= n; j++)
if (s == -1 || D[i][j] < D[i][s] ||
D[i][j] == D[i][s] && N[j] < N[s])
s = j;
Pivot(i, s);
}
}
if (!Simplex(2)) return numeric_limits<long double>::infinity();
x = vector<long double>(n);
for (int i = 0; i < m; i++)
if (B[i] < n) x[B[i]] = D[i][n + 1];
return D[m][n + 1];
}
};
void edgelist2adjlists(long long n, const vector<long long> &froms,
const vector<long long> &tos, vector<long long> &v2e0,
vector<long long> &e2n) {
v2e0.resize(n);
v2e0.assign(n, -1);
long long en = froms.size();
e2n.resize(en);
for (int i = 0; i < en; i++) {
long long f = froms[i];
long long t = tos[i];
e2n[i] = v2e0[f];
v2e0[f] = i;
}
}
struct FordFulk {
private:
const vector<long long> &v2e0;
const vector<long long> &e2f;
const vector<long long> &e2t;
const vector<long long> &e2c;
const vector<long long> &e2n;
long long s, t;
long long find_aug_path(const vector<long long> &v2e0,
const vector<long long> &e2f,
const vector<long long> &e2t,
const vector<long long> &e2c,
const vector<long long> &e2n, long long s,
long long t, vector<long long> &epath) {
vector<long long> q2v;
vector<long long> q2p;
vector<long long> q2e;
vector<long long> q2f;
vector<bool> inq(v2e0.size(), false);
q2v.push_back(s);
q2p.push_back(-1);
q2e.push_back(-1);
q2f.push_back(INT_MAX);
inq[s] = true;
for (long long i = 0; i < q2v.size(); i++) {
long long crt = q2v[i];
long long f = q2f[i];
for (long long j = v2e0[crt]; j != -1; j = e2n[j]) {
long long to = e2t[j];
long long rem = e2c[j];
if (inq[to]) continue;
if (rem <= 0) continue;
q2v.push_back(to);
q2p.push_back(i);
q2e.push_back(j);
q2f.push_back(min(f, rem));
inq[to] = true;
}
}
for (long long i = 0; i < q2v.size(); i++) {
if (q2v[i] != t) continue;
stack<long long> stk;
for (long long j = i; j > 0; j = q2p[j]) {
stk.push(q2e[j]);
}
while (!stk.empty()) {
epath.push_back(stk.top());
stk.pop();
}
return q2f[i];
}
return 0;
}
public:
FordFulk(const vector<long long> &_v2e0, const vector<long long> &_e2f,
const vector<long long> &_e2t, const vector<long long> &_e2c,
const vector<long long> &_e2n, long long _s, long long _t)
: s(_s), t(_t), v2e0(_v2e0), e2f(_e2f), e2t(_e2t), e2c(_e2c), e2n(_e2n) {}
long long eval() {
long long en = e2f.size();
map<pair<long long, long long>, long long> rsd;
for (long long i = 0; i < en; i++) {
long long f = e2f[i];
long long t = e2t[i];
rsd[make_pair(f, t)] += e2c[i];
rsd[make_pair(t, f)] += 0;
}
map<pair<long long, long long>, long long> nei;
long long ren = 0;
for (auto er : rsd) {
nei[er.first] = ren++;
}
long long rvn = v2e0.size();
vector<long long> rv2e0(rvn, -1);
vector<long long> re2f(ren);
vector<long long> re2t(ren);
vector<long long> re2c(ren);
vector<long long> re2n(ren);
vector<long long> re2p(ren);
long long rei = 0;
for (auto er : rsd) {
long long f = er.first.first;
long long t = er.first.second;
long long c = er.second;
re2f[rei] = f;
re2t[rei] = t;
re2c[rei] = c;
re2p[rei] = nei[make_pair(t, f)];
re2n[rei] = rv2e0[f];
rv2e0[f] = rei;
++rei;
}
long long sol = 0;
vector<long long> epath;
while (true) {
epath.clear();
long long res = find_aug_path(rv2e0, re2f, re2t, re2c, re2n, s, t, epath);
if (res == 0) break;
for (auto ei : epath) {
re2c[ei] -= res;
re2c[re2p[ei]] += res;
}
sol += res;
}
return sol;
}
};
template <typename T>
struct LazySegTree1D {
vector<T> v;
vector<long long> opr;
vector<T> opd;
vector<long long> nxt;
long long LEFT;
long long RGHT;
T (*fnx)(long long, T);
T (*fab)(T, T);
LazySegTree1D(long long _l, long long _r, T _v, T (*_fnx)(long long, T),
T (*_fab)(T, T))
: v(1), opr(1), opd(1), nxt(1), LEFT(_l), RGHT(_r), fnx(_fnx), fab(_fab) {
v[0] = fnx(RGHT - LEFT + 1, _v);
opr[0] = 0;
opd[0] = _v;
nxt[0] = -1;
}
void _split(long long i, long long l0, long long r0) {
assert(nxt[i] == -1);
assert(opr[i] == 0);
assert(l0 < r0);
long long n = v.size();
nxt[i] = n;
long long m0 = (l0 + r0) / 2;
v.push_back(fnx(m0 - l0 + 1, opd[i]));
v.push_back(fnx(r0 - m0, opd[i]));
opr.push_back(0);
opr.push_back(0);
opd.push_back(opd[i]);
opd.push_back(opd[i]);
nxt.push_back(-1);
nxt.push_back(-1);
}
void _pushdown(long long i, long long l0, long long r0) {
if (opr[i] == -1) return;
long long m0 = (l0 + r0) / 2;
if (nxt[i] == -1)
_split(i, l0, r0);
else if (opr[i] >= 0) {
_set(nxt[i], l0, m0, l0, m0, opr[i], opd[i]);
_set(nxt[i] + 1, m0 + 1, r0, m0 + 1, r0, opr[i], opd[i]);
}
opr[i] = -1;
}
void _set(long long i, long long l0, long long r0, long long l1, long long r1,
long long o1, T v1) {
assert(l1 >= l0 && r1 <= r0);
if (l0 == l1 && r0 == r1) {
if (o1 == 0) {
v[i] = fnx(r0 - l0 + 1, v1);
opr[i] = 0;
opd[i] = v1;
} else if (o1 == 1) {
v[i] = fab(v[i], fnx(r0 - l0 + 1, v1));
if (opr[i] == -1) {
opr[i] = 1;
opd[i] = v1;
} else if (opr[i] == 0) {
opr[i] = 0;
opd[i] = fab(opd[i], v1);
} else if (opr[i] == 1) {
opr[i] = 1;
opd[i] = fab(opd[i], v1);
}
}
return;
}
long long m0 = (l0 + r0) / 2;
_pushdown(i, l0, r0);
if (l1 <= m0) _set(nxt[i], l0, m0, l1, min(r1, m0), o1, v1);
if (r1 > m0) _set(nxt[i] + 1, m0 + 1, r0, max(l1, m0 + 1), r1, o1, v1);
v[i] = fab(v[nxt[i]], v[nxt[i] + 1]);
}
T _get(long long i, long long l0, long long r0, long long l1, long long r1) {
assert(l0 <= l1 && r1 <= r0);
if (l0 == l1 && r1 == r0) return v[i];
_pushdown(i, l0, r0);
long long m0 = (l0 + r0) / 2;
if (r1 <= m0) return _get(nxt[i], l0, m0, l1, r1);
if (m0 + 1 <= l1) return _get(nxt[i] + 1, m0 + 1, r0, l1, r1);
T lv = _get(nxt[i], l0, m0, l1, m0);
T rv = _get(nxt[i] + 1, m0 + 1, r0, m0 + 1, r1);
return fab(lv, rv);
}
void updres(long long l1, long long r1, T v1) {
_set(0, LEFT, RGHT, l1, r1, 1, v1);
}
void setval(long long l1, long long r1, T v1) {
_set(0, LEFT, RGHT, l1, r1, 0, v1);
}
T get(long long l1, long long r1) { return _get(0, LEFT, RGHT, l1, r1); }
};
void readll(long long &x) {
int r;
scanf("%d", &r);
x = r;
}
int min_ab(int a, int b) { return min(a, b); }
int min_nx(long long n, int x) { return x; }
int main() {
long long n, m;
readll(n);
readll(m);
vector<long long> x(n);
vector<long long> t(n);
vector<long long> kil(n);
vector<pair<long long, long long>> xi(n);
long long maxreach = 0;
long long fmax = 0;
long long mmax = 0;
for (long long i = 0; i < n; i++) {
readll(x[i]);
readll(t[i]);
xi[i] = make_pair(x[i], i);
fmax = max(fmax, x[i] + t[i]);
}
sort(xi.begin(), xi.end());
vector<long long> p(m);
vector<long long> b(m);
for (long long i = 0; i < m; i++) {
readll(p[i]);
readll(b[i]);
mmax = max(mmax, p[i]);
fmax += b[i];
}
LazySegTree1D<int> tree(0, max(fmax, mmax), n, min_nx, min_ab);
for (long long i = 0; i < n; i++) {
long long fgi = xi[i].second;
long long x0 = x[fgi];
long long x1 = x[fgi] + t[fgi];
tree.updres(x0, x1, i);
}
map<long long, long long> p2t;
map<long long, long long> p2c;
for (long long i = 0; i < m; i++) {
p2t[p[i]] += b[i];
p2c[p[i]]++;
auto itt = p2t.find(p[i]);
auto itc = p2c.find(p[i]);
while (true) {
if (itt == p2t.end()) {
assert(itc == p2c.end());
break;
}
long long pos = itt->first;
int j = tree.get(pos, pos);
if (j == n) break;
long long fgi = xi[j].second;
kil[fgi] += itc->second;
t[fgi] += itt->second;
tree.updres(x[fgi], x[fgi] + t[fgi], j);
itt = p2t.erase(itt);
itc = p2c.erase(itc);
}
}
for (long long i = 0; i < n; i++) {
int ti = t[i];
int ki = kil[i];
printf("%d %d\n", ki, ti);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void print_array(T a[], int size) {
for (int i = 0; i < size; i++) cout << a[i] << " ";
cout << endl;
}
template <class T>
void print_array_v(T &a) {
int size = a.size();
for (int i = 0; i < size; i++) cout << a[i] << " ";
cout << endl;
}
map<long long int, long long int> arr;
pair<long long int, long long int> a[100005];
map<long long int, vector<long long int> > e;
set<long long int> flag;
int main() {
long long int n, i, val, j;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
arr[a[i].first]++;
arr[a[i].second]++;
e[a[i].first].push_back(a[i].second);
e[a[i].second].push_back(a[i].first);
}
for (auto ii : arr) {
if (ii.second == 1) {
val = ii.first;
break;
}
}
cout << val << " ";
flag.insert(val);
for (i = 1; i <= n; i++) {
for (j = 0; j < e[val].size(); j++) {
if (flag.find(e[val][j]) == flag.end()) {
cout << e[val][j] << " ";
flag.insert(e[val][j]);
val = e[val][j];
break;
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("2,Ofast,inline")
using namespace std;
const int N = 4005;
const int M = 1e6 + 10;
const int inf = 0x3f3f3f3f;
int r, R, k;
template <typename T>
void read(T &x) {
int f = 0;
register char c = getchar();
while (c < '0' || c > '9') f |= (c == '-'), c = getchar();
for (x = 0; c >= '0' && c <= '9'; c = getchar())
x = (x << 3) + (x << 1) + (c ^ '0');
if (f) x = -x;
}
struct Vec {
double x, y;
Vec(double _x = 0, double _y = 0) : x(_x), y(_y) {}
inline Vec operator+(Vec &b) { return Vec(x + b.x, y + b.y); }
inline Vec operator-(Vec &b) { return Vec(x - b.x, y - b.y); }
inline Vec operator*(double b) { return Vec(x * b, y * b); }
inline bool operator<(const Vec &b) const {
if (x != b.x) return x < b.x;
return y < b.y;
}
};
double sqr(double x) { return x * x; }
double dist(Vec a, Vec b) { return sqrt(sqr(a.x - b.x) + sqr(a.y - b.y)); }
Vec reverse(Vec a) {
double d = dist(Vec(0, 0), a);
double k = 4.0 * R * R / d / d;
return Vec(a.x * k, a.y * k);
}
void solve() {
read(R);
read(r);
read(k);
Vec A(r, 0), B(R, 0);
double right = 2.0 * R * R / r;
Vec C((R * 2 + right) / 2, 0);
double rx = right - C.x;
C.y += k * 2 * rx;
double d = dist(Vec(0, 0), C);
Vec D = C * (1.0 - rx / d);
Vec E = C * (1.0 + rx / d);
D = reverse(D);
E = reverse(E);
printf("%.10lf\n", dist(D, E) / 2);
}
int main() {
int T;
read(T);
while (T--) solve();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[111];
int n;
scanf("%d", &n);
scanf("%s", a);
int sign = 0;
int s;
for (s = 0; a[s] == '.'; s++)
;
for (int i = s; i < n; i++) {
for (int j = 1; j < n - s - 1; j++) {
if (j * 4 + i >= n) continue;
if (a[i] == '*' && a[i + j] == '*' && a[i + 2 * j] == '*' &&
a[i + 3 * j] == '*' && a[i + 4 * j] == '*') {
sign = 1;
break;
}
}
if (sign) break;
}
if (sign)
printf("yes\n");
else
printf("no\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define REM 1000000007
int main()
{
lli t;
cin >> t;
while(t--)
{
lli n;
cin >> n;
lli i = 0, j = 0;
lli a[n];
lli odd = 0, even = 0;
for(i = 0; i < n; i++ )
{
cin >> a[i];
if(i%2) odd += a[i];
else even += a[i];
}
for(i = (even>=odd); i < n; i+=2 )
{
a[i] = 1;
}
for(i = 0; i < n; i++ )
{
cout << a[i] << " ";
}
}
} | 3 |
#include <bits/stdc++.h>
using namespace std;
int ans, flag, a[20][300010], n, i, x, anx[20], as[20];
void dfs(int x, int y) {
if (y >= ans) return;
if (x < 2) {
anx[1] = 0;
if (a[x][0]) {
y++;
anx[1] = -1;
}
if (a[x][2]) {
y++;
anx[1] = 1;
}
if (y < ans) {
ans = y;
for (int i = 1; i <= 18; i++) as[i] = anx[i];
}
return;
}
int flag = 0;
for (int i = 0; i <= 1 << x - 1; i++) a[x - 1][i] = 0;
for (int i = 0; i <= 1 << x; i++)
if (a[x][i]) {
if (i & 1) flag = 1;
a[x - 1][i >> 1] = 1;
}
anx[x] = flag;
dfs(x - 1, y + flag);
if (flag) {
for (int i = 0; i <= 1 << x - 1; i++) a[x - 1][i] = 0;
for (int i = 0; i <= 1 << x; i++)
if (a[x][i]) a[x - 1][i + 1 >> 1] = 1;
anx[x] = -flag;
dfs(x - 1, y + flag);
}
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &x), a[18][x + (1 << 17)] = 1;
ans = 20;
dfs(18, 0);
printf("%d\n", ans);
for (i = 18; i >= 1; i--)
if (as[i]) printf("%d ", as[i] * (1 << 18 - i));
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
scanf("%lld", &n);
long long A[n + 1];
long long tm = 1;
vector<pair<long long, long long>> v;
for (long long i = 1; i <= n; i++) {
scanf("%lld", A + i);
long long a = 0;
if (A[i] < n) {
if (A[i] >= tm) {
a = 1;
} else if (A[i] < tm) {
a = 0;
}
} else if (A[i] == n) {
a = 1;
} else {
a = A[i] / n;
if (tm + (A[i] / n) * n <= A[i]) {
a++;
}
}
tm++;
v.push_back({a, i});
}
sort(v.begin(), v.end());
cout << (v[0].second) << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[5005];
a[0] = 0;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i) a[i] = a[i] + a[i - 1];
double ans = 0;
int sum;
for (int j = k; j <= n; ++j)
for (int i = j; i <= n; ++i) ans = max(ans, (double)(a[i] - a[i - j]) / j);
printf("%.15lf", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
vector<int> a[MAXN];
vector<int> b[MAXN];
vector<int> w;
pair<int, int> segt[4 * MAXN];
int l[MAXN];
int r[MAXN];
int lx[MAXN];
int rx[MAXN];
int kx[MAXN];
int ky[MAXN];
int type[MAXN];
int head[MAXN];
bool cmp(const int& x, const int& y) { return (r[x] - l[x]) < (r[y] - l[y]); }
void update(int id, int L, int R, int x, pair<int, int> val) {
if (L > x || R < x) {
return;
}
if (L == R) {
segt[id] = val;
return;
}
int mid = (L + R) / 2;
update(2 * id + 1, L, mid, x, val);
update(2 * id + 2, mid + 1, R, x, val);
segt[id] = max(segt[2 * id + 1], segt[2 * id + 2]);
}
pair<int, int> get_max(int id, int L, int R, int l, int r) {
if (L > r || R < l || l > r) {
return make_pair(0, 0);
}
if (L >= l && R <= r) {
return segt[id];
}
int mid = (L + R) / 2;
return max(get_max(2 * id + 1, L, mid, l, r),
get_max(2 * id + 2, mid + 1, R, l, r));
}
void dsu_update(int x) {
if (head[head[x]] != head[head[head[x]]]) {
dsu_update(head[x]);
}
head[x] = head[head[x]];
}
void dsu(int x, int y) {
dsu_update(x);
dsu_update(y);
if (head[x] == head[y]) {
return;
}
lx[head[y]] = min(lx[head[y]], lx[head[x]]);
rx[head[y]] = max(rx[head[y]], rx[head[x]]);
head[head[x]] = head[y];
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
int q, z = 1, t = 1;
cin >> q;
for (int i = 1; i <= q; i++) {
cin >> type[i];
if (type[i] == 1) {
cin >> l[z] >> r[z];
w.push_back(l[z]);
w.push_back(r[z]);
z++;
}
if (type[i] == 2) {
cin >> kx[i] >> ky[i];
}
}
sort(w.begin(), w.end());
w.resize(unique(w.begin(), w.end()) - w.begin());
for (int i = 1; i <= z; i++) {
a[lower_bound(w.begin(), w.end(), l[i]) - w.begin()].push_back(i);
b[lower_bound(w.begin(), w.end(), r[i]) - w.begin()].push_back(i);
}
for (int i = 0; i < w.size(); i++) {
sort(a[i].begin(), a[i].end(), cmp);
sort(b[i].begin(), b[i].end(), cmp);
for (int j = 0; j < b[i].size(); j++) {
rx[b[i][j]] = t++;
}
for (int j = (int)(a[i].size()) - 1; j >= 0; j--) {
lx[a[i][j]] = t++;
}
}
z = 1;
for (int i = 1; i <= q; i++) {
if (type[i] == 1) {
head[z] = z;
l[z] = lx[z];
r[z] = rx[z];
pair<int, int> e = get_max(0, 1, MAXN - 1, 1, l[z] - 1);
while (e.first > l[z]) {
dsu_update(e.second);
update(0, 1, MAXN - 1, lx[head[e.second]], make_pair(0, 0));
dsu(z, e.second);
e = get_max(0, 1, MAXN - 1, 1, l[z] - 1);
}
e = get_max(0, 1, MAXN - 1, l[z] + 1, r[z] - 1);
while (e.first > r[z]) {
dsu_update(e.second);
update(0, 1, MAXN - 1, lx[head[e.second]], make_pair(0, 0));
dsu(z, e.second);
e = get_max(0, 1, MAXN - 1, l[z] + 1, r[z] - 1);
}
dsu_update(z);
update(0, 1, MAXN - 1, lx[head[z]], make_pair(rx[head[z]], z));
z++;
}
if (type[i] == 2) {
dsu_update(kx[i]);
dsu_update(ky[i]);
if (lx[head[kx[i]]] >= lx[head[ky[i]]] &&
rx[head[kx[i]]] <= rx[head[ky[i]]]) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll N = 1e6 + 10;
ll k[N];
const ll mod = 1e9 + 7;
ll fpow(ll b, ll e) {
if (!e) return 1;
ll x = fpow(b, e / 2);
ll answer = (x * x) % mod;
if (e % 2 == 1) answer = (answer * b) % mod;
return answer;
}
void test() {
ll n, p;
cin >> n >> p;
map<ll, ll> occ;
for (ll i = 0; i < n; ++i) {
cin >> k[i];
occ[-k[i]]++;
}
if (p == 1) {
cout << n % 2 << "\n";
return;
}
ll maximum_dif = n;
for (ll z = 1; z <= n; z++) {
if (fpow(p, z) >= n) {
maximum_dif = z;
break;
}
}
pair<ll, ll> tenho = {0, 0};
for (auto P : occ) {
ll val, cnt;
tie(val, cnt) = P;
val *= -1;
if (tenho.second == 0) {
if (cnt % 2 == 1) tenho = {val, 1};
continue;
}
ll dif = tenho.first - val;
bool ok = true;
if (dif < maximum_dif) {
ll y = 1;
for (int i = 0; i < dif; ++i) y *= p;
y *= tenho.second;
if (y >= n) ok = false;
} else
ok = false;
if (ok) {
ll need = fpow(p, dif) * tenho.second;
ll have = cnt;
if (have == need) {
tenho = {0, 0};
} else if (have < need) {
tenho = {val, need - have};
} else {
tenho = {val, (have - need) % 2};
}
} else {
ll Left = (fpow(p, tenho.first) * tenho.second) % mod;
for (ll i = 0; i < n; ++i) {
if (k[i] <= val) {
Left -= fpow(p, k[i]);
Left += mod;
Left %= mod;
}
}
cout << Left << "\n";
return;
}
}
cout << (fpow(p, tenho.first) * tenho.second) % mod << "\n";
}
int main() {
ios::sync_with_stdio(false);
ll tc;
cin >> tc;
while (tc--) {
test();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool isrange(int second, int first, int n, int m) {
if (0 <= second && second < n && 0 <= first && first < m) return true;
return false;
}
int dy[4] = {1, 0, -1, 0}, dx[4] = {0, 1, 0, -1},
ddy[8] = {1, 0, -1, 0, 1, 1, -1, -1}, ddx[8] = {0, 1, 0, -1, 1, -1, 1, -1};
const int MAX = 202;
int arr[MAX][MAX], col[MAX], row[MAX], n, m;
bool suc() {
int wh = -1;
for (int e = 0; e < n; e++) {
for (int p = 0; p < m; p++) {
if (wh == -1) {
if (arr[e][p] == 1) wh = 0;
} else {
if (arr[e][p] == 0) return false;
}
}
}
printf("YES\n");
for (int e = 0; e < n; e++) printf("%d", row[e]);
printf("\n");
for (int e = 0; e < m; e++) printf("%d", col[e]);
exit(0);
}
void solve(int tc) {
scanf("%d%d", &n, &m);
for (int e = 0; e < n; e++) {
for (int p = 0; p < m; p++) {
scanf("%d", &arr[e][p]);
}
}
for (int p = 0; p < m; p++) {
if (arr[0][p] == 0) {
for (int e = 0; e < n; e++) {
arr[e][p] ^= 1;
}
col[p] = 1;
}
}
for (int e = 0; e < n; e++) {
if (arr[e][0] == 0) {
for (int p = 0; p < m; p++) {
arr[e][p] ^= 1;
}
row[e] = 1;
}
}
suc();
row[0] ^= 1;
for (int p = 0; p < m; p++) {
arr[0][p] ^= 1;
}
for (int p = 1; p < m; p++) {
for (int e = 0; e < n; e++) {
arr[e][p] ^= 1;
}
col[p] ^= 1;
}
suc();
for (int p = 1; p < m; p++) {
for (int e = 0; e < n; e++) {
arr[e][p] ^= 1;
}
col[p] ^= 1;
suc();
}
for (int e = 1; e < n; e++) {
for (int p = 0; p < m; p++) {
arr[e][p] ^= 1;
}
row[e] ^= 1;
suc();
}
printf("NO");
}
int main(void) {
int tc = 1;
for (int test_number = 1; test_number <= tc; test_number++) {
solve(test_number);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t, l, r, x, y, a, b, m, pos, k, n, temp, temp1;
cin >> t;
while (t--) {
long long c1 = 0, c2 = 0, a1 = 0, a2 = 0;
cin >> n >> k;
vector<long long> a, b;
for (long long i = 0; i < n; i++) {
cin >> temp;
a.push_back(temp);
}
sort(a.begin(), a.end());
long long ans = 0;
for (long long i = 1; i < a.size(); i++) {
ans += ((k - a[i]) / a[0]);
}
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 4e5 + 22;
int n;
int ch[MAXN], dp[MAXN], dpu[MAXN], prob[MAXN], probup[MAXN];
pair<int, int> mx1[MAXN], mx2[MAXN];
vector<int> G[MAXN];
void dfs(int v, int par = n) {
ch[v] = 1;
for (int i = 0; i < G[v].size(); i++) {
int u = G[v][i];
if (u == par) continue;
dfs(u, v);
if (ch[u] > (n / 2)) prob[v] = u;
dp[v] = max(dp[v], dp[u]);
ch[v] += ch[u];
if (dp[u] > mx1[v].first)
mx2[v] = mx1[v], mx1[v] = make_pair(dp[u], u);
else if (dp[u] > mx2[v].first)
mx2[v] = make_pair(dp[u], u);
}
if (ch[v] <= (n) / 2) dp[v] = max(dp[v], ch[v]);
}
void dfsu(int v, int par = n) {
for (int i = 0; i < G[v].size(); i++) {
int u = G[v][i];
if (u == par) continue;
if (n - ch[u] > n / 2)
probup[u] = v;
else
dpu[u] = n - ch[u];
dpu[u] = max(dpu[u], dpu[v]);
if (u != mx1[v].second)
dpu[u] = max(dpu[u], mx1[v].first);
else
dpu[u] = max(dpu[u], mx2[v].first);
dfsu(u, v);
}
}
int main() {
cin >> n;
for (int i = (1); i < (n); i++) {
int x, y;
cin >> x >> y;
x--, y--;
G[x].push_back(y);
G[y].push_back(x);
}
memset(prob, -1, sizeof(prob));
memset(probup, -1, sizeof(probup));
dfs(0);
dfsu(0);
for (int i = (0); i < (n); i++) {
if (prob[i] == -1 && probup[i] == -1) {
cout << 1 << " ";
continue;
}
if (probup[i] == -1) {
int u = prob[i];
cout << !(ch[u] - dp[u] > (n / 2)) << " ";
continue;
}
cout << !((n - ch[i]) - dpu[i] > (n / 2)) << " ";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int modpow(long long int a, long long int n, long long int temp) {
long long int res = 1, y = a;
while (n > 0) {
if (n & 1) res = (res * y) % temp;
y = (y * y) % temp;
n /= 2;
}
return res % temp;
}
char a[502][502];
int n, m, k, r, cnt = 0;
int visited[502][502];
void dfs(int i, int j) {
if (cnt == r) return;
visited[i][j] = 1;
cnt++;
if (j + 1 < m && a[i][j + 1] == '.' && !visited[i][j + 1]) dfs(i, j + 1);
if (j - 1 >= 0 && a[i][j - 1] == '.' && !visited[i][j - 1]) dfs(i, j - 1);
if (i - 1 >= 0 && a[i - 1][j] == '.' && !visited[i - 1][j]) dfs(i - 1, j);
if (i + 1 < n && a[i + 1][j] == '.' && !visited[i + 1][j]) dfs(i + 1, j);
}
int main() {
int d = 0;
pair<int, int> pos;
scanf("%d", &n);
scanf("%d", &m);
scanf("%d", &k);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
visited[i][j] = 0;
if (a[i][j] == '.') {
d++;
pos = make_pair(i, j);
}
}
}
r = d - k;
dfs(pos.first, pos.second);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == '.' && !visited[i][j])
printf("X");
else
printf("%c", a[i][j]);
}
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long C, wr, wb, hr, hb, ans;
int main() {
cin >> C >> hr >> hb >> wr >> wb;
for (int i = 0; i < 1000000; i++) {
if (i * wr <= C) ans = max(ans, i * hr + (C - i * wr) / wb * hb);
if (i * wb <= C) ans = max(ans, i * hb + (C - i * wb) / wr * hr);
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, n, i, j, k, max[3];
cin >> N;
int ar[3][N];
bool flag = 0;
string s[N];
for (i = 0; i < 3; i++) {
for (j = 0; j < N; j++) ar[i][j] = 0;
}
for (i = 0; i < N; i++) {
cin >> n;
getchar();
cin >> s[i];
string S[n];
for (j = 0; j < n; j++) {
cin >> S[j];
if (S[j][1] == S[j][0] && S[j][4] == S[j][3] && S[j][7] == S[j][6] &&
S[j][6] == S[j][4] && S[j][3] == S[j][1])
ar[0][i]++;
else if (S[j][1] < S[j][0] && S[j][4] < S[j][3] && S[j][7] < S[j][6] &&
S[j][6] < S[j][4] && S[j][3] < S[j][1])
ar[1][i]++;
else
ar[2][i]++;
}
}
for (i = 0; i < 3; i++) {
max[i] = *max_element(ar[i], ar[i] + N);
}
cout << "If you want to call a taxi, you should call: ";
for (i = 0; i < N; i++) {
if (ar[0][i] == max[0]) {
if (flag == 0) {
flag = 1;
cout << s[i];
} else
cout << ", " << s[i];
}
}
cout << ".";
cout << endl;
cout << "If you want to order a pizza, you should call: ";
flag = 0;
for (i = 0; i < N; i++) {
if (ar[1][i] == max[1]) {
if (flag == 0) {
flag = 1;
cout << s[i];
} else
cout << ", " << s[i];
}
}
cout << ".";
cout << endl;
cout
<< "If you want to go to a cafe with a wonderful girl, you should call: ";
flag = 0;
for (i = 0; i < N; i++) {
if (ar[2][i] == max[2]) {
if (flag == 0) {
flag = 1;
cout << s[i];
} else
cout << ", " << s[i];
}
}
cout << ".";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int n, x;
cin >> n >> x;
int c = 0;
for (int i = 1; i <= n; i++)
if (x % i == 0 && x / i <= n) c++;
cout << c;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename typ>
void vout(vector<typ>& v) {
for (int vint = 0; vint < (int)(v).size(); vint++) cout << (v)[vint] << ' ';
cout << endl;
}
template <typename typ>
void arrout(typ* arr, int l) {
for (int i = 0; i < l; i++) cout << arr[i] << ' ';
cout << endl;
}
int gcd(int a, int b) {
while (b) {
a = a % b;
swap(a, b);
}
return a;
}
int main() {
long long n, m;
cin >> n >> m;
string x, y;
cin >> x >> y;
long long l1 = (int)(x).size(), l2 = (int)(y).size();
int g = gcd(l1, l2);
long long ans = 0;
long long c1[26];
long long c2[26];
for (int d = 0; d < g; ++d) {
memset(c1, 0, sizeof(c1));
for (int i = d; i < l1; i += g) c1[x[i] - 'a']++;
memset(c2, 0, sizeof(c2));
for (int j = d; j < l2; j += g) c2[y[j] - 'a']++;
long long s1 = 0, s2 = 0;
for (int i = 0; i < 26; ++i) {
s1 += c1[i];
s2 += c2[i];
ans -= c1[i] * c2[i];
}
ans += s1 * s2;
}
long long lcm = l1 * l2;
lcm /= g;
ans *= (n * l1) / lcm;
cout << (ans) << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
vector<long long> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
long long sum = 0;
for (long long i = 0; i < m; i++) {
if (a[i] <= 0) sum += a[i];
}
if (sum <= 0) {
cout << abs(sum);
} else {
cout << "0";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
register char c = ' ';
register int v = 0, x = 1;
while ((c < '0') || (c > '9')) {
if (c == '-') x = -1;
c = getchar();
}
while ((c >= '0') && (c <= '9')) {
v = (v << 1) + (v << 3) + (c ^ 48);
c = getchar();
}
return v * x;
}
inline void write(register int x) {
if (x < 0) x = -x, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 ^ 48);
}
const int N = 1010, M = 1e5 + 10, mod = 998244353;
int n, k, ans, a[N], res[M], dp[N][N], sum[N][N];
int main() {
n = read(), k = read(), a[0] = -1e9;
for (register int i = 1; i <= n; i++) a[i] = read();
sort(a + 1, a + n + 1);
for (register int v = 1; v * (k - 1) <= a[n]; v++) {
register int now = 0;
dp[0][0] = sum[0][0] = 1;
for (register int i = 1; i <= n; i++) {
while (a[now] <= a[i] - v) now++;
for (register int j = 0; j <= k; j++) {
if (j) dp[i][j] = sum[now - 1][j - 1];
sum[i][j] = (sum[i - 1][j] + dp[i][j]) % mod;
}
res[v] = (res[v] + dp[i][k]) % mod;
}
ans = (ans + res[v]) % mod;
}
write(ans);
return ~~(0 - 0);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void maloosh_lazma() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int main() {
maloosh_lazma();
int a, b, c;
cin >> a >> b >> c;
int tot = 1, tot2 = 1, cnt = 0;
for (int i = 1; i <= c; i++) {
int mod = i % a;
int mod2 = i % b;
if (mod == mod2 && mod == 0) {
cnt++;
}
}
cout << cnt;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
const int MOD = 1000000007;
int val[1505];
pii iv[1505];
int spanleft[1505];
int psum[1505];
int pmax[1505][1505];
int dp[1505][1505];
int n, s, m, k;
bool check(int x) {
memset(pmax, 0, sizeof pmax);
for (int i = (1); i < ((n) + 1); i++) psum[i] = (val[i] <= x) + psum[i - 1];
for (int c = (1); c < ((m) + 1); c++) {
for (int i = (0); i < (s); i++) {
dp[i][c] = psum[iv[i].second] + pmax[iv[i].first - 1][c - 1] -
psum[iv[i].first - 1];
if (spanleft[i] != -1 && c != 1) {
int c2 = psum[iv[i].second] + dp[spanleft[i]][c - 1] -
psum[iv[spanleft[i]].second];
dp[i][c] = max(dp[i][c], c2);
}
pmax[iv[i].second][c] = max(pmax[iv[i].second][c], dp[i][c]);
if (k <= dp[i][c]) return true;
}
for (int i = (1); i < ((n) + 1); i++)
pmax[i][c] = max(pmax[i][c], pmax[i - 1][c]);
}
return false;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> s >> m >> k;
for (int i = (1); i < ((n) + 1); i++) cin >> val[i];
for (int i = (0); i < (s); i++) cin >> iv[i].first >> iv[i].second;
sort(iv, iv + s);
for (int i = (0); i < (s); i++) {
spanleft[i] = -1;
for (int j = (0); j < (i); j++)
if (iv[i].first <= iv[j].second) {
spanleft[i] = j;
break;
}
}
int low = 0, high = 1000000001, ans = 1000000001;
while (low <= high) {
int mid = (low + high) / 2;
if (check(mid)) {
ans = mid;
high = mid - 1;
} else
low = mid + 1;
}
if (ans == 1000000001)
cout << -1 << endl;
else
cout << ans << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, a1, a2, b1, b2;
cin >> t;
while (t--) {
int f = 0;
cin >> a1 >> b1 >> a2 >> b2;
if (a1 == a2) {
if (b1 + b2 == a1) f = 1;
}
if (a1 == b2) {
if (b1 + a2 == a1) f = 1;
}
if (b1 == a2) {
if (a1 + b2 == b1) f = 1;
}
if (b1 == b2) {
if (a1 + a2 == b1) f = 1;
}
if (f == 0)
cout << "No" << endl;
else
cout << "Yes" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long find(long long l, long long r, long long x) {
if (l == r) {
return l;
}
long long size = r - l + 1LL;
long long m = l + size / 2LL - 1LL;
if (x % 2 == 1) {
return l + x / 2LL;
} else {
long long npos = x / 2LL;
return find(m + 1, r, npos);
}
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
long long n;
int q;
cin >> n >> q;
for (int i = 0; i < q; i++) {
long long now;
cin >> now;
if (now <= n && now % 2LL == 1LL) {
cout << (now + 1LL) / 2LL << "\n";
continue;
}
long long size = 1LL;
long long mini = -1LL;
long long temp = now;
if (now % 2LL == 0LL) {
temp--;
}
mini = (temp + 1LL) / 2LL + 1LL;
while (n - (2LL * size) + 1LL >= mini) {
size = 2LL * size;
}
long long l = n - size + 1LL;
long long r = n;
long long x = (l * 2LL - 2LL) / 2LL - (now - 1LL) / 2LL;
x = size - x + 1;
cout << find(l, r, x) << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int A[100005], prime[100005];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < 100005; i++) prime[i] = 1;
prime[0] = 0;
prime[1] = 0;
int val = 0;
for (int i = 2; i <= n; ++i) {
if (prime[i]) {
A[i] = ++val;
for (int j = 2 * i; j <= n; j += i) {
prime[j] = 0;
if (A[j] == 0) A[j] = val;
}
}
}
for (int i = 2; i <= n; ++i) {
printf("%d ", A[i]);
}
printf("\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, a[600000], L, R, r, t, l, f;
long long s;
bool ok(long long x) {
long long r = 0;
for (long long i = 0; i < n; i++)
if (a[i] > x) r += (a[i] - x);
if (r <= t) return 1;
return 0;
}
bool ok1(long long x) {
long long r = 0;
for (long long i = 0; i < n; i++)
if (a[i] < x) r += (x - a[i]);
if (r <= t) return 1;
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> t;
L = 2e9;
for (long long i = 0; i < n; i++) {
cin >> a[i];
s += a[i];
L = min(L, a[i]);
R = max(R, a[i]);
}
long long d1 = R, d2 = L;
l = L;
r = R;
while (r - l > 10) {
long long mid = (r + l) / 2;
if (ok(mid))
r = mid;
else
l = mid + 1;
}
for (long long i = l; i <= r; i++)
if (ok(i)) d1 = min(d1, i);
l = L;
r = R;
while (r - l > 10) {
long long mid = (r + l) / 2;
if (ok1(mid))
l = mid;
else
r = mid - 1;
}
for (long long i = l; i <= r; i++)
if (ok1(i)) d2 = max(d2, i);
if (s % n == 0)
f = 0;
else
f = 1;
cout << max(f, d1 - d2);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int n, m;
char mat[25][25];
};
struct node rec[25 * 25];
struct node rotate(struct node in) {
struct node out = in;
swap(out.n, out.m);
int i, j;
for (i = 0; i < in.n; i++) {
for (j = 0; j < in.m; j++) {
out.mat[j][in.n - i - 1] = in.mat[i][j];
}
}
return out;
}
int equal(struct node a, struct node b) {
if (a.n != b.n || a.m != b.m) return 0;
int i, j;
for (i = 0; i < a.n; i++) {
for (j = 0; j < a.m; j++) {
if (a.mat[i][j] != b.mat[i][j]) return 0;
}
}
return 1;
}
int rsame(struct node a, struct node b) {
int i;
for (i = 0; i < 4; i++) {
if (equal(a, b)) return 1;
b = rotate(b);
}
return 0;
}
int x, y;
char g[25][25];
int main() {
int i, j, pi, pj, ri, rj;
int n, ans, ans_x, ans_y;
while (scanf("%d%d", &x, &y) != EOF) {
memset(rec, 0, sizeof(rec));
for (i = 0; i < x; i++) {
scanf("%s", g[i]);
}
ans = 0;
for (i = 1; i <= x; i++) {
for (j = 1; j <= y; j++) {
if (x % i == 0 && y % j == 0) {
if (i == 1 && j == 3) {
int qq = 0;
}
n = i * j;
for (pi = 0; pi < n; pi++) {
rec[pi].n = x / i;
rec[pi].m = y / j;
int rx = (pi / j) * rec[pi].n;
int ry = (pi % j) * rec[pi].m;
for (ri = 0; ri < rec[pi].n; ri++) {
for (rj = 0; rj < rec[pi].m; rj++) {
rec[pi].mat[ri][rj] = g[ri + rx][rj + ry];
}
}
}
if (i == 1 && j == 3) {
int qq = 0;
}
for (pi = 0; pi < n; pi++) {
for (pj = 0; pj < n; pj++) {
if (pi != pj && rsame(rec[pi], rec[pj])) {
break;
}
}
if (pj < n) break;
}
if (i == 2 && j == 2) {
int qq = 0;
}
if (pi == n) {
if (ans == 0) {
ans_x = rec[0].n, ans_y = rec[0].m;
} else {
if ((ans_x * ans_y > rec[0].n * rec[0].m) ||
((ans_x * ans_y == rec[0].n * rec[0].m) &&
rec[0].n < ans_x)) {
ans_x = rec[0].n, ans_y = rec[0].m;
}
}
ans++;
}
}
}
}
printf("%d\n", ans);
printf("%d %d\n", ans_x, ans_y);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, r;
cin >> n >> r;
vector<double> c;
vector<double> v;
for (long long i = 0; i < n; i++) {
double num;
cin >> num;
double x, y = 0.0;
long long f = 0;
double ans = 0.0;
for (long long j = 0; j < i; j++) {
if (v[j] >= num - 2 * r && v[j] <= num + 2 * r) {
f = 1;
y = c[j];
x = v[j];
double d = (double)(r * r);
d *= 4;
d -= (double)((num - x) * (num - x));
d = (double)(sqrt(d));
d += y;
if (d > ans) {
ans = d;
}
}
}
if (f == 0) {
cout << fixed << setprecision(10) << r << " ";
c.push_back((double)r);
} else {
cout << fixed << setprecision(10) << ans << " ";
c.push_back(ans);
}
v.push_back(num);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[3];
long long int pro = 1;
for (int i = 0; i < 3; i++) {
cin >> a[i];
pro = pro * a[i];
}
int p = sqrt(pro);
cout << 4 * (p / a[0] + p / a[1] + p / a[2]);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long n, k;
long long all_path = 0;
long long rem[5] = {};
vector<long> g[200000];
long long dp[200000][5] = {};
bool vis[200000] = {};
bool done[200000] = {};
void dfs(long now) {
vis[now] = 1;
dp[now][0] = 1;
for (long long f = (long long)0; f <= (long long)g[now].size() - 1; ++f) {
if (!vis[g[now][f]]) {
dfs(g[now][f]);
}
}
long long tmp[5] = {};
bool first = 1;
for (long long f = (long long)0; f <= (long long)g[now].size() - 1; ++f) {
if (done[g[now][f]]) {
if (first) {
for (long long ff = (long long)0; ff <= (long long)k - 1; ++ff) {
tmp[ff] = dp[g[now][f]][ff];
}
first = 0;
} else {
for (long long ff = (long long)0; ff <= (long long)k - 1; ++ff) {
for (long long fff = (long long)0; fff <= (long long)k - 1; ++fff) {
rem[(ff + fff + 2) % k] += tmp[ff] * dp[g[now][f]][fff];
}
tmp[ff] += dp[g[now][f]][ff];
}
}
}
}
for (long long f = (long long)0; f <= (long long)k - 1; ++f) {
dp[now][(f + 1) % k] += tmp[f];
}
for (long long f = (long long)0; f <= (long long)k - 1; ++f) {
rem[f] += dp[now][f];
}
done[now] = 1;
}
bool vis1[200000] = {};
bool done1[200000] = {};
long long dp1[200000] = {};
void calc_all_path1(long now) {
vis1[now] = 1;
dp1[now] = 1;
for (long long f = (long long)0; f <= (long long)g[now].size() - 1; ++f) {
if (!vis1[g[now][f]]) {
calc_all_path1(g[now][f]);
}
}
for (long long f = (long long)0; f <= (long long)g[now].size() - 1; ++f) {
if (done1[g[now][f]]) {
dp1[now] += dp1[g[now][f]];
}
}
done1[now] = 1;
}
bool vis2[200000] = {};
void calc_all_path2(long now) {
vis2[now] = 1;
for (long long f = (long long)0; f <= (long long)g[now].size() - 1; ++f) {
if (!vis2[g[now][f]]) {
all_path += (dp1[0] - dp1[g[now][f]]) * dp1[g[now][f]];
calc_all_path2(g[now][f]);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(15);
cin >> n >> k;
for (long long f = (long long)0; f <= (long long)n - 2; ++f) {
long long x, y;
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(0);
rem[0] -= n;
calc_all_path1(0);
calc_all_path2(0);
long long x = 0;
for (long long f = (long long)1; f <= (long long)k - 1; ++f) {
x += rem[f] * (k - f);
}
cout << (all_path + x) / k;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool ans[35005][35], mark[35005][35];
long long Pow(long long a, long long b, long long n) {
long long ans = 1;
for (int i = 0; i < b && ans < n; i++) ans *= a;
return ans;
}
bool win(long long a, long long b, long long n) {
if (!mark[a][b]) {
mark[a][b] = true;
ans[a][b] = false;
long long p1 = Pow(a + 1, b, n), p2 = Pow(a, b + 1, n);
if (p2 >= n && b == 1)
ans[a][b] = 1 - (n - a) % 2;
else
ans[a][b] =
(p1 < n && !win(a + 1, b, n)) || (p2 < n && !win(a, b + 1, n));
}
return ans[a][b];
}
int main() {
long long a, b, n;
cin >> a >> b >> n;
if (a == 1) {
int winner = -1, now = 0;
while (b <= 30) {
if (Pow(a + 1, b, n) < n && !win(a + 1, b, n)) {
winner = now;
break;
} else {
now = 1 - now;
b++;
}
}
if (winner == -1)
cout << "Missing" << endl;
else if (winner == 0)
cout << "Masha" << endl;
else
cout << "Stas" << endl;
return 0;
}
if (win(a, b, n))
cout << "Masha" << endl;
else
cout << "Stas" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool ff(string x) {
for (int j = 0; j < x.size(); j++) {
if (x[j] != '0' && x[j] != '1') {
return false;
}
}
return true;
}
long long f(int x) {
string ans = "";
while (x > 0) {
ans += ((char)(x % 2)) + '0';
x /= 2;
}
reverse(ans.begin(), ans.end());
long long a = 0;
for (int i = 0; i < ans.size(); i++) {
a = a * 10 + (long long)(ans[i] - '0');
}
return a;
}
vector<pair<long long, long long> > v;
int main() {
ios::sync_with_stdio(false);
long long n;
cin >> n;
for (int i = 1; i <= 512; i++) {
v.push_back(make_pair(i, f(i)));
}
if (n == 1000000000)
cout << "512\n";
else
for (int i = 0; i < v.size(); i++) {
if (v[i].second > n) {
cout << v[i - 1].first << endl;
return 0;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e6 + 5;
int n, m;
bool check(int x, int y) {
if (x < 0 || y < 0 || x >= n || y >= m) return 0;
return 1;
}
int e[N];
int pos(int x, int y) { return x * m + y; }
bool vis[N];
int in[N];
int d = 0;
int ti[N], cnt;
void dfs(int u, int depx) {
d = max(d, depx);
vis[u] = 1;
ti[u] = ++cnt;
int v = e[u];
if (!ti[v] && v != -1) {
dfs(v, depx + 1);
}
ti[u] = 0;
}
void solve() {
cin >> n >> m;
for (int i = 0; i < n * m; i++) {
e[i] = -1;
vis[i] = 0;
in[i] = 0;
}
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < m; j++) {
if (s[j] == 'L' && check(i, j - 1))
e[pos(i, j)] = pos(i, j - 1), in[pos(i, j - 1)]++;
else if (s[j] == 'R' && check(i, j + 1))
e[pos(i, j)] = pos(i, j + 1), in[pos(i, j + 1)]++;
else if (s[j] == 'U' && check(i - 1, j))
e[pos(i, j)] = pos(i - 1, j), in[pos(i - 1, j)]++;
else if (s[j] == 'D' && check(i + 1, j))
e[pos(i, j)] = pos(i + 1, j), in[pos(i + 1, j)]++;
}
}
d = 0;
int ans = 0, x = 0, y = 0;
for (int i = 0; i < n * m; i++) {
if (in[i] == 0) {
d = 0;
dfs(i, 1);
if (d > ans) {
ans = d, x = i / m, y = i % m;
}
}
}
for (int i = 0; i < n * m; i++) {
if (!vis[i]) {
dfs(i, 1);
if (d > ans) {
ans = d, x = i / m, y = i % m;
}
}
}
cout << x + 1 << ' ' << y + 1 << ' ' << ans << '\n';
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long int l = ((n - 1) * (n - 1) + (n - 1)) / 2;
long int v[l], z = 0;
long int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
v[z] = (a[i] + a[j]);
z++;
}
}
sort(v, v + l);
long int count = 0, max = 0;
for (long int i = 1; i < l; i++) {
if (v[i] == v[i - 1]) {
count++;
} else if (count > max) {
max = count;
count = 0;
} else
count = 0;
}
cout << max + 1 << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a > b) swap(a, b);
if (a == 0) return b;
return gcd(b % a, a);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t, i;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long arr[n];
for (i = 0; i < n; i++) {
cin >> arr[i];
}
long long sum = 0;
for (i = 0; i < n; i++) {
if (i % 2 && arr[i] > 0)
arr[i] *= -1;
else if (i % 2 == 0 && arr[i] < 0)
arr[i] *= -1;
}
for (i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100100;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long hcf(long long a, long long b) {
if (b > a) swap(a, b);
return a * b / gcd(a, b);
}
long long sz[MAXN];
vector<long long> V[MAXN];
long long dp[MAXN];
long long ans;
long long N, a, b, T;
long long A[MAXN];
void dfs(int x, int p) {
if ((long long)V[x].size() == 1 && x != 1) {
sz[x] = 1;
dp[x] = A[x];
return;
}
long long running_gcd = 1;
for (auto v : V[x])
if (v != p) {
dfs(v, x);
running_gcd = hcf(running_gcd, sz[v]);
}
long long max_fact = 1e18;
for (auto v : V[x])
if (v != p) {
long long rep = dp[v] / running_gcd;
if (running_gcd > 1e15) {
cout << T;
exit(0);
}
max_fact = min(max_fact, rep * running_gcd);
}
for (auto v : V[x])
if (v != p) ans += dp[v] - max_fact;
long long child = (long long)V[x].size() - 1;
if (x == 1) ++child;
dp[x] = max_fact * child;
sz[x] = child * running_gcd;
}
int main() {
cin >> N;
for (int i = 1; i <= N; ++i) {
cin >> A[i];
T += A[i];
}
for (int i = 0; i < N - 1; ++i) {
cin >> a >> b;
V[a].emplace_back(b);
V[b].emplace_back(a);
}
dfs(1, -1);
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 207;
int dp[2][MAXN][MAXN];
int main() {
int n;
while (~scanf("%d", &n)) {
memset(dp, 0, sizeof(dp));
int i, j, now = 0;
dp[now][0][0] = 1;
while (n--) {
now ^= 1;
memset(dp[now], 0, sizeof(dp[now]));
int a, b;
scanf("%d%d", &a, &b);
for (i = 0; i < MAXN; i++)
for (j = 0; j < MAXN; j++) {
if (!dp[now ^ 1][i][j]) continue;
dp[now][i + a][j] = 1;
if (j + b < MAXN) dp[now][i][j + b] = 1;
}
}
int ans;
for (i = 0; i < MAXN; i++) {
int bf = 0;
for (j = 0; j <= i; j++)
if (dp[now][i][j]) {
bf = 1;
break;
}
if (bf) {
ans = i;
break;
}
}
printf("%d\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int mxn = 100005;
int n, m, a[mxn], b[mxn];
int dp_left[mxn][2][2];
int dp_right[mxn][2][2];
inline void update(int &x, int y) {
if (y > x) x = y;
}
bool chk(int t) {
memset(dp_left, -0x3f, sizeof(dp_left));
memset(dp_right, -0x3f, sizeof(dp_right));
dp_left[1][0][0] = 1;
dp_right[1][1][0] = t + 1;
for (int i = 1; i < n; ++i)
for (int c0 = 0; c0 < (int)(2); ++c0)
for (int c1 = 0; c1 < (int)(2); ++c1) {
if (dp_left[i][c0][c1] >= a[i] - t)
update(dp_left[i + 1][c0][i == 1 ? 0 : c1],
std::max(dp_left[i][c0][c1], a[i] + 1));
if (dp_right[i][c0][c1] >= a[i] - t)
update(dp_left[i + 1][c0][i == 1 ? 0 : c1],
std::max(dp_right[i][c0][c1],
std::max(a[i] + 1, a[i - 1] + t + 1)));
update(dp_right[i + 1][c0][i == 1 ? 1 : c1],
dp_left[i][c0][c1] >= a[i] ? a[i] + t + 1 : dp_left[i][c0][c1]);
update(dp_right[i + 1][c0][i == 1 ? 1 : c1], dp_right[i][c0][c1] >= a[i]
? a[i] + t + 1
: dp_right[i][c0][c1]);
}
if (dp_right[n][0][0] >= m - t) return 1;
if (dp_left[n][0][0] >= m - t) return 1;
if (dp_right[n][0][1] >= m - t) return 1;
if (dp_left[n][0][1] >= m - t) return 1;
if (dp_right[n][1][0] >= m + a[1] - t) return 1;
if (dp_left[n][1][0] >= m + a[1] - t) return 1;
if (dp_right[n][1][1] >= m) return 1;
if (dp_left[n][1][1] >= m) return 1;
return 0;
}
int main() {
scanf("%d", &m);
scanf("%d", &n);
for (int i = 0; i < (int)(n); ++i) scanf("%d", &a[i]), --a[i];
std::sort(a, a + n);
int mx = 0;
for (int i = 0; i < (int)(n - 1); ++i) mx = std::max(mx, a[i + 1] - a[i] - 1);
mx = std::max(mx, a[0] + m - a[n - 1] - 1);
bool fnd = 0;
for (int i = 0; i < (int)(n - 1); ++i)
if (mx == a[i + 1] - a[i] - 1) {
fnd = 1;
for (int j = 0; j < (int)(n); ++j) b[j] = a[(i + j + 1) % n];
break;
}
if (!fnd) {
for (int j = 0; j < (int)(n); ++j) b[j] = a[j];
}
for (int i = 0; i < (int)(n); ++i)
a[i] = b[i] - b[0] >= 0 ? b[i] - b[0] : b[i] + m - b[0];
if (n == 1) return printf("%d\n", m - 1), 0;
int lb = 0, rb = mx;
while (lb < rb) {
int md = (lb + rb) >> 1;
if (chk(md))
rb = md;
else
lb = md + 1;
}
printf("%d\n", lb);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
struct TNode {
int u;
long long val;
} cur, tmp;
vector<TNode> adj[400005];
vector<int> ls, rs;
int i, n, q, s, l1, r1, l2, r2, t, w;
long long tree[400005];
bool chk[400005], fin[400005];
inline bool operator<(const TNode &a, const TNode &b) {
return a.val > b.val || (a.val == b.val && a.u > b.u);
}
priority_queue<TNode, vector<TNode>, less<TNode>> pq;
void init(int l, int r, int i) {
if (l == s && r == s) {
tree[i] = 0;
pq.push((TNode){i, 0});
} else
tree[i] = INF;
if (l == r) {
fin[i] = true;
return;
}
init(l, (l + r) >> 1, i << 1);
init(((l + r) >> 1) + 1, r, (i << 1) + 1);
}
void add(int l, int r, int i, int L, int R, vector<int> &x) {
if (l > R || r < L) return;
if (L <= l && r <= R) {
x.push_back(i);
return;
}
add(l, (l + r) >> 1, i << 1, L, R, x);
add(((l + r) >> 1) + 1, r, (i << 1) + 1, L, R, x);
}
void upd(int i) {
if (fin[i]) return;
if (tree[i << 1] > tree[i]) {
tree[i << 1] = tree[i];
pq.push((TNode){i << 1, tree[i]});
upd(i << 1);
}
if (tree[(i << 1) + 1] > tree[i]) {
tree[(i << 1) + 1] = tree[i];
pq.push((TNode){(i << 1) + 1, tree[i]});
upd((i << 1) + 1);
}
}
long long que(int l, int r, int i, int u) {
if (l == r) return tree[i] == INF ? -1 : tree[i];
int m = (l + r) >> 1;
return u <= m ? que(l, m, i << 1, u) : que(m + 1, r, (i << 1) + 1, u);
}
void Dijkstra() {
while (!pq.empty()) {
for (cur = pq.top(), pq.pop(), upd(cur.u); cur.u > 0 && (!chk[cur.u]);
cur.u >>= 1) {
chk[cur.u] = true;
for (TNode v : adj[cur.u])
if (tree[v.u] > cur.val + v.val) {
tree[v.u] = cur.val + v.val;
pq.push((TNode){v.u, tree[v.u]});
}
}
while (!pq.empty() && tree[pq.top().u] > pq.top().val) pq.pop();
}
}
int main() {
scanf("%d%d%d", &n, &q, &s);
init(1, n, 1);
while (q--) {
scanf("%d", &t);
if (t == 1) {
scanf("%d%d%d", &l1, &l2, &w);
r1 = l1;
r2 = l2;
} else if (t == 2) {
scanf("%d%d%d%d", &l1, &l2, &r2, &w);
r1 = l1;
} else {
scanf("%d%d%d%d", &l2, &l1, &r1, &w);
r2 = l2;
}
add(1, n, 1, l1, r1, ls);
add(1, n, 1, l2, r2, rs);
for (int i : ls)
for (int j : rs) adj[i].push_back((TNode){j, w});
ls.clear();
rs.clear();
}
Dijkstra();
for (i = 1; i <= n; i++) printf("%I64d ", que(1, n, 1, i));
}
| 7 |
#include <bits/stdc++.h>
int main() {
int a, b;
scanf("%d %d", &a, &b);
for (int i = b + 1; i <= a + b + 1; i++) printf("%d ", i);
for (int i = b; i >= 1; i--) printf("%d ", i);
putchar('\n');
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1005;
int N, M, Q;
int n1, m1, n2, m2, n, m;
struct ListNode {
int val;
ListNode *right;
ListNode *down;
};
ListNode nodes[MAXN][MAXN];
void inputNodes() {
for (int j = 1; j <= M; ++j) {
nodes[0][j - 1].right = &nodes[0][j];
}
for (int i = 1; i <= N; ++i) {
nodes[i - 1][0].down = &nodes[i][0];
for (int j = 1; j <= M; ++j) {
scanf("%d", &nodes[i][j].val);
nodes[i - 1][j].down = &nodes[i][j];
nodes[i][j - 1].right = &nodes[i][j];
nodes[i][j].down = NULL;
nodes[i][j].right = NULL;
}
}
}
void printNodes() {
ListNode *p = &nodes[0][0];
p = p->down;
p = p->right;
ListNode *q = p;
while (p != NULL) {
while (q != NULL) {
printf("%d ", q->val);
q = q->right;
}
printf("\n");
p = p->down;
q = p;
}
}
inline ListNode *findPos(int n, int m) {
ListNode *res = &nodes[0][0];
while (n--) res = res->down;
while (m--) res = res->right;
return res;
}
int main() {
while (scanf("%d%d%d", &N, &M, &Q) != EOF) {
inputNodes();
while (Q--) {
scanf("%d%d%d%d%d%d", &n1, &m1, &n2, &m2, &n, &m);
ListNode *left1 = findPos(n1, m1 - 1);
ListNode *left2 = findPos(n2, m2 - 1);
ListNode *up1 = findPos(n1 - 1, m1);
ListNode *up2 = findPos(n2 - 1, m2);
ListNode *right1 = findPos(n1, m1 + m - 1);
ListNode *right2 = findPos(n2, m2 + m - 1);
ListNode *down1 = findPos(n1 + n - 1, m1);
ListNode *down2 = findPos(n2 + n - 1, m2);
for (int i = 0; i < n; ++i) {
swap(left1->right, left2->right);
left1 = left1->down;
left2 = left2->down;
}
for (int i = 0; i < m; ++i) {
swap(up1->down, up2->down);
up1 = up1->right;
up2 = up2->right;
}
for (int i = 0; i < n; ++i) {
swap(right1->right, right2->right);
right1 = right1->down;
right2 = right2->down;
}
for (int i = 0; i < m; ++i) {
swap(down1->down, down2->down);
down1 = down1->right;
down2 = down2->right;
}
}
printNodes();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void boost() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int n, x = 1;
bool flag = 1;
int main() {
cin >> n;
if (n == 2) {
cout << 1 << " " << 2;
return 0;
}
if (n == 1) {
cout << 1;
return 0;
}
int l = 1, r = n;
while (l <= r) {
if (flag) {
cout << l << " ";
l++;
flag = 0;
} else {
cout << r << " ";
r--;
flag = 1;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y, z;
cin >> n >> z;
while (n--) {
cin >> x >> y;
if (x == z || x == 7 - z || y == z || y == 7 - z) {
cout << "NO\n";
return 0;
}
}
cout << "YES\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)1e12;
const int MaxN = 128;
long long dp[MaxN][MaxN][MaxN];
long long c[MaxN], p[MaxN][MaxN];
int main() {
ios::sync_with_stdio(false);
long long n, m, kkk;
cin >> n >> m >> kkk;
for (int i = 1; i <= n; i++) cin >> c[i];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> p[i][j];
for (int i = 0; i < MaxN; i++)
for (int j = 0; j < MaxN; j++)
for (int k = 0; k < MaxN; k++) dp[i][j][k] = -1;
if (c[1] == 0LL) {
for (int i = 1; i <= m; i++) dp[1][i][1] = p[1][i];
} else {
dp[1][c[1]][1] = 0;
}
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int k = 1; k <= kkk; k++) {
if (c[i] != 0LL && j != c[i]) {
dp[i][j][k] = -1LL;
continue;
} else {
dp[i][j][k] = INF;
for (int l = 1; l <= m; l++) {
if (l == j) {
if (dp[i - 1][l][k] == -1LL)
continue;
else
dp[i][j][k] =
min(dp[i][j][k],
dp[i - 1][l][k] + p[i][j] * (j == c[i] ? 0 : 1));
} else {
if (dp[i - 1][l][k - 1] == -1LL)
continue;
else
dp[i][j][k] =
min(dp[i][j][k],
dp[i - 1][l][k - 1] + p[i][j] * (j == c[i] ? 0 : 1));
}
}
}
}
}
}
long long ans = INF;
for (int i = 1; i <= m; i++)
if (dp[n][i][kkk] != -1) ans = min(ans, dp[n][i][kkk]);
if (ans == INF) ans = -1;
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T mod(T a, T b) {
T ans;
if (b == 0)
return -1;
else
ans = (a < 0 ? mod(((a % b) + b), b) : a % b);
return ans;
}
long long fast_exp(long long base, long long n, long long M) {
long long ans = 1;
while (n) {
if (n % 2 == 1) ans = (ans * base) % M;
base = (base * base) % M;
n = n >> 1;
}
return ans % M;
}
void solve() {
long long int l, r, x, y;
long double k, left = 0, right = 0;
cin >> l >> r >> x >> y >> k;
for (int b = x; b < y + 1; b++) {
long double a = k * b * 10;
if (int(a) % 10 == 0 and int(a / 10) > l - 1 and int(a / 10) < r + 1) {
cout << "YES" << endl;
return;
}
}
cout << "NO" << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double eps = 1e-7;
int main() {
int t;
double a, b, ans;
scanf("%d", &t);
while (t--) {
scanf("%lf%lf", &a, &b);
ans = 0.50000000;
if (b < eps) {
printf("%lf\n", 1.0);
continue;
}
if (a < eps) {
printf("%lf\n", 0.5);
continue;
}
if (a / b - 4.0 < -eps) {
ans += 0.5 * (a * a / 8.0) / (a * b);
} else {
ans += 0.5 * (a * b - b * 2.0 * b) / (a * b);
}
printf("%lf\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin>>t;while(t--){
int i,n,k,j[300010],tem,a[300010],ind[300010];
cin>>n>>k;
for(i=1;i<=n;i++) a[i]=2e9,ind[i]=0;
for(i=0;i<k;i++){
cin>>j[i];
}
for(i=0;i<k;i++){
cin>>tem;
a[j[i]]=tem;
}
for(i=2;i<=n;i++){
a[i]=min(a[i],a[i-1]+1);
}
for(i=n-1;i>0;i--){
a[i]=min(a[i],a[i+1]+1);
}
for(i=1;i<=n;i++) cout<<a[i]<<' ';
cout<<endl;
}
} | 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const long long inf = 0x3f3f3f3f3f3f3f3f;
long long dp[maxn][1 << 8];
struct node {
int a, id;
bool operator<(const node &rhs) const {
if (a == rhs.a) return id < rhs.id;
return a > rhs.a;
}
} a[maxn];
int f[maxn][10];
inline int bitcount(int x) {
int res = 0;
while (x) {
if (x & 1) res++;
x >>= 1;
}
return res;
}
int main(void) {
int n, p, k;
scanf("%d%d%d", &n, &p, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].a);
a[i].id = i;
}
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= p; j++) {
scanf("%d", &f[i][j]);
}
}
int ts = 1 << p;
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
int j = a[i].id;
for (int s = 0; s < ts; s++) {
int bit = bitcount(s);
int in = i - 1 - bit;
if (in < k && dp[i - 1][s] != -1)
dp[i][s] = dp[i - 1][s] + a[i].a;
else
dp[i][s] = dp[i - 1][s];
for (int k = 1; k <= p; k++) {
if (((s >> (k - 1)) & 1) && dp[i - 1][s ^ (1 << (k - 1))] != -1) {
dp[i][s] = max(dp[i][s], dp[i - 1][s ^ (1 << (k - 1))] + f[j][k]);
}
}
}
}
printf("%I64d\n", dp[n][ts - 1]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 10;
map<int, vector<int> > pos;
struct SuffixArray {
int s[maxn];
int sa[maxn], rk[maxn], tp[maxn], c[maxn], height[maxn];
void radixsort(int n, int m) {
for (int i = 0; i <= m; ++i) c[i] = 0;
for (int i = 1; i <= n; ++i) ++c[rk[i]];
for (int i = 1; i <= m; ++i) c[i] += c[i - 1];
for (int i = n; i >= 1; --i) sa[c[rk[tp[i]]]--] = tp[i];
}
void build_sa(int n, int m) {
for (int i = 1; i <= n; ++i) {
rk[i] = s[i], tp[i] = i;
}
radixsort(n, m);
for (int k = 1; k <= n; k <<= 1) {
int p = 0;
for (int i = n - k + 1; i <= n; ++i) tp[++p] = i;
for (int i = 1; i <= n; ++i) {
if (sa[i] > k) tp[++p] = sa[i] - k;
}
radixsort(n, m);
std::swap(rk, tp);
p = rk[sa[1]] = 1;
for (int i = 2; i <= n; ++i) {
rk[sa[i]] =
(tp[sa[i]] == tp[sa[i - 1]] && tp[sa[i] + k] == tp[sa[i - 1] + k])
? p
: ++p;
}
if (p >= n) break;
m = p;
}
int k = 0;
for (int i = 1; i <= n; ++i) {
if (k) --k;
int j = sa[rk[i] - 1];
while (i + k <= n && j + k <= n && s[i + k] == s[j + k]) ++k;
height[rk[i]] = k;
}
}
} sa;
char s[maxn];
int sum[maxn];
int dp[maxn][24];
void init_rmq(int n, int a[]) {
for (int i = 1; i <= n; ++i) dp[i][0] = a[i];
for (int j = 1; (1 << j) <= n; ++j) {
for (int i = 1; i + (1 << j) - 1 <= n; ++i) {
dp[i][j] = min(dp[i][j - 1], dp[i + (1 << (j - 1))][j - 1]);
}
}
}
inline int rmq(int l, int r) {
int k = 31 - __builtin_clz(r - l + 1);
return min(dp[l][k], dp[r - (1 << k) + 1][k]);
}
int main() {
int n;
scanf("%d", &n);
scanf("%s", s + 1);
for (int i = 1; i <= n; ++i) {
if (s[i] == '(')
sum[i] = 1, sa.s[i] = 1;
else
sum[i] = -1, sa.s[i] = 2;
}
sa.build_sa(n, 3);
for (int i = 1; i <= n; ++i) sum[i] += sum[i - 1];
for (int i = 1; i <= n; ++i) pos[sum[i]].push_back(i);
init_rmq(n, sum);
long long ans = 0;
for (int i = 1; i <= n; ++i) {
int x = sa.sa[i];
if (sa.s[x] == 2) continue;
int ed = x + sa.height[i];
int l = ed, r = n, res = l;
while (l <= r) {
int mid = (l + r) >> 1;
if (rmq(x, mid) >= sum[x - 1]) {
res = mid, l = mid + 1;
} else {
r = mid - 1;
}
}
auto &vec = pos[sum[x - 1]];
ans += upper_bound(vec.begin(), vec.end(), r) -
lower_bound(vec.begin(), vec.end(), ed);
}
printf("%lld\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int fa[200];
bool visit[200];
void init() {
for (int k = 0; k < 200; k++) fa[k] = k;
}
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
bool Union(int a, int b) {
a = find(a);
b = find(b);
if (a == b) return false;
fa[a] = b;
return true;
}
int a[200];
int main() {
int n, m;
int ans;
while (cin >> n >> m) {
memset(visit, false, sizeof(visit));
init();
ans = 0;
int flag = 0;
for (int i = 0, num; i < n; i++) {
cin >> num;
if (num == 0) ans++;
for (int j = 0; j < num; j++) {
flag = 1;
cin >> a[j];
visit[a[j]] = true;
for (int z = 0; z < j; z++) Union(a[j], a[z]);
}
}
for (int i = 1; i <= m; i++)
if (visit[i] && fa[i] == i) ans++;
cout << ans - flag << endl;
}
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.