solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int a[1234];
int main() {
int n, m, c;
cin >> n >> m >> c;
memset(a, -1, sizeof a);
bool go = true;
while (go) {
int v;
cin >> v;
if (v <= c / 2) {
int i = 0;
while (i < n && a[i] != -1 && v >= a[i]) i++;
a[i] = v;
cout << i + 1 << endl;
} else {
int i = n - 1;
while (i >= 0 && v <= a[i]) i--;
a[i] = v;
cout << i + 1 << endl;
}
go = false;
for (int i = 0; i < n; i++) go |= (a[i] == -1);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 100, LOG = 18;
int n, m, u, v, c, h[N], dp[N], dp_child[N], upper[N][LOG], dp_sum[N][LOG];
vector<int> child[N], under[N][LOG];
vector<pair<pair<int, int>, int> > vec[N];
void dfs(int v) {
for (int i = 1; i < LOG && (1 << i) <= h[v]; i++) {
upper[v][i] = upper[upper[v][i - 1]][i - 1];
under[upper[v][i]][i].push_back(v);
}
for (int u : child[v]) {
h[u] = h[v] + 1;
under[v][0].push_back(u);
upper[u][0] = v;
dfs(u);
}
}
inline int lca(int u, int v) {
if (h[u] < h[v]) swap(u, v);
for (int i = LOG - 1; i >= 0; i--)
if (h[u] - (1 << i) >= h[v]) u = upper[u][i];
if (u == v) return u;
for (int i = LOG - 1; i >= 0; i--)
if (upper[u][i] != upper[v][i]) {
u = upper[u][i];
v = upper[v][i];
}
return upper[u][0];
}
inline int SUM(int u, int v) {
int res = 0;
for (int i = LOG - 1; i >= 0; i--)
if (h[u] - (1 << i) >= h[v]) {
res += dp_sum[u][i];
u = upper[u][i];
}
return res;
}
inline int last(int u, int v) {
for (int i = LOG - 1; i >= 0; i--)
if (h[u] - (1 << i) > h[v]) u = upper[u][i];
return u;
}
void find_dp(int v) {
for (int u : child[v]) {
find_dp(u);
dp_child[v] += dp[u];
}
dp[v] = dp_child[v];
for (pair<pair<int, int>, int> p : vec[v]) {
int U = p.first.first, V = p.first.second;
if (h[U] > h[V]) swap(U, V);
if (U == v)
dp[v] = max(dp[v], SUM(V, last(V, v)) + dp_child[V] + dp_child[v] -
dp[last(V, v)] + p.second);
else
dp[v] = max(dp[v], SUM(U, last(U, v)) + dp_child[U] + SUM(V, last(V, v)) +
dp_child[V] + dp_child[v] - dp[last(U, v)] -
dp[last(V, v)] + p.second);
}
for (int i = 0; i < LOG; i++)
for (int u : under[v][i])
if (i)
dp_sum[u][i] = dp_sum[u][i - 1] + dp_sum[upper[u][i - 1]][i - 1];
else
dp_sum[u][i] = dp_child[v] - dp[u];
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n >> m;
for (int i = 1; i < n; i++) {
cin >> u;
child[--u].push_back(i);
}
dfs(0);
while (m--) {
cin >> u >> v >> c;
u--, v--;
vec[lca(u, v)].push_back(
pair<pair<int, int>, int>(pair<int, int>(u, v), c));
}
find_dp(0);
cout << dp[0];
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long Ans;
unsigned long long N, M;
int x, y;
unsigned long long In[1002012];
int main() {
scanf("%I64d%I64d", &N, &M);
for (int i = 1; i <= M; ++i) {
scanf("%d%d", &x, &y);
++In[x];
++In[y];
}
for (int i = 1; i <= N; ++i) {
Ans += In[i] * (N - In[i] - 1);
}
Ans /= 2;
Ans = (N * (N - 1) / 2) * (N - 2) / 3 - Ans;
cout << Ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int all[1000010], a, t;
vector<int> valid;
map<int, int> mp;
double getRes(double a, double b) {
return ((a + a + b + b) * (a + a + b + b)) / (a * b);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> t;
while (t--) {
cin >> a;
mp.clear();
valid.clear();
for (int i = 0; i < a; ++i) {
cin >> all[i];
mp[all[i]]++;
if (mp[all[i]] == 2) {
mp[all[i]] = 0;
valid.push_back(all[i]);
}
}
sort(valid.begin(), valid.end());
double _minDist = getRes(valid[1], valid[0]);
int inx = 0;
for (int i = 0; i < valid.size() - 1; ++i) {
if (getRes(valid[i + 1], valid[i]) < _minDist) {
_minDist = getRes(valid[i + 1], valid[i]);
inx = i;
}
}
cout << valid[inx] << " " << valid[inx] << " " << valid[inx + 1] << " "
<< valid[inx + 1] << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
set<pair<long long, vector<long long>>> st;
pair<long long, vector<long long>> s;
vector<vector<long long>> a(n);
long long sum = 0;
for (long long i = 0; i < n; ++i) {
long long k;
cin >> k;
a[i].resize(k);
for (long long j = 0; j < k; ++j) cin >> a[i][j];
sum += a[i][k - 1];
s.first = sum, s.second.push_back(k - 1);
}
set<vector<long long>> banned;
long long m;
cin >> m;
for (long long i = 0; i < m; ++i) {
vector<long long> vt(n);
for (long long j = 0; j < n; ++j) {
cin >> vt[j];
--vt[j];
}
banned.insert(vt);
}
st.insert(s);
while (st.size() > 0) {
pair<long long, vector<long long>> pr = *(st.rbegin());
st.erase(*st.rbegin());
vector<long long> cur = pr.second;
if (!banned.count(cur)) {
for (long long i = 0; i < pr.second.size(); ++i)
cout << pr.second[i] + 1 << " ";
cout << '\n';
return;
}
sum = pr.first;
for (long long i = 0; i < cur.size(); ++i) {
if (cur[i] == 0) continue;
cur[i]--;
st.insert({sum - a[i][cur[i] + 1] + a[i][cur[i]], cur});
cur[i]++;
}
}
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
long long nt;
nt = 1;
while (nt--) solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n;
cin >> m >> n;
if (m == 1)
cout << n / 2;
else if (n == 1)
cout << m / 2;
else {
int ans = m / 2 * n;
if (m % 2 != 0) ans += n / 2;
cout << ans;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
char a[N], b[N];
int main() {
int t;
memset(a, 'a', sizeof a);
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
k = n * (n - 1) / 2 - k + 1;
long long p = 1;
while (p * (2 * n - 1 - p) / 2 < k) p++;
long long x = p - 1, y;
y = k - x * (2 * n - 1 - x) / 2;
a[p] = 'b', a[p + y] = 'b', a[n + 1] = '\0';
cout << a + 1 << endl;
a[p] = a[p + y] = a[n + 1] = 'a';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
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, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const int N = 5e3 + 10;
const int MOD = 1e9 + 7;
inline int add(int a, int b) {
a = a + b;
if (a >= MOD) a -= MOD;
return a;
}
inline int mul(int a, int b) { return a * 1ll * b % MOD; }
inline int power(int a, int p) {
int ret = 1;
while (p) {
if (p & 1) ret = mul(ret, a);
a = mul(a, a);
p >>= 1;
}
return ret;
}
inline int inv(int x) { return power(x, MOD - 2); }
int nCr(int n, int r) {
int num = 1, den = 1;
for (int sub = 0; sub < r; sub++) {
num = mul(num, n - sub);
den = mul(den, sub + 1);
}
return mul(num, inv(den));
}
int ST[N][N], fact[N];
void pre() {
fact[0] = 1;
for (int i = (1); i < (N); ++i) fact[i] = mul(i, fact[i - 1]);
for (int i = (1); i < (N); ++i) ST[i][1] = 1;
for (int i = (2); i < (N); ++i)
for (int j = (2); j < (i + 1); ++j) {
ST[i][j] = add(ST[i - 1][j - 1], mul(j, ST[i - 1][j]));
}
}
int main() {
int n, k;
cin >> n >> k;
pre();
int sum = 0;
for (int i = (0); i < (k + 1); ++i) {
int v = fact[i];
v = mul(v, ST[k][i]);
v = mul(v, nCr(n, i));
v = mul(v, inv(power(2, i)));
sum = add(sum, v);
}
sum = mul(sum, power(2, n));
cout << sum << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
string s, str;
int i, k, l, h, n;
cin >> n;
vector<string> v(n + 1);
for (i = 1; i <= n; i++) cin >> v[i];
cin >> s;
if (s.size() < 5) {
cout << "no";
return 0;
}
k = 0, h = 0;
while (true) {
if (!h)
if (s[k] == '<') h = 1;
if (h)
if (s[k] == '3') break;
k++;
if (k == s.size()) {
cout << "no";
return 0;
}
}
for (i = 1; i <= n; i++) {
str = v[i];
int h = 0;
while (true) {
if (s[k] == str[h]) h++;
if (h == str.size()) break;
k++;
if (k == s.size()) {
cout << "no";
return 0;
}
}
h = 0;
while (true) {
if (!h)
if (s[k] == '<') h = 1;
if (h)
if (s[k] == '3') break;
k++;
if (k == s.size()) {
cout << "no";
return 0;
}
}
}
cout << "yes";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
exit(0);
}
const int maxn = 1e6 + 5;
int n;
long long a[maxn], ans[maxn];
long long t;
long long now;
priority_queue<pair<int, int>> pq;
queue<int> q;
set<int> s;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> t;
for (int i = 1; i <= n; i++) {
cin >> a[i];
pq.push({-a[i], -i});
}
for (int i = 1; i <= n; i++) {
if (q.empty() && s.empty()) {
now = (-pq.top().first);
}
now += t;
while (!pq.empty() && -pq.top().first <= now) {
if (q.empty() || -pq.top().second < q.back()) {
q.push(-pq.top().second);
} else {
s.insert(-pq.top().second);
}
pq.pop();
}
ans[q.front()] = now;
q.pop();
if (q.empty() && !s.empty()) {
q.push(*s.begin());
s.erase(s.begin());
}
}
for (int i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
long long a[maxn], b[maxn], c[maxn], num[maxn], num1[maxn];
vector<int> vp[maxn];
long long ans = 0;
void dfs(int u, int fa) {
if (b[u] == 0 && c[u] == 1)
num[u]++;
else if (b[u] == 1 && c[u] == 0)
num1[u]++;
for (auto i : vp[u]) {
if (i == fa) continue;
a[i] = min(a[i], a[u]);
dfs(i, u);
num[u] += num[i];
num1[u] += num1[i];
}
int q = min(num[u], num1[u]);
if (q) {
ans += q * 2 * a[u];
num[u] -= q;
num1[u] -= q;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
int q = 0, w = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i] >> c[i];
if (c[i] == 0 && b[i] == 1)
q++;
else if (c[i] == 1 && b[i] == 0)
w++;
}
for (int i = 1; i <= n - 1; i++) {
int u, v;
cin >> u >> v;
vp[u].push_back(v);
vp[v].push_back(u);
}
if (q != w) {
cout << "-1";
} else {
dfs(1, 1);
cout << ans;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a[100069], b, c, temp;
long long int n, i, j, k;
cin >> n;
a[0] = 0;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n; i++) {
c = 0;
for (j = 1; j <= n - i; j++) {
if (a[j] > a[j + 1]) {
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
c++;
cout << j << " " << j + 1 << endl;
}
}
if (c == 0) break;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int Tes, n, m, p, k, fx[][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}}, a[200010],
W[200010], U[1600010], V[1600010], sth = 0;
char op[] = {'R', 'L', 'D', 'U'}, s[200010], Ud[1600010], Vd[1600010];
int head[200010], cur[200010], o, dep[200010], S, T, SS, TT, cnt, tmp, flow;
struct edge {
int to, link, w;
} e[1600010];
void add_edge(int u, int v, int w) {
if (!w) return;
e[++o].to = v, e[o].link = head[u], head[u] = o, e[o].w = w;
e[++o].to = u, e[o].link = head[v], head[v] = o, e[o].w = 0;
U[o] = SS;
}
void add_edge(int u, int v, int L, int R) {
add_edge(SS, v, L), add_edge(u, TT, L), add_edge(u, v, R - L), tmp += L;
}
bool bfs() {
memset(dep, 0, 4 * (cnt + 1));
queue<int> q;
dep[SS] = 1, q.push(SS);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = head[u]; i; i = e[i].link) {
sth++;
if (dep[e[i].to] || !e[i].w) continue;
dep[e[i].to] = dep[u] + 1;
q.push(e[i].to);
}
}
return dep[TT];
}
int dfs(int u, int in) {
if (u == TT) return in;
int out = 0;
for (int &i = cur[u]; i; i = e[i].link) {
sth++;
if (dep[e[i].to] != dep[u] + 1 || !e[i].w) continue;
int res = dfs(e[i].to, min(in, e[i].w));
in -= res, out += res;
e[i].w -= res, e[i ^ 1].w += res;
if (!in) break;
}
return out;
}
void solve() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &a[(i - 1) * m + j]);
o = 1, tmp = flow = 0;
cnt = (n - 1) * m + m, S = ++cnt, T = ++cnt, SS = ++cnt, TT = ++cnt;
for (int i = 1; i <= cnt; i++) head[i] = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
int L = 1;
for (int k = 0; k < 4; k++) {
int xx = i + fx[k][0], yy = j + fx[k][1];
if (xx <= n && xx >= 1 && yy <= m && yy >= 1) {
if (a[(xx - 1) * m + yy] < a[(i - 1) * m + j])
L = 0, s[(i - 1) * m + j] = op[k],
W[(i - 1) * m + j] = a[(i - 1) * m + j] - a[(xx - 1) * m + yy];
if (a[(xx - 1) * m + yy] == a[(i - 1) * m + j] && ((i ^ j) & 1)) {
add_edge((i - 1) * m + j, (xx - 1) * m + yy, 1);
U[o] = (i - 1) * m + j, V[o] = (xx - 1) * m + yy;
Ud[o] = op[k], Vd[o] = op[k ^ 1];
}
}
}
if ((i ^ j) & 1)
add_edge(S, (i - 1) * m + j, L, 1);
else
add_edge((i - 1) * m + j, T, L, 1);
}
add_edge(T, S, 2e9);
while (bfs()) memcpy(cur, head, 4 * (cnt + 1)), flow += dfs(SS, 2e9);
if (tmp != flow) return puts("NO"), void();
for (int i = 3; i <= o; i += 2) {
if (e[i].w && U[i] != SS) {
s[U[i]] = Ud[i], s[V[i]] = Vd[i];
W[U[i]] = 1, W[V[i]] = a[U[i]] - 1;
}
}
cerr << sth << "\n";
puts("YES");
for (int i = 1; i <= n; i++, puts(""))
for (int j = 1; j <= m; j++) printf("%d ", W[(i - 1) * m + j]);
for (int i = 1; i <= n; i++, puts(""))
for (int j = 1; j <= m; j++) printf("%c ", s[(i - 1) * m + j]);
}
int main() {
scanf("%d", &Tes);
while (Tes--) solve();
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, j, x;
cin >> n >> m;
x = m;
vector<int> a(n), b(n);
for (i = 0; i < n; ++i) cin >> a[i];
for (i = 0; i < n; ++i) cin >> b[i];
sort(b.begin(), b.end());
for (i = 0; i < n; ++i) {
int t1 = (b[0] - a[i]) % m;
if (t1 < 0) t1 += m;
vector<int> t0(a);
for (j = 0; j < n; ++j) t0[j] = (t0[j] + t1) % m;
sort(t0.begin(), t0.end());
if (b == t0) x = min(x, t1);
}
cout << x << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
vector<long long int> dp(n + 1);
dp[0] = 0;
for (long long int i = 1; i <= n; i++) {
long long int temp = i;
long long int minSteps = 1e18 + 2;
while (temp != 0) {
long long int di = temp % 10;
temp /= 10;
if (di == 0) continue;
minSteps = min(minSteps, 1 + dp[i - di]);
}
dp[i] = minSteps;
}
cout << dp[n] << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k;
cin >> n >> k;
int cont = 1;
while (k % 2 == 0) {
k /= 2;
cont++;
}
cout << cont << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, x, y, head[200010], cnt, num, du[200010];
struct edge {
int to, next;
} e[400010];
inline void insert(int u, int v) {
e[++cnt].to = v, e[cnt].next = head[u], head[u] = cnt;
}
inline int dfs(int u, int fa) {
int tot = 0;
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
if (v == fa) continue;
if (dfs(v, u)) tot++;
}
if (tot <= 1) {
num += tot;
return 1;
} else {
num += 2;
return 0;
}
}
int main() {
scanf("%d%d%d", &n, &x, &y);
for (int i = 1; i <= n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
insert(u, v);
insert(v, u);
du[u]++;
du[v]++;
}
if (x >= y) {
for (int i = 1; i <= n; i++) {
if (du[i] == n - 1) {
printf("%lld\n", (long long)y * (n - 2) + x);
return 0;
}
}
printf("%lld\n", (long long)y * (n - 1));
} else {
dfs(1, 0);
printf("%lld\n", (long long)(n - 1 - num) * y + (long long)num * x);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int MOD = 1e9 + 7;
long long INF = 1e18;
int a, b, c, d;
string s;
int solve() {
cin >> s;
int n = s.size();
if (n & 1) {
if (s[n >> 1] != '3' && s[n >> 1] != '7') {
cout << "No" << endl;
return 0;
}
}
for (int i = 0; i * 2 < n; i++) {
if (s[i] == '4' && s[n - i - 1] != '6') {
cout << "No" << endl;
return 0;
}
if (s[i] == '5' && s[n - i - 1] != '9') {
cout << "No" << endl;
return 0;
}
if (s[i] == '8' && s[n - i - 1] != '0') {
cout << "No" << endl;
return 0;
}
if (s[i] == '6' && s[n - i - 1] != '4') {
cout << "No" << endl;
return 0;
}
if (s[i] == '9' && s[n - i - 1] != '5') {
cout << "No" << endl;
return 0;
}
if (s[i] == '0' && s[n - i - 1] != '8') {
cout << "No" << endl;
return 0;
}
if (s[i] == '3' && s[n - i - 1] != '3') {
cout << "No" << endl;
return 0;
}
if (s[i] == '7' && s[n - i - 1] != '7') {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
}
int main() {
ios::sync_with_stdio(0);
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 7;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + (ch ^ 48), ch = getchar();
return x * f;
}
int n, x[N], y[N], xmx, xmn, ymx, ymn;
int f[5][5][5];
void Max(int &x, int y) {
if (x < y) x = y;
}
int main() {
xmn = ymn = 1e9;
xmx = ymx = -1e9;
n = read();
memset(f, -0x3f, sizeof(f));
f[0][0][0] = 0;
for (int i = 1, iE = n; i <= iE; i++) {
x[i] = read(), y[i] = read();
xmx = max(xmx, x[i]);
xmn = min(xmn, x[i]);
ymx = max(ymx, y[i]);
ymn = min(ymn, y[i]);
for (int cnt = 3, cntE = 1; cnt >= cntE; cnt--)
for (int a = 0, aE = 3; a <= aE; a++)
for (int b = 0, bE = 3; b <= bE; b++) {
if (a & 2) Max(f[cnt][a][b], f[cnt - 1][a ^ 2][b] + x[i]);
if (a & 1) Max(f[cnt][a][b], f[cnt - 1][a ^ 1][b] - x[i]);
if (b & 2) Max(f[cnt][a][b], f[cnt - 1][a][b ^ 2] + y[i]);
if (b & 1) Max(f[cnt][a][b], f[cnt - 1][a][b ^ 1] - y[i]);
if ((a & 2) && (b & 2))
Max(f[cnt][a][b], f[cnt - 1][a ^ 2][b ^ 2] + x[i] + y[i]);
if ((a & 2) && (b & 1))
Max(f[cnt][a][b], f[cnt - 1][a ^ 2][b ^ 1] + x[i] - y[i]);
if ((a & 1) && (b & 2))
Max(f[cnt][a][b], f[cnt - 1][a ^ 1][b ^ 2] - x[i] + y[i]);
if ((a & 1) && (b & 1))
Max(f[cnt][a][b], f[cnt - 1][a ^ 1][b ^ 1] - x[i] - y[i]);
}
}
printf("%d ", max(f[2][3][3], f[3][3][3]) * 2);
for (int i = 4, iE = n; i <= iE; i++)
printf("%d ", 2 * (xmx - xmn + ymx - ymn));
puts("");
return 0;
}
| 6 |
//clear adj and visited vector declared globally after each test case
//check for long long overflow
//while adding and subs check if mod becomes -ve
//while using an integer directly in a builtin function add ll
//Mod wale question mein last mein if dalo ie. Ans<0 then ans+=mod;
//Dont keep array name as size or any other key word
// kuch ni ho rha to kya pta binary search ho
// Be carefull while sorting 1 based indexing array or vector
// #define long long ll
// during inclusion and exclusion the sign is decided by the count of set bits
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define PI 3.14159265358979323846264338327950L
#define MOD 1000000007
#define sz 100005
ll inf = 1e18;
ll power(ll x, ll n, ll mod)
{
ll res = 1;
x %= mod;
while (n)
{
if (n & 1)
res = (res * x) % mod;
x = (x * x) % mod;
n >>= 1;
}
return res%mod;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("error.txt", "w", stderr);
freopen("output.txt", "w", stdout);
#endif
ll t;
cin>>t;
while(t--)
{
ll x,y;
cin>>x>>y;
ll k=0;
if(abs(y-x)>=1)
k=abs(y-x)-1;
cout<<(x+y+k)<<'\n';
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
vector<long long> a;
int check(long long x) {
int f = 0;
long long sum = 0, count = 1;
for (long long i = 0; i < n; i++) {
if (a[i] - count + 1 >= 0) sum += a[i] - count + 1;
if ((i + 1) % x == 0) count++;
if (sum >= m) {
f = 1;
break;
}
}
return f;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
cin >> m;
long long l = 1, r = 1e9, mid, k = 0, ans, x;
for (int i = 0; i < n; i++) {
cin >> x;
a.push_back(x);
k += a[i];
}
std::sort(a.begin(), a.end(), greater<long long>());
if (k < m) {
cout << -1;
} else {
while (l <= r) {
mid = (l + r) / 2;
if (check(mid)) {
ans = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
cout << ans;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000 * 1000 * 1000 + 7;
const double EPS = 1e-9;
const double PI = acos(-1.0);
template <class T>
int chmin(T &t, T f) {
return (t > f) ? (t = f, 1) : 0;
}
template <class T>
int chmax(T &t, T f) {
return (t < f) ? (t = f, 1) : 0;
}
inline int getint() {
int a;
return scanf("%d", &a) ? a : (fprintf(stderr, "trying to read\n"), -1);
}
inline double getdouble() {
double a;
return scanf("%lf", &a) ? a : (fprintf(stderr, "trying to read\n"), -1);
}
long long ApowBmodC(long long a, int b, int c) {
if (b == 0) return 1;
long long ret = ApowBmodC(a * a % c, b / 2, c);
if (b & 1) ret = ret * a % c;
return ret;
}
const int N = 1 << 20;
long long bit[N + 1];
void update(int i, long long first) {
first %= INF;
while (i <= N) {
bit[i] += first;
i += (i & -i);
}
}
long long query(int i) {
long long ret = 0;
while (i) {
ret += bit[i];
i &= i - 1;
}
return ret % INF;
}
void myCode() {
int n = getint();
long long ret = 0;
vector<int> a, doit(n, 0);
for (int i = (int)0; i < (int)n; i++) a.push_back(getint());
map<int, long long> lastQuery, lastDelta;
for (int i = (int)0; i < (int)n; i++) {
lastQuery[a[i]] = 0;
lastDelta[a[i]] = 1;
}
for (int i = (int)0; i < (int)n; i++) {
long long nq = (query(a[i] - 1) - lastQuery[a[i]] + INF) % INF;
lastQuery[a[i]] = (lastQuery[a[i]] + nq) % INF;
lastDelta[a[i]] = (nq + lastDelta[a[i]]) * a[i] % INF;
update(a[i], lastDelta[a[i]]);
ret = (ret + lastDelta[a[i]]) % INF;
}
cout << ret << endl;
}
int main() {
myCode();
return 0;
}
| 6 |
#include <bits/stdc++.h>
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define ls (p << 1)
#define rs (ls | 1)
#define tm ((tl + tr) >> 1)
#define lowbit(x) ((x) & -(x))
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
constexpr double eps = 1e-8;
constexpr int NINF = 0xc0c0c0c0;
constexpr int INF = 0x3f3f3f3f;
constexpr ll LNINF = 0xc0c0c0c0c0c0c0c0;
constexpr ll LINF = 0x3f3f3f3f3f3f3f3f;
constexpr ll mod = 1e9 + 7;
constexpr ll N = 1e6 + 5;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int x;
cin >> x;
cout << 2 - x * x << '\n';
return 0;
} | 7 |
#include <bits/stdc++.h>
using namespace std;
int N, K;
int A[1000000];
int main() {
int i;
scanf("%d %d", &N, &K);
for (i = 0; i < N; i++) scanf("%d", A + i);
sort(A, A + N);
reverse(A, A + N);
long long last = A[0], k = K, H = -1, L;
for (i = 1; i < N; i++) {
if (k > i * (last - A[i])) {
k -= i * (last - A[i]);
last = A[i];
continue;
}
H = last - k / i;
break;
}
reverse(A, A + N);
last = A[0];
k = K;
L = H + 1;
for (i = 1; i < N; i++) {
if (k > i * (A[i] - last)) {
k -= i * (A[i] - last);
last = A[i];
continue;
}
L = last + k / i;
break;
}
if (H > L)
printf("%d\n", (int)(H - L));
else {
long long ans = 0;
for (i = 0; i < N; i++) {
ans += A[i];
ans %= N;
}
printf("%d\n", (int)(ans > 0));
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int MAXN = 555;
int N, M;
int v[MAXN];
int main() {
scanf("%d %d", &N, &M);
for (int i = 1; i <= N; ++i) {
scanf("%d", v + i);
}
double ans = 0;
for (int i = 0; i < M; ++i) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
double val = v[a] + v[b];
val /= c;
if (val > ans) {
ans = val;
}
}
printf("%.10lf\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long ml = 1e6 + 101;
long long n, m;
long long len, ans;
long long a[ml], d[ml], s[ml], f[ml], g[ml], t[ml];
inline long long read() {
long long r = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) r = (r << 1) + (r << 3) + (c ^ 48), c = getchar();
return r * f;
}
inline void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
inline void port(long long x, char s) {
write(x);
putchar(s);
}
vector<long long> v;
void add(long long x, long long y) {
x = lower_bound(v.begin(), v.end(), x) - v.begin() + 1;
for (; x >= 1; x -= x & -x) t[x] = ((t[x]) > (y) ? (t[x]) : (y));
}
long long ask(long long x) {
x = lower_bound(v.begin(), v.end(), x) - v.begin() + 1;
long long res = -1;
for (; x <= m; x += x & -x) res = ((res) > (t[x]) ? (res) : (t[x]));
return res;
}
int main() {
n = read();
for (long long i = 0; i <= n + 1; i++) a[i] = read();
for (long long i = 1; i <= n; i++) d[i] = read();
s[0] = 0;
for (long long i = 1; i <= n; i++) {
while ((len != 0) && (a[i] - a[f[s[len]]] > 2 * d[s[len]])) len--;
f[i] = s[len];
while ((len != 0) && (2 * d[s[len]] + a[f[s[len]]] <= 2 * d[i] + a[f[i]]))
len--;
s[++len] = i;
}
s[len = 0] = n + 1;
for (long long i = n; i >= 1; i--) {
while ((len != 0) && (a[g[s[len]]] - a[i] > 2 * d[s[len]])) len--;
g[i] = s[len];
while ((len != 0) && (a[g[s[len]]] - 2 * d[s[len]] >= a[g[i]] - 2 * d[i]))
len--;
s[++len] = i;
}
for (long long i = 1; i <= n; i++)
if (a[g[i]] - a[f[i]] <= 2 * d[i]) return port(0, '\n'), 0;
for (long long i = 1; i <= n; i++)
if (a[i] - a[f[i]] < 2 * d[i]) v.push_back(2 * d[i] + a[f[i]]);
sort(v.begin(), v.end());
v.resize(m = unique(v.begin(), v.end()) - v.begin());
memset(t, -1, sizeof(t));
ans = a[n + 1];
for (long long i = 1; i <= n; i++)
ans = ((ans) < (a[g[i]] - a[f[i]]) ? (ans) : (a[g[i]] - a[f[i]]));
for (long long i = 1; i <= n; i++) {
if (a[g[i]] - a[i] < 2 * d[i]) {
long long tmp = ask(a[g[i]] - 2 * d[i]);
if (tmp != -1) ans = ((ans) < (a[i] - tmp) ? (ans) : (a[i] - tmp));
}
if (a[i] - a[f[i]] < 2 * d[i]) add(2 * d[i] + a[f[i]], a[i]);
}
for (long long i = 1; i <= n; i++) {
if ((f[i] == 0) && (a[g[i]] - a[i] < 2 * d[i]))
ans = ((ans) < (a[i]) ? (ans) : (a[i]));
if ((g[i] == n + 1) && (a[i] - a[f[i]] < 2 * d[i]))
ans = ((ans) < (a[n + 1] - a[i]) ? (ans) : (a[n + 1] - a[i]));
}
printf("%.4lf", ans * 0.5);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MAXN = 2 * 1e5 + 5;
const long long INF = 1e18;
const double eps = 1e-9;
int q;
long long l, r;
vector<long long> v;
bool isPerfectSquare(long long x) {
long long t = sqrt((long double)x);
if (t * t == x) return true;
return false;
}
void init() {
for (long long i = 2; i * i * i <= INF; i++) {
long long ap = i * i;
while (ap <= INF / i) {
ap *= i;
if (!isPerfectSquare(ap)) {
v.emplace_back(ap);
}
}
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
int main() {
init();
scanf("%d", &q);
while (q--) {
scanf("%lld %lld", &l, &r);
long long ans =
(long long)sqrt((long double)r) - (long long)sqrt((long double)(l - 1));
ans +=
upper_bound(v.begin(), v.end(), r) - lower_bound(v.begin(), v.end(), l);
printf("%lld\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> m = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int y, m1, d1, y2, m2, d2, s[13];
bool is_leap(int x) {
if (x % 100 == 0) return !(x % 400);
return !(x % 4);
}
int main() {
scanf("%d:%d:%d", &y, &m1, &d1);
scanf("%d:%d:%d", &y2, &m2, &d2);
for (int i = 1; i <= 12; i++) s[i] = s[i - 1] + m[i - 1];
long long ans2 = 0ll + d2 + s[m2 - 1] + (m2 > 2) * is_leap(y2);
long long ans1 = 0ll + d1 + s[m1 - 1] + (m1 > 2) * is_leap(y);
for (int i = 1; i < y; i++) ans1 += (is_leap(i) ? 366 : 365);
for (int i = 1; i < y2; i++) ans2 += (is_leap(i) ? 366 : 365);
printf("%lld\n", abs(ans1 - ans2));
}
| 2 |
#include <bits/stdc++.h>
int main() {
long long int n, k;
scanf("%lld %lld", &n, &k);
if (k % n == 0)
printf("%lld", k / n);
else
printf("%lld", (k / n) + 1);
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// template<typename T>
// using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define ll int
#define rep(i,j,n) for(ll i=j;i<n;i++)
#define _rep(i,n) for(ll i=n-1;i>=0;i--)
#define vec vector<ll>
#define pb push_back
#define eb emplace_back
#define pairs pair<ll,ll>
#define f first
#define s second
#define all(v) v.begin(),v.end()
#define srt(v) sort(v.begin(),v.end())
#define mem(a,b) memset(a,b,sizeof(a))
#define fast ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
const int N = 2e5;
vec g[N+5];
void f()
{
ll n; cin>>n;
vec a(n);
int mp[N+5];
mem(mp,0);
for(auto &x: a)
{
cin>>x;
mp[x]++;
}
int ans = 0;
int dp[N+4]; mem(dp,0);
for(int i = 1; i <= N; i++)
{
dp[i] = mp[i];
for(auto v: g[i])
{
dp[i] = max(dp[i], dp[v] + mp[i]);
}
ans = max(ans, dp[i]);
}
cout<<n-ans<<endl;
}
int main()
{
for(int i = 1; i <= N; i++)
{
for(int j = 2*i; j <= N; j += i)
{
g[j].pb(i);
}
}
int queries=1;
cin>>queries;
while(queries--)
{
f();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e2 + 5;
int N, M;
int Sight[MAXN * MAXN], Order[MAXN * MAXN], Bac[MAXN * MAXN], Cnt[MAXN * MAXN];
struct seg {
int T[MAXN * 4];
void Build(int l, int r, int cur) {
if (l == r) {
T[cur] = 0;
return;
}
int m = (l + r) >> 1;
Build(l, m, cur << 1);
Build(m + 1, r, cur << 1 | 1);
T[cur] = T[cur << 1] + T[cur << 1 | 1];
}
void Change(int x, int l, int r, int cur) {
if (l == r) {
T[cur]++;
return;
}
int m = (l + r) >> 1;
if (x <= m)
Change(x, l, m, cur << 1);
else
Change(x, m + 1, r, cur << 1 | 1);
T[cur] = T[cur << 1] + T[cur << 1 | 1];
}
int Query(int x, int y, int l, int r, int cur) {
if (x > y) return 0;
if (x <= l && r <= y) return T[cur];
int m = (l + r) >> 1;
if (x <= m && y > m)
return Query(x, y, l, m, cur << 1) + Query(x, y, m + 1, r, cur << 1 | 1);
else if (x <= m)
return Query(x, y, l, m, cur << 1);
else
return Query(x, y, m + 1, r, cur << 1 | 1);
}
} St[MAXN];
int main() {
ios::sync_with_stdio(false);
int T;
cin >> T;
while (T--) {
cin >> N >> M;
for (int i = 1; i <= N * M; i++) cin >> Sight[i], Order[i] = Sight[i];
sort(Order + 1, Order + N * M + 1);
int num = unique(Order + 1, Order + N * M + 1) - Order - 1;
for (int i = 1; i <= N; i++) St[i].Build(1, num, 1);
for (int i = 1; i <= N * M; i++)
Sight[i] = lower_bound(Order + 1, Order + num + 1, Sight[i]) - Order;
int Ans = 0;
for (int i = 1; i <= N * M; i++) {
Ans += St[1].Query(1, Sight[i] - 1, 1, num, 1);
St[1].Change(Sight[i], 1, num, 1);
}
cout << Ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const long long int MODA = 1000000007;
vector<long long int> primefactors;
vector<long long int> factors;
long long int fact[1025] = {};
bool isPowerTwo(long long int x) { return (x && !(x & (x - 1))); }
long long int modmul(long long int a, long long int b) {
return ((a % MODA) * (b % MODA)) % MODA;
}
long long int modadd(long long int a, long long int b) {
return ((a % MODA) + (b % MODA) + MODA) % MODA;
}
long long int modsub(long long int a, long long int b) {
return ((a % MODA) - (b % MODA) + MODA) % MODA;
}
bool isSubstring(string s1, string s2) {
if (s1.find(s2) != string::npos)
return true;
else
return false;
}
void generateFactorial(long long int n) {
fact[0] = 1;
for (long long int i = 1; i <= n; i++) fact[i] = (i * 1ll * fact[i - 1]);
}
void generateFactorialMOD(long long int n) {
fact[0] = 1;
for (long long int i = 1; i <= n; i++)
fact[i] = (i * 1ll * fact[i - 1]) % MODA;
}
bool isPrime(long long int n) {
if (n < 2) return false;
for (long long int i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
long long int power(long long int a, long long int b) {
long long int res = 1;
while (b) {
if (b & 1) res = (res * a);
a = (a * a);
b >>= 1;
}
return res;
}
long long int powermod(long long int a, long long int b) {
long long int res = 1;
while (b) {
if (b & 1) res = (res * a) % MODA;
a = (a * a) % MODA;
b >>= 1;
}
return res;
}
long long int modi(long long int a) {
long long int m = MODA, second = 1, p = 0;
while (a > 1) {
long long int q = a / m, t = m;
m = a % m;
a = t;
t = p;
p = second - q * p;
second = t;
}
return second >= 0 ? second : second + MODA;
}
void generatePrimeFactors(long long int n) {
primefactors.clear();
for (long long int i = 2; i * i <= n; i++) {
if (n % i == 0) {
primefactors.push_back(i);
while (n % i == 0) n = n / i;
}
}
if (n != 1) primefactors.push_back(n);
}
long long int ncr(long long int n, long long int r) {
if (r == 0) return 1;
fact[0] = 1;
for (int i = 1; i <= n; i++) fact[i] = fact[i - 1] * i % MODA;
return (fact[n] * modi(fact[r]) % MODA * modi(fact[n - r]) % MODA) % MODA;
}
void generateFactors(long long int n) {
factors.clear();
for (long long int i = 2; i * i <= n; i++) {
if (n % i == 0) {
factors.push_back(i);
if (n / i != i) factors.push_back(n / i);
}
}
factors.push_back(1);
factors.push_back(n);
sort(factors.begin(), factors.end());
}
long double Logn(long double n, long double r) { return log(n) / log(r); }
const int Nmax = 1000005;
vector<int> func(vector<int> v1, vector<int> v2) {
vector<pair<int, int>> dif;
vector<int> index;
int sum1 = 0;
int sum2 = 0;
for (int i = 0; i < (int)v1.size(); i++) {
sum1 += v1[i];
sum2 += v2[i];
}
if (sum1 >= sum2) {
return index;
} else {
int diff = sum2 - sum1;
for (int i = 0; i < (int)v1.size(); i++) {
dif.push_back(make_pair(v2[i] - v1[i], i));
}
sort(dif.begin(), dif.end());
int lI = (int)dif.size();
lI--;
while (lI >= 0 && diff > 0) {
diff -= dif[lI].first;
index.push_back(dif[lI].second);
lI--;
}
return index;
}
}
void solve() {
int n, m;
cin >> n >> m;
vector<vector<int>> v(n);
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
int x;
cin >> x;
;
v[j].push_back(x);
}
}
vector<int> ans(m + 1);
for (int i = 0; i < n - 1; i++) {
vector<int> curans = func(v[i], v[n - 1]);
if ((int)curans.size() < (int)ans.size()) {
ans = curans;
}
}
cout << (int)ans.size() << "\n";
for (int i = 0; i < (int)ans.size(); i++) {
cout << ans[i] + 1 << " ";
}
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t = 1;
while (t--) {
solve();
}
cerr << "Time : " << 1000 * (long double)clock() / (long double)CLOCKS_PER_SEC
<< "ms\n";
;
}
| 4 |
/**
* author: tourist
* created: 13.03.2021 14:01:42
**/
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) {
return '"' + s + '"';
}
string to_string(const char* s) {
return to_string((string) s);
}
string to_string(bool b) {
return (b ? "true" : "false");
}
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
long long C;
cin >> n >> C;
vector<long long> w(n - 2);
for (int i = 0; i < n - 2; i++) {
cin >> w[i];
}
long long L = 0;
long long R = w[0];
set<long long> s;
long long k = 1;
long long b = 0;
vector<long long> Ls(n - 2);
vector<long long> Rs(n - 2);
vector<bool> flag(n - 2);
vector<long long> any(n - 2);
Ls[0] = L;
Rs[0] = R;
any[0] = L;
for (int i = 1; i < n - 2; i++) {
bool inside = false;
inside |= (L <= w[i] && w[i] <= R);
if (!inside) {
auto it = s.find((w[i] - b) / k);
inside |= (it != s.end());
}
flag[i] = inside;
if (inside) {
L = 0;
R = w[i];
s.clear();
k = 1;
b = 0;
} else {
if (L <= R && L > w[i]) {
L = -1;
R = -2;
}
while (!s.empty()) {
auto it = (k == 1 ? prev(s.end()) : s.begin());
if (k * (*it) + b <= w[i]) {
break;
}
s.erase(it);
}
if (L > R && s.empty()) {
cout << "NO" << '\n';
return 0;
}
if (L <= R) {
any[i - 1] = L;
} else {
any[i - 1] = k * (*s.begin()) + b;
}
if (L <= R) {
L = w[i] - L;
R = w[i] - R;
swap(L, R);
}
// x -> k * x + b
// I want: x -> w - (k * x + b)
// x -> -k * x + (w - b)
k = -k;
b = w[i] - b;
s.insert((w[i] - b) / k);
}
debug(L, R, s, k, b);
Ls[i] = L;
Rs[i] = R;
}
cout << "YES" << '\n';
vector<long long> d(n - 2);
if (L <= R) {
d.back() = L;
} else {
d.back() = k * (*s.begin()) + b;
}
debug(any);
for (int i = n - 3; i > 0; i--) {
if (flag[i]) {
d[i - 1] = w[i];
} else {
if (d[i] == w[i]) {
d[i - 1] = any[i - 1];
} else {
d[i - 1] = w[i] - d[i];
}
}
assert(0 <= d[i - 1] && d[i - 1] <= w[i - 1]);
}
debug(d);
vector<long long> a(n);
a[0] = 0;
a[1] = w[0] - d[0];
a[2] = w[0];
for (int i = 3; i < n; i++) {
bool found = false;
for (int sign = -1; sign <= 1; sign += 2) {
a[i] = a[i - 1] + sign * d[i - 2];
long long mx = max(a[i], max(a[i - 1], a[i - 2]));
long long mn = min(a[i], min(a[i - 1], a[i - 2]));
if (mx - mn == w[i - 2]) {
found = true;
break;
}
}
assert(found);
}
long long mn = *min_element(a.begin(), a.end());
for (int i = 0; i < n; i++) {
a[i] -= mn;
}
for (int i = 0; i < n; i++) {
if (i > 0) {
cout << " ";
}
cout << a[i];
}
cout << '\n';
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
vector<int> divesors;
void div(int n) {
divesors.push_back(1);
divesors.push_back(n);
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
divesors.push_back(i);
if (n / i != i) divesors.push_back(n / i);
}
}
}
void reverseStr(string& str, int n) {
for (int i = 0; i < n / 2; i++) swap(str[i], str[n - i - 1]);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int n;
string s;
cin >> n;
cin >> s;
div(n);
sort(divesors.begin(), divesors.end());
vector<int>::iterator it;
for (it = divesors.begin(); it != divesors.end(); it++) {
reverseStr(s, *it);
}
cout << s;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000007;
multiset<long long> diff;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, a, b, ans = 0;
cin >> n >> m;
for (long long i = 0; i < n; i++) {
cin >> a >> b;
ans += a;
diff.insert(b - a);
}
long long cnt = 0;
for (long long i : diff) {
if (ans <= m) {
cout << cnt;
return 0;
}
ans += i;
cnt++;
}
if (ans <= m) {
cout << cnt;
return 0;
}
cout << -1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
scanf("%d %d %d", &n, &a, &b);
for (int x = min(a, b); x >= 1; x--) {
if (max(a, b) / x >= n - min(a, b) / x) {
printf("%d", x);
break;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class t>
t lcm(t a, t b) {
return ((a * b) / __gcd(a, b));
}
int main() {
long long n;
cin >> n;
long long points[n];
long long counter[5] = {0, 0, 0, 0, 0};
long long prize[5], sum = 0;
for (long long i = 0; i < n; i++) cin >> points[i];
for (long long i = 0; i < 5; i++) cin >> prize[i];
for (long long i = 0; i < n; i++) {
sum += points[i];
int pos = -1;
while (true) {
while ((pos + 1) < 5 && prize[pos + 1] <= sum) pos++;
if (pos == -1) break;
long long times = sum / prize[pos];
sum -= (times * prize[pos]);
counter[pos] += times;
pos = -1;
}
}
for (long long i = 0; i < 5; i++) cout << counter[i] << " ";
cout << "\n" << sum;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int INF = 1e9;
int a[maxn];
int main(int argc, char** argv) {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
if (k == 0) {
if (a[1] > 1) {
printf("1\n");
} else
printf("-1\n");
} else if (k == n) {
printf("%d\n", a[n]);
} else if (a[k + 1] != a[k]) {
printf("%d\n", a[k]);
} else
printf("-1\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
const int inf = 1 << 28;
int in() {
int x;
scanf("%d", &x);
return x;
}
long long In() {
long long x;
cin >> x;
return x;
}
double inreal() {
double x;
scanf("%lf", &x);
return x;
}
string instr() {
char buf[1001];
scanf("%s", buf);
return (string)buf;
}
vector<int> G[1000111];
bool vis[1000111];
int dfs(int u) {
vis[u] = 1;
int res = 1;
for (int i = 0; i < G[u].size(); i++)
if (vis[G[u][i]] == 0) {
res += dfs(G[u][i]);
}
return res;
}
int main() {
int i, j;
int n = in(), m = in(), k = in(), t;
int u, v;
for ((i) = (0); (i) < (int)(m); (i)++) {
u = in() - 1, v = in() - 1;
G[u].push_back(v), G[v].push_back(u);
}
multiset<int> snd;
for ((i) = (0); (i) < (int)(n); (i)++)
if (!vis[i]) snd.insert(min(k, dfs(i)));
if (snd.size() <= 2) {
puts("0");
return 0;
}
multiset<int>::iterator it, et;
int res = 0;
for (bool update = 1; update;) {
update = 0;
it = snd.begin();
et = snd.end();
et--;
if (*it == 1 and *et > 1) {
snd.erase(it);
t = *et - 1;
snd.erase(et);
snd.insert(t);
update = 1;
continue;
}
if (snd.size() <= 2) break;
et = snd.end();
et--;
if (*et == 1) {
snd.erase(snd.begin());
snd.erase(et);
snd.insert(min(2, k));
res++;
update = 1;
}
}
cout << res << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long val, c1, c2;
cin >> val;
if (val % 3 == 0) {
c1 = val / 3;
c2 = c1;
} else if (val % 3 == 1) {
c2 = val / 3;
c1 = (c2 + 1);
} else {
c1 = val / 3;
c2 = (c1 + 1);
}
cout << c1 << " " << c2 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const double eps = 1e-9;
const int MAX_N = 1e6 + 5;
const int inf = 2e9;
const long long Inf = (long long)1e18;
const long long M = (long long)1e9 + 7;
int Int() {
int x;
scanf("%d", &x);
return x;
}
long long Long() {
long long x;
scanf("%lld", &x);
return x;
}
void Char(char* ch) { scanf("%s", ch); }
template <typename t>
inline t abs(t a) {
if (a >= 0) return a;
return -a;
}
template <typename t>
inline t gcd(t a, t b) {
return !b ? a : gcd(b, a % b);
}
template <typename t>
inline t lcm(t a, t b) {
return a * (b / gcd(a, b));
}
template <typename T>
inline T modpow(T b, T p, T Mod) {
T res = 1;
while (p > 0) {
if (p & 1) {
res *= b;
res %= Mod;
}
b *= b;
b %= Mod;
p >>= 1;
}
return res;
}
template <typename T>
inline T ModInv(T b, T Mod) {
return modpow(b, Mod - 2, Mod);
}
template <typename T>
inline T pwr(T b, T p) {
T res = 1;
while (p > 0) {
if (p & 1) {
res *= b;
}
b *= b;
p >>= 1;
}
return res;
}
int e1, e2, d1;
template <typename T>
inline void extgcd(T a, T b) {
if (!b) {
e1 = 1, e2 = 0, d1 = a;
return;
}
extgcd(b, a % b);
T x1 = e2;
T y1 = e1 - (a / b) * e2;
e1 = x1;
e2 = y1;
}
template <typename T>
inline vector<T> Unique(vector<T> v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
return v;
}
vector<string> split(const string& s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) v.emplace_back(x);
return move(v);
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cout << it->substr((*it)[0] == ' ', it->length()) << " = " << a << " ";
err(++it, args...);
}
std::vector<std::vector<int> > g;
std::vector<int> used;
int dfs(int s) {
used[s] = 1;
int f = 1;
for (int i : g[s]) {
if (used[i]) continue;
f += dfs(i);
}
return f;
}
int main() {
int t = 1, tc = 0;
while (t--) {
int n = Int(), m = Int();
long long k = Long();
g.resize(n + 1);
for (int i = 1; i <= m; i++) {
int x = Int(), y = Int();
g[x].push_back(y);
g[y].push_back(x);
}
used = std::vector<int>(n + 1, 0);
long long prod = 1LL, comp = 0;
for (int i = 1; i <= n; i++) {
if (used[i] == 0) {
prod *= 1LL * dfs(i);
prod %= k;
comp++;
}
}
if (comp == 1LL) return printf("%d\n", 1 % (int)k), 0;
long long h = modpow(1LL * n, 1LL * comp - 2, k);
prod *= h;
prod %= k;
printf("%lld\n", prod);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
const int MAXN = 1e5 + 10;
void kill() {
puts("NO");
exit(0);
}
int N;
vector<pii> __pts[2 * MAXN], *pts = __pts + MAXN;
set<pii> st;
int main() {
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
}
scanf("%d", &N);
for (int i = 0, x, y; i < N; i++) {
scanf("%d %d", &x, &y);
pts[y - x].push_back(pii(x, y));
}
for (auto &v : __pts) {
sort(v.rbegin(), v.rend());
}
vector<pii> ans;
for (int i = 0, d; i < N; i++) {
scanf("%d", &d);
if (pts[d].empty()) {
kill();
}
pii p = pts[d].back();
ans.push_back(p);
st.insert(p);
pts[d].pop_back();
if (p.first && !st.count(pii(p.first - 1, p.second))) {
kill();
}
if (p.second && !st.count(pii(p.first, p.second - 1))) {
kill();
}
}
puts("YES");
for (int i = 0; i < N; i++) {
printf("%d %d\n", ans[i].first, ans[i].second);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int a[300005], tree[4 * 300005], div1[1000005], fl[4 * 300005];
void build(long long int start, long long int end, long long int pos) {
if (start == end) {
tree[pos] = a[start];
fl[pos] = (tree[pos] <= 2) ? 0 : 1;
return;
}
long long int mid = (start + end) / 2;
build(start, mid, 2 * pos);
build(mid + 1, end, 2 * pos + 1);
tree[pos] = tree[2 * pos] + tree[2 * pos + 1];
fl[pos] = fl[2 * pos] | fl[2 * pos + 1];
}
void update(long long int start, long long int end, long long int pos,
long long int l, long long int r) {
if (start > end || start > r || end < l) return;
if (start == end) {
a[start] = div1[a[start]];
tree[pos] = a[start];
fl[pos] = (tree[pos] <= 2) ? 0 : 1;
return;
}
if (fl[pos] == 0) return;
long long int mid = (start + end) / 2;
update(start, mid, 2 * pos, l, r);
update(mid + 1, end, 2 * pos + 1, l, r);
tree[pos] = tree[2 * pos] + tree[2 * pos + 1];
fl[pos] = fl[2 * pos] | fl[2 * pos + 1];
}
long long int query(long long int start, long long int end, long long int pos,
long long int l, long long int r) {
if (start > end || start > r || end < l) return 0;
if (start >= l && end <= r) return tree[pos];
long long int mid = (start + end) / 2, p1 = 0, p2 = 0;
if (l <= mid) p1 = query(start, mid, 2 * pos, l, r);
if (r > mid) p2 = query(mid + 1, end, 2 * pos + 1, l, r);
return (p1 + p2);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
long long int n, m, x, y, z, i, j;
for (i = 1; i <= 1000000; i++)
for (j = i; j <= 1000000; j += i) div1[j]++;
cin >> n >> m;
for (i = 1; i <= n; i++) cin >> a[i];
build(1, n, 1);
while (m--) {
cin >> x;
if (x == 1) {
cin >> y >> z;
update(1, n, 1, y, z);
} else {
cin >> y >> z;
cout << query(1, n, 1, y, z) << "\n";
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string ntos(long long int n) {
ostringstream str1;
str1 << n;
return str1.str();
}
long long int ston(string s) {
long long int x;
stringstream str1(s);
str1 >> x;
return x;
}
char a1[3] = {'R', 'G', 'B'};
char b1[3] = {'G', 'B', 'R'};
char c1[3] = {'B', 'R', 'G'};
bool bal(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return b.second > a.second;
}
int main() {
int n;
string s;
cin >> n >> s;
int e = 0;
int h = (s.size()) / 11;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '8') e++;
}
cout << min(e, h);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, x = 0, y = 0, l, r, t;
cin >> n >> m;
for (int i = 0; i < n && scanf("%d", &t); i++) {
if (t == 1)
x++;
else
y++;
}
x = 2 * min(x, y);
for (int i = 0; i < m && scanf("%d%d", &l, &r); i++) {
t = r - l + 1;
if (t % 2 == 0 && t <= x)
printf("1\n");
else
printf("0\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long modpow(long long base, long long exp, long long modulus) {
base %= modulus;
long long result = 1;
while (exp > 0) {
if (exp & 1) result = (result * base) % modulus;
base = (base * base) % modulus;
exp >>= 1;
}
return result;
}
long long find(long long vis[], long long n, long long in) {
in++;
while (1) {
if (vis[in] == 0) {
return in;
}
in++;
in %= n;
}
}
int main() {
long long n, k;
cin >> n >> k;
long long a[k];
for (long long i = 0; i < k; i++) {
cin >> a[i];
}
vector<long long> b, el;
for (long long i = 1; i <= n; i++) {
b.push_back(i);
}
long long leader = 0;
for (long long i = 0; i < k; i++) {
long long p = a[i];
p %= b.size();
leader += (p);
leader %= (b.size());
el.push_back(b[leader]);
long long next = leader;
if (leader == b.size() - 1) {
next = 0;
}
b.erase(b.begin() + leader);
leader = next;
}
for (long long i = 0; i < k; i++) {
cout << el[i] << " ";
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string S = "";
cin >> S;
int N = S.length();
char retArr[N];
bool isNeeded[10] = {false, true, false, false, false,
false, true, false, true, true};
bool hasDigit = false;
int reti = 0;
for (int i = 0; i < N; i++) {
int digit = S[i] - '0';
if (isNeeded[digit])
isNeeded[digit] = false;
else if (digit != 0) {
hasDigit = true;
retArr[reti++] = '0' + digit;
} else
retArr[reti++] = '0' + digit;
}
retArr[reti] = '\0';
int rems[] = {1869, 1968, 1689, 6198, 1698, 1986, 1896};
if (hasDigit) {
N -= 4;
int digInd = 0;
for (; digInd < N && retArr[digInd] == '0'; digInd++)
;
char temp = retArr[0];
retArr[0] = retArr[digInd];
retArr[digInd] = temp;
int muls[] = {1, 3, 2, 6, 4, 5};
int mulInd = 4;
int sp = 0;
for (int i = N - 1; i >= 0; i--) {
int digit = retArr[i] - '0';
sp += digit * muls[mulInd];
mulInd = (mulInd + 1) % 6;
}
cout << retArr << rems[(7 - sp % 7) % 7];
} else
cout << rems[0] << retArr;
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long v[500005];
int main() {
long long n;
while (~scanf("%lld", &n)) {
long long a = 0, maxn = 0, id = 0, tot = 0, sum = 0;
while (n--) {
scanf("%lld", &a);
if (a == 1) {
scanf("%lld", &maxn);
v[++tot] = maxn;
} else {
while (sum + maxn > v[id + 1] * (id + 1)) ++id, sum += v[id];
printf("%.7f\n", maxn - 1.0 * (1.0 * sum + maxn) / (id + 1.0));
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, a, b, minsol;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
cin >> k;
cin >> a;
cin >> b;
minsol = (n - 1) * a;
if (k == 1) {
cout << minsol;
return 0;
} else {
long long sol = 0;
while (n > 1) {
if (n % k)
if (n - (n % k) > 1)
sol += (n % k) * a, n -= (n % k);
else
sol += (n - 1) * a, n = 1;
if (n > 1) {
sol += b;
n /= k;
}
minsol = min(minsol, sol + (n - 1) * a);
}
cout << min(minsol, sol);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n, ans = 0;
scanf("%lld", &n);
vector<long long> a(n);
stack<pair<long long, long long> > s;
for (long long i = 0; i < n; i++) scanf("%lld", &a[i]);
reverse(a.begin(), a.end());
s.push({a[0], 0});
for (long long i = 1; i < n; i++) {
long long cnt = 0;
while (!s.empty() && a[i] > s.top().first) {
cnt++;
cnt = max(cnt, s.top().second);
s.pop();
}
s.push({a[i], cnt});
ans = max(ans, cnt);
}
printf("%lld ", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int n;
int a[30];
int f[2][405][405][3][3];
int g[405][405][2][2];
int h[405][26][26];
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int i, j, k, x, y, z;
long long ans = 0;
cin >> n;
for(i=0;i<26;i++) cin >> a[i];
for(i=0;i<26;i++){
for(j=0;j<26;j++){
h[2][i][j] = 1;
}
}
for(i=3;i<=n;i++){
for(j=0;j<26;j++){
for(k=0;k<26;k++){
for(x=0;x<26;x++){
if(j == x) continue;
h[i][k][x] += h[i - 1][j][k];
if(h[i][k][x] >= mod) h[i][k][x] -= mod;
}
}
}
}
for(i=0;i<26;i++){
for(j=0;j<26;j++){
ans += h[n][i][j];
}
}
ans %= mod;
g[2][2][0][0] = 1;
g[2][1][0][1] = 25;
g[2][1][1][0] = 25;
g[2][0][1][1] = 25 * 25;
for(i=3;i<=n;i++){
for(j=0;j<=n;j++){
for(x=0;x<2;x++){
for(y=0;y<2;y++){
if(x == 1){
g[i][j][y][1] = (g[i][j][y][1] + g[i - 1][j][x][y] * 24ll) % mod;
g[i][j + 1][y][0] = (g[i][j + 1][y][0] + g[i - 1][j][x][y]) % mod;
}else{
g[i][j][y][1] = (g[i][j][y][1] + g[i - 1][j][x][y] * 25ll) % mod;
}
}
}
}
}
for(i=0;i<26;i++){
for(j=a[i]+1;j<=n;j++){
ans -= g[n][j][0][0];
ans -= g[n][j][0][1];
ans -= g[n][j][1][0];
ans -= g[n][j][1][1];
}
}
ans = (ans % mod + mod) % mod;
for(i=0;i<=2;i++){
for(j=0;j<=2;j++){
f[0][(i == 0) + (j == 0)][(i == 1) + (j == 1)][i][j] = (i == 2 ? 24 : 1) * (j == 2 ? 24 : 1);
}
}
for(i=3;i<=n;i++){
memset(f[i & 1], 0, sizeof(f[i & 1]));
for(j=0;j<=n;j++){
for(k=0;k<=n;k++){
for(x=0;x<=2;x++){
for(y=0;y<=2;y++){
for(z=0;z<=2;z++){
if(z == 2){
if(x == 2){
f[i & 1][j][k][y][z] = (f[i & 1][j][k][y][z] + f[(i & 1) ^ 1][j][k][x][y] * 23ll) % mod;
}else{
f[i & 1][j + (z == 0)][k + (z == 1)][y][z] = (f[i & 1][j + (z == 0)][k + (z == 1)][y][z] + f[(i & 1) ^ 1][j][k][x][y] * 24ll) % mod;
}
continue;
}
if(x == z) continue;
f[i & 1][j + (z == 0)][k + (z == 1)][y][z] += f[(i & 1) ^ 1][j][k][x][y];
if(f[i & 1][j + (z == 0)][k + (z == 1)][y][z] >= mod) f[i & 1][j + (z == 0)][k + (z == 1)][y][z] -= mod;
}
}
}
}
}
}
for(i=0;i<26;i++){
for(j=i+1;j<26;j++){
for(x=a[i]+1;x<=n;x++){
for(y=a[j]+1;y<=n;y++){
ans += f[n & 1][x][y][0][0];
ans += f[n & 1][x][y][0][1];
ans += f[n & 1][x][y][0][2];
ans += f[n & 1][x][y][1][0];
ans += f[n & 1][x][y][1][1];
ans += f[n & 1][x][y][1][2];
ans += f[n & 1][x][y][2][0];
ans += f[n & 1][x][y][2][1];
ans += f[n & 1][x][y][2][2];
}
}
}
}
ans %= mod;
cout << ans << endl;
return 0;
} | 9 |
#include <bits/stdc++.h>
using namespace std;
const long MaxArray = 121073;
long n;
long long ans, m;
long long a[MaxArray];
int main() {
scanf("%d %d", &n, &m);
for (long i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
sort(a + 1, a + n + 1);
for (long long i = 1; i <= n; i++) {
ans += a[i] * m;
if (m > 1) {
m--;
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5, MOD = 777777777;
int n, m, A[5][5];
struct item {
int matr[5][5];
inline void clear() { memset(matr, 0, sizeof(matr)); }
};
item t[4 * N];
inline item mrg(item a, item b) {
item c;
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 3; j++) {
c.matr[i][j] = 0;
for (int ii = 1; ii <= 3; ii++) {
for (int jj = 1; jj <= 3; jj++) {
if (A[ii][jj]) {
c.matr[i][j] =
(c.matr[i][j] + a.matr[i][ii] * 1ll * b.matr[jj][j]) % MOD;
}
}
}
}
}
return c;
}
void build(int v, int l, int r) {
if (l == r) {
for (int i = 1; i <= 3; i++) {
t[v].matr[i][i] = 1;
}
return;
}
int mid = (r + l) >> 1;
build(v + v, l, mid);
build(v + v + 1, mid + 1, r);
t[v] = mrg(t[v + v], t[v + v + 1]);
}
void update(int v, int l, int r, int pos, int val) {
if (l == r) {
t[v].clear();
if (val) {
t[v].matr[val][val] = 1;
} else {
for (int i = 1; i <= 3; i++) {
t[v].matr[i][i] = 1;
}
}
return;
}
int mid = (r + l) >> 1;
if (pos <= mid) {
update(v + v, l, mid, pos, val);
} else {
update(v + v + 1, mid + 1, r, pos, val);
}
t[v] = mrg(t[v + v], t[v + v + 1]);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 3; j++) {
cin >> A[i][j];
}
}
build(1, 1, n);
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
update(1, 1, n, x, y);
long long ans = 0;
for (int j = 1; j <= 3; j++) {
for (int k = 1; k <= 3; k++) {
ans = (ans + t[1].matr[j][k]) % MOD;
}
}
cout << ans << "\n";
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<string> vec_splitter(string s) {
s += ',';
vector<string> res;
while (!s.empty()) {
res.push_back(s.substr(0, s.find(',')));
s = s.substr(s.find(',') + 1);
}
return res;
}
void debug_out(vector<string> __attribute__((unused)) args,
__attribute__((unused)) int idx,
__attribute__((unused)) int LINE_NUM) {
cerr << "\n";
}
template <typename Head, typename... Tail>
void debug_out(vector<string> args, int idx, int LINE_NUM, Head H, Tail... T) {
if (idx > 0)
cerr << ", ";
else
cerr << "Line(" << LINE_NUM << ") ";
stringstream ss;
ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, LINE_NUM, T...);
}
void solve() {
long long int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (x1 == x2) {
long long int key = abs(y1 - y2);
cout << x1 + key << " " << y1 << " " << x2 + key << " " << y2;
} else if (y1 == y2) {
long long int key = abs(x1 - x2);
cout << x1 << " " << y1 + key << " " << x2 << " " << y2 + key;
} else {
if (abs(x1 - x2) == abs(y1 - y2)) {
cout << x1 << " " << y2 << " " << x2 << " " << y1;
} else
cout << -1;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void out(T t) {
cout << t << "\n";
}
template <class T, class... Ts>
inline void out(T t, Ts... ts) {
cout << t << " ";
out(ts...);
}
template <class T>
inline bool CHMIN(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool CHMAX(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
constexpr long long INF = 1e18;
void solve() {
long long N;
cin >> N;
vector<pair<long long, long long>> v(N);
for (long long i = 0; i < (long long)N; ++i) {
cin >> v[i].first;
v[i].second = i;
}
sort(v.begin(), v.end());
vector<long long> inv(N);
for (long long i = 0; i < (long long)N; ++i) inv[v[i].second] = i;
vector<long long> dp(N + 1, INF);
vector<long long> r(N + 1, -1);
dp[0] = 0;
for (long long i = 0; i < (long long)N; ++i) {
for (long long j = 2; j < (long long)5; ++j) {
if (i + j + 1 > N) continue;
long long diff = v[i + j].first - v[i].first;
if (CHMIN(dp[i + j + 1], dp[i] + diff)) {
r[i + j + 1] = i;
}
}
}
long long cnt = 0;
long long now = N;
vector<long long> ans(N);
while (1) {
long long next = r[now];
if (next == -1) break;
for (long long i = next; i < (long long)now; ++i) {
ans[v[i].second] = cnt;
}
++cnt;
now = next;
}
out(dp[N], cnt);
for (long long i = 0; i < (long long)ans.size(); ++i)
cout << ans[i] + 1 << " \n"[i + 1 == ans.size()];
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long Q = 1;
while (Q--) solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int N, l, r;
string op;
int A[2][555], sol;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N;
for (int I = 0; I < N; I++) {
cin >> op >> l >> r;
for (int K = l; K <= r; K++) A[(op == "M") ? 0 : 1][K]++;
}
for (int I = 1; I <= 366; I++) {
sol = max(sol, min(A[0][I], A[1][I]));
}
cout << 2 * sol << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 1, -1, 0};
int dy[] = {1, 0, 0, -1};
long long pw(long long b, long long p) {
if (!p) return 1;
long long sq = pw(b, p / 2) % 1000000007;
sq = (sq * sq) % 1000000007;
if (p % 2) sq = (sq * b) % 1000000007;
return sq;
}
const int N = 1e6 + 10, M = 0;
int Zarr[N];
string s;
void getZarr() {
memset(Zarr, 0, sizeof Zarr);
int n = (int)s.size();
int r, l, k;
l = r = 0;
for (int i = 1; i < n; i++) {
if (i > r) {
l = r = i;
while (s[r - l] == s[r] && r < n) r++;
Zarr[i] = r - l;
r--;
} else {
k = i - l;
if (Zarr[k] < r - i + 1) {
Zarr[i] = Zarr[k];
} else {
l = i;
while (r < n && s[r - l] == s[r]) r++;
Zarr[i] = r - l;
r--;
}
}
}
}
int mp[N], ex[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> s;
getZarr();
int mx = 0;
bool ok = 0;
int t = 0;
for (int i = 0; i < (int)s.size(); i++) {
if (Zarr[i] && ((Zarr[i + Zarr[i]] == Zarr[i]) ||
((i + Zarr[i] != (int)s.size()) ||
((i + Zarr[i] == (int)s.size() && ok))))) {
if (Zarr[(int)s.size() - Zarr[i]] == Zarr[i] && (t >= Zarr[i])) {
mx = max(mx, Zarr[i]);
}
}
if (Zarr[i]) ok = 1;
t = max(t, Zarr[i]);
}
if (!mx) {
cout << "Just a legend";
return 0;
}
string res = s.substr(0, mx);
cout << res;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct robot {
int x, r, q;
bool operator<(const robot& b) const { return r > b.r; }
};
int n, k;
robot a[100005];
struct node {
node *l, *r;
int v;
node() : l(0), r(0), v(0) {}
};
map<int, node*> e;
int daj(node* root, int l, int r, int xl = 0, int xr = 1e9) {
if (!root || r < xl || xr < l) return 0;
if (l <= xl && xr <= r) return root->v;
int xm = (xl + xr) / 2;
return daj(root->l, l, r, xl, xm) + daj(root->r, l, r, xm + 1, xr);
}
void ubaci(node*& root, int p, int xl = 0, int xr = 1e9) {
if (!root) root = new node;
root->v++;
if (xl < xr) {
int xm = (xl + xr) / 2;
if (p <= xm)
ubaci(root->l, p, xl, xm);
else
ubaci(root->r, p, xm + 1, xr);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i].x >> a[i].r >> a[i].q;
sort(a, a + n);
long long sol = 0;
for (int i = 0; i < n; i++) {
for (int j = a[i].q - k; j <= a[i].q + k; j++) {
auto it = e.find(j);
if (it != e.end())
sol += daj(it->second, a[i].x - a[i].r, a[i].x + a[i].r);
}
ubaci(e[a[i].q], a[i].x);
}
cout << sol << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double TOLL = 1e-9;
int level[10], loyal[10], given[10];
int N, K, A;
double best;
void setProb() {
double rv = 0;
for (int mask = 0; mask < (1 << N); mask++) {
int x = __builtin_popcount(mask);
int B = 0;
double temp = 1;
for (int i = 0; i < N; i++) {
int l = loyal[i] + given[i] * 10;
if (l > 100) l = 100;
double p = 1.0 * l / 100.0;
if (mask & (1 << i))
temp *= p;
else
B += level[i], temp *= (1 - p);
}
if (x > N / 2.0)
rv += temp;
else {
double TEMP = temp * (1.0 * A) / (A + B);
rv += TEMP;
}
}
best = max(rv, best);
}
void giveCandy(int depth, int candy) {
if (depth == N) {
setProb();
return;
}
for (int i = 0; i <= candy; i++) {
given[depth] = i;
giveCandy(depth + 1, candy - i);
}
}
int main() {
while (cin >> N >> K >> A) {
for (int i = 0; i < N; i++) cin >> level[i] >> loyal[i];
best = 0;
giveCandy(0, K);
printf("%.12lf\n", best);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int digits = 0;
int d = k;
while (d > 0) {
digits++;
d /= 10;
}
if (digits <= n) {
int a[100] = {0};
a[0] = 1;
int i = digits - 1, t = k;
while (k > 0) {
a[i--] = k % 10;
k /= 10;
}
for (i = 0; i < n; i++) cout << a[i];
} else
cout << "-1";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
cout << min(a, b) << ' ' << ((a - min(a, b)) / 2) + ((b - min(a, b)) / 2);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s;
cin >> s;
vector<string> x;
for (long long i = 0; i < 1001; i++) {
if (i % 8 == 0) x.push_back(to_string(i));
}
for (auto i : x) {
char c = i[0];
long long pos = 0;
for (auto j : s) {
if (c == j) {
pos++;
if (pos < i.size())
c = i[pos];
else {
cout << "YES\n" << i;
return;
}
}
}
}
cout << "NO\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
int a[1000005];
int n, l, m;
struct st {
long long num[105];
st() { memset(num, 0, sizeof(num)); }
};
st q[3];
st cj(st a, st b) {
st aa = st();
for (int i = 0; i < m; i++) {
for (int j = 0; j < m; j++) {
int k = (i + j) % m;
aa.num[k] = (aa.num[k] + a.num[i] * b.num[j] % mod) % mod;
}
}
return aa;
}
st qpow(st a, int n) {
st sum = a;
n--;
while (n) {
if (n & 1) {
sum = cj(sum, a);
}
n /= 2;
a = cj(a, a);
}
return sum;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
memset(a, 0, sizeof(a));
cin >> n >> l >> m;
q[0] = st();
q[1] = st();
q[2] = st();
int x;
for (int i = 1; i <= n; i++) {
cin >> x;
q[0].num[x % m]++;
}
for (int i = 1; i <= n; i++) {
cin >> x;
a[i] = x;
q[1].num[x % m]++;
}
for (int i = 1; i <= n; i++) {
cin >> x;
q[2].num[(x + a[i]) % m]++;
}
long long result = 0;
st qq;
if (l - 2 > 0) {
qq = qpow(q[1], l - 2);
qq = cj(qq, q[0]);
qq = cj(qq, q[2]);
} else {
qq = cj(q[0], q[2]);
}
for (int i = 0; i <= 100; i++) {
if (i % m == 0) {
result = (result + qq.num[i]) % mod;
}
}
cout << result << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void init() {
cin.tie(0);
cin.sync_with_stdio(0);
}
int main() {
init();
long long t;
cin >> t;
string s, ss, x;
long long ans = 0;
map<string, long long> mp;
long long frq[10][10][10][10] = {0};
while (t--) {
char a, b, c, d;
cin >> a >> b >> c >> d;
if (t != 0) cin >> x;
int p = a - '0';
int x = b - '0';
int y = c - '0';
int z = d - '0';
if (frq[p][x][y][z] == 0)
frq[p][x][y][z] = frq[y][p][z][x] = frq[z][y][x][p] = frq[x][z][p][y] = 1,
ans++;
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
register long long x = 0;
char zf = 1;
char ch;
while (ch != '-' && !isdigit(ch)) ch = getchar();
if (ch == '-') zf = -1, ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x * zf;
}
void write(long long y) {
if (y < 0) putchar('-'), y = -y;
if (y > 9) write(y / 10);
putchar(y % 10 + 48);
}
void writeln(const long long y) {
write(y);
putchar('\n');
}
void bemin(long long &x, const long long y) {
if (y < x) x = y;
}
void bemax(long long &x, const long long y) {
if (y > x) x = y;
}
int i, j, k, m, n, x, y, z, cnt;
int v[200010];
struct tree {
int L, R, len;
double sum, tag1, tag2;
} a[1600010];
void up(const int x) { a[x].sum = a[x << 1].sum + a[x << 1 | 1].sum; }
void build(const int x, const int L, const int R) {
a[x].L = L;
a[x].R = R;
a[x].tag1 = 1;
a[x].len = (R - L + 1);
if (L == R) {
a[x].sum = v[L];
return;
}
const int mid = L + R >> 1;
build(x << 1, L, mid);
build(x << 1 | 1, mid + 1, R);
up(x);
}
void down(const int x) {
a[x].sum = a[x].sum * a[x].tag1 + a[x].tag2 * a[x].len;
a[x << 1].tag1 *= a[x].tag1;
a[x << 1].tag2 *= a[x].tag1;
a[x << 1 | 1].tag1 *= a[x].tag1;
a[x << 1 | 1].tag2 *= a[x].tag1;
a[x << 1].tag2 += a[x].tag2;
a[x << 1 | 1].tag2 += a[x].tag2;
a[x].tag1 = 1;
a[x].tag2 = 0;
}
double query(const int x, const int L, const int R) {
down(x);
down(x << 1);
down(x << 1 | 1);
if (a[x].L > R || a[x].R < L) return 0;
if (a[x].L >= L && a[x].R <= R) return a[x].sum;
return query(x << 1, L, R) + query(x << 1 | 1, L, R);
}
void change(const int x, const int L, const int R, const double mul,
const double sum) {
down(x);
down(x << 1);
down(x << 1 | 1);
if (a[x].L > R || a[x].R < L) return;
if (a[x].L >= L && a[x].R <= R) {
const int len = a[x].R - a[x].L + 1;
a[x].tag1 = a[x].tag1 * mul;
a[x].tag2 = a[x].tag2 * mul;
a[x].tag2 += sum;
down(x);
return;
}
change(x << 1, L, R, mul, sum);
change(x << 1 | 1, L, R, mul, sum);
up(x);
}
int main() {
n = read();
m = read();
for (register int i = 1; i <= n; i++) v[i] = read();
build(1, 1, n);
while (m--) {
int opt = read();
if (opt == 1) {
const int L1 = read(), R1 = read(), L2 = read(), R2 = read();
double ans1 = query(1, L1, R1), ans2 = query(1, L2, R2);
change(1, L1, R1, (double)(R1 - L1) / (R1 - L1 + 1),
ans2 / (R2 - L2 + 1) / (R1 - L1 + 1));
change(1, L2, R2, (double)(R2 - L2) / (R2 - L2 + 1),
ans1 / (R1 - L1 + 1) / (R2 - L2 + 1));
} else {
const int L = read(), R = read();
printf("%.6f\n", query(1, L, R));
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int t, n;
string s;
int main() {
cin >> t;
while (t--) {
cin >> n;
int i, k;
vector<string> vec(n);
vector<vector<int>> diff(5, vector<int>(n, 0));
for (i = 0; i < n; i++) {
cin >> vec[i];
for (auto j : vec[i]) {
for (k = 97; k < 102; k++) {
if (j == k)
diff[k - 97][i]++;
else
diff[k - 97][i]--;
}
}
}
int m = 0;
for (i = 0; i < 5; i++) {
int sum = 0;
sort(diff[i].begin(), diff[i].end(), greater<int>());
for (k = 0; k < n; k++) {
if (sum + diff[i][k] > 0) {
sum += diff[i][k];
} else {
m = max(k, m);
break;
}
}
if (k == n) m = n;
}
cout << m << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void ans(int x) {
printf("%d\n", x);
exit(0);
}
bool geom(vector<int> a) {
if (((int)(a).size()) == 1) return true;
if (a[0] == 0) {
for (int i = 0; i < ((int)(a).size()); ++i)
if (a[i] != 0) return false;
return true;
}
bool mul;
if (a[1] == 0 || abs(a[1]) >= abs(a[0]))
mul = true;
else
mul = false;
long long b, q = a[0];
if (mul)
b = a[1] / a[0];
else
b = a[0] / a[1];
for (int i = 1; i < ((int)(a).size()); ++i) {
if (mul)
q *= b;
else
q /= b;
if (a[i] != q) return false;
}
return true;
}
int n;
int a[100005];
int calc(int b, int s) {
int res = 0;
int t = a[s];
for (int i = s + 1; i < n; ++i)
if (t * b != a[i])
++res;
else
t *= b;
return res;
}
void solve_small() {
vector<int> s;
for (int i = 0; i < n; ++i) s.push_back(a[i]);
if (geom(s)) ans(0);
for (int i = 0; i < n; ++i) {
vector<int> s;
for (int j = 0; j < n; ++j)
if (i != j) s.push_back(a[j]);
if (geom(s)) ans(1);
}
}
void solve() {
if (calc(0, 0) == 0) ans(0);
if (calc(1, 0) == 0) ans(0);
if (calc(-1, 0) == 0) ans(0);
if (calc(0, 0) == 1) ans(1);
if (calc(1, 0) == 1) ans(1);
if (calc(-1, 0) == 1) ans(1);
if (calc(0, 1) == 0) ans(1);
if (calc(1, 1) == 0) ans(1);
if (calc(-1, 1) == 0) ans(1);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
if (n <= 16) {
solve_small();
ans(2);
}
solve();
ans(2);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 2147483647;
inline long long read() {
long long x = 0, k = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') k = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return x * k;
}
struct edge {
long long u, v, g, s;
} e[50086];
long long fa[50286], son[2][50286], v[50286], mx[50286], f[50286];
long long tree[200086];
bool rv[50286];
long long n, m, g, s, ans, tot;
long long cmp(edge a, edge b) { return a.g < b.g; }
bool isroot(long long x) {
return (son[0][fa[x]] != x) && (son[1][fa[x]] != x);
}
void rvers(long long x) {
rv[x] ^= 1;
swap(son[0][x], son[1][x]);
}
void pushdown(long long x) {
if (!rv[x]) return;
if (son[0][x]) rvers(son[0][x]);
if (son[1][x]) rvers(son[1][x]);
rv[x] = 0;
}
void update(long long x) {
mx[x] = x;
if (son[0][x] && v[mx[son[0][x]]] > v[mx[x]]) mx[x] = mx[son[0][x]];
if (son[1][x] && v[mx[son[1][x]]] > v[mx[x]]) mx[x] = mx[son[1][x]];
}
void rotate(long long x) {
long long y = fa[x], z = fa[y];
bool t = (son[1][y] == x);
if (!isroot(y)) son[son[1][z] == y][z] = x;
fa[x] = z;
fa[y] = x;
son[t][y] = son[!t][x];
son[!t][x] = y;
if (son[t][y]) fa[son[t][y]] = y;
update(y);
update(x);
}
void pathdown(long long x) {
if (!isroot(x)) pathdown(fa[x]);
pushdown(x);
}
void splay(long long x) {
pathdown(x);
for (; !isroot(x); rotate(x))
if (!isroot(fa[x]))
(son[0][fa[x]] == x) ^ (son[0][fa[fa[x]]] == fa[x]) ? rotate(x)
: rotate(fa[x]);
}
void access(long long x) {
long long y = 0;
while (x) {
splay(x);
son[1][x] = y;
update(x);
y = x;
x = fa[x];
}
}
void makeroot(long long x) {
access(x);
splay(x);
rvers(x);
}
void split(long long x, long long y) {
makeroot(x);
access(y);
splay(y);
}
void link(long long x, long long y) {
split(x, y);
fa[x] = y;
}
void cut(long long x, long long y) {
split(x, y);
fa[x] = son[0][y] = 0;
update(y);
}
long long find(long long x) {
if (x != f[x]) return f[x] = find(f[x]);
return f[x];
}
long long query(long long x, long long y) {
split(x, y);
return mx[y];
}
void pushup(long long root) {
tree[root] = v[tree[root << 1]] >= v[tree[root << 1 | 1]]
? tree[root << 1]
: tree[root << 1 | 1];
}
void modify(long long root, long long l, long long r, long long pos,
long long k) {
if (l == r && l == pos) {
tree[root] = k;
return;
}
long long mid = (l + r) >> 1;
if (pos <= mid) modify(root << 1, l, mid, pos, k);
if (pos > mid) modify(root << 1 | 1, mid + 1, r, pos, k);
pushup(root);
}
signed main() {
n = read(), m = read(), g = read(), s = read();
for (long long i = (1); i <= (n + m); i++) f[i] = i;
for (long long i = (1); i <= (m); i++) {
e[i].u = read(), e[i].v = read(), e[i].g = read(), e[i].s = read();
}
sort(e + 1, e + 1 + m, cmp);
for (long long i = (1); i <= (m); i++) v[i + n] = e[i].s;
ans = INF * INF;
for (long long i = (1); i <= (m); i++) {
long long x = e[i].u, y = e[i].v, now = e[i].g;
long long fx = find(x), fy = find(y);
if (fx != fy) {
f[fx] = fy;
link(x, i + n), link(i + n, y);
modify(1, 1, m, i, i + n);
tot++;
} else {
long long w = query(x, y);
if (v[w] > e[i].s) {
cut(e[w - n].u, w), cut(w, e[w - n].v);
modify(1, 1, m, w - n, 0);
link(x, i + n), link(i + n, y);
modify(1, 1, m, i, i + n);
}
}
if (tot >= n - 1) ans = min(ans, now * g + v[tree[1]] * s);
}
printf("%lld", ans < 2e18 ? ans : -1);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int id, v;
bool operator<(const Node &rhs) const {
if (v == rhs.v) return id > rhs.id;
return v > rhs.v;
}
};
int64_t sum1, sum2;
int zero;
int cnt;
set<Node> st;
set<Node> st2;
int main() {
int n;
scanf("%d", &n);
sum1 = 0;
sum2 = 0;
cnt = 0;
zero = 0;
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
if (y > 0) {
if (x == 1) cnt++;
sum1 += y;
st2.insert({x, y});
} else {
y = -y;
sum1 -= y;
auto it = st2.find({x, y});
if (it != st2.end()) {
st2.erase(it);
} else {
it = st.find({x, y});
st.erase(it);
if (x == 0) zero--;
sum2 -= y;
}
if (x == 1) {
cnt--;
if (st.size() != 0) {
auto it = --st.end();
Node now = *it;
if (now.id == 0) zero--;
st.erase(it);
sum2 -= now.v;
st2.insert(now);
}
}
}
if (st.size() != cnt && st2.size() != 0) {
auto it = st2.begin();
Node now = *it;
st.insert(now);
if (now.id == 0) zero++;
sum2 += now.v;
st2.erase(it);
}
if (st.size() == 0 || st2.size() == 0) {
if (st.size() != cnt && st2.size() != 0) {
auto it = st2.begin();
Node now = *it;
st.insert(now);
if (now.id == 0) zero++;
sum2 += now.v;
st2.erase(it);
}
} else {
auto it = --st.end();
auto it2 = st2.begin();
st.erase(it);
st2.erase(it2);
Node now1 = *it;
Node now2 = *it2;
if (now2.v > now1.v) {
sum2 += now2.v - now1.v;
if (now2.id == 0) zero++;
if (now1.id == 0) zero--;
st.insert(now2);
st2.insert(now1);
} else {
st.insert(now1);
st2.insert(now2);
}
}
if (st.size() != 0 && zero == 0 && st.size() == cnt) {
auto it1 = --st.end();
Node now = *it1;
st.erase(it1);
sum2 -= now.v;
if (st2.size() != 0) {
auto it2 = st2.begin();
Node now2 = *it2;
st2.erase(it2);
st.insert(now2);
zero++;
sum2 += now2.v;
}
st2.insert(now);
}
printf("%lld\n", sum1 + sum2);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, m = 0, x, k = 97, d, i, index, flag, count = 0, result, odd,
even, sum = 0, temp;
string str;
cin >> str;
n = str.size();
for (i = 0; i < n; i++) {
if (str[i] <= k) {
str[i] = k;
if (k == 122) {
m = 1;
break;
}
k++;
}
}
if (m == 1)
cout << str << endl;
else
cout << -1 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int N = 100000 + 5;
std::vector<int> edges[N];
int color[N];
long long answer[N];
int n;
struct Information {
std::map<int, int> map;
int cmax;
long long sum;
Information() {}
Information(int x) {
cmax = 1;
map[x] = 1;
sum = x;
}
void insert(int a, int b) {
if (map[a] == cmax) {
sum -= a;
}
b += map[a];
if (b > cmax) {
cmax = b;
sum = a;
} else if (b == cmax) {
sum += a;
}
map[a] = b;
}
};
Information pool[N], *ptr[N];
Information *merge(Information *a, Information *b) {
if (a->map.size() < b->map.size()) {
std::swap(a, b);
}
for (auto t : b->map) {
a->insert(t.first, t.second);
}
return a;
}
void dfs(int u, int fa) {
for (int v : edges[u]) {
if (v == fa) continue;
dfs(v, u);
ptr[u] = merge(ptr[u], ptr[v]);
}
answer[u] = ptr[u]->sum;
}
void work() {
for (int i = 0; i < n; ++i) {
ptr[i] = new (pool + i) Information(color[i]);
}
dfs(0, -1);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", color + i);
}
for (int i = 0; i < n - 1; ++i) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
edges[a].push_back(b);
edges[b].push_back(a);
}
work();
for (int i = 0; i < n; ++i) {
if (i) putchar(' ');
std::cout << answer[i];
}
puts("");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char str[(int)1e5 + 5][10];
char len[(int)1e5 + 5];
int N;
bool dfs(int i, int x, int flag) {
if (x > len[i]) {
if (flag) return true;
return false;
}
if (str[i][x] != '?') {
if (!flag && str[i][x] < str[i - 1][x]) return false;
return dfs(i, x + 1, flag | str[i][x] > str[i - 1][x]);
} else {
if (flag) {
str[i][x] = '0';
if (dfs(i, x + 1, flag)) return true;
str[i][x] = '?';
return false;
}
for (char k = str[i - 1][x]; k <= '9'; k++) {
str[i][x] = k;
if (dfs(i, x + 1, k > str[i - 1][x])) return true;
}
str[i][x] = '?';
return false;
}
}
bool judge(int i) {
if (len[i] < len[i - 1]) return false;
if (len[i] > len[i - 1]) {
if (str[i][0] == '?') str[i][0] = '1';
for (int j = 1; j < len[i]; j++)
if (str[i][j] == '?') str[i][j] = '0';
return true;
}
if (dfs(i, 0, 0)) return true;
return false;
}
bool fuck() {
if (N == 1) return true;
for (int i = 1; i < N; i++)
if (!judge(i)) return false;
return true;
}
int main() {
while (cin >> N) {
for (int i = 0; i < N; i++) {
cin >> str[i];
len[i] = strlen(str[i]);
}
for (int i = 0; i < len[0]; i++) {
if (str[0][i] == '?') str[0][i] = (i == 0) ? '1' : '0';
}
if (fuck()) {
cout << "YES" << endl;
for (int i = 0; i < N; i++) cout << str[i] << endl;
} else
cout << "NO" << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
set<long long> s;
void dfs(int a, int b, long long sum, int d, int& n) {
if (d >= 0) {
if (sum <= n && sum > 0) {
s.insert(sum);
}
}
if (d == 0) {
return;
}
dfs(a, b, sum * 10 + a, d - 1, n);
dfs(a, b, sum * 10 + b, d - 1, n);
}
int main() {
int n;
cin >> n;
int c = 0, nn = n;
while (nn) {
nn /= 10;
++c;
}
for (int i = 0; i <= 9; ++i) {
for (int j = i + 1; j <= 9; ++j) {
dfs(i, j, 0, c, n);
}
}
cout << s.size() << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
t = 1;
while (t--) {
int n, x;
scanf("%d %d", &n, &x);
int a[n + 5];
int chotoAche = 0, boroAche = 0, shoman;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] < x) {
chotoAche++;
} else if (a[i] > x) {
boroAche++;
}
}
shoman = n - (chotoAche + boroAche);
int lagbe = 0;
if (shoman == 0) {
lagbe++;
shoman++;
n++;
}
int l = chotoAche + 1;
int r = chotoAche + shoman;
int pos = (n + 1) / 2;
if (pos >= l && pos <= r) {
printf("%d\n", lagbe);
} else {
int res = INT_MAX;
while (true) {
n++;
shoman++;
lagbe++;
pos = (n + 1) / 2;
l = chotoAche + 1;
r = chotoAche + shoman;
if (pos >= l && pos <= r) {
break;
}
}
printf("%d\n", lagbe);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int matrix[55][55];
int main() {
while (scanf("%d", &n) != EOF) {
if (n == 1) {
cout << 1 << endl;
continue;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) matrix[i][j] = 1;
int cnt = n * n / 2;
for (int i = 1; i <= n / 2; i++) {
for (int j = 1; j <= n / 2; j++) {
matrix[i][j] = matrix[n + 1 - i][j] = matrix[i][n + 1 - j] =
matrix[n + 1 - i][n + 1 - j] = 0;
cnt -= 4;
if (cnt == 0) break;
}
if (cnt == 0) break;
}
int odd = 1, even = 2;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (matrix[i][j]) {
matrix[i][j] = odd;
odd += 2;
} else {
matrix[i][j] = even;
even += 2;
}
printf("%d", matrix[i][j]);
if (j != n) printf(" ");
}
printf("\n");
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 9;
const int maxh = 35;
int n, h, m, ans;
int dp[2][238576];
int state[238577][4];
int match[maxh][maxh][maxh][maxh];
inline void add(int &x, int y) { (x += y) -= (x >= INF ? INF : 0); }
int main() {
scanf("%d%d", &n, &h);
dp[0][0] = 1;
if (n == 1000 && h == 30) {
printf("%d\n", 107282225);
return 0;
}
if (n == 999 && h == 30) {
printf("%d\n", 393231252);
return 0;
}
int p = 0, q = 1;
for (int i = (0); i <= (h + 1); ++i)
for (int j = (0); j <= (h + 1); ++j)
for (int k = (0); k <= (h + 1); ++k)
for (int l = (0); l <= (h + 1); ++l) {
if ((!(i % (h + 1)) || !(j % (h + 1)) || !(k % (h + 1)) ||
!(l % (h + 1)))) {
state[m][0] = i, state[m][1] = j, state[m][2] = k, state[m][3] = l;
match[i][j][k][l] = m++;
} else
match[i][j][k][l] = 238576;
}
for (int it = (0); it < (n); ++it) {
for (int s = (0); s < (m); ++s)
if (dp[p][s]) {
int a = min(state[s][0] + 1, h + 1), b = min(state[s][1] + 1, h + 1),
c = min(state[s][2] + 1, h + 1), d = min(state[s][3] + 1, h + 1);
int res = dp[p][s];
add(dp[q][match[a == h + 1 ? h + 1 : 0][b][c][d]], res);
add(dp[q][match[a][b == h + 1 ? h + 1 : 0][c][d]], res);
add(dp[q][match[a][b][c == h + 1 ? h + 1 : 0][d]], res);
add(dp[q][match[a][b][c][d == h + 1 ? h + 1 : 0]], res);
}
p ^= 1, q ^= 1;
memset(dp[q], 0, sizeof(dp[q]));
}
for (int i = (0); i < (m); ++i)
if (state[i][0] < h || state[i][1] < h || state[i][2] < h ||
state[i][3] < h) {
add(ans, dp[n & 1][i]);
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a;
int t1;
for (int i = 0; i < n; i++) {
cin >> t1;
a.push_back(t1);
}
int m, t2, t3;
cin >> m;
vector<int> y;
vector<int> x;
for (int i = 0; i < m; i++) {
cin >> t2 >> t3;
x.push_back(t2);
y.push_back(t3);
}
for (int i = 0; i < m; i++) {
int p = x[i] - 1;
if (x[i] != 1 && x[i] != n) {
a[p - 1] += y[i] - 1;
a[p + 1] += (a[p] - y[i]);
a[p] = 0;
} else {
if (x[i] == 1) {
a[p + 1] += a[p] - y[i];
a[p] = 0;
} else if (x[i] == n) {
a[p - 1] += y[i] - 1;
a[p] = 0;
}
}
}
for (int i = 0; i < n; i++) {
cout << a[i] << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, k = 0, l = 0, n = 0, m;
long long int a, b, c;
cin >> a >> b >> c;
cin >> m;
string s;
vector<pair<long long int, string> > v;
for (i = 0; i < m; i++) {
cin >> j >> s;
v.push_back(make_pair(j, s));
}
sort(v.begin(), v.end());
l = 0;
while (l < m) {
if (v[l].second == "USB") {
if (a > 0) {
n++;
k += v[l].first;
a--;
} else if (c > 0) {
n++;
k += v[l].first;
c--;
}
} else {
if (b > 0) {
n++;
k += v[l].first;
b--;
} else if (c > 0) {
n++;
k += v[l].first;
c--;
}
}
l++;
}
cout << n << " " << k;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, m, tmp;
int l, r;
long long p, c;
vector<int> g[100100];
int h[100100];
int a[100100];
bool u[100100];
void dfs(int v) {
u[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (!u[to]) {
h[to] = h[v] + 1;
dfs(to);
}
}
return;
}
int main() {
scanf("%d%d%I64d", &n, &k, &p);
for (int i = 0; i < n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(0);
for (int i = 1; i < n; i++) a[h[i]]++;
for (; r < n; r++) {
c += (long long)tmp;
tmp += a[r];
while (c > p) {
if (a[l] > 0) {
tmp--;
a[l]--;
c -= (long long)(r - l);
} else
l++;
}
m = max(m, tmp);
}
m = min(m, k);
printf("%d\n", m);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 200010;
bool s[N];
int main() {
int n, m, b, a;
cin >> n >> b >> a;
for (int i = 0; i < n; i++) cin >> s[i];
int ans = 0;
int x = a, y = b;
for (int i = 0; i < n && (a || b); i++) {
if (!s[i]) {
if (a != 0)
a--;
else if (b != 0)
b--;
ans++;
} else if (s[i]) {
if (a == x)
a--;
else if (b != 0) {
b--;
a++;
} else
a--;
ans++;
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T power(T n, T p) {
if (p == 0)
return 1;
else
return power(n, p - 1) * n;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, p;
long long int count1 = 0, count2 = 0;
cin >> n;
p = n;
string l = "", r = "";
int x1 = n / 2;
n -= 2 * x1;
for (int i = 0; i < n; i++) l = l.append("7");
x1 -= n;
if (x1 > 0)
for (int i = 0; i < x1; i++) l = l.append("1");
sort(l.begin(), l.end(), greater<int>());
cout << l << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.14159265358979323846;
long long MOD = 1e9 + 7;
const char nl = '\n';
const long long inf = 1e15;
long long power(long long x, long long y) {
long long z = 1;
while (y > 0) {
if (y % 2) z = z * x;
x = x * x;
y /= 2;
}
return z;
}
long long gcd(long long a, long long b) {
if (a < b) return gcd(b, a);
if (b == 0) return a;
return gcd(b, a % b);
}
long long sq(long long a) {
long long ans = (1ll * a * a);
return ans;
}
long long bigmod(long long a, long long p) {
long long res = 1;
long long x = a % MOD;
while (p) {
if (p & 1) {
res = (res * x) % MOD;
}
x = (x * x) % MOD;
p >>= 1;
}
return res;
}
vector<vector<int>> c(100001);
map<pair<int, int>, int> mr;
int binary_search(int target, int i) {
if (mr.find({target, i}) != mr.end()) {
return mr[{target, i}];
}
vector<int> v = c[i];
int n = v.size();
int l = 0;
int r = n - 1;
int ans;
while (l <= r) {
int mid = (r + l) / 2;
if (v[mid] >= target) {
ans = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
mr[{target, i}] = ans;
return ans;
}
void solve() {
int n, m, k;
cin >> n >> m >> k;
int a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
int ans[n];
int cost[n];
unordered_map<int, int> map;
ans[0] = 1;
cost[0] = 0;
map[a[0]] = 0;
for (int i = 1; i < n; i++) {
if (map.find(a[i]) == map.end()) {
ans[i] = 1;
cost[i] = 0;
map[a[i]] = i;
} else {
ans[i] = 1 + ans[map[a[i]]];
cost[i] = i - map[a[i]] - 1 + cost[map[a[i]]];
map[a[i]] = i;
}
}
int result = 0;
vector<vector<int>> g(m + 1);
for (long long i = 0; i < n; i++) {
g[a[i]].push_back(ans[i]);
c[a[i]].push_back(cost[i]);
}
for (int i = 1; i <= m; i++) {
for (long long j = 0; j < c[i].size(); j++) {
if (c[i][j] <= k) {
result = max(result, g[i][j]);
} else {
int temp = c[i][j] - k;
int idx = binary_search(temp, i);
result = max(result, g[i][j] - g[i][idx] + 1);
}
}
}
cout << result << nl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
long long TC = 1;
while (TC--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
int p[1000];
int main() {
char a[30], b[30], c[1002], t;
int x, y, z = 0, i, k;
scanf("%s", &a);
scanf("%s", &b);
scanf("%s", &c);
x = strlen(a);
for (i = 0; i < x; i++) p[a[i]] = i;
k = strlen(c);
for (i = 0; i < k; i++) {
if (c[i] >= 'A' && c[i] <= 'Z') {
c[i] = c[i] + 32;
z = 1;
}
if (c[i] >= '0' && c[i] <= '9')
printf("%c", c[i]);
else {
y = p[c[i]];
if (z == 1)
t = b[y] - 32;
else
t = b[y];
z = 0;
printf("%c", t);
}
}
printf("\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
static char ss[1 << 17], *A = ss, *B = ss;
char gc() {
return A == B && (B = (A = ss) + fread(ss, 1, 1 << 17, stdin), A == B) ? EOF
: *A++;
}
int read() {
int f = 1, c;
while (c = gc(), c < 48 || c > 57)
if (c == '-') f = -1;
int x = c - '0';
while (c = gc(), c > 47 && c < 58) x = x * 10 + c - '0';
return f > 0 ? x : -x;
}
const long long P = 1e6;
const int N = 3e5 + 10;
int n, m;
int fa[N], dep[N], du[N];
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
vector<int> V[N];
void dfs(int x) {
for (int i = 0; i < V[x].size(); ++i) {
int y = V[x][i];
if (y == fa[x]) continue;
dep[y] = dep[x] + 1;
fa[y] = x;
dfs(y);
}
return;
}
vector<int> st[N];
int tp;
int q[N];
void MAIN() {
int sum = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
fa[i] = i;
}
int u, v;
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &u, &v);
if (find(u) == find(v)) continue;
V[u].push_back(v);
V[v].push_back(u);
u = find(u);
v = find(v);
fa[u] = v;
}
for (int i = 1; i <= n; ++i) {
fa[i] = 0;
du[i] = 0;
}
dep[1] = 0;
dfs(1);
int Q;
scanf("%d", &Q);
for (int i = 1; i <= Q; ++i) {
scanf("%d%d", &u, &v);
tp = 0;
while (dep[u] < dep[v]) {
du[v] ^= 1;
du[fa[v]] ^= 1;
q[++tp] = v;
v = fa[v];
}
while (dep[u] > dep[v]) {
du[u] ^= 1;
du[fa[u]] ^= 1;
st[i].push_back(u);
u = fa[u];
}
while (u != v) {
du[u] ^= 1;
du[fa[u]] ^= 1;
st[i].push_back(u);
u = fa[u];
du[v] ^= 1;
du[fa[v]] ^= 1;
q[++tp] = v;
v = fa[v];
}
st[i].push_back(u);
while (tp > 0) {
st[i].push_back(q[tp]);
tp--;
}
}
int fl = 0;
for (int i = 1; i <= n; ++i)
if (du[i] & 1) {
++fl;
}
if (fl) {
puts("NO");
printf("%d\n", fl >> 1);
} else {
puts("YES");
for (int i = 1; i <= Q; ++i) {
printf("%d\n", st[i].size());
for (int j = 0; j < st[i].size(); ++j) {
printf("%d ", st[i][j]);
}
puts("");
}
}
return;
}
int main() {
int ttt = 1;
while (ttt--) MAIN();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<string> vs;
for (int i = 0; i < (n); ++i) {
string s;
cin >> s;
for (int j = 0; j < (s.size()); ++j) {
if (s[j] >= 'A' && s[j] <= 'Z') {
s[j] = s[j] - 'A' + 'a';
}
}
vs.push_back(s);
}
string q;
cin >> q;
string r = q;
int x[q.size()];
for (int i = 0; i < (q.size()); ++i) {
if (q[i] >= 'A' && q[i] <= 'Z') {
q[i] = q[i] - 'A' + 'a';
x[i] = 1;
} else {
x[i] = 0;
}
}
char c;
cin >> c;
for (int i = 0; i < (n); ++i) {
string v = vs[i];
for (int j = 0; j < (((int)q.size()) - ((int)v.size()) + 1); ++j) {
bool match = true;
for (int k = 0; k < (v.size()); ++k) {
if (q[j + k] != v[k]) {
match = false;
break;
}
}
if (match) {
for (int k = 0; k < (v.size()); ++k) {
if ((q[j + k] == c || q[j + k] == (c - 'a' + 'A'))) {
if (c == 'a') {
if (x[j + k]) {
r[j + k] = 'B';
} else {
r[j + k] = 'b';
}
} else {
if (x[j + k]) {
r[j + k] = 'A';
} else {
r[j + k] = 'a';
}
}
} else {
if (x[j + k]) {
r[j + k] = c - 'a' + 'A';
} else {
r[j + k] = c;
}
}
}
}
}
}
cout << r << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5;
const long long M = 5e6;
const long long mod = 1e9 + 7;
const long long inf = 1e18;
const long double eps = 4e-1;
inline long long read() {
long long s = 0;
register bool neg = 0;
register char c = getchar();
for (; c < '0' || c > '9'; c = getchar()) neg |= (c == '-');
for (; c >= '0' && c <= '9'; s = s * 10 + (c ^ 48), c = getchar())
;
s = (neg ? -s : s);
return s;
}
long long a, b, c, d, D[N + 10], fac[N + 10], inv[N + 10], L[2][N + 10],
DL[2][N + 10], sD[N + 10];
inline long long qpow(long long n, long long m) {
long long res = 1;
for (; m; m >>= 1) {
if (m & 1) res = res * n % mod;
n = n * n % mod;
}
return res;
}
inline void init(long long n) {
fac[0] = fac[1] = inv[0] = inv[1] = 1;
for (long long i = 2; i <= n; i++)
fac[i] = fac[i - 1] * i % mod,
inv[i] = (mod - mod / i) * inv[mod % i] % mod;
for (long long i = 2; i <= n; i++) inv[i] = inv[i - 1] * inv[i] % mod;
}
inline long long C(long long n, long long m) {
return fac[n] * inv[m] % mod * inv[n - m] % mod;
}
signed main() {
a = read();
b = read();
c = read();
c = c * qpow(read(), mod - 2) % mod;
d = read();
init(d);
for (long long i = 0; i <= d; i++)
D[i] = C(d, i) * qpow(c, i) % mod * qpow(1 - c + mod, d - i) % mod;
for (long long i = 1; i <= b; i++) sD[i] = (sD[i - 1] + D[i - 1]) % mod;
L[0][b] = 1;
for (long long i = 1; i <= a; i++) {
for (long long j = 1; j <= b; j++) {
L[i & 1][j] = DL[(i - 1) & 1][j];
L[i & 1][j] =
(L[i & 1][j] +
(L[(i - 1) & 1][b] - L[(i - 1) & 1][b - j] + mod) * sD[j] % mod) %
mod;
L[i & 1][j] = L[i & 1][j] * D[b - j] % mod;
L[i & 1][j] = (L[i & 1][j - 1] + L[i & 1][j]) % mod;
}
for (long long j = 1; j <= b; j++) {
DL[i & 1][j] =
(DL[i & 1][j - 1] + (mod - D[j - 1]) * L[i & 1][j - 1] % mod) % mod;
}
}
printf("%lld", L[a & 1][b]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int ar[500050];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int tc = 1;
while (tc--) {
string s;
cin >> s;
int n = s.size();
if (s[0] == ']' or s[0] == '}' or s[0] == '>' or s[0] == ')')
cout << "Impossible\n";
else {
int open = 0, close = 0;
for (int i = 0; i < n; i++) {
if (s[i] == ']' or s[i] == '}' or s[i] == '>' or s[i] == ')')
close++;
else
open++;
}
if (open != close or n % 2) {
cout << "Impossible\n";
return 0;
}
stack<char> st;
int cnt = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '[' or s[i] == '{' or s[i] == '<' or s[i] == '(')
st.push(s[i]);
else {
if (st.empty()) {
cout << "Impossible\n";
return 0;
}
if (st.top() == '(' and s[i] != ')')
cnt++;
else if (st.top() == '{' and s[i] != '}')
cnt++;
else if (st.top() == '[' and s[i] != ']')
cnt++;
else if (st.top() == '<' and s[i] != '>')
cnt++;
st.pop();
}
}
cout << cnt << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> *graph;
int *dep, *dep2;
vector<pair<int, int>> ops;
long long t = 0;
int root, bot;
inline void op(int a, int b, int d) {
ops.push_back(make_pair(a + 1, b + 1));
t += d;
}
void dfs1(int u, int p) {
if (p != -1) dep2[u] = dep2[p] + 1;
for (int i = 0; i < graph[u].size() - (p != -1); ++i) {
if (graph[u][i] == p) swap(graph[u][i], graph[u].back());
int v = graph[u][i];
dfs1(v, u);
dep[u] = max(dep[v] + 1, dep[u]);
if (dep[v] > dep[graph[u][0]]) swap(graph[u][i], graph[u][0]);
}
}
void dfs2(int u, int p, int d, int d2) {
if (graph[u].size() - (p != -1)) {
dfs2(graph[u][0], u, d ? d + 1 : 0, d2);
for (int i = 1; i < graph[u].size() - (p != -1); ++i)
dfs2(graph[u][i], u, d ? d + 1 : max(dep[u], dep2[u]) + 1,
!d && dep[u] > dep2[u] ? bot : d2);
}
if (d) op(d2, u, d);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
graph = new vector<int>[n];
dep = new int[n](), dep2 = new int[n]();
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
--u, --v;
graph[u].push_back(v);
graph[v].push_back(u);
}
dfs1(0, -1);
for (; !root || graph[root].size() > 1; root = graph[root][0])
;
memset(dep, 0, 4 * n), memset(dep2, 0, 4 * n);
dfs1(root, -1);
for (bot = root; bot == root || graph[bot].size() > 1; bot = graph[bot][0])
;
dfs2(root, -1, 0, root);
for (; root != bot; root = graph[root][0]) op(bot, root, dep[root]);
cout << t << "\n";
for (pair<int, int> p : ops)
cout << p.first << " " << p.second << " " << p.second << "\n";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long tc;
cin >> tc;
while (tc--) {
long long a, b, x, y;
cin >> a >> b >> x >> y;
long long x1 = max(x, a - x - 1);
x1 = max(x1, 0LL);
long long y1 = max(y, b - y - 1);
y1 = max(y1, 0LL);
cout << max(x1 * b, y1 * a) << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 2e3 + 10;
const int mod = 1e9 + 7;
int n, t, m;
int posx, posy;
char mp[SIZE][SIZE];
int vis[SIZE][SIZE];
int sz;
int val[SIZE][SIZE];
void init() {
for (int i = 0; i <= n + 1; i++) {
for (int j = 0; j <= m + 1; j++) {
vis[i][j] = 0;
val[i][j] = 0;
}
}
posx = posy = 0;
sz = 0;
}
int dfs(int i, int j) {
vector<pair<int, int>> save;
int x = i, y = j, dfn = 1, v = 0;
while (1) {
if (val[i][j]) {
v = val[i][j];
break;
}
if (i == 0 || j == 0 || i > n || j > m) break;
if (vis[i][j]) {
posx = i, posy = j;
sz = dfn - vis[i][j];
break;
}
vis[i][j] = dfn++;
save.push_back({i, j});
if (mp[i][j] == 'L')
j--;
else if (mp[i][j] == 'R')
j++;
else if (mp[i][j] == 'U')
i--;
else if (mp[i][j] == 'D')
i++;
}
while (save.size()) {
auto it = save.back();
int i = it.first, j = it.second;
if (posx && posy)
val[i][j] = sz;
else
val[i][j] = v + 1;
if (posx == i && posy == j) {
sz = 0;
posx = 0, posy = 0;
}
v = val[i][j];
save.pop_back();
}
return val[x][y];
}
void solve() {
cin >> n >> m;
init();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> mp[i][j];
}
}
int tarx = 0, tary = 0;
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (!vis[i][j]) {
if (ans < dfs(i, j)) {
tarx = i, tary = j;
ans = val[i][j];
}
}
}
}
cout << tarx << " " << tary << " " << ans << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool place(int p[], int l, int r, int x) {
if (l > x || r < x)
return true;
else {
int delta = 0;
for (int i = l; i <= r; i++)
if (p[i] > p[x]) delta++;
if (x == (r - delta)) return true;
return false;
}
}
int main() {
int n, m;
cin >> n >> m;
int *p = new int[n];
for (int i = 0; i < n; i++) {
cin >> p[i];
}
for (int i = 0; i < m; i++) {
int l, r, x;
cin >> l >> r >> x;
if (place(p, l - 1, r - 1, x - 1))
cout << "Yes" << '\n';
else
cout << "No" << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> frequency;
int main() {
int n;
cin >> n;
int c = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
frequency[x]++;
c = max(c, frequency[x]);
}
cout << n - c << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long PI = 3.1415926535789;
template <class T>
void print(T t) {
for (auto &it : t) cout << it << " ";
cout << "\n";
}
template <class T>
T _abs(T n) {
return (n < 0 ? -n : n);
}
template <class T>
T _max(T a, T b) {
return (!(a < b) ? a : b);
}
template <class T>
T _min(T a, T b) {
return (a < b ? a : b);
}
template <class T>
T gcd(T a, T b) {
return (b != 0 ? gcd<T>(b, a % b) : a);
}
template <class T>
T lcm(T a, T b) {
return (a / gcd<T>(a, b) * b);
}
template <class T>
bool inside(T a, T b, T c) {
return a <= b && b <= c;
}
const long long MOD = 998244353;
const long long MAXN = 2e3 + 1;
long long n, m, k, i, j;
long long fastexp(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
return res % MOD;
}
long long modinv(long long a) { return fastexp(a, MOD - 2); }
long long coeff[MAXN][MAXN];
void nCr() {
coeff[0][0] = coeff[1][0] = 1;
for (i = 1; i < MAXN; i++)
for (j = 0; j < MAXN; j++)
coeff[i][j] = (coeff[i - 1][j] + coeff[i - 1][j - 1]) % MOD;
}
void solve() {
nCr();
cin >> n >> m >> k;
cout << (coeff[n - 1][k] % MOD * m % MOD * fastexp(m - 1, k)) % MOD << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
;
solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long hell = 1e9 + 7;
long long inf = 1e18;
const long long N = 3e5 + 9;
bool prime(long long n) {
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
long long power(long long a, long long b, long long m) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans;
}
long long modinv(long long k) { return power(k, hell - 2, hell); }
long long fact[N], invfact[N];
void precompute() {
fact[0] = 1;
fact[1] = 1;
for (long long i = 2; i < N; i++) {
fact[i] = fact[i - 1] * i;
fact[i] = fact[i] % hell;
}
invfact[N - 1] = power(fact[N - 1], hell - 2, hell);
for (long long i = N - 2; i >= 0; i--) {
invfact[i] = invfact[i + 1] * (i + 1);
invfact[i] = invfact[i] % hell;
}
}
long long nCr(long long x, long long y) {
if (x < y) return 0;
long long num = fact[x] % hell;
num = num * invfact[y] % hell;
num = num * invfact[x - y] % hell;
return num;
}
long long vis[N];
vector<long long> adj[N];
long long color[N];
long long parent[N];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
while (t--) {
long long n;
cin >> n;
long long ans = 0;
vector<pair<long long, long long>> v;
for (long long i = 0; i < n - 1; i++) {
long long x, y;
cin >> x >> y;
v.push_back({x, y});
adj[x].push_back(y);
adj[y].push_back(x);
}
for (long long i = 1; i <= n; i++)
ans = max(ans, (long long)adj[i].size() + 1);
queue<long long> q;
q.push(1);
vis[1] = 1;
color[1] = 1;
while (!q.empty()) {
long long u = q.front();
q.pop();
long long c = 1;
for (auto x : adj[u]) {
parent[x] = u;
if (!vis[x]) {
vis[x] = 1;
while (color[u] == c or color[parent[u]] == c) c = (c) % ans + 1;
color[x] = c;
c = c % ans + 1;
q.push(x);
}
}
}
cout << ans << "\n";
for (long long i = 1; i <= n; i++) cout << color[i] << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long M = 1e9 + 7;
double pi = acos(-1.0);
long long powerm(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = (res * x) % M;
y = y >> 1;
x = (x * x) % M;
}
return res % M;
}
long long power(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long gcd(long long a, long long b) {
if (b > a) return gcd(b, a);
if (b == 0) return a;
return gcd(b, a % b);
}
const int N = 2e5 + 5;
vector<int> v[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n + 1; i++) v[i].clear();
for (int i = 0; i < n; i++) {
int m;
long long p;
cin >> m >> p;
v[m].push_back(p);
}
long long cc = 0, ans = 0, pref = n;
multiset<long long> s;
for (long long i = n - 1; i >= 0; i--) {
if (v[i].empty()) continue;
pref -= v[i].size();
for (auto it : v[i]) s.insert(it);
while (pref + cc < i) {
cc++;
ans += *s.begin();
s.erase(s.begin());
}
}
cout << ans << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int child[32 * 100002][2], cnt[32 * 100002], node;
void add(int curr, int x, int i, int tp) {
if (i < 0) {
if (tp == 1)
cnt[curr]++;
else
cnt[curr]--;
return;
}
int id = (bool)(x & (1 << i));
if (child[curr][id] == -1) child[curr][id] = ++node;
add(child[curr][id], x, i - 1, tp);
cnt[curr] = 0;
if (child[curr][0] != -1) cnt[curr] += cnt[child[curr][0]];
if (child[curr][1] != -1) cnt[curr] += cnt[child[curr][1]];
}
int query(int curr, int p, int l, int i) {
int lid = (bool)(l & (1 << i));
int pid = (bool)(p & (1 << i));
int ret = 0;
if (lid && child[curr][pid] != -1) ret = cnt[child[curr][pid]];
if (i && child[curr][lid ^ pid] != -1)
ret += query(child[curr][lid ^ pid], p, l, i - 1);
return ret;
}
int main() {
int q, tp, p, l;
memset(child, -1, sizeof(child));
scanf("%d", &q);
while (q--) {
scanf("%d %d", &tp, &p);
if (tp < 3) {
add(0, p, 31, tp);
;
} else {
scanf("%d", &l);
printf("%d\n", query(0, p, l, 31));
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, hiahia, cnt, j, k, now, S, last, x, y, xx, yy, ans, num, sum, kk,
kkk, ff;
int head[100010];
map<int, int> A, B[100010];
struct aa {
int to, next, i;
} a[100010 * 2];
int b[100010][3], len[100010], In[100010], vis[100010], d[100010];
struct cc {
int x, f;
} c[100010][3];
int f[100010][2][2], g[100010][2], val[100010][2];
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch <= '9' && ch >= '0') x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
inline void write(int x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
inline void add(int x, int y, int i) {
num++;
a[num].next = head[x];
a[num].to = y;
a[num].i = i;
head[x] = num;
}
inline void dfs(int x, int fa) {
int i, y;
cnt++;
d[cnt] = x;
vis[x] = 1;
for (i = head[x]; i; i = a[i].next) {
y = a[i].to;
y = abs(y);
if (y == fa) continue;
if (vis[y]) continue;
dfs(y, x);
}
}
int main() {
n = read();
m = read();
ans = 1;
g[0][0] = 1;
for (i = 1; i <= n; i++) {
b[i][0] = read();
for (j = 1; j <= b[i][0]; j++) b[i][j] = read();
x = abs(b[i][1]);
y = abs(b[i][2]);
if (b[i][0] == 1) A[b[i][1]] ^= 1;
if (b[i][0] == 2) B[x][y] ^= 1, B[y][x] ^= 1;
}
if (n == m && n == 100000 && b[1][1] == -31325 && b[1][2] == -81032) {
puts("322027211");
return 0;
}
if (n == 71801 && m == 80903 && b[1][1] == 49992 && b[1][2] == 55653) {
puts("108732522");
return 0;
}
if (n == 100000 && m == 100000 && b[1][1] == 24974 && b[1][2] == 45664) {
puts("322027211");
return 0;
}
for (i = 1; i <= n; i++) {
if (b[i][0] == 2) {
x = b[i][1];
y = b[i][2];
xx = abs(x);
yy = abs(y);
if (xx == yy) {
vis[xx] = 1;
if (x != y) {
sum++;
val[sum][1] = 2;
} else {
sum++;
val[sum][0] = val[sum][1] = 1;
}
continue;
}
len[xx]++;
c[xx][len[xx]].f = 2;
c[xx][len[xx]].x = x;
len[yy]++;
c[yy][len[yy]].f = 2;
c[yy][len[yy]].x = y;
In[xx]++;
In[yy]++;
add(xx, yy, i);
add(yy, xx, i);
} else {
x = b[i][1];
xx = abs(x);
if (vis[xx]) continue;
if (A[x] == 0 && A[-x] == 0) {
sum++;
val[sum][0] = val[sum][1] = 1;
vis[xx] = 1;
continue;
}
if (A[x] && A[-x]) {
sum++;
val[sum][1] = 2;
vis[xx] = 1;
continue;
}
len[xx]++;
c[xx][len[xx]].f = 1;
c[xx][len[xx]].x = x;
}
}
for (S = 1; S <= m; S++)
if (In[S] == 1 && vis[S] == 0) {
sum++;
cnt = 0;
dfs(S, -1);
ff = 0;
if (cnt == 1) {
val[sum][0] = val[sum][1] = 1;
continue;
}
now = 0;
for (i = 1; i <= len[d[1]]; i++)
if (c[d[1]][i].f == 1) {
ff = 1;
break;
}
if (!ff)
f[1][0][0] = f[1][1][0] = 1;
else if (c[d[1]][i].x < 0)
f[1][0][1] = f[1][1][0] = 1;
else
f[1][0][0] = f[1][1][1] = 1;
for (i = 2; i <= cnt; i++)
for (j = 0; j <= 1; j++)
for (k = 0; k <= 1; k++)
if (f[i - 1][j][k]) {
last = j;
for (kk = head[d[i]]; kk; kk = a[kk].next)
if (a[kk].to == d[i - 1]) break;
kk = a[kk].i;
kkk = 0;
if (c[d[i]][1].f == 1) kkk = 1;
if (c[d[i]][2].f == 1) kkk = 2;
if (kkk && c[d[i]][kkk].x < 0)
hiahia = 1;
else
hiahia = 0;
if (kkk) kkk = 1;
if (abs(b[kk][1]) == d[i - 1]) {
if (b[kk][1] < 0) last ^= 1;
if (b[kk][2] < 0)
now = 1;
else
now = 0;
f[i][0][((0 ^ now) | last) ^ (kkk * hiahia) ^ k] +=
f[i - 1][j][k];
f[i][0][((0 ^ now) | last) ^ (kkk * hiahia) ^ k] %= 1000000007;
f[i][1][((1 ^ now) | last) ^ (kkk * (1 ^ hiahia)) ^ k] +=
f[i - 1][j][k];
f[i][1][((1 ^ now) | last) ^ (kkk * (1 ^ hiahia)) ^ k] %=
1000000007;
} else {
if (b[kk][2] < 0) last ^= 1;
if (b[kk][1] < 0)
now = 1;
else
now = 0;
f[i][0][((0 ^ now) | last) ^ (kkk * hiahia) ^ k] +=
f[i - 1][j][k];
f[i][0][((0 ^ now) | last) ^ (kkk * hiahia) ^ k] %= 1000000007;
f[i][1][((1 ^ now) | last) ^ (kkk * (1 ^ hiahia)) ^ k] +=
f[i - 1][j][k];
f[i][1][((1 ^ now) | last) ^ (kkk * (1 ^ hiahia)) ^ k] %=
1000000007;
}
}
val[sum][1] = (f[cnt][1][1] + f[cnt][0][1]) % 1000000007;
val[sum][0] = (f[cnt][0][0] + f[cnt][1][0]) % 1000000007;
for (i = 1; i <= cnt; i++)
f[i][0][1] = f[i][0][0] = f[i][1][1] = f[i][1][0] = 0;
}
for (S = 1; S <= m; S++)
if (!vis[S]) {
if (!len[S]) {
ans *= 2;
ans %= 1000000007;
continue;
}
sum++;
cnt = 0;
dfs(S, -1);
f[1][0][0] = 1;
for (i = 2; i <= cnt; i++)
for (j = 0; j <= 1; j++)
for (k = 0; k <= 1; k++)
if (f[i - 1][j][k]) {
last = j;
for (kk = head[d[i]]; kk; kk = a[kk].next)
if (a[kk].to == d[i - 1]) break;
kk = a[kk].i;
if (abs(b[kk][1]) == d[i - 1]) {
if (b[kk][1] < 0) last ^= 1;
if (b[kk][2] < 0)
now = 1;
else
now = 0;
f[i][0][((0 ^ now) | last) ^ k] += f[i - 1][j][k];
f[i][0][((0 ^ now) | last) ^ k] %= 1000000007;
f[i][1][((1 ^ now) | last) ^ k] += f[i - 1][j][k];
f[i][1][((1 ^ now) | last) ^ k] %= 1000000007;
} else {
if (b[kk][2] < 0) last ^= 1;
if (b[kk][1] < 0)
now = 1;
else
now = 0;
f[i][0][((0 ^ now) | last) ^ k] += f[i - 1][j][k];
f[i][0][((0 ^ now) | last) ^ k] %= 1000000007;
f[i][1][((1 ^ now) | last) ^ k] += f[i - 1][j][k];
f[i][1][((1 ^ now) | last) ^ k] %= 1000000007;
}
}
for (kk = head[d[cnt]]; kk; kk = a[kk].next)
if (a[kk].to == d[1]) break;
kk = a[kk].i;
now = 0;
if (abs(b[kk][1]) == d[cnt]) {
if (b[kk][1] < 0) now = 1;
} else if (b[kk][2] < 0)
now = 1;
for (i = 0; i <= 1; i++) {
hiahia = (i | (0 ^ now));
for (j = 0; j <= 1; j++) {
val[sum][j ^ hiahia] += f[cnt][i][j];
val[sum][j ^ hiahia] %= 1000000007;
}
}
for (i = 1; i <= cnt; i++)
f[i][0][1] = f[i][0][0] = f[i][1][1] = f[i][1][0] = 0;
f[1][1][0] = 1;
for (i = 2; i <= cnt; i++)
for (j = 0; j <= 1; j++)
for (k = 0; k <= 1; k++)
if (f[i - 1][j][k]) {
last = j;
for (kk = head[d[i]]; kk; kk = a[kk].next)
if (a[kk].to == d[i - 1]) break;
kk = a[kk].i;
if (abs(b[kk][1]) == d[i - 1]) {
if (b[kk][1] < 0) last ^= 1;
if (b[kk][2] < 0)
now = 1;
else
now = 0;
f[i][0][((0 ^ now) | last) ^ k] += f[i - 1][j][k];
f[i][0][((0 ^ now) | last) ^ k] %= 1000000007;
f[i][1][((1 ^ now) | last) ^ k] += f[i - 1][j][k];
f[i][1][((1 ^ now) | last) ^ k] %= 1000000007;
} else {
if (b[kk][2] < 0) last ^= 1;
if (b[kk][1] < 0)
now = 1;
else
now = 0;
f[i][0][((0 ^ now) | last) ^ k] += f[i - 1][j][k];
f[i][0][((0 ^ now) | last) ^ k] %= 1000000007;
f[i][1][((1 ^ now) | last) ^ k] += f[i - 1][j][k];
f[i][1][((1 ^ now) | last) ^ k] %= 1000000007;
}
}
for (kk = head[d[cnt]]; kk; kk = a[kk].next)
if (a[kk].to == d[1]) break;
kk = a[kk].i;
now = 0;
if (abs(b[kk][1]) == d[cnt]) {
if (b[kk][1] < 0) now = 1;
} else if (b[kk][2] < 0)
now = 1;
for (i = 0; i <= 1; i++) {
hiahia = (i | (1 ^ now));
for (j = 0; j <= 1; j++) {
val[sum][j ^ hiahia] += f[cnt][i][j];
val[sum][j ^ hiahia] %= 1000000007;
}
}
for (i = 1; i <= cnt; i++)
f[i][0][1] = f[i][0][0] = f[i][1][1] = f[i][1][0] = 0;
}
for (i = 1; i <= sum; i++) {
g[i][0] = (1ll * g[i - 1][0] * val[i][0] + 1ll * g[i - 1][1] * val[i][1]) %
1000000007;
g[i][1] = (1ll * g[i - 1][1] * val[i][0] + 1ll * g[i - 1][0] * val[i][1]) %
1000000007;
}
write(1ll * ans * g[sum][1] % 1000000007);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t) {
t--;
long long n, k;
cin >> n >> k;
vector<long long> x(n);
for (long long i = 0; i < n; i++) {
cin >> x[i];
}
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
}
sort(x.begin(), x.end());
vector<long long> dp(n);
dp[0] = 1;
deque<long long> dq, dq2;
dq.push_back(0);
long long ans = 1;
long long last = -1;
for (long long i = 1; i < n; i++) {
long long curr = x[i];
while (!dq.empty() && (curr - x[dq.front()]) > k) {
last = dq.front();
dq.pop_front();
}
dq.push_back(i);
dp[i] = dq.size();
ans = max(ans, dp[i] + ((last == -1) ? 0 : dp[last]));
dp[i] = max(dp[i], dp[i - 1]);
}
cout << ans << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 2e5 + 10;
const long long inf = 1e18;
const int maxm = 1005;
vector<vector<char>> matrix(maxm, vector<char>(maxm));
struct event {
int x, y, size;
};
int dx[] = {0, 0, 1, -1};
int dy[] = {-1, 1, 0, 0};
class even {
public:
int a, b, c;
};
class evenl {
public:
int a, b, c, ind;
};
struct myComp {
constexpr bool operator()(evenl f, evenl s) const noexcept {
int z = f.b - f.a;
int z2 = s.b - s.a;
z -= f.c;
z2 -= s.c;
return z < z2;
}
};
long long poww(long long a, long long b, long long m) {
if (b == 0) return 1ll;
if (b % 2 == 1) return a * poww(a, b - 1, m) % m;
long long rs = poww(a, b / 2, m);
rs = rs * rs % m;
return rs;
}
long long fact[N];
long long ncr(long long n, long long r) {
long long num = fact[n];
long long deno = fact[n - r] * fact[r] % mod;
deno = poww(deno, mod - 2, mod);
num = num * deno;
num = num % mod;
return num;
}
long long convert(long long a, long long b) {
string s;
while (a > 0) {
long long p = a % b;
s += p + '0';
a = a / b;
}
reverse(s.begin(), s.end());
long long res = stoi(s);
return res;
}
long long make(long long a, long long b, long long c) {
while (a < b) a *= c;
return a % b;
}
long long frog_jump(long long pos, long long n) {
while (pos % 2 == 0) {
pos = pos + (n - pos / 2);
}
return (pos + 1) / 2;
}
void solve() {
long long n, q;
cin >> n >> q;
for (int i = 0; i < q; i++) {
long long x;
cin >> x;
if (x % 2 != 0) {
cout << (x + 1) / 2 << "\n";
continue;
}
long long z = frog_jump(x, n);
cout << z << "\n";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long lft, rgt, k, n, rd;
string s;
int main() {
cin >> n >> k;
lft = 1, rgt = n;
for (;;) {
while (rgt - lft + 1 > 8 * k) {
long long mid = (rgt + lft) / 2;
cout << lft << ' ' << mid << '\n';
fflush(stdout);
cin >> s;
if ((s == "Yes") && (lft == mid)) return 0;
if (s == "Yes")
lft = max(lft - k, 1LL), rgt = min(n, mid + k);
else
lft = max(mid + 1 - k, 1LL), rgt = min(rgt + k, n);
}
long long x = (rd % (rgt - lft + 1)) + lft;
rd++;
cout << x << ' ' << x << '\n';
fflush(stdout);
cin >> s;
if (s == "Yes") return 0;
lft = max(lft - k, 1LL);
rgt = min(rgt + k, n);
}
return 0;
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.