solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1e6;
int tree[4 * maxn];
int tp[4 * maxn];
struct seg_tree {
void init(int v, int l, int r) {
tree[v] = r - l;
if (r == l + 1) return;
int m = (r + l) / 2;
init(2 * v + 1, l, m);
init(2 * v + 2, m, r);
}
seg_tree(int n) {
for (int i = 0; i < 4 * n; i++) tp[i] = 1;
init(0, 0, n);
}
inline void push(int v, int l, int r) {
if (tp[v] == 1) return;
tree[v] = ((long long)tree[v] * tp[v]) % mod;
if (r > l + 1) {
tp[2 * v + 1] = ((long long)tp[2 * v + 1] * tp[v]) % mod;
tp[2 * v + 2] = ((long long)tp[2 * v + 2] * tp[v]) % mod;
}
tp[v] = 1;
}
int seg_mult(int v, int l, int r, int tl, int tr, int val) {
push(v, l, r);
if (r <= tl || l >= tr) return tree[v];
if (l >= tl && r <= tr) {
tp[v] = val;
push(v, l, r);
return tree[v];
}
int m = (r + l) / 2;
return tree[v] = (seg_mult(2 * v + 1, l, m, tl, tr, val) +
seg_mult(2 * v + 2, m, r, tl, tr, val)) %
mod;
}
int seg_sum(int v, int l, int r, int tl, int tr) {
push(v, l, r);
if (r <= tl || l >= tr) return 0;
if (l >= tl && r <= tr) return tree[v];
int m = (r + l) / 2;
return (seg_sum(2 * v + 1, l, m, tl, tr) +
seg_sum(2 * v + 2, m, r, tl, tr)) %
mod;
}
};
int32_t main() {
int n, k;
cin >> n >> k;
seg_tree dp(n);
long long fak = 1;
for (int i = 1; i < n; i++) {
fak *= i + 1;
fak %= mod;
int ndp = dp.seg_sum(0, 0, n, max(0, i - k), i);
dp.seg_mult(0, 0, n, 0, i, i);
dp.seg_mult(0, 0, n, i, i + 1, ndp);
}
cout << (fak - dp.seg_sum(0, 0, n, 0, n) + mod) % mod;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 0;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 1; i < n - 1; i++)
if ((a[i] > a[i - 1] && a[i] > a[i + 1]) ||
(a[i] < a[i - 1] && a[i] < a[i + 1]))
ans++;
cout << ans;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
const long long MOD = 1e9 + 9;
bool isPrime(long long x) {
for (int i = 2; i * i <= x; i++)
if (x % i == 0) return false;
return true;
}
double dist(double a, double b, double c, double d) {
return sqrt((c - a) * (c - a) + (d - b) * (d - b));
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.precision(10);
cout << fixed;
srand(time(0));
int n, k, a, b, q;
cin >> n >> k >> a >> b >> q;
vector<int> sega(2 * n + 5), segb(2 * n + 5);
auto geta = [&](int l, int r) {
int res = 0;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) {
res += sega[l++];
}
if (r & 1) {
res += sega[--r];
}
}
return res;
};
auto getb = [&](int l, int r) {
int res = 0;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) {
res += segb[l++];
}
if (r & 1) {
res += segb[--r];
}
}
return res;
};
auto updatea = [&](int pos, int x) {
pos += n;
for (sega[pos] = min(a, sega[pos] + x); pos > 1; pos >>= 1) {
sega[pos >> 1] = sega[pos] + sega[pos ^ 1];
}
};
auto updateb = [&](int pos, int x) {
pos += n;
for (segb[pos] = min(b, segb[pos] + x); pos > 1; pos >>= 1) {
segb[pos >> 1] = segb[pos] + segb[pos ^ 1];
}
};
while (q--) {
int t;
cin >> t;
if (t == 1) {
int p, x;
cin >> p >> x;
p--;
updatea(p, x);
updateb(p, x);
} else {
int ans, p;
cin >> p;
p--;
ans = getb(0, p) + geta(p + k, n);
cout << ans << "\n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[300005];
int main() {
int n, m, i, l, r, x;
set<int> s;
cin >> n >> m;
for (i = 1; i <= n; i++) s.insert(i);
for (i = 1; i <= m; i++) {
scanf("%d%d%d", &l, &r, &x);
for (set<int>::iterator it = s.lower_bound(l);
it != s.end() && (*it) <= r;) {
if (*it != x) {
a[*it] = x;
s.erase(it++);
} else
it++;
}
}
for (i = 1; i <= n; i++) printf("%d ", a[i]);
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long infl = 0x3f3f3f3f3f3f3f3fLL;
const long long infi = 0x3f3f3f3f;
mt19937_64 mt(chrono::steady_clock::now().time_since_epoch().count());
const long long mod = 1e9 + 7;
const long long N = 2e5 + 5;
void solve() {
long long n, x, y, dne;
cin >> n >> x >> y;
vector<long long> a(n), b(n);
vector<vector<long long>> g(n + 2);
for (long long i = 0; i < n; i++) {
cin >> a[i];
g[a[i]].push_back(i);
}
priority_queue<pair<long long, long long>> q;
for (long long i = 1; i <= n + 1; i++) {
if (((long long)g[i].size()))
q.push({((long long)g[i].size()), i});
else
dne = i;
}
for (long long i = 1; i <= x; i++) {
pair<long long, long long> p = q.top();
q.pop();
long long col = p.second;
b[g[col].back()] = a[g[col].back()];
g[col].pop_back();
if (((long long)g[col].size())) q.push({((long long)g[col].size()), col});
}
long long z = y - x, mx = 0;
if (z < 0) {
cout << "NO" << '\n';
return;
}
vector<pair<long long, long long>> v;
for (long long i = 1; i <= n + 1; i++) {
for (auto &pos : g[i]) v.push_back({i, pos});
mx = max(mx, ((long long)g[i].size()));
}
for (long long i = 0; i < ((long long)v.size()); i++) {
long long col = v[i].first;
long long pos = (i + mx) % ((long long)v.size());
if (z && v[pos].first ^ col) {
b[v[pos].second] = col;
z--;
} else
b[v[pos].second] = dne;
}
if (z) {
cout << "NO" << '\n';
return;
}
cout << "YES" << '\n';
for (long long i = 0; i < n; i++) cout << b[i] << " ";
cout << '\n';
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
long long t = 1;
cin >> t;
while (t--) solve();
return 0;
}
long long powm(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;
}
long long divide(long long a, long long b) {
return (a % mod) * powm(b, mod - 2) % mod;
}
long long norm(long long a) {
while (a >= mod) a -= mod;
while (a < 0) a += mod;
return a;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
| 8 |
#include <bits/stdc++.h>
using namespace std;
int cluster[201], order[201];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
int s;
cin >> s;
for (int j = 0; j < s; ++j) {
int a;
cin >> a;
cluster[a] = i;
order[a] = j;
}
}
vector<int> x, y;
int free = 1;
for (int i = 1; i <= n; ++i) {
if (cluster[i] == 0) free = i;
}
for (int i = 1; i < n; ++i) {
int id = i;
for (int j = i; j <= n; ++j) {
if ((cluster[id] == 0 || cluster[id] > cluster[j]) && cluster[j] != 0)
id = j;
}
for (int j = i; j <= n; ++j)
if (cluster[id] == cluster[j] && order[j] < order[id]) id = j;
if (id == i || cluster[id] == 0) continue;
if (cluster[i] != 0) {
x.push_back(i);
y.push_back(free);
}
x.push_back(id);
y.push_back(i);
swap(cluster[i], cluster[free]);
swap(order[i], order[free]);
swap(cluster[id], cluster[i]);
swap(order[id], order[i]);
free = id;
}
cout << x.size() << '\n';
for (int i = 0; i < x.size(); ++i) cout << x[i] << ' ' << y[i] << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bitset<50> q;
int main(int argc, char** argv) {
long n;
cin >> n;
q = n;
bool isFirst = false;
for (int i = 50; i >= 0; i--) {
if (q[i] != 0) {
isFirst = true;
}
if (q[i] != 0 && isFirst) {
cout << i + 1 << " ";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const int P = 543577;
int n;
struct edge {
int x, nxt;
} e[N * 2];
int h[N], tot;
int r[N];
unsigned long long f[N], g[N];
int fa[N];
bool vis[N];
set<unsigned long long> s;
int lef[N], rig[N];
unsigned long long a[N];
int k;
int siz[N];
void inse(int x, int y) {
e[++tot].x = y;
e[tot].nxt = h[x];
h[x] = tot;
}
void calcf(int x) {
vis[x] = 1;
siz[x] = 1;
for (int p = h[x]; p; p = e[p].nxt)
if (!vis[e[p].x]) {
fa[e[p].x] = x;
calcf(e[p].x);
siz[x] += siz[e[p].x];
rig[e[p].x] = lef[x];
lef[x] = e[p].x;
}
k = 0;
for (int y = lef[x]; y; y = rig[y]) a[++k] = f[y];
sort(a + 1, a + 1 + k);
f[x] = 0;
for (int i = 1; i <= k; i++) f[x] = f[x] * P + a[i] + 1;
f[x] = f[x] * P + siz[x];
}
void calcg(int x) {
for (int y = lef[x]; y; y = rig[y]) {
k = 0;
if (x > 1) a[k = 1] = g[x];
for (int u = lef[x]; u; u = rig[u])
if (u != y) a[++k] = f[u];
sort(a + 1, a + 1 + k);
g[y] = 0;
for (int i = 1; i <= k; i++) g[y] = g[y] * P + a[i] + 1;
g[y] = g[y] * P + n - siz[y];
calcg(y);
}
}
void calc() {
int ans = 0;
s.clear();
for (int x = 1; x <= n; x++) {
if (r[x] >= 4) continue;
a[k = 1] = 1;
if (x > 1) a[++k] = g[x];
for (int y = lef[x]; y; y = rig[y]) a[++k] = f[y];
sort(a + 1, a + 1 + k);
long long val = 0;
for (int i = 1; i <= k; i++) val = val * P + a[i] + 1;
val = val * P + n + 1;
if (s.find(val) == s.end()) {
ans++;
s.insert(val);
}
}
printf("%d\n", ans);
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
inse(x, y);
inse(y, x);
r[x]++, r[y]++;
}
calcf(1);
g[1] = 0;
calcg(1);
calc();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll MOD = 1e9 + 7;
const int N = 200;
struct Mat {
bool data[N][N];
bool f_row[N];
bool f_col[N];
int w, h, ones;
Mat(int h, int w) {
this->w = w;
this->h = h;
ones = 0;
for (int i = 0; i < N; ++i) {
f_row[i] = 0;
f_col[i] = 0;
for (int j = 0; j < N; ++j) {
data[i][j] = 0;
}
}
}
void set(int y, int x, int v) {
ones -= data[y][x] - v;
data[y][x] = v;
}
bool get(int y, int x) { return data[y][x]; }
void flip(int y, int x) { set(y, x, get(y, x) ^ 1); }
void flipCol(int x) {
for (int y = 0; y < h; ++y) flip(y, x);
f_col[x] ^= 1;
}
void flipRow(int y) {
for (int x = 0; x < w; ++x) flip(y, x);
f_row[y] ^= 1;
}
void print() {
cout << "YES\n";
for (int y = 0; y < h; ++y) cout << f_row[y];
cout << '\n';
for (int x = 0; x < w; ++x) cout << f_col[x];
cout << '\n';
}
};
void fixCols(Mat& m) {
for (int y = 1; y < m.h; ++y) {
if (m.get(y, 0)) m.flipRow(y);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int h, w;
cin >> h >> w;
Mat m1(h, w);
Mat m2(h, w);
for (int y = 0; y < h; ++y) {
for (int x = 0; x < w; ++x) {
int b;
cin >> b;
m1.set(y, x, b);
m2.set(y, x, b);
}
}
m2.flipRow(0);
for (int x = 0; x < w; ++x) {
if (m1.get(0, x)) m1.flipCol(x);
if (m2.get(0, x)) m2.flipCol(x);
}
fixCols(m1);
fixCols(m2);
for (int i = h * w - 1; i >= -1; --i) {
if (m1.ones == 0) {
m1.print();
return 0;
} else if (m2.ones == 0) {
m2.print();
return 0;
} else {
if (i == -1) {
cout << "NO\n";
return 0;
}
int x = i % w;
int y = i / w;
m1.flip(y, x);
m2.flip(y, x);
if (y == 0) {
if (m1.get(y, x)) {
m1.flipCol(x);
if (x == 0) fixCols(m1);
}
if (m2.get(y, x)) {
m2.flipCol(x);
if (x == 0) fixCols(m2);
}
} else if (x == 0) {
if (m1.get(y, x)) {
m1.flipRow(y);
}
if (m2.get(y, x)) {
m2.flipRow(y);
}
}
}
}
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:512000000")
using namespace std;
void solve();
void precalc();
clock_t start;
int testNumber = 1;
bool todo = true;
int main() {
start = clock();
int t = 1;
cout.sync_with_stdio(0);
cin.tie(0);
precalc();
cout.precision(10);
cout << fixed;
int testNum = 1;
while (t--) {
solve();
++testNumber;
}
return 0;
}
template <typename T>
T binpow(T q, T w, T mod) {
if (!w) return 1 % mod;
if (w & 1) return q * 1LL * binpow(q, w - 1, mod) % mod;
return binpow(q * 1LL * q % mod, w / 2, mod);
}
void precalc() {}
template <typename T>
T gcd(T q, T w) {
while (w) {
q %= w;
swap(q, w);
}
return q;
}
template <typename T>
T lcm(T q, T w) {
return q / gcd(q, w) * w;
}
struct Line {
long double a, b;
long double border;
};
vector<int> uk;
vector<vector<Line>> lines;
void append(int id, Line new_line) {
while (!lines[id].empty()) {
Line last = lines[id].back();
long double x = (last.a - new_line.a) / (last.b - new_line.b);
if (x < last.border) {
lines[id].pop_back();
if (uk[id] >= lines[id].size() && uk[id] > 0) {
--uk[id];
}
} else {
new_line.border = x;
break;
}
}
if (lines[id].empty()) {
new_line.border = 0;
}
lines[id].push_back(new_line);
}
long double get_val(const Line& line, long double x) {
return line.a - line.b * x;
}
void solve() {
int n, k;
cin >> n >> k;
vector<int> t(n);
for (int i = 0; i < n; ++i) {
cin >> t[i];
}
vector<vector<long double>> dp(n + 1, vector<long double>(k + 1, 4e18));
dp[0][0] = 0;
uk.assign(k + 1, 0);
lines.resize(k + 1);
lines[0].push_back({0, 0, 0});
vector<long double> pref_sum(n + 1);
for (int i = 0; i < n; ++i) {
pref_sum[i + 1] = pref_sum[i] + t[i];
}
vector<long double> sum_obr(n + 1);
for (int i = 0; i < n; ++i) {
sum_obr[i + 1] = sum_obr[i] + 1.0 / t[i];
}
vector<long double> sum_vals(n + 1);
for (int i = 0; i < n; ++i) {
sum_vals[i + 1] = sum_vals[i] + pref_sum[i + 1] / 1.0 / t[i];
}
for (int i = 0; i < n; ++i) {
for (int used = k - 1; used >= 0; --used) {
while (uk[used] + 1 < lines[used].size() &&
get_val(lines[used][uk[used]], sum_obr[i + 1]) >
get_val(lines[used][uk[used] + 1], sum_obr[i + 1])) {
++uk[used];
}
if (uk[used] < lines[used].size()) {
dp[i + 1][used + 1] =
sum_vals[i + 1] + get_val(lines[used][uk[used]], sum_obr[i + 1]);
append(used + 1, {dp[i + 1][used + 1] - sum_vals[i + 1] +
sum_obr[i + 1] * pref_sum[i + 1],
pref_sum[i + 1], 4e18});
}
}
}
cout << dp[n][k] << "\n";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
pair<int, int> arr[105];
vector<int> v;
int main() {
ios_base::sync_with_stdio(0);
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, k, m = 0, sum = 0;
cin >> n >> k;
for (int i = 0; i < n; ++i) cin >> arr[i].first, arr[i].second = i + 1;
sort(arr, arr + n);
for (int i = 0; i < n; ++i)
if (sum + arr[i].first <= k)
m++, v.push_back(arr[i].second), sum += arr[i].first;
cout << m << "\n";
for (int i = 0; i < m; ++i) cout << v[i] << " ";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char s[2010][2010];
int preR[2010][2010];
int preC[2010][2010];
long long dp[2010][2010][2];
long long dpR[2010][2010];
long long dpC[2010][2010];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
scanf("%s", s[i]);
}
for (int i = n - 1; i >= 0; i--) {
for (int j = m - 1; j >= 0; j--) {
preR[i][j] = preR[i][j + 1];
preC[i][j] = preC[i + 1][j];
preR[i][j] += s[i][j] == 'R';
preC[i][j] += s[i][j] == 'R';
}
}
int mod = 1e9 + 7;
if (s[n - 1][m - 1] == 'R') {
cout << 0;
return 0;
}
dp[n - 1][m - 1][0] = 1;
dpR[n - 1][m - 1] = 1;
dpC[n - 1][m - 1] = 1;
dp[n - 1][m - 1][1] = 1;
int x = 1;
for (int i = n - 2; i >= 0; i--) {
int j = m - 1;
if (s[i][j] == 'R') x = 0;
dp[i][j][0] = x;
dp[i][j][1] = x;
dpR[i][j] = dpR[i][j + 1];
dpC[i][j] = dpC[i + 1][j];
dpR[i][j] += dp[i][j][0];
dpR[i][j] %= mod;
dpC[i][j] += dp[i][j][1];
dpC[i][j] %= mod;
}
x = 1;
for (int j = m - 2; j >= 0; j--) {
int i = n - 1;
if (s[i][j] == 'R') x = 0;
dp[i][j][0] = x;
dp[i][j][1] = x;
dpR[i][j] = dpR[i][j + 1];
dpC[i][j] = dpC[i + 1][j];
dpR[i][j] += dp[i][j][0];
dpR[i][j] %= mod;
dpC[i][j] += dp[i][j][1];
dpC[i][j] %= mod;
}
for (int i = n - 2; i >= 0; i--) {
for (int j = m - 2; j >= 0; j--) {
if (preC[i][j] < n - i) {
int nm = preC[i][j];
nm = n - i - nm;
long long r = dpC[i + 1][j + 1] - dpC[i + nm][j + 1];
if (!nm) r = 0;
r %= mod;
r += mod;
r %= mod;
dp[i][j][0] += r;
dp[i][j][0] %= mod;
nm = preR[i][j] - (s[i][j] == 'R');
nm = m - j - nm;
r = dpR[i + 1][j + 1] - dpR[i + 1][j + nm];
if (!nm) r = 0;
r %= mod;
r += mod;
r %= mod;
dp[i][j][0] += r;
dp[i][j][0] %= mod;
}
if (preR[i][j] < m - j) {
int nm = preC[i][j] - (s[i][j] == 'R');
nm = n - i - nm;
long long r = dpC[i + 1][j + 1] - dpC[i + nm][j + 1];
if (!nm) r = 0;
r %= mod;
r += mod;
r %= mod;
dp[i][j][1] += r;
dp[i][j][1] %= mod;
nm = preR[i][j];
nm = m - j - nm;
r = dpR[i + 1][j + 1] - dpR[i + 1][j + nm];
if (!nm) r = 0;
r %= mod;
r += mod;
r %= mod;
dp[i][j][1] += r;
dp[i][j][1] %= mod;
}
dpR[i][j] = dpR[i][j + 1];
dpC[i][j] = dpC[i + 1][j];
dpR[i][j] += dp[i][j][0];
dpR[i][j] %= mod;
dpC[i][j] += dp[i][j][1];
dpC[i][j] %= mod;
}
}
cout << dp[0][0][0] << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
long long s, sum;
int T, n;
pair<int, int> L[N];
bool judge(long long val) {
long long v = s;
int num = (n + 1) / 2;
for (int i = 1; i <= n; i++) {
v -= L[i].first;
if (L[i].first >= val) num--;
}
vector<int> cost;
for (int i = 1; i <= n; i++) {
if (L[i].first < val and L[i].second >= val) {
cost.push_back(val - L[i].first);
}
}
sort(cost.begin(), cost.end());
if (cost.size() < num) return false;
for (int i = 0; i < num; i++) v -= cost[i];
return v >= 0;
}
int main() {
cin >> T;
while (T--) {
cin >> n >> s;
sum = 0;
for (int i = 1; i <= n; i++)
cin >> L[i].first >> L[i].second, sum += L[i].first;
sort(L + 1, L + 1 + n);
int mid = (n + 1) / 2;
long long l = L[mid].first, r = 1e10;
long long ans = l;
while (l <= r) {
long long m = (l + r) / 2;
if (judge(m)) {
ans = max(ans, m);
l = m + 1;
} else {
r = m - 1;
}
}
cout << ans << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string ans = "YES";
vector<string> chess(8);
for (int i = 0; i < 8; i++) cin >> chess[i];
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
if (chess[i][j] == chess[i][j + 1]) {
ans = "NO";
break;
}
}
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 23;
int a[maxn];
int tmp[2][1 << maxn], *d = tmp[0], *dn = tmp[1];
int cur[maxn];
void update(int &x, int val) {
if (x == -1 || x > val) x = val;
}
int main() {
int n;
while (scanf("%d", &n) >= 1) {
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
d[0] = -1;
d[1] = 1;
for (int pos = 1; pos < n; pos++) {
int r = 0;
for (int i = 0; i < pos; i++)
for (int j = i; j < pos; j++)
if (a[i] + a[j] == a[pos]) cur[r++] = ((1 << i) | (1 << j));
memset(dn, -1, sizeof(dn[0]) * (1 << (pos + 1)));
for (int mask = 0; mask < (1 << pos); mask++) {
if (d[mask] == -1) continue;
bool ok = 0;
for (int i = 0; i < r; i++) {
if ((mask & cur[i]) != cur[i]) continue;
ok = 1;
break;
}
if (!ok) continue;
for (int i = 0; i < pos; i++) {
if (!((mask >> i) & 1)) continue;
update(dn[mask ^ (1 << i) ^ (1 << pos)], d[mask]);
}
update(dn[mask ^ (1 << pos)], d[mask] + 1);
}
swap(d, dn);
}
int ans = n + 1;
for (int i = 0; i < (1 << n); i++)
if (d[i] != -1) ans = min(ans, d[i]);
printf("%d\n", ans == n + 1 ? -1 : ans);
}
return 0;
}
| 7 |
#include <stdio.h>
// #include <iostream>
#include <algorithm>
// #include <cmath>
// #include <string>
// #include <string.h>
// #include <vector>
// #include <bits/stdc++.h>
using namespace std;
// const int INF32 = 2000000000;
// const int INF64 = 2000000000000000000;
// const int MOD17 = 1000000007;
int tc, n, arr[200002];
int main(){
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
scanf("%d", &tc);
while(tc--){
scanf("%d", &n);
for(int i = 0; i < n; i++){
scanf("%d", &arr[i]);
}
if(n == 1 || n == 2){
printf("0\n");
continue;
}
sort(arr, arr+n);
int j = 0;
long long ans = 0;
for(int i = 0; i < n; i++){
if(j < i) j = i;
while(j+1 < n && arr[j+1] - arr[i] <= 2) j++;
if(j - i > 1){
ans += (long long) (j-i-1)*(j-i)>>1;
}
}
printf("%lld\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << ' ' << H;
debug_out(T...);
}
const long long INF = 1e18;
const long long MOD = 1e9 + 7;
const int N = 1e5 + 2, K = 1e4 + 2;
int n, m, k, C[N];
bool M[N];
long long h, A[N], D[K];
set<pair<int, int> > S, T;
priority_queue<pair<int, int> > PQ;
vector<pair<int, int> > G[N];
void Dijkstra() {
for (int i = 0; i < k; i++) D[i] = INF;
D[0] = 0;
S.insert(make_pair(0, 0));
while (!S.empty()) {
int v = S.begin()->second;
S.erase(S.begin());
for (auto [u, w] : G[v])
if (D[v] + w < D[u]) {
S.erase(make_pair(D[u], u));
D[u] = D[v] + w;
S.insert(make_pair(D[u], u));
}
}
}
void AddEdge(int v, int u, int w) { G[v].push_back(make_pair(u, w)); }
bool Reach(long long x) { return D[x % k] <= x / k; }
void AddJump(long long x) {
for (int i = 0; i < k; i++)
G[i].push_back(make_pair((i + x) % k, (i + x) / k));
S.clear();
Dijkstra();
for (int i = 0; i < n; i++)
if (!M[i] && Reach(A[i])) S.insert(make_pair(-C[i], i));
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
mt19937 Rnd(time(0));
cin >> h >> n >> m >> k;
for (int i = 0; i < n; i++) cin >> A[i] >> C[i], A[i]--;
AddJump(k);
while (m--) {
int t;
cin >> t;
if (t == 1) {
long long x;
cin >> x;
AddJump(x);
} else if (t == 2) {
int x, y;
cin >> x >> y, x--;
if (!M[x] && Reach(A[x]))
S.erase(make_pair(-C[x], x)), S.insert(make_pair(-C[x] + y, x));
C[x] -= y;
} else {
if (S.empty()) {
cout << 0 << '\n';
continue;
}
int x = S.begin()->second;
S.erase(S.begin());
M[x] = true;
cout << C[x] << '\n';
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, h, a[100005], cnt, out[100005], siz[100005], hd[100005], dfn[100005],
low[100005], tim, sd[100005];
struct node {
int from, to, next;
} e[200005];
int read() {
int f = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
f = f * 10 + ch - '0';
ch = getchar();
}
return f * w;
}
void addedge(int x, int y) {
e[++cnt].next = hd[x];
e[cnt].from = x;
e[cnt].to = y;
hd[x] = cnt;
}
stack<int> q;
int num;
bool vis[100005];
void tarjan(int x) {
q.push(x);
dfn[x] = low[x] = ++tim;
vis[x] = 1;
for (int i = hd[x]; i; i = e[i].next) {
int to = e[i].to;
if (vis[to]) {
low[x] = min(low[x], dfn[to]);
} else if (!dfn[to]) {
tarjan(to);
low[x] = min(low[x], low[to]);
}
}
if (dfn[x] == low[x]) {
num++;
while (!q.empty()) {
int xx = q.top();
q.pop();
siz[num]++;
sd[xx] = num;
vis[xx] = 0;
if (x == xx) {
break;
}
}
}
}
int main() {
n = read(), m = read(), h = read();
for (int i = 1; i <= n; i++) {
a[i] = read();
}
for (int i = 1; i <= m; i++) {
int x = read(), y = read();
if ((a[x] + 1) % h == a[y]) addedge(x, y);
if ((a[y] + 1) % h == a[x]) addedge(y, x);
}
for (int i = 1; i <= n; i++) {
if (!dfn[i]) tarjan(i);
}
for (int i = 1; i <= cnt; i++) {
if (sd[e[i].from] != sd[e[i].to]) {
out[sd[e[i].from]]++;
}
}
siz[0] = 0x3f3f3f3f;
int pos = 0;
for (int i = 1; i <= num; i++) {
if (siz[i] < siz[pos] && !out[i]) pos = i;
}
printf("%d\n", siz[pos]);
for (int i = 1; i <= n; i++) {
if (sd[i] == pos) printf("%d ", i);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.1415926535897932384626433832795;
const long long mod = 1000000007;
long long a[] = {1, 2, 9, 64, 625, 7776, 117649, 2097152};
int main() {
long long n, k;
cin >> n >> k;
long long ans = a[k - 1];
for (int i = (0); i < (n - k); ++i) {
ans *= (n - k);
ans %= mod;
}
cout << ans % mod << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
ostream& operator<<(ostream& str, const pair<int, int>& p) {
str << p.first << " " << p.second;
return str;
}
template <typename T>
void join(T& arr, string sep) {
bool first = true;
for (auto t : arr) {
if (first) {
first = false;
cout << t;
} else {
cout << sep << t;
}
}
cout << "\n";
}
const int md = 1e9 + 7;
int MOD(int x) {
int r = x % md;
if (r < 0) {
r += md;
}
return r;
}
void solve() {
int n, m, k;
cin >> n >> m >> k;
int res = 0;
vector<vector<pair<int, int>>> g(n);
for (int i = 0; i < (int)(m); ++i) {
int u, v, w;
cin >> u >> v >> w;
u--;
v--;
g[u].push_back({w, v});
}
vector<map<pair<int, int>, int>> inn(n);
for (int u = 0; u < (int)(n); ++u) {
if (g[u].empty()) {
cout << 0 << endl;
return;
}
sort(g[u].begin(), g[u].end());
for (int i = 0; i < (int)(g[u].size()); ++i) {
g[u][i].first = i + 1;
inn[g[u][i].second][{g[u].size(), i + 1}]++;
}
}
vector<vector<vector<vector<int>>>> bad(
k + 1, vector<vector<vector<int>>>(
k + 1, vector<vector<int>>(k + 1, vector<int>(k + 1, 0))));
for (int u = 0; u < (int)(n); ++u) {
if (inn[u].empty()) {
cout << 0 << endl;
return;
}
for (auto& kv1 : inn[u]) {
if (kv1.second > 1) {
bad[kv1.first.first][kv1.first.second][kv1.first.first]
[kv1.first.second] = 1;
}
for (auto& kv2 : inn[u]) {
if (kv1.first == kv2.first && kv1.second == kv2.second) continue;
bad[kv1.first.first][kv1.first.second][kv2.first.first]
[kv2.first.second] = 1;
}
}
}
vector<int> cur(k);
function<void(int)> permute = [&](int i) {
if (i >= k) {
bool success = true;
for (int ii = 0; ii < (int)(k); ++ii) {
for (int jj = (int)(ii + 1); jj < (int)(k); ++jj) {
if (bad[ii + 1][cur[ii]][ii + 1][cur[ii]] ||
bad[jj + 1][cur[jj]][jj + 1][cur[jj]]) {
success = false;
break;
}
if (bad[ii + 1][cur[ii]][jj + 1][cur[jj]] ||
bad[jj + 1][cur[jj]][ii + 1][cur[ii]]) {
success = false;
break;
}
}
if (!success) break;
}
if (success) res++;
return;
}
for (int j = (int)(1); j < (int)(i + 2); ++j) {
cur[i] = j;
permute(i + 1);
}
};
permute(0);
cout << res << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tt = 1;
for (int t = 1; t <= tt; t++) {
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
constexpr int maxn = 1 << 18;
struct IO {
private:
static constexpr int ibufsiz = 1 << 20;
char ibuf[ibufsiz + 1], *inow = ibuf, *ied = ibuf;
static constexpr int obufsiz = 1 << 20;
char obuf[obufsiz + 1], *onow = obuf;
const char *oed = obuf + obufsiz;
public:
char getchar() {
if (inow == ied) {
ied = ibuf + sizeof(char) * fread(ibuf, sizeof(char), ibufsiz, stdin);
*ied = '\0';
inow = ibuf;
}
return *inow++;
}
template <typename T>
void read(T &x) {
static bool flg;
flg = 0;
x = 0;
char c = getchar();
while (!isdigit(c)) flg = c == '-' ? 1 : flg, c = getchar();
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
if (flg) x = -x;
}
template <typename T, typename... Y>
void read(T &x, Y &...X) {
read(x);
read(X...);
}
int readi() {
static int res;
read(res);
return res;
}
long long readll() {
static long long res;
read(res);
return res;
}
void flush() {
fwrite(obuf, sizeof(char), onow - obuf, stdout);
fflush(stdout);
onow = obuf;
}
void putchar(const char c) {
*onow++ = c;
if (onow == oed) {
fwrite(obuf, sizeof(char), obufsiz, stdout);
onow = obuf;
}
}
template <typename T>
void write(T x, const char split = '\0') {
static unsigned char buf[32];
if (x < 0) putchar('-'), x = -x;
int p = 0;
do {
buf[++p] = x % 10;
x /= 10;
} while (x);
for (int i = p; i >= 1; i--) putchar(buf[i] + '0');
if (split != '\0') putchar(split);
}
void puts(char const *str, const char split = '\n') {
while (*str) putchar(*(str++));
putchar(split);
}
void lf() { putchar('\n'); }
~IO() { fwrite(obuf, sizeof(char), onow - obuf, stdout); }
} io;
long long ans;
int val[maxn], f[maxn], cnt[maxn], n;
void init() {
for (int i = 0; i < maxn; i++) f[i] = i;
}
int find(const int x) { return x == f[x] ? x : f[x] = find(f[x]); }
void merge(const int a, const int b) {
const int x = find(a), y = find(b);
f[x] = y;
}
int main() {
io.read(n);
for (int i = 1; i <= n; i++) io.read(val[i]), cnt[val[i]]++;
cnt[0]++;
init();
for (int w = (1 << 18) - 1; w >= 0; w--)
for (int s = w; s; s = (s - 1) & w) {
const int a = s, b = w ^ s;
if (!cnt[a] || !cnt[b]) continue;
if (find(a) == find(b)) continue;
merge(a, b);
ans += 1ll * w * (cnt[a] + cnt[b] - 1);
cnt[a] = cnt[b] = 1;
}
for (int i = 1; i <= n; i++) ans -= val[i];
io.write(ans, '\n');
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long mod = 1000000007;
int main() {
int tests;
cin >> tests;
string inp;
while (tests--) {
std::vector<pair<int, int> > ret;
inp.clear();
cin >> inp;
if (inp.find('X') != -1) ret.push_back(make_pair(1, 12));
for (int pos = 0; pos < 6; pos++)
if (inp[pos] == 'X' and inp[pos + 6] == 'X') {
ret.push_back(make_pair(2, 6));
break;
}
for (int pos = 0; pos < 4; pos++)
if (inp[pos] == 'X' and inp[pos + 4] == 'X' and inp[pos + 8] == 'X') {
ret.push_back(make_pair(3, 4));
break;
}
for (int pos = 0; pos < 3; pos++)
if (inp[pos] == 'X' and inp[pos + 3] == 'X' and inp[pos + 6] == 'X' and
inp[pos + 9] == 'X') {
ret.push_back(make_pair(4, 3));
break;
}
for (int pos = 0; pos < 2; pos++)
if (inp[pos] == 'X' and inp[pos + 2] == 'X' and inp[pos + 4] == 'X' and
inp[pos + 6] == 'X' and inp[pos + 8] == 'X' and
inp[pos + 10] == 'X') {
ret.push_back(make_pair(6, 2));
break;
}
if (inp.find('O') == -1) ret.push_back(make_pair(12, 1));
cout << int((ret).size());
(int((ret).size()) == 0) ? cout << "\n" : cout << " ";
for (int pos = 0; pos < int((ret).size()); pos++) {
cout << ret[pos].first << "x" << ret[pos].second;
(pos == int((ret).size()) - 1) ? cout << "\n" : cout << " ";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int font[3002];
int cost[3002];
int af[3002];
for (int i = 0; i < n; i++) {
cin >> font[i];
}
for (int i = 0; i < n; i++) {
cin >> cost[i];
}
for (int i = 0; i < n - 1; i++) {
int lw = 100000001;
int idx = -1;
for (int j = i + 1; j < n; j++) {
if (font[j] > font[i] && cost[j] < lw) {
idx = j;
lw = cost[j];
}
}
af[i] = idx;
}
int mincost = 2000000000;
for (int i = 0; i < n - 2; i++) {
for (int j = i + 1; j < n - 1; j++) {
if (font[i] < font[j]) {
int sum = cost[i] + cost[j];
if (af[j] != -1) {
sum += cost[af[j]];
if (sum < mincost) mincost = sum;
}
}
}
}
if (mincost != 2000000000)
cout << mincost;
else
cout << -1;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool lambs[101];
int main() {
int n, m;
cin >> n >> m;
while (n--) {
int x;
cin >> x;
while (x--) {
int y;
cin >> y;
lambs[y] = true;
}
}
for (int i = 1; i < m + 1; i++)
if (lambs[i] == false) {
cout << "NO";
return 0;
}
cout << "YES";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
int main() {
long long i;
scanf("%lld%lld", &n, &m);
for (i = 1; i <= n; i++) {
printf("%d", !(i % ((n - m) / 2 + 1)));
}
printf("\n");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int64_t power(int64_t a, int64_t b) {
int64_t ans = 1;
while (b) {
if (b & 1) {
ans = (ans * a) % (int64_t)(1e9 + 7);
}
a = (a * a) % (int64_t)(1e9 + 7);
b >>= 1;
}
return ans;
}
int64_t mmi(int64_t n) { return power(n, (int64_t)(1e9 + 7) - 2); }
int64_t two(int64_t n) { return (1LL << n); }
void onbit(int64_t &n, int64_t x) { n |= two(x); }
void offbit(int64_t &n, int64_t x) { n &= ~two(x); }
int64_t cntbit(int64_t n) {
int64_t res = 0;
while (n and ++res) n -= n & -n;
return res;
}
int64_t dx[] = {-1, 0, 1, 0}, dy[] = {0, -1, 0, 1};
int64_t n;
vector<pair<int64_t, int64_t> > v;
void solve() {
int64_t i;
cin >> n;
for (i = 0; i < n; i++) {
int64_t x, y;
cin >> x >> y;
v.push_back(make_pair(y, 1));
v.push_back(make_pair(x, 0));
}
sort(v.begin(), v.end());
int64_t cnt = 0;
for (i = 0; i < v.size(); i++) {
if (v[i].second == 0)
cnt++;
else
cnt--;
if (cnt > 2) {
cout << "NO";
return;
}
}
cout << "YES";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int64_t t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
bool isPrime(long long n) {
long long c;
if (n <= 1) return false;
c = sqrt(n);
for (int i = 2; i <= c; i++)
if (n % i == 0) return false;
return true;
}
const long long N = 1e6 + 7;
long long l, k, d, tr, n, m, sum, mini = 1e9 + 7, maxi, a, b, c, x, y;
long long t[N];
set<int> vis;
vector<int> v;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
for (long long i = 0; i < n; i++) {
cin >> t[i];
}
if (n - 1 >= k) {
mini = t[0];
for (int i = 1; i < n; i++) {
if (t[i] > mini) {
t[n + a] = mini;
a++;
mini = t[i];
} else {
t[n + a] = t[i];
a++;
}
}
t[a + n] = N;
for (int i = 0; i < n; i++) {
b = 1;
while (t[i] > t[i + b]) {
b++;
if (i) {
if (b == k) {
cout << t[i];
i = n + a;
break;
}
} else {
if (b - 1 == k) {
cout << t[i];
i = n + a;
break;
}
}
}
}
} else {
sort(t, t + n);
mini = t[n - 1];
cout << mini;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
char ch = getchar();
long long f = 1;
while (!isdigit(ch)) {
if (ch == '-') f *= -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - 48;
ch = getchar();
}
x *= f;
}
template <typename T, typename... Args>
void read(T &first, Args &...args) {
read(first);
read(args...);
}
template <typename T>
void write(T arg) {
T x = arg;
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) {
write(x / 10);
}
putchar(x % 10 + '0');
}
template <typename T, typename... Ts>
void write(T arg, Ts... args) {
write(arg);
if (sizeof...(args) != 0) {
putchar(' ');
write(args...);
}
}
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
const int N = 2e5 + 5;
int n, k;
int a[N], maxn[N][32], minn[N][32];
void getST() {
for (int i = 1; i <= n; ++i) maxn[i][0] = minn[i][0] = a[i];
for (int j = 1; (1 << j) <= n; ++j)
for (int i = 1; i + (1 << j) - 1 <= n; ++i) {
maxn[i][j] = max(maxn[i][j - 1], maxn[i + (1 << (j - 1))][j - 1]);
minn[i][j] = min(minn[i][j - 1], minn[i + (1 << (j - 1))][j - 1]);
}
}
int RMQMax(int l, int r) {
int k = log2(r - l + 1);
return max(maxn[l][k], maxn[r - (1 << k) + 1][k]);
}
int RMQMin(int l, int r) {
int k = log2(r - l + 1);
return min(minn[l][k], minn[r - (1 << k) + 1][k]);
}
vector<pair<int, int> > ve;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
int len = -1;
for (int i = 1; i <= n; i++) cin >> a[i];
getST();
for (int i = 1; i <= n; i++) {
int l = i, r = n + 1;
while (l < r) {
int mid = (l + r) >> 1;
if (RMQMax(i, mid) - RMQMin(i, mid) > k)
r = mid;
else
l = mid + 1;
}
if (l - i > len) {
ve.clear();
len = l - i;
ve.push_back(make_pair(i, l - 1));
} else if (l - i == len)
ve.push_back(make_pair(i, l - 1));
}
cout << len << ' ' << ve.size() << endl;
for (auto it : ve) cout << it.first << ' ' << it.second << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n;
if (n == 2) {
cout << 1 << '\n';
cout << 2 << '\n';
return 0;
}
if (n == 3) {
cout << 1 << '\n';
cout << 3 << '\n';
return 0;
}
if (n % 2 == 0) {
cout << n / 2 << '\n';
for (int i = 0; i <= n / 2 - 1; i += 1) cout << 2 << ' ';
cout << '\n';
} else {
cout << n / 2 << '\n';
for (int i = 0; i <= n / 2 - 1 - 1; i += 1) cout << 2 << ' ';
cout << 3 << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int d[2][51][51];
void dfs(string a[51], int i, int j1, int v, int n) {
int j = j1 - 1;
if (d[v][i][j1]) return;
d[v][i][j1] = 1;
if (i - 1 > 0 && a[i - 1][j] == '0') {
dfs(a, i - 1, j1, v, n);
}
if (i + 1 <= n && a[i + 1][j] == '0') {
dfs(a, i + 1, j1, v, n);
}
if (j1 - 1 > 0 && a[i][j - 1] == '0') {
dfs(a, i, j1 - 1, v, n);
}
if (j1 + 1 <= n && a[i][j + 1] == '0') {
dfs(a, i, j1 + 1, v, n);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int r[2], c[2];
cin >> r[0] >> c[0];
cin >> r[1] >> c[1];
string a[51];
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 0; i < 2; i++) {
dfs(a, r[i], c[i], i, n);
}
int ans = INT_MAX;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (d[0][i][j]) {
for (int k = 1; k <= n; k++) {
for (int l = 1; l <= n; l++) {
if (d[1][k][l]) {
ans = min(ans, (i - k) * (i - k) + (j - l) * (j - l));
}
}
}
}
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e7 + 5, INF = 1e18 + 7;
long long n, k, q, a[maxn];
bool mrk[maxn];
vector<long long> ans;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (long long i = 0; i < n; i++) cin >> a[i], mrk[a[i]] = true;
cin >> q;
while (q--) {
long long x, res = INF;
cin >> x;
for (long long i = 0; i < n; i++) {
long long j = k - 1, sum = x - a[i];
while (j >= 0 && sum >= 0) {
if (sum == 0)
res = min(res, k - j);
else {
for (long long o = 1; o <= j; o++) {
long long d = sum / o;
if (sum == d * o && d < maxn && mrk[d]) res = min(res, k - j + o);
}
}
j--;
sum -= a[i];
}
}
if (res == INF)
ans.push_back(-1);
else
ans.push_back(res);
}
for (long long i = 0; i < ans.size(); i++) cout << ans[i] << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int N, l[82], r[82], V[200];
double Ans[82], F[82][82];
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; ++i)
scanf("%d%d", l + i, r + i), V[++*V] = l[i], V[++*V] = r[i];
sort(V + 1, V + *V + 1);
*V = unique(V + 1, V + *V + 1) - V;
for (int i = 1; i <= N; ++i) {
memset(Ans, 0, sizeof Ans);
for (int j = 1, p, m, L, R; j < *V - 1; ++j)
if (l[i] <= V[j] && r[i] > V[j]) {
L = V[j];
R = V[j + 1];
memset(F, p = m = 0, sizeof F);
**F = 1;
for (int k = 1; k <= N; ++k)
if (k ^ i)
if (r[k] <= L)
++p;
else if (l[k] < R) {
double inp = 1. * (L - l[k]) / (r[k] - l[k]),
inm = 1. * (R - L) / (r[k] - l[k]);
for (int x = m; ~x; --x)
for (int y = m - x; ~y; --y) {
F[x + 1][y] += F[x][y] * inp;
F[x][y + 1] += F[x][y] * inm;
F[x][y] *= 1 - inp - inm;
}
++m;
}
double tmp = 1. * (R - L) / (r[i] - l[i]);
for (int x = m; ~x; --x)
for (int y = m - x; ~y; --y)
if (F[x][y] > 1e-12)
for (int k = x + 1 + p; k <= x + y + 1 + p; ++k)
Ans[k] += F[x][y] / (y + 1) * tmp;
}
for (int i = 1; i <= N; ++i) printf("%.8lf ", Ans[i]);
puts("");
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p = 0, l, i;
cin >> n;
string s;
cin >> s;
vector<int> vec;
for (i = 0; i < n; i++) {
if (s[i] == 'B') {
p++;
} else {
if (p != 0) vec.push_back(p);
p = 0;
}
}
if (p != 0) {
vec.push_back(p);
}
l = vec.size();
if (l == 0) {
cout << 0;
} else {
cout << l << endl;
for (i = 0; i < vec.size(); i++) {
cout << vec[i] << " ";
}
}
}
| 0 |
#include <bits/stdc++.h>
const int N = 1e6 + 100;
int n, m;
std::vector<int> f[N];
std::vector<int> vec[N];
int cntTeam;
void init() {
std::cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
if (u < v) {
std::swap(u, v);
}
f[u].push_back(v);
}
for (int i = 1; i <= n; i++) {
int t;
scanf("%d", &t);
while (t--) {
int l;
scanf("%d", &l);
vec[i].push_back(l);
cntTeam = std::max(cntTeam, l);
}
}
}
void getRand(int belong[]) {
for (int i = 1; i <= cntTeam; i++) {
belong[i] = rand() % 2;
}
}
void work() {
static int belong[N];
while (true) {
getRand(belong);
bool flag = true;
for (int i = 1; i <= n; i++) {
int cnt[2] = {0, 0};
for (int j = 0; j < (int)vec[i].size(); j++) {
cnt[belong[vec[i][j]]]++;
}
if (!(cnt[0] > 0 && cnt[1] > 0)) {
flag = false;
break;
}
}
if (flag) {
break;
}
}
static int g[N][2];
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (int)vec[i].size(); j++) {
g[i][belong[vec[i][j]]] = vec[i][j];
}
}
static int state[N];
for (int i = 1; i <= n; i++) {
int cnt = 0;
for (int j = 0; j < (int)f[i].size(); j++) {
cnt += (state[f[i][j]] == 1);
}
if (cnt > (int)f[i].size() - cnt) {
state[i] = 0;
} else {
state[i] = 1;
}
}
for (int i = 1; i <= n; i++) {
printf("%d%c", g[i][state[i]], " \n"[i == n]);
}
for (int i = 1; i <= cntTeam; i++) {
printf("%d%c", belong[i] + 1, " \n"[i == cntTeam]);
}
}
int main() {
init();
work();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int X = 0;
char ch = 0, w = 0;
while (ch < 48 || ch > 57) ch = getchar(), w |= (ch == '-');
while (ch >= 48 && ch <= 57) X = X * 10 + (ch ^ 48), ch = getchar();
return w ? -X : X;
}
struct Node {
long long mx, cmx, mx2, tg, tg2, s;
int c;
inline void ladd(long long t) {
s += t * c;
tg += t;
mx += t;
mx2 += t;
}
inline void ladd2(long long t) {
mx += t;
s += cmx * t;
tg2 += t;
}
} a[150500 << 2];
int n;
inline void up(int u) {
int l = u << 1, r = u << 1 | 1;
a[u].s = a[l].s + a[r].s;
a[u].c = a[l].c + a[r].c;
if (a[l].mx == a[r].mx) {
a[u].mx = a[l].mx;
a[u].cmx = a[l].cmx + a[r].cmx;
a[u].mx2 = max(a[l].mx2, a[r].mx2);
} else {
if (a[l].mx > a[r].mx) swap(l, r);
a[u].mx = a[r].mx;
a[u].cmx = a[r].cmx;
a[u].mx2 = max(a[l].mx, a[r].mx2);
}
}
void build(int l = 1, int r = n, int u = 1) {
a[u].c = a[u].tg = a[u].tg2 = 0;
if (l == r) {
a[u].s = a[u].mx = 0;
a[u].cmx = 1;
a[u].mx2 = -1ll << 50;
return;
}
int mid = (l + r) >> 1;
build(l, mid, u << 1);
build(mid + 1, r, u << 1 | 1);
up(u);
}
void ladd(int u) {
if (a[u].tg) {
a[u << 1].ladd(a[u].tg);
a[u << 1 | 1].ladd(a[u].tg);
a[u].tg = 0;
}
if (a[u].tg2) {
int l = u << 1, r = u << 1 | 1, mx = max(a[l].mx, a[r].mx);
if (a[l].mx == mx) a[l].ladd2(a[u].tg2);
if (a[r].mx == mx) a[r].ladd2(a[u].tg2);
a[u].tg2 = 0;
}
}
int wfl, wfr, wfc;
void add(int l = 1, int r = n, int u = 1) {
if (wfl <= l && r <= wfr) {
a[u].ladd(wfc);
return;
}
int mid = (l + r) >> 1;
ladd(u);
if (wfl <= mid) add(l, mid, u << 1);
if (mid < wfr) add(mid + 1, r, u << 1 | 1);
up(u);
}
void chg(int l = 1, int r = n, int u = 1) {
if (wfc >= a[u].mx) return;
if (wfl <= l && r <= wfr && wfc > a[u].mx2) {
a[u].ladd2(wfc - a[u].mx);
return;
}
int mid = (l + r) >> 1;
ladd(u);
if (wfl <= mid) chg(l, mid, u << 1);
if (mid < wfr) chg(mid + 1, r, u << 1 | 1);
up(u);
}
int to;
void cre(int l = 1, int r = n, int u = 1) {
if (l == r) {
a[u].mx = a[u].s = wfc;
a[u].c = 1;
return;
}
int mid = (l + r) >> 1;
ladd(u);
if (to <= mid)
cre(l, mid, u << 1);
else
cre(mid + 1, r, u << 1 | 1);
up(u);
}
int qryc(int l = 1, int r = n, int u = 1) {
if (wfl <= l && r <= wfr) return a[u].c;
int mid = (l + r) >> 1, ret = 0;
if (wfl <= mid) ret = qryc(l, mid, u << 1);
if (mid < wfr) ret += qryc(mid + 1, r, u << 1 | 1);
return ret;
}
int x[150500], p[150500];
long long ans[150500];
bool cmp(const int &A, const int &B) { return x[A] < x[B]; }
void calc() {
for (int i = 1; i <= n; i++) p[i] = i;
sort(p + 1, p + n + 1, cmp);
build();
for (int i = 1; i <= n; i++) {
wfl = 1;
wfr = p[i] - 1;
if (wfl <= wfr) {
wfc = qryc() + 1;
chg();
}
wfl = p[i] + 1;
wfr = n;
wfc = 1;
add();
to = p[i];
wfc = i + 1;
cre();
ans[i] += a[1].s;
}
}
int main() {
n = read();
for (int i = 1; i <= n; i++) scanf("%d", &x[i]);
calc();
reverse(x + 1, x + n + 1);
calc();
for (int i = 1; i <= n; i++) printf("%lld\n", ans[i] - 1ll * i * (i + 2));
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int dX[] = {-1, 0, 1, 0, -1, 1, 1, -1};
int dY[] = {0, 1, 0, -1, 1, 1, -1, -1};
inline void Refresh() {}
long long int n;
long long int parent[200007];
long long int curWater[200007];
long long int capacity[200007];
long long int add(long long int quantity, long long int pos) {
if (pos == n) {
curWater[pos] = min(curWater[pos] + quantity, capacity[pos]);
return n;
}
if (curWater[pos] + quantity <= capacity[pos]) {
curWater[pos] += quantity;
return pos;
} else {
parent[pos] = add(quantity - capacity[pos] + curWater[pos],
max(pos + 1, parent[pos]));
curWater[pos] = capacity[pos];
return parent[pos];
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> capacity[i];
curWater[i] = 0;
parent[i] = i;
}
long long int q, type, k, p, x;
cin >> q;
for (long long int i = 0; i < q; ++i) {
cin >> type;
if (type == 1) {
cin >> p >> x;
add(x, p);
} else {
cin >> k;
cout << curWater[k] << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
n++;
n /= 2;
if (k <= n)
cout << k * 2 - 1;
else {
k -= n;
cout << k * 2;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> T;
vector<long> K, D;
long n, s;
long long dfs(int q, int from) {
if (!K[q]) return 0;
K[q]--;
long long sum = 1;
vector<long long> ff(D[q]);
for (int i = 0; i < D[q]; ++i) {
if (T[q][i] != from)
ff[i] = dfs(T[q][i], q) + 1;
else
ff[i] = 0;
}
sort(ff.begin(), ff.end());
reverse(ff.begin(), ff.end());
long long h = min(K[q], D[q]);
for (int i = 0; i < h; ++i) {
sum += (ff[i]);
if (ff[i]) K[q]--;
}
for (int i = 0; i < D[q] && K[q] > 0; ++i)
if (K[T[q][i]] > 0 && T[q][i] != from) {
h = min(K[T[q][i]], K[q]);
K[q] -= h;
sum += 2 * h;
}
return sum;
}
int main() {
cin >> n;
K.resize(n);
D.resize(n, 0);
for (int i = 0; i < n; ++i) cin >> K[i];
T.resize(n);
long x, y;
for (int i = 0; i < n - 1; ++i) {
cin >> x >> y;
x--, y--;
T[x].push_back(y);
T[y].push_back(x);
D[x]++;
D[y]++;
}
cin >> s;
s--;
K[s]++;
cout << (dfs(s, -1) - 1);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 505;
int N;
long long D[MAX][MAX], D2[MAX][MAX], ans[MAX];
int X[MAX];
int main() {
cin >> N;
for (int i = 0, _n = (int)N; i < _n; i++)
for (int j = 0, _n = (int)N; j < _n; j++) cin >> D[i][j];
for (int i = 0, _n = (int)N; i < _n; i++) cin >> X[i], X[i]--;
for (int k = 0, _n = (int)N; k < _n; k++) {
int c = X[N - k - 1];
for (int i = 0, _n = (int)N; i < _n; i++)
for (int j = 0, _n = (int)N; j < _n; j++)
D[i][j] = min(D[i][j], D[i][c] + D[c][j]);
for (int i = 0, _n = (int)k + 1; i < _n; i++)
for (int j = 0, _n = (int)k + 1; j < _n; j++) {
int a = X[N - i - 1];
int b = X[N - j - 1];
ans[N - k - 1] += D[a][b];
}
}
for (int i = 0, _n = (int)N; i < _n; i++) {
if (i) cout << " ";
cout << ans[i];
}
cout << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e6 + 5;
const int INF = 0x7fffffff;
bool p(long long a) {
for (long long i = 2; i <= sqrt(a); i++) {
if (a % i == 0) return 0;
}
return 1;
}
int main() {
int n;
cin >> n;
int c = n;
while (!p(c)) {
c++;
}
cout << c << '\n';
for (int i = 1; i < n; i++) cout << i << ' ' << i + 1 << '\n';
cout << 1 << ' ' << n << '\n';
for (int i = 1; i <= c - n; i++) cout << i << ' ' << n - i << '\n';
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
inline bool isSame(double c, double d) { return abs(c - d) < 1e-9; }
long long binpow(long long base, long long exp, int mod) {
long long res = 1;
while (exp > 0) {
if (exp % 2 == 1) res = (res * base) % mod;
exp = exp >> 1;
base = (base * base) % mod;
}
return res;
}
long long mod(long long x) {
return ((x % 1000000007LL + 1000000007LL) % 1000000007LL);
}
long long add(long long a, long long b) { return mod(mod(a) + mod(b)); }
long long mul(long long a, long long b) { return mod(mod(a) * mod(b)); }
long long int decbin(string s) { return stoll(s, 0, 2); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int sum = 0;
map<long long int, long long int> m;
long long int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
sum += arr[i];
}
if (((2 * sum) % n) != 0) {
cout << 0 << "\n";
} else {
long long int x = 0, t = (2 * sum) / n;
for (int i = 0; i < n; i++) {
x += m[t - arr[i]];
m[arr[i]]++;
}
cout << x << "\n";
}
};
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long ara[100009];
long long i, j, k, l, r, m, n;
string b;
cin >> n;
for (i = 0; i < n; i++) cin >> ara[i];
cin >> b;
l = -1000000000, r = 1000000000;
for (i = 4; i < n;) {
if (b[i] == '1' && b[i - 1] == '0' && b[i - 2] == '0' && b[i - 3] == '0' &&
b[i - 4] == '0') {
vector<long long> v;
for (j = i; j >= i - 4; j--) {
v.push_back(ara[j]);
}
sort(v.begin(), v.end());
l = max(l, v[v.size() - 1] + 1);
i += 5;
} else if (b[i] == '0' && b[i - 1] == '1' && b[i - 2] == '1' &&
b[i - 3] == '1' && b[i - 4] == '1') {
vector<long long> v;
for (j = i; j >= i - 4; j--) {
v.push_back(ara[j]);
}
sort(v.begin(), v.end());
r = min(r, v[0] - 1);
i += 5;
} else {
i++;
}
}
cout << l << " " << r << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long N[3000 + 10];
vector<long long> v;
long long c = 0;
for (int i = 0; i < n; i++) cin >> N[i];
for (int i = 0; i < n; i++) {
long long minn = 100000000000000, pos;
for (int j = i + 1; j < n; j++) {
if (N[j] < minn) {
minn = N[j];
pos = j;
}
}
if (N[i] != N[pos] and minn < N[i]) {
swap(N[i], N[pos]);
v.push_back(i);
v.push_back(pos);
c++;
}
}
cout << c << endl;
int k = 0;
for (int i = 0; i < v.size(); i++) {
k++;
cout << v[i];
if (k == 2) {
k = 0;
cout << endl;
} else
cout << " ";
}
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
long long INF = 1000 * 1000 * 1000;
int main() {
long long a, n;
cin >> a >> n;
vector<long long> sq(0);
for (long long i = 1; i * i <= 10000000; ++i) sq.push_back(i * i);
vector<bool> use(10000001);
long long res = (a + a + n - 1) * n / 2;
for (int j = sq.size() - 1; j > 0; --j)
for (long long k = 1; sq[j] * k < a + n; ++k) {
long long cur = k * sq[j];
if (use[cur] || cur < a) continue;
use[cur] = true;
res -= cur;
res += k;
}
cout << res;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
struct node {
long long int v, c, t;
node(long long int v, long long int c, long long int t) : v(v), c(c), t(t){};
node(){};
bool operator<(const node &rid) const { return t > rid.t; }
};
long long int a[200005], b[200005];
bool pd(long long int x) {
priority_queue<node> q;
for (int i = 1; i <= n; i++) q.push(node(a[i], b[i], a[i] / b[i]));
for (int i = 1; i <= m; i++) {
node now = q.top();
q.pop();
if (now.v / now.c + 1ll < i) return 0;
if (now.v / now.c + 1ll >= m) return 1;
now.v += x;
now.t = now.v / now.c;
q.push(node(now));
}
return true;
}
int main() {
while (~scanf("%d%d", &n, &m)) {
long long int maxb = 0;
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++) {
scanf("%lld", &b[i]);
maxb = max(maxb, b[i]);
}
long long int l = 0, r = 1ll * (m - 1) * maxb + 1;
while (l < r) {
long long int mid = l + (r - l) / 2;
if (pd(mid))
r = mid;
else
l = mid + 1;
}
if (l >= 1ll * (m - 1) * maxb + 1)
printf("-1\n");
else
printf("%lld\n", l);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100100 * 3;
const int INF = 1E9;
const int base = 1E9 + 7;
void no() {
cout << "no\n";
exit(0);
}
int a[maxn];
pair<int, int> b[maxn];
char ans[3030][3030];
int n, m;
void validate() {
vector<int> draws;
n = m;
for (int i = 0; i < n; i++)
if (a[i] & 1) draws.push_back(i);
memset(ans, 0, sizeof(ans));
for (int i = 0; i < draws.size(); i += 2) {
int x, y;
x = draws[i], y = draws[i + 1];
a[x]--, a[y]--;
ans[x][y] = ans[y][x] = 'D';
}
for (int i = 0; i < n; i++) b[i] = make_pair(a[i], i);
for (int i = 0; i < n; i++) ans[i][i] = 'X';
for (int i = 0; i < n; i++) {
sort(b + i, b + n);
reverse(b + i, b + n);
int g = b[i].second;
for (int j = n - 1; j > i; j--)
if (ans[g][b[j].second] == 0) {
char w = 'W', l = 'L';
if (b[i].first > 0) {
ans[g][b[j].second] = w, ans[b[j].second][g] = l;
b[i].first -= 2;
} else {
ans[g][b[j].second] = l, ans[b[j].second][g] = w;
b[j].first -= 2;
}
}
if (b[i].first != 0) no();
}
puts("yes");
for (int i = 0; i < n; i++) puts(ans[i]);
}
int solve() {
cin >> m >> n;
for (int i = 0; i < n; i++) cin >> a[i];
int sum = 0;
for (int i = 0; i < n; i++) sum += a[i];
if (sum > m * (m - 1)) no();
if (sum + (m - n) * a[n - 1] < m * (m - 1)) no();
while (sum < m * (m - 1))
for (int i = n; sum < m * (m - 1) && i < m; i++) a[i]++, sum++;
validate();
}
int main() {
solve();
return 0;
}
| 10 |
#include<bits/stdc++.h>
#define int long long
using namespace std;
inline int read(){
int f=0,x=0;
char ch=getchar();
while(!isdigit(ch)){f|=(ch=='-');ch=getchar();}
while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
return f?-x:x;
}
const int N=1e5+10;
char a[N];int s[N];
signed main(){
int n=read(),q=read();
scanf("%s",a+1);
for(int i=1;i<=n;i++)s[i]=s[i-1]+a[i]-'a'+1;
while(q--){
int l=read(),r=read();
printf("%d\n",s[r]-s[l-1]);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int Mod(int x) { return (x % 1000000007 + 1000000007) % 1000000007; }
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
long long lcm(long long a, long long b) { return (a * (b / gcd(a, b))); }
long long bigmod(long long b, long long p, long long m) {
if (p == 0) return 1;
if (p % 2 == 0) {
long long temp = bigmod(b, p / 2, m);
return (temp * temp) % m;
}
return (bigmod(b, p - 1, m) * (b % m)) % m;
}
char inp[10010];
string scan() {
scanf("%s", inp);
string s;
for (int i = 0; inp[i]; i++) s += inp[i];
return s;
}
vector<vector<int> > v;
vector<bool> visited;
int dfs(int node) {
visited[node] = 1;
for (int i = 0; i < (int)v[node].size(); i++) {
if (!visited[v[node][i]]) dfs(v[node][i]);
}
}
int connectedcomponenetscnt(int head) {
int cnt = 0;
for (int i = 1; i < 500; i++) {
if (!visited[i]) {
dfs(i);
cnt++;
}
}
return cnt;
}
int k1, k2, n, m, MOD;
long long memo[2001][4001][2];
long long solve(int i, int sum, int use) {
if (i == n && use) {
return (sum == 0 && use);
}
if (i > n) return 0;
long long &ret = memo[i][sum][use];
if (ret != -1) return ret;
long long x1 = 0, x2 = 0, x3 = 0;
x1 = solve(i + 1, sum + 1, use);
if (sum >= 1) x2 = solve(i + 1, sum - 1, use);
if (!use && sum - k2 >= 0) x3 = solve(i, sum - k2 + k1, 1);
return ret = (x1 + x2 + x3) % MOD;
}
int main() {
memset(memo, -1, sizeof(memo));
MOD = 1e9 + 7;
cin >> n >> m;
n = n - m;
string s;
cin >> s;
for (int i = 0; i < m; i++) {
if (s[i] == '(')
k1++;
else if (k1 > 0)
k1--;
else
k2++;
}
if (k1 > 2000)
cout << 0;
else
cout << solve(0, 0, 0);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, r;
vector<int> X, Y;
vector<pair<int, int> > Points;
vector<pair<int, int> > hull;
vector<pair<int, int> > cur, save;
int best = -1;
void Rec(int ind, int sumx, int sumx2, int sumy, int sumy2) {
if (cur.size() == n) {
int tmp = n * (sumx2 + sumy2) - (sumx * sumx + sumy * sumy);
if (tmp > best) {
best = tmp;
save = cur;
}
return;
}
for (int i = ind; i < hull.size(); ++i) {
cur.push_back(hull[i]);
int x = hull[i].first, y = hull[i].second;
Rec(i, sumx + x, sumx2 + x * x, sumy + y, sumy2 + y * y);
cur.pop_back();
}
}
int main() {
cin >> n >> r;
if (n == 2) {
cout << 4 * r * r << endl;
cout << r << " " << 0 << endl;
cout << -r << " " << 0 << endl;
return 0;
}
vector<int> max_Y(r + 1, 0);
for (int x = 0; x <= r; ++x) {
for (int y = r; y >= 0; --y)
if (x * x + y * y <= r * r) {
max_Y[x] = y;
break;
}
}
for (int x = r; x >= -r; --x) Points.push_back(make_pair(x, max_Y[abs(x)]));
for (int x = -r + 1; x < r; ++x)
Points.push_back(make_pair(x, -max_Y[abs(x)]));
hull.push_back(Points[0]);
hull.push_back(Points[1]);
for (int i = 2; i <= Points.size(); ++i) {
int ind = i % Points.size();
while (hull.size() >= 2) {
int x1 = hull[hull.size() - 1].first - hull[hull.size() - 2].first;
int y1 = hull[hull.size() - 1].second - hull[hull.size() - 2].second;
int x2 = Points[ind].first - hull[hull.size() - 2].first;
int y2 = Points[ind].second - hull[hull.size() - 2].second;
int cross = x1 * y2 - y1 * x2;
if (cross <= 0)
hull.pop_back();
else
break;
}
if (i < Points.size()) hull.push_back(Points[ind]);
}
Rec(0, 0, 0, 0, 0);
cout << best << endl;
for (int i = 0; i < save.size(); ++i)
cout << save[i].first << " " << save[i].second << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 100000;
int m, n;
int a[Maxn + 5], p[Maxn + 5];
int x[Maxn + 5], k[Maxn + 5];
int e_pos[Maxn + 5], steps[Maxn + 5];
int Root[Maxn + 5];
struct Segment_Node {
int lson, rson;
int val;
} seg[Maxn * 25 + 5];
int id_tot;
void build(int &root, int left = 1, int right = n) {
root = ++id_tot;
seg[root].val = right - left + 1;
if (left == right) {
return;
}
int mid = (left + right) >> 1;
build(seg[root].lson, left, mid);
build(seg[root].rson, mid + 1, right);
}
int find_kth(int root, int k, int left = 1, int right = n) {
if (left == right) {
return left;
}
int mid = (left + right) >> 1;
if (k <= seg[seg[root].lson].val) {
return find_kth(seg[root].lson, k, left, mid);
}
return find_kth(seg[root].rson, k - seg[seg[root].lson].val, mid + 1, right);
}
void update(int &root, int last, int x, int a, int left = 1, int right = n) {
root = ++id_tot;
seg[root] = seg[last];
seg[root].val += a;
if (left == right) {
return;
}
int mid = (left + right) >> 1;
if (x <= mid) {
update(seg[root].lson, seg[last].lson, x, a, left, mid);
} else {
update(seg[root].rson, seg[last].rson, x, a, mid + 1, right);
}
}
int query(int root, int x, int left = 1, int right = n) {
if (left == right) {
return seg[root].val;
}
int mid = (left + right) >> 1;
if (x <= mid) {
return query(seg[root].lson, x, left, mid);
}
return seg[seg[root].lson].val + query(seg[root].rson, x, mid + 1, right);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
e_pos[0] = a[1] - 1;
steps[0] = 0;
for (int i = 1; i < n; i++) {
int delta = (a[i + 1] - e_pos[i - 1] - 1) / i;
e_pos[i] = e_pos[i - 1] + i * delta;
steps[i] = steps[i - 1] + delta;
}
for (int i = 2; i <= n; i++) {
p[i] = (p[i - 1] + a[i] - a[i - 1]) % (i - 1);
}
build(Root[n]);
for (int i = n; i > 0; i--) {
p[i] = find_kth(Root[i], p[i] + 1);
update(Root[i - 1], Root[i], p[i], -1);
}
for (int t = 1; t <= m; t++) {
int x, k;
scanf("%d%d", &x, &k);
if (x < a[1]) {
printf("%d\n", x);
continue;
}
int bel = lower_bound(e_pos + 1, e_pos + n, x) - e_pos;
k += steps[bel - 1] + (x - e_pos[bel - 1] - 1) / bel + 1;
int ord = (x - e_pos[bel - 1] - 1) % bel + 1;
ord = find_kth(Root[bel], ord);
bel = lower_bound(steps + 1, steps + n, k) - steps;
printf("%lld\n", e_pos[bel - 1] + 1ll * (k - steps[bel - 1] - 1) * bel +
query(Root[bel], ord));
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, a[100000], b[8], typecnt = 0, first, second, third;
cin >> n;
for (i = 0; i < n; ++i) {
scanf("%d", a + i);
if (!b[a[i]])
b[a[i]] = 1, ++typecnt;
else
++b[a[i]];
}
if (typecnt < 3 || b[5] > 0 || b[7] > 0 || (b[2] == 0 && b[4] > 0) ||
(b[6] == 0 && b[3] > 0))
cout << "-1\n";
else {
first = b[1];
second = b[2] + b[3];
third = b[4] + b[6];
if (first == second && second == third && b[6] >= b[3] && b[2] >= b[4]) {
for (i = 0; i < b[4]; ++i) printf("1 2 4\n");
for (i = 0; i < (b[6] - b[3]); ++i) printf("1 2 6\n");
for (i = 0; i < b[3]; ++i) printf("1 3 6\n");
} else
printf("-1\n");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dis[2005][2005];
bool vis[2005][2005];
int n, m, k, a, b;
bool find(int x, int y, int d) {
int l = max(1, x - d);
int r = min(n, x + d);
int dy;
for (int i = l; i <= r; i++) {
dy = d - abs(x - i);
if (y - dy > 0 && !vis[i][y - dy]) {
a = i;
b = y - dy;
return true;
}
if (y + dy <= m && !vis[i][y + dy]) {
a = i;
b = y + dy;
return true;
}
}
return false;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
memset(dis, 0, sizeof(dis));
memset(vis, false, sizeof(vis));
int x, y;
for (int i = 0; i < k; i++) {
scanf("%d%d", &x, &y);
for (int i = -1; i <= 1; i++)
for (int j = -1; j <= 1; j++)
if (x + i > 0 && x + i <= n && y + j > 0 && y + j <= m)
dis[x][y] = max(dis[x + i][y + j] - abs(i) - abs(j), dis[x][y]);
while (!find(x, y, dis[x][y])) dis[x][y]++;
printf("%d %d\n", a, b);
vis[a][b] = true;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n, a, fst, sec, sm, j;
while (cin >> n) {
fst = 0;
sm = 0;
for (i = 0; i < n; i++) {
cin >> a;
if (a > fst) fst = a;
sm += a;
}
sec = sm - fst;
cout << abs(fst - sec) + 1 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e5 + 5, LG = 26, SM = 350, inf = 1e9 + 1, mod = 95542721;
set<int> se;
set<int>::iterator vasat;
int rotbe;
int ted[M];
long long int ans;
int ansp;
int rng = 1687;
void ins(int x) {
rotbe += (x >= *vasat);
ted[x]++;
se.insert(x);
auto vst2 = vasat;
int rtbt2 = rotbe;
if (x >= *vasat) {
auto ite = vasat;
int rot = rotbe;
for (int rep = 0; rep < rng; rep++) {
if (1LL * (*ite) * rot > ans) {
rtbt2 = rot;
vst2 = ite;
ans = 1LL * (*ite) * rot;
ansp = *ite;
}
rot -= ted[*ite];
ite++;
if (ite == se.end()) break;
}
} else {
auto ite = vasat;
int rot = rotbe;
for (int rep = 0; rep < rng; rep++) {
if (1LL * (*ite) * rot > ans) {
rtbt2 = rot;
vst2 = ite;
ans = 1LL * (*ite) * rot;
ansp = *ite;
}
if (ite == se.begin()) break;
ite--;
rot += ted[*ite];
}
}
rotbe = rtbt2;
vasat = vst2;
}
int n, w;
vector<int> b[M];
int main() {
ted[0]++;
se.insert(0);
vasat = se.begin();
rotbe = 1;
scanf("%d%d", &n, &w);
int mxb = 0;
for (int i = 0; i < n; i++) {
int ai, bi;
scanf("%d%d", &ai, &bi);
mxb = max(mxb, bi);
b[bi].push_back(ai);
}
mxb += 2;
int tnaf = n;
for (int c = 0; c < mxb; c++) {
printf("%lld %d\n", ans + 1LL * tnaf * c * w, ansp);
for (int y : b[c]) {
ins(y);
tnaf--;
}
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n], b[n - 1], c[n - 2];
for (int i = 0; i < n; ++i) cin >> a[i];
b[n - 1] = 1e9 + 4;
c[n - 2] = 1e9 + 4;
for (int i = 0; i < n - 1; ++i) cin >> b[i];
for (int i = 0; i < n - 2; ++i) cin >> c[i];
sort(a, a + n);
sort(b, b + n - 1);
sort(c, c + n - 2);
for (int i = 0;; ++i)
if (a[i] != b[i]) {
cout << a[i] << " ";
break;
} else
cerr << "P";
for (int i = 0;; ++i)
if (b[i] != c[i]) {
cout << b[i];
break;
} else
cerr << "O";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int w = 0, f = 0;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') f = 1, c = getchar();
while (c >= '0' && c <= '9') w = w * 10 + c - '0', c = getchar();
return f ? -w : w;
}
long long a, b, n, ans = 0;
int main() {
a = read(), b = read();
n = a + b;
long long l = 1, r, g;
while (l <= n) {
g = n / l;
if (g > a || g > b) {
l = n / g + 1;
continue;
}
r = n / g;
long long a_low = (a + g) / (g + 1);
long long a_hi = a / g;
long long b_low = (b + g) / (g + 1);
long long b_hi = b / g;
if (a_hi >= a_low && b_hi >= b_low)
ans += min(r, a_hi + b_hi) - max(l, a_low + b_low) + 1;
l = r + 1;
}
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
const int MAX = 1e5 + 7;
using namespace std;
string st = "fedabc";
void solve(unsigned long long n, char c) {
n--;
unsigned long long res = 16LL * (n / 4LL);
if (n % 2) res += 7;
res += st.find(c) + 1;
cout << res;
}
void mysolve(unsigned long long n, char c) {
unsigned long long l = 0, r = n / 2;
unsigned long long res = 0;
while (l <= r) {
unsigned long long mid = (l + r) / 2;
if ((1 + (mid + (mid * 3LL))) <= n) {
res = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
unsigned long long currF = (1 + (res + (res * 3)));
unsigned long long served = 2LL * res;
unsigned long long sec = 6;
if ((currF == n) || (currF + 2 == n)) {
sec += ((served - 1) * 6) + (currF - 1);
} else if (currF + 1 == n || currF + 3 == n) {
sec += (served * 6) + (currF);
} else if (currF + 4 == n || currF + 6 == n) {
sec += ((served + 1) * 6) + (currF + 1);
}
for (auto i : st) {
sec++;
if (i == c) break;
}
cout << sec;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
unsigned long long n = stoll(s.substr(0, s.size() - 1));
char seat = s[s.size() - 1];
solve(n, seat);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long LINF = 1e18;
const int INF = 1e9;
const int MOD = 1e9 + 7;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
int t;
cin >> t;
while (t--) {
long long n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
long long menor = a - b;
long long maior = a + b;
bool flag = false;
if (n * menor >= c - d and n * menor <= c + d)
flag = true;
else if (n * menor < c - d and n * maior >= c - d)
flag = true;
if (flag)
cout << "Yes\n";
else
cout << "No\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long b[200 * 1000 + 10], c[200 * 1000 + 10], v[200 * 1000 + 10];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k, s, t;
cin >> n >> k >> s >> t;
for (long long i = 1; i <= n; i++) cin >> c[i] >> v[i];
for (long long j = 1; j <= k; j++) cin >> b[j];
sort(b + 1, b + k + 1);
b[k + 1] = s;
long long l = 0, r = 1e9;
long long tc = 0;
for (long long j = 1; j <= k + 1; j++) {
if (b[j] - b[j - 1] > r) {
cout << "-1\n";
return 0;
}
tc += (b[j] - b[j - 1]) * 2 - min(r - (b[j] - b[j - 1]), b[j] - b[j - 1]);
}
if (tc > t) {
cout << "-1";
return 0;
}
while (r - l > 1) {
long long m = (l + r) / 2;
tc = 0;
for (long long j = 1; j <= k + 1; j++) {
if (b[j] - b[j - 1] > m) {
l = m;
goto m1;
}
tc += (b[j] - b[j - 1]) * 2 - min(m - (b[j] - b[j - 1]), b[j] - b[j - 1]);
}
if (tc <= t)
r = m;
else
l = m;
m1:;
}
long long ans = LLONG_MAX;
for (long long i = 1; i <= n; i++) {
if (v[i] >= r && c[i] < ans) ans = c[i];
}
if (ans == LLONG_MAX)
cout << "-1";
else
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%d%d", &n, &k);
multiset<int> st;
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
st.insert(a);
}
vector<int> h(k), bf(k, -1);
for (int i = 0; i < k; i++) {
scanf("%d", &h[i]);
if (i) {
if (h[i] < h[i - 1])
bf[i] = i - 1;
else
bf[i] = bf[i - 1];
}
}
vector<vector<int>> ans;
while (st.size()) {
int last = 0;
vector<int> cur;
int at = k - 1;
while (st.size()) {
bool done = 0;
while (cur.size() < h[at]) {
if (st.empty()) break;
auto it = st.upper_bound(at + 1);
if (it == st.begin()) {
done = 1;
break;
}
it--;
cur.push_back(*it);
st.erase(it);
}
if (done) break;
at = bf[at];
if (at == -1) break;
}
ans.push_back(cur);
}
printf("%d\n", ans.size());
for (vector<int> a : ans) {
printf("%d ", a.size());
for (int i : a) printf("%d ", i);
printf("\n");
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int nax = 1e5 + 5;
int n, m, k, q;
set<int> zbior[nax];
int wjakiejskladowejjestem[nax];
vector<int> skladowe[nax];
map<int, int> krawedzie[nax];
int rozmiar[nax];
void pre() {
cin >> n >> m >> k >> q;
for (int i = 1; i <= n; i++) {
zbior[i].insert(i);
skladowe[i].push_back(i);
wjakiejskladowejjestem[i] = i;
rozmiar[i] = 1;
}
}
void dodaj(int v, int u) {
int V = wjakiejskladowejjestem[v];
int U = wjakiejskladowejjestem[u];
if (zbior[v].count(U)) {
return;
}
skladowe[U].push_back(v);
rozmiar[U]++;
zbior[v].insert(U);
}
void debug(int kt) {
set<int>::iterator it;
it = zbior[kt].begin();
while (it != zbior[kt].end()) {
cout << *it << endl;
it++;
}
cout << "*********************" << endl;
for (int i = 1; i <= n; i++) cout << rozmiar[i] << " ";
cout << "*********************" << endl;
}
void query(int v, int u) {
v = wjakiejskladowejjestem[v];
if (zbior[u].count(v))
cout << "Yes" << endl;
else
cout << "No" << endl;
}
void zrob(int v, int u, int kolor) {
if (krawedzie[v][kolor] == 0) {
krawedzie[v][kolor] = u;
return;
}
int A = wjakiejskladowejjestem[u];
int B = krawedzie[v][kolor];
B = wjakiejskladowejjestem[B];
if (A == B) return;
if (rozmiar[A] < rozmiar[B]) swap(A, B);
for (int i = 0; i < skladowe[B].size(); i++) {
int akt = skladowe[B][i];
zbior[akt].erase(B);
zbior[akt].insert(A);
if (wjakiejskladowejjestem[akt] == B) wjakiejskladowejjestem[akt] = A;
skladowe[A].push_back(akt);
}
skladowe[B].clear();
rozmiar[A] += rozmiar[B];
rozmiar[B] = 0;
}
void add_edge(int u, int v, int kolor) {
dodaj(u, v);
dodaj(v, u);
zrob(u, v, kolor);
zrob(v, u, kolor);
}
int main() {
pre();
while (m--) {
int x, y, z;
cin >> x >> y >> z;
add_edge(x, y, z);
}
while (q--) {
char zz;
cin >> zz;
if (zz == '?') {
int x, y;
cin >> x >> y;
query(x, y);
} else {
int x, y, z;
cin >> x >> y >> z;
add_edge(x, y, z);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename num_t>
inline void addmod(num_t& a, const long long& b, const int& m) {
a = (a + b) % m;
if (a < 0) a += m;
}
template <typename num_t>
inline void update_max(num_t& a, const num_t& b) {
a = max(a, b);
}
template <typename num_t>
inline void update_min(num_t& a, const num_t& b) {
a = min(a, b);
}
template <typename num_t>
num_t gcd(num_t lhs, num_t rhs) {
return !lhs ? rhs : gcd(rhs % lhs, lhs);
}
template <typename num_t>
num_t pw(num_t n, num_t k, num_t mod) {
num_t res = 1;
for (; k; k >>= 1) {
if (k & 1) res = 1ll * res * n % mod;
n = 1ll * n * n % mod;
}
return res;
}
const int inf = 1e9 + 7;
const long long ll_inf = 1ll * inf * inf;
const int MAX_N = 1500 + 7;
const int mod = inf;
int n, m;
string s[MAX_N];
bitset<MAX_N * 2> check[MAX_N * 2];
int x[4] = {0, 0, -1, 1};
int y[4] = {-1, 1, 0, 0};
void solve() {
cin >> n >> m;
pair<int, int> root = {-1, -1};
for (int i = (0), _b = (n); i < _b; ++i) {
cin >> s[i];
for (int j = (0), _b = (m); j < _b; ++j)
if (s[i][j] == 'S') root = {i, j};
}
static pair<int, int> queue_[MAX_N * MAX_N * 4];
int top = 0;
queue_[top++] = root;
check[root.first][root.second] = true;
for (int j = 0; j < top; ++j) {
int u = queue_[j].first;
int v = queue_[j].second;
for (int j = (0), _b = (4); j < _b; ++j) {
int new_u = u + x[j];
int new_v = v + y[j];
addmod(new_u, 0, n * 2);
addmod(new_v, 0, m * 2);
int ori_u = new_u;
addmod(ori_u, 0, n);
int ori_v = new_v;
addmod(ori_v, 0, m);
if (s[ori_u][ori_v] != '#' && !check[new_u][new_v]) {
check[new_u][new_v] = true;
queue_[top++] = {new_u, new_v};
}
}
}
if (check[root.first][root.second + m] ||
check[root.first + n][root.second + m] ||
check[root.first + n][root.second]) {
cout << "Yes\n";
} else {
cout << "No\n";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
const bool multiple_test = false;
int test = 1;
if (multiple_test) cin >> test;
for (int i = 0; i < test; ++i) {
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long(n), (m), (q);
scanf("%lld%lld%lld", &(n), &(m), &(q));
;
vector<long long> A((n));
for (long long i = 0; i < n; i++) scanf("%lld", &A[i]);
;
vector<long long> B;
long long val = 1 << n;
vector<long long> ma(val, 0);
char s[100];
for (long long i = 0; i < (m); i++) {
scanf("%s", s);
int res = 0;
for (long long j = 0; j < (n); j++) res = 2 * res + (s[j] - '0');
if (ma[res] == 0) {
B.push_back(res);
}
ma[res]++;
}
vector<vector<long long>> vec(val, vector<long long>(101, 0));
vector<long long> vals(val, 0);
for (long long i = 0; i < (val); i++) {
for (long long j = 0; j < (n); j++) {
if ((i >> j) & 1) vals[i] += A[n - j - 1];
}
}
for (long long i = 0; i < (val); i++) {
for (long long j = 0; j < (B.size()); j++) {
long long vector = (~(i ^ B[j])) & (val - 1);
long long v = vals[vector];
if (v <= 100) vec[i][v] += ma[B[j]];
}
}
for (long long i = 0; i < (val); i++) {
for (long long j = 0; j < (101); j++)
vec[i][j] += (j - 1 >= 0 ? vec[i][j - 1] : 0);
}
for (long long i = 0; i < (q); i++) {
scanf("%s", s);
int res = 0;
for (long long j = 0; j < (n); j++) res = 2 * res + (s[j] - '0');
long long(k);
scanf("%lld", &(k));
;
printf("%lld\n", vec[res][k]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int t, n, m, flag;
int vis[200010], xo[200010];
struct node {
int a, b, c;
} tr[200010];
vector<pair<int, int>> g[200010];
int count(int x) {
int s = 0;
while (x) {
s += (x & 1);
x >>= 1;
}
return s;
}
void dfs(int u) {
vis[u]++;
for (int i = 0; i < g[u].size(); i++) {
auto p = g[u][i];
int v = p.first, va = p.second;
if (vis[v]) {
if (va == xo[u] ^ xo[v]) continue;
flag++;
return;
} else {
xo[v] = xo[u] ^ va;
dfs(v);
}
}
}
int main() {
cin >> t;
while (t--) {
flag = 0;
cin >> n >> m;
for (int i = 0; i <= n; i++) vis[i] = xo[i] = 0, g[i].clear();
for (int i = 1; i < n; i++) {
int a, b, c;
cin >> a >> b >> c;
tr[i] = {a, b, c};
if (c != -1) {
g[a].push_back({b, count(c) % 2});
g[b].push_back({a, count(c) % 2});
}
}
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
g[a].push_back({b, c});
g[b].push_back({a, c});
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) dfs(i);
}
if (flag) {
cout << "NO" << endl;
continue;
}
cout << "YES" << '\n';
for (int i = 1; i < n; i++) {
if (tr[i].c == -1) {
tr[i].c = xo[tr[i].a] ^ xo[tr[i].b];
}
cout << tr[i].a << ' ' << tr[i].b << ' ' << tr[i].c << '\n';
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long get_pow(long long a, long long b, long long c) {
long long ans = 1;
while (b) {
if (b & 1) {
ans = ans * a;
ans = ans % c;
}
a = a * a;
a = a % c;
b = b / 2;
}
return ans;
}
char b[1200000], n[1200000];
int main() {
long long c;
scanf("%s%s%lld", b, n, &c);
long long lenb;
long long lenn;
lenb = strlen(b);
lenn = strlen(n);
long long i;
for (i = lenn - 1; i >= 0; i--) {
if (n[i] == '0')
n[i] = '9';
else {
n[i]--;
break;
}
}
long long bb = 0;
for (i = 0; i < lenb; i++) {
bb = (bb * 10 + b[i] - '0') % c;
}
long long ans = 1;
for (i = 0; i < lenn; i++) {
ans = get_pow(ans, 10, c);
ans = ans * get_pow(bb, n[i] - '0', c);
ans = ans % c;
}
if (bb == 0) bb = c;
ans = ans * (bb - 1) % c;
if (ans == 0)
printf("%lld\n", c);
else
printf("%lld\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 22;
const int M = 22;
const int INF = 1e9;
int n, m;
int dp[1 << N];
char str[N][M];
int val[N][M], cst[N][M], msk[N][M];
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", str[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &val[i][j]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int total = 0;
int maxn = 0;
for (int k = 0; k < n; k++) {
if (str[i][j] == str[k][j]) {
msk[i][j] |= (1 << k);
total += val[k][j];
maxn = max(maxn, val[k][j]);
}
}
cst[i][j] = total - maxn;
}
}
for (int i = 1; i < (1 << n); i++) dp[i] = INF;
dp[0] = 0;
for (int i = 1; i < (1 << n); i++) {
int first = 0;
while ((i & (1 << first)) == 0) first++;
for (int j = 0; j < m; j++) {
dp[i] = min(dp[i], dp[i ^ (1 << first)] + val[first][j]);
dp[i] = min(dp[i], dp[i & (i ^ msk[first][j])] + cst[first][j]);
}
}
printf("%d\n", dp[(1 << n) - 1]);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct A {
int P, len;
bool operator<(const A &k) const {
return P * len * (100 - k.P) - k.P * k.len * (100 - P) > 0;
}
} w[50001];
double S, t;
int n, i;
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d%d", &w[i].len, &w[i].P);
}
sort(w + 1, w + n + 1);
for (i = 1; i <= n; i++) {
S += w[i].len + t * (100.0 - w[i].P) * 0.01;
t += w[i].P * w[i].len * 0.01;
}
printf("%.10lf\n", S);
}
| 6 |
#include <bits/stdc++.h>
using lli = long long int;
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
int x = 0, y = 0;
while ((n % b != 0) && (n > 0)) {
x++;
n = n - a;
}
if (n % b == 0 && n >= 0) {
y = n / b;
cout << "YES" << endl;
cout << x << " " << y << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int N, K;
int A[101][101];
void solve() {
int i, j, k, l, r, x, y;
string s;
cin >> N >> K;
for (y = 0; y < (N); y++)
for (x = 0; x < (N); x++)
if (A[y][x] == 0) {
if (y == x && K > 0) {
A[y][x] = 1;
K--;
} else if (K > 1) {
A[y][x] = A[x][y] = 1;
K -= 2;
}
}
if (K > 0) return (void)printf("-1\n");
for (y = 0; y < (N); y++) {
for (x = 0; x < (N); x++) (void)printf("%d ", A[y][x]);
(void)printf("\n");
}
}
int main(int argc, char** argv) {
string s;
int i;
if (argc == 1) ios::sync_with_stdio(false), cin.tie(0);
for (i = 0; i < (argc - 1); i++) s += argv[i + 1], s += '\n';
for (i = 0; i < (s.size()); i++) ungetc(s[s.size() - 1 - i], stdin);
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double pii = acos(-1.0);
const double eps = 1e-6;
const long long Inf = 1LL << 62;
const long long mod = 1000000007;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
;
string s, second = "";
;
cin >> s;
deque<int> d[27];
int c = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '>') {
second.push_back(s[i]);
if (second.length() == 3) {
d[second[1] - 'a'].push_back(c);
c++;
int space = 2 * d[second[1] - 'a'].back();
for (int j = 1; j <= space; j++) cout << " ";
cout << second << endl;
} else {
int space = 2 * d[second[2] - 'a'].back();
for (int j = 1; j <= space; j++) cout << " ";
cout << second << endl;
c--;
d[second[2] - 'a'].pop_back();
}
second.clear();
} else
second.push_back(s[i]);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 10;
const int P = 998244353;
const int INF = 0x3f3f3f3f;
int n, dp[N][N], f[N];
char s[N];
int qsm(int n, int q = P - 2) {
int ans = 1;
while (q) {
if (q & 1) {
ans = 1LL * ans * n % P;
}
n = 1LL * n * n % P;
q >>= 1;
}
return ans;
}
void solve() {
n = strlen(s);
for (int i = 0; i < n; ++i) {
f[i + 1] = f[i] + (s[i] == '?');
}
for (int len = 2; len <= n; ++len) {
for (int i = 0; i + len - 1 < n; ++i) {
int j = i + len - 1;
if (s[i] != '(') {
dp[i][j] = (dp[i][j] + dp[i + 1][j]) % P;
}
if (s[j] != ')') {
dp[i][j] = (dp[i][j] + dp[i][j - 1]) % P;
}
if (s[i] != '(' && s[j] != ')') {
dp[i][j] = (1LL * dp[i][j] - dp[i + 1][j - 1] + P) % P;
}
if (s[i] != ')' && s[j] != '(') {
dp[i][j] =
(1LL * dp[i][j] + dp[i + 1][j - 1] + qsm(2, f[j] - f[i + 1])) % P;
}
}
}
printf("%d\n", dp[0][n - 1]);
}
int main() {
scanf("%s", s);
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int f[400][400];
int MAX = 300 * 300;
int main() {
int li = 0;
for (int i = 0; i <= 400; ++i) {
for (int j = 0; j <= 400; ++j) {
f[i][j] = li;
++li;
}
}
int ost = f[201][201];
int x, y;
int R;
scanf("%d %d %d", &x, &y, &R);
int start = f[x][y];
int n;
scanf("%d", &n);
vector<pair<int, int> > H(n);
for (int i = 0; i < n; ++i) scanf("%d %d", &H[i].first, &H[i].second);
int m;
scanf("%d", &m);
vector<pair<int, int> > T(m);
for (int i = 0; i < m; ++i) scanf("%d %d", &T[i].first, &T[i].second);
vector<vector<int> > G(MAX);
for (int i = 0; i <= 200; ++i) {
for (int j = 0; j <= 200; ++j) {
int akt = f[i][j];
for (int k = 1; k <= i && k <= n; ++k) {
int nast = f[i - k + H[k - 1].first][j + H[k - 1].second];
int s = (i - k + H[k - 1].first) + (j + H[k - 1].second);
if (s > R) nast = ost;
G[akt].push_back(nast);
}
for (int k = 1; k <= j && k <= m; ++k) {
int nast = f[i + T[k - 1].first][j - k + T[k - 1].second];
int s = (i + T[k - 1].first) + (j - k + T[k - 1].second);
if (s > R) nast = ost;
G[akt].push_back(nast);
}
}
}
queue<int> Q;
vector<int> Dl(MAX, -1);
vector<vector<int> > Tr(MAX);
vector<int> st_we(MAX, 0);
Dl[start] = 0;
Q.push(start);
while (!Q.empty()) {
int akt = Q.front();
Q.pop();
for (int i = 0; i < G[akt].size(); ++i) {
if (Dl[G[akt][i]] == -1) {
Dl[G[akt][i]] = Dl[akt] + 1;
Q.push(G[akt][i]);
}
Tr[akt].push_back(G[akt][i]);
++st_we[G[akt][i]];
}
}
if (Dl[f[0][0]] != -1) {
printf("Ivan\n%d", Dl[f[0][0]]);
return 0;
}
for (int i = 0; i <= 200; ++i)
for (int j = 0; j <= 200; ++j)
if (st_we[f[i][j]] == 0 && Dl[f[i][j]] != -1) Q.push(f[i][j]);
vector<int> topo;
while (!Q.empty()) {
int akt = Q.front();
Q.pop();
topo.push_back(akt);
for (int i = 0; i < Tr[akt].size(); ++i) {
--st_we[Tr[akt][i]];
if (st_we[Tr[akt][i]] == 0) Q.push(Tr[akt][i]);
}
}
for (int i = 0; i <= 200; ++i) {
for (int j = 0; j <= 200; ++j) {
if (st_we[f[i][j]] != 0 && Dl[f[i][j]] != -1) {
printf("Draw");
return 0;
}
}
}
vector<int> dp(MAX);
reverse(topo.begin(), topo.end());
for (int i = 0; i < topo.size(); ++i) {
int akt = topo[i];
if (akt == ost)
dp[akt] = 0;
else {
dp[akt] = 0;
for (int j = 0; j < Tr[akt].size(); ++j)
dp[akt] = max(dp[akt], dp[Tr[akt][j]] + 1);
}
}
printf("Zmey\n%d", dp[start]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int k, n, a[2005], i, k1;
int main() {
cin >> n >> k;
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (i = 0; i < n; i++) {
a[i] = a[i] + k;
}
for (i = 0; i < n; i++) {
if (a[i] <= 5) k1 = k1 + 1;
}
cout << k1 / 3;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int y[110], x[110];
int main() {
int n, a, b, s = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x[i] >> y[i];
if (x[i] != y[i]) {
s = 1;
} else if (i != 1 && x[i - 1] < x[i] && s != 1) {
s = 2;
}
}
if (s == 1)
cout << "rated\n";
else if (s == 2)
cout << "unrated\n";
else
cout << "maybe\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, x, ans, k;
long long binpow(long long a, long long b) {
if (b == 1)
return a;
else if (b == 0)
return 1;
else {
if (b % 2 == 0)
return binpow(a, b / 2) * binpow(a, b / 2);
else
return binpow(a, b - 1) * a;
}
}
const long long mo = 998244353;
int main() {
cin >> n >> x;
k = x;
long long len;
for (long long i = 0; i <= 10; i++)
if (k < binpow(10, i)) {
len = i;
break;
}
long long l = 0, r = 0;
for (long long i = len; i > 1; i--) {
k = x / binpow(10, i - 1);
k %= 10;
l += ((((k * ((binpow(10, i * 2 - 2) % mo) * 10) % mo) % mo)) % mo);
l %= mo;
r += ((((k * (binpow(10, i * 2 - 2) % mo)) % mo)) % mo);
r %= mo;
}
l += (x % 10) * 10;
l %= mo;
r += (x % 10);
r %= mo;
ans += (l + r) % mo;
ans %= mo;
for (long long q = 1; q < n; q++) {
cin >> x;
{
long long l = 0, r = 0;
for (long long i = len; i > 1; i--) {
k = x / binpow(10, i - 1);
k %= 10;
l += (((k * ((binpow(10, i * 2 - 2) % mo) * 10) % mo) % mo) % mo);
l %= mo;
r += ((((k * (binpow(10, i * 2 - 2) % mo)) % mo)) % mo);
r %= mo;
}
l += (x % 10) * 10;
l %= mo;
r += (x % 10);
r %= mo;
ans += (l + r) % mo;
ans %= mo;
}
}
cout << (((ans * n) % mo)) % mo;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
set<int> chat;
set<int>::iterator it;
int n, k, q, i, t[150009], ch, id;
cin >> n >> k >> q;
for (i = 1; i <= n; i++) scanf("%d", &t[i]);
for (i = 0; i < q; i++) {
scanf("%d%d", &ch, &id);
if (ch == 1) {
chat.insert(t[id]);
it = chat.begin();
if (chat.size() > k) chat.erase(it);
} else {
if (chat.find(t[id]) == chat.end())
printf("NO\n");
else
printf("YES\n");
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1000000007;
const int MM = 998244353;
template <typename T, typename U>
static inline void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static inline void amax(T &x, U y) {
if (x < y) x = y;
}
int _runtimeTerror_() {
int n, m;
cin >> n >> m;
vector<int> x(n + 1), y(n + 1);
for (int i = 1; i <= n; ++i) {
cin >> x[i] >> y[i];
}
vector<int> psum(m + 5), last(n + 1);
const int B = 500;
vector<vector<int>> tmp(B + 1, vector<int>(B + 1));
for (int i = 1; i <= m; ++i) {
int op, k;
cin >> op >> k;
if (op == 1) {
if (y[k] + x[k] > B) {
for (int cur = i + x[k]; cur <= m; cur += x[k] + y[k]) {
++psum[cur];
--psum[min(m + 1, cur + y[k])];
}
} else {
for (int j = x[k]; j <= x[k] + y[k] - 1; ++j) {
++tmp[x[k] + y[k]][(i + j) % (x[k] + y[k])];
}
}
last[k] = i;
} else {
if (y[k] + x[k] > B) {
for (int cur = last[k] + x[k]; cur <= m; cur += x[k] + y[k]) {
if (cur + y[k] < i) {
continue;
}
--psum[max(cur, i)];
++psum[min(m + 1, cur + y[k])];
}
} else {
for (int j = x[k]; j <= x[k] + y[k] - 1; ++j) {
--tmp[x[k] + y[k]][(last[k] + j) % (x[k] + y[k])];
}
}
}
psum[i] += psum[i - 1];
int ans = psum[i];
for (int j = 1; j <= B; ++j) {
ans += tmp[j][i % j];
}
cout << ans << "\n";
}
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) _runtimeTerror_();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
long long pows(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
long long powm(long long x, long long y, long long m = 1000000007) {
x = x % m;
long long res = 1;
while (y) {
if (y & 1) res = res * x;
res %= m;
y = y >> 1;
x = x * x;
x %= m;
}
return res;
}
long long modInverse(long long a, long long m = 1000000007) {
return powm(a, m - 2, m);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, i, j, k, x, y, z, t, e, f, p, q, g, l, r, o, w, h,
count1 = 0, prod = 1, a, b, c, d, index, x1, x2, y1, y2, diff, ans = 0,
sum = 0, sum1 = 0, sum2 = 0, flag = 0, flag1 = 0, flag2 = 0;
string s, s1, s2;
cin >> n;
vector<long long> ar(n);
p = 0;
for (int i = 0; i < n; i++) {
cin >> ar[i];
p += ar[i] - 1;
}
sort(ar.begin(), ar.end());
vector<long long> v(100001, 1);
for (i = 2; i < 100001; i++) {
x = i;
while (x < 100000000000001) {
v[i]++;
x *= i;
}
}
ans = 3e18;
ans = min(ans, p);
for (i = 2; i < 100001; i++) {
if (v[i] < n) {
break;
}
x = 1;
y = i;
p = 0;
for (j = 0; j < n; j++) {
p += abs(ar[j] - x);
x *= y;
}
ans = min(ans, p);
}
cout << ans << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mxN = 5e3 + 33;
vector<pair<int, int> > g[mxN + 33];
vector<vector<int> > dp, p;
int n, m, T;
void dfs(int v, int cnt = 1, int t = 0, int pr = n - 1) {
if (t > T || t >= dp[v][cnt]) {
return;
}
if (v == 0) {
dp[v][cnt] = 0;
}
dp[v][cnt] = t;
p[v][cnt] = pr;
for (auto &i : g[v]) {
dfs(i.first, cnt + 1, t + i.second, v);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> T;
dp.assign(n + 1, vector<int>(n + 1, 1e9 + 33));
p.resize(n + 1, vector<int>(n + 1));
for (int i = 0; i < m; i++) {
int x, y, w;
cin >> x >> y >> w;
x--;
y--;
g[x].push_back({y, w});
}
dfs(0);
int mx = 1, lst = n - 1;
for (int i = 1; i <= n; i++) {
if (dp[n - 1][i] <= T) {
mx = max(mx, i);
}
}
vector<int> ans;
ans.push_back(n - 1);
lst = n - 1;
int dop = mx;
while (lst != 0) {
lst = p[lst][dop];
ans.push_back(lst);
dop--;
}
reverse(ans.begin(), ans.end());
cout << mx << '\n';
for (auto i : ans) {
cout << i + 1 << " ";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> vc, vis;
int main() {
int t;
cin >> t;
while (t--) {
vc.clear();
int n, m;
cin >> n >> m;
vis.reserve(3 * n + 1);
for (int i = 0; i < 3 * n + 1; i++) vis[i] = 0;
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
if (!vis[u] && !vis[v]) {
vis[u] = vis[v] = 1;
vc.push_back(i);
}
}
if (vc.size() >= n) {
puts("Matching");
for (int i = 0; i < n; i++) printf("%d ", vc[i]);
cout << endl;
} else {
puts("IndSet");
int cnt = 0;
for (int i = 1; i <= 3 * n; i++) {
if (!vis[i]) {
printf("%d ", i);
cnt++;
}
if (cnt == n) {
cout << endl;
break;
}
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> t(n);
for (int i = 0; i < n; ++i) cin >> t[i];
int nb = 0;
for (int i = 0; i < n; ++i)
for (int j = 1; j < n; ++j)
if (t[j - 1] > t[j]) {
nb++;
swap(t[j - 1], t[j]);
}
if (nb % 2 == 1)
cout << 1 + 2 * (nb - 1) << endl;
else
cout << 2 * nb << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct outputer;
struct outputable {};
template <typename T>
inline auto sqr(T x) -> decltype(x * x) {
return x * x;
}
template <typename T1, typename T2>
inline bool umx(T1& a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool umn(T1& a, T2 b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const int N = 50;
const int64_t mod = 1000000007;
struct Input {
int n, m;
bool read() { return !!(cin >> n >> m); }
void init(const Input& input) { *this = input; }
};
struct Data : Input {
int64_t ans;
void write() { cout << ans << endl; }
};
namespace Main {
struct Solution : Data {
int64_t d[N + 1][N + 1], nd[N + 1][N + 1];
int64_t p[N + 1][N + 1];
int64_t pw(int64_t a, int64_t k) {
int64_t res = 1;
while (k) {
if (k & 1) {
(res *= a) %= mod;
}
(a *= a) %= mod;
k >>= 1;
}
return res;
}
void solve() {
memset(d, 0, sizeof d);
memset(p, 0, sizeof p);
d[0][0] = 1;
for (int i = int(1); i < int(N + 1); ++i) {
for (int j = int(1); j < int(i + 1); ++j) {
for (int x = int(0); x < int(i); ++x) {
for (int y = int(j - 1); y < int(x + 1); ++y) {
(p[i][j] += d[x][y] * d[i - 1 - x][j - 1] * (2 - (y == j - 1))) %=
mod;
}
}
memcpy(nd, d, sizeof d);
int64_t c = 1;
for (int k = int(1); k < int(N / i + 1); ++k) {
(c *= (p[i][j] + k - 1) * pw(k, mod - 2) % mod) %= mod;
for (int x = int(N - i * k + 1) - 1; x >= int(0); --x) {
for (int y = int(x + 1) - 1; y >= int(0); --y) {
(nd[x + k * i][y + k * j] += d[x][y] * c) %= mod;
}
}
}
memcpy(d, nd, sizeof d);
}
}
ans = d[n][m - 1];
}
void clear() { *this = Solution(); }
};
} // namespace Main
Main::Solution sol;
int main() {
cout.setf(ios::showpoint | ios::fixed);
cout.precision(20);
sol.read();
sol.solve();
sol.write();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long a[100005];
unordered_map<long long, int> mp;
struct query {
int l, r, index;
};
int block = 320;
struct query b[100005];
int ans[100005];
int currentAns = 0;
void add(int current) {
mp[a[current]]++;
if (mp[a[current]] == a[current])
currentAns++;
else if (mp[a[current]] == 1 + a[current])
currentAns--;
}
void remove(int current) {
mp[a[current]]--;
if (mp[a[current]] == a[current])
currentAns++;
else if (mp[a[current]] == a[current] - 1)
currentAns--;
}
bool compare(struct query x, struct query y) {
if (x.l / block != y.l / block) return (x.l < y.l);
return (x.r < y.r);
}
int main() {
int n, m, left, right;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%I64d", a + i);
}
for (int i = 1; i <= m; ++i) {
scanf("%d %d", &left, &right);
b[i].l = left;
b[i].r = right;
b[i].index = i;
}
sort(b + 1, b + m + 1, compare);
int currentL = 1;
int currentR = 1;
for (int i = 1; i <= m; ++i) {
int L = b[i].l;
int R = b[i].r;
while (currentR <= R) {
add(currentR);
currentR++;
}
while (currentL > L) {
add(currentL - 1);
currentL--;
}
while (currentL < L) {
remove(currentL);
currentL++;
}
while (currentR > R + 1) {
remove(currentR - 1);
currentR--;
}
ans[b[i].index] = currentAns;
}
for (int i = 1; i <= m; ++i) printf("%d\n", ans[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int ck[1024];
int main() {
int n;
scanf("%d", &n);
vector<int> ans;
if (n == 1) {
printf("0\n");
return 0;
} else {
for (int i = 2; i <= n; i++)
if (!ck[i]) {
for (int j = i * i; j <= n; j += i) ck[j] = 1;
int j = i;
while (j <= n) {
ans.push_back(j);
j *= i;
}
}
}
printf("%d\n", ans.size());
for (int i = 0; i < int(ans.size()); i++) printf("%d ", ans[i]);
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int max(int i, int j) { return i > j ? i : j; }
int min(int i, int j) { return i < j ? i : j; }
int main(int argc, char** argv) {
int m;
cin >> m;
vector<int> rets;
int i = 1;
int cur = 0;
while (cur <= m) {
int t = i;
while (t % 5 == 0) {
t /= 5;
++cur;
}
if (cur == m) {
rets.push_back(i);
}
++i;
}
cout << rets.size() << endl;
for (i = 0; i < rets.size(); ++i) cout << rets[i] << " ";
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string FILE_NAME = "testcase.289A";
string NAME;
string itos(int n) {
stringstream ss;
ss << n;
return ss.str();
}
int main() {
ios_base::sync_with_stdio(0);
long long n, k;
cin >> n >> k;
long long p = 0LL;
for (int i = 0; i < (n); i++) {
int l, r;
cin >> l >> r;
p += (long long)(r - l + 1LL);
}
if (p % k == 0LL) {
cout << 0 << endl;
} else {
long long res = (k - (p % k) + k) % k;
cout << res << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> node;
int main() {
int n, m;
cin >> n >> m;
node.resize(n + 1);
for (long long i = 0; i < n; i++) {
cin >> node[i];
}
double best = 0;
for (long long i = 0; i < m; i++) {
double a, b, c;
cin >> a >> b >> c;
a--;
b--;
best = max(best, 1.0 * (node[a] + node[b]) / c);
}
cout.precision(10);
cout << fixed << best << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
int main() {
int N;
cin >> N;
int a = 0, b = 0;
vector<int> tab(N / 2);
for (int i = 0; i < N / 2; ++i) {
int x;
cin >> tab[i];
}
sort(tab.begin(), tab.end());
for (int i = 0; i < N / 2; ++i) {
a += abs((2 * i + 1) - tab[i]);
b += abs((2 * i + 2) - tab[i]);
}
cout << min(a, b);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string s;
bool ok(int i, int j) {
if (j - i > 1 && s[i] == '0') return false;
if (j - i > 8) return false;
int x = 0;
for (int k = i; k < j; k++) x = x * 10 + s[k] - '0';
return x <= 1000000;
}
int calc(int i, int j) {
int x = 0;
for (int k = i; k < j; k++) x = x * 10 + s[k] - '0';
return x;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> s;
int ans = -1;
for (int i = 1; i < s.size(); i++)
for (int j = i + 1; j < s.size(); j++) {
int sum = 0;
if (ok(0, i))
sum += calc(0, i);
else
continue;
if (ok(i, j))
sum += calc(i, j);
else
continue;
if (ok(j, s.size()))
sum += calc(j, s.size());
else
continue;
ans = max(ans, sum);
}
cout << ans << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1005;
const int MAXM = 400005;
struct Opr {
int tp, r, c, id;
long long v;
} opr[MAXM], a[MAXM];
int n, m, tot;
long long sum[MAXN];
long long ans[MAXM];
bool isq[MAXM];
vector<int> M[MAXN];
vector<int> Q[MAXN];
void modify(int p, long long v) {
while (p <= n) {
sum[p] ^= v;
p += p & -p;
}
}
long long query(int p) {
long long res = 0;
while (p >= 1) {
res ^= sum[p];
p -= p & -p;
}
return res;
}
void addq(int tp, int r, int c, long long v, int id) {
if (!r || !c) return;
opr[++tot] = (Opr){tp, r, c, id, v};
}
bool cmpdn(const Opr &a, const Opr &b) {
return a.r == b.r ? a.tp > b.tp : a.r < b.r;
}
void solve(int l, int r) {
if (l == r) return;
int mid = l + r >> 1, p = 0;
for (int i = l; i <= mid; i++)
if (opr[i].tp == 2) a[++p] = opr[i];
for (int i = mid + 1; i <= r; i++)
if (opr[i].tp == 1) a[++p] = opr[i];
if (p <= 1000)
sort(a + 1, a + p + 1, cmpdn);
else {
p = 0;
for (int i = 1; i <= 1000; i++) {
M[i].clear();
Q[i].clear();
}
for (int i = l; i <= mid; i++)
if (opr[i].tp == 2) M[opr[i].r].push_back(i);
for (int i = mid + 1; i <= r; i++)
if (opr[i].tp == 1) Q[opr[i].r].push_back(i);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < M[i].size(); j++) a[++p] = opr[M[i][j]];
for (int j = 0; j < Q[i].size(); j++) a[++p] = opr[Q[i][j]];
}
}
for (int i = 1; i <= p; i++) {
if (a[i].tp == 1)
ans[a[i].id] ^= query(a[i].c);
else if ((a[i].r & 1) && (a[i].c & 1))
modify(a[i].c, a[i].v);
}
if (p <= 50) {
for (int i = 1; i <= p; i++)
if (a[i].tp == 2 && (a[i].r & 1) && (a[i].c & 1)) modify(a[i].c, a[i].v);
} else
memset(sum, 0, sizeof(sum));
for (int i = 1; i <= p; i++) {
if (a[i].tp == 1) {
if (a[i].c & 1) ans[a[i].id] ^= query(n - a[i].c);
} else if (a[i].r & 1)
modify(n - a[i].c + 1, a[i].v);
}
if (p <= 50) {
for (int i = 1; i <= p; i++)
if (a[i].tp == 2 && (a[i].r & 1)) modify(n - a[i].c + 1, a[i].v);
} else
memset(sum, 0, sizeof(sum));
reverse(a + 1, a + p + 1);
for (int i = 1; i <= p; i++) {
if (a[i].tp == 2)
modify(n - a[i].c + 1, a[i].v);
else if ((a[i].r & 1) && (a[i].c & 1))
ans[a[i].id] ^= query(n - a[i].c);
}
if (p <= 50) {
for (int i = 1; i <= p; i++)
if (a[i].tp == 2) modify(n - a[i].c + 1, a[i].v);
} else
memset(sum, 0, sizeof(sum));
for (int i = 1; i <= p; i++) {
if (a[i].tp == 1) {
if (a[i].r & 1) ans[a[i].id] ^= query(a[i].c);
} else if (a[i].c & 1)
modify(a[i].c, a[i].v);
}
if (p <= 50) {
for (int i = 1; i <= p; i++)
if (a[i].tp == 2 && (a[i].c & 1)) modify(a[i].c, a[i].v);
} else
memset(sum, 0, sizeof(sum));
solve(l, mid);
solve(mid + 1, r);
}
int main() {
scanf("%d%d", &n, &m);
for (int tp, r0, r1, c0, c1, i = 1; i <= m; i++) {
long long v;
scanf("%d%d%d%d%d", &tp, &r0, &c0, &r1, &c1);
if (tp == 2) scanf("%lld", &v);
addq(tp, r1, c1, v, i);
addq(tp, r0 - 1, c1, v, i);
addq(tp, r1, c0 - 1, v, i);
addq(tp, r0 - 1, c0 - 1, v, i);
if (tp == 1) isq[i] = 1;
}
solve(1, tot);
for (int i = 1; i <= m; i++)
if (isq[i]) printf("%lld\n", ans[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 9;
int main() {
long long n;
scanf("%lld", &n);
for (long long i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
printf("%lld", 1 + (n - i) / 2);
return 0;
}
}
printf("%d", 1);
}
| 2 |
#include <bits/stdc++.h>
const int MOD = 1e9 + 7;
inline int add(int a, int b) { return (a += b) >= MOD ? a - MOD : a; }
inline int sub(int a, int b) { return (a -= b) < 0 ? a + MOD : a; }
inline int mul(int a, int b) { return 1ll * a * b % MOD; }
inline void upd(int& a, int b) { (a += b) >= MOD ? a -= MOD : 233; }
inline int qpow(int a, int p) {
int ret = 1;
for (; p; p >>= 1, a = mul(a, a))
if (p & 1) ret = mul(ret, a);
return ret;
}
inline int read() {
int ret, cc, sign = 1;
while (!isdigit(cc = getchar())) sign = cc == '0' ? -1 : sign;
ret = cc - 48;
while (isdigit(cc = getchar())) ret = cc - 48 + ret * 10;
return ret * sign;
}
const int MAXN = 210;
struct matrix {
int n, m;
int a[MAXN][MAXN];
matrix(int n = 0, int m = 0) : n(n), m(m) { memset(a, 0, sizeof a); }
inline int* operator[](int x) { return a[x]; }
inline const int* operator[](int x) const { return a[x]; }
inline matrix operator*(const matrix& rhs) const {
matrix ret(n, rhs.m);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (a[i][j])
for (int k = 1; k <= rhs.m; ++k)
ret[i][k] = add(ret[i][k], mul(a[i][j], rhs[j][k]));
return ret;
}
};
int num[20][20];
int cnt[20];
int tot;
int n, K, m, U;
int main() {
scanf("%d%d%d", &n, &K, &m), U = (1 << m) - 1;
for (int i = 0; i <= K; ++i)
for (int S = 0; S <= U; ++S) num[i][S] = ++tot;
for (int i = 0; i <= U; ++i) cnt[i] = cnt[i >> 1] + (i & 1);
matrix A(tot, tot), F(tot, tot);
for (int i = 0; i <= K; ++i) {
for (int S = 0; S <= U; ++S) {
int T = S << 1 & U;
upd(F[num[i][S]][num[i][T]], 1);
if (i < K) upd(F[num[i][S]][num[i + 1][T | 1]], cnt[S] + 1);
}
}
A[1][1] = 1;
while (n) {
if (n & 1) A = A * F;
F = F * F, n >>= 1;
}
int ans = 0;
for (int S = 0; S <= U; ++S) upd(ans, A[1][num[K][S]]);
printf("%d\n", ans);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
bool is_ok(vector<int64_t> taken, int64_t val) {
for (auto j : taken)
if ((j & val) == val) return true;
return false;
}
signed main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int64_t n, i, ans;
cin >> n;
pair<int64_t, int64_t> a[n];
map<int64_t, int64_t> cnt;
for (int64_t i = 0; i < n; i++) {
cin >> a[i].first;
cnt[a[i].first]++;
}
for (int64_t i = 0; i < n; i++) cin >> a[i].second;
ans = 0;
vector<int64_t> taken;
vector<pair<int64_t, int64_t>> rem;
map<int64_t, bool> vis;
for (int64_t i = 0; i < n; i++) {
if (cnt[a[i].first] > 1) {
ans += a[i].second;
if (!vis[a[i].first]) taken.push_back(a[i].first);
vis[a[i].first] = true;
} else
rem.push_back(a[i]);
}
for (auto j : rem) {
if (is_ok(taken, j.first)) {
taken.push_back(j.first);
ans += j.second;
}
}
cout << ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
int a[N];
long long pre[N];
int main(int argc, char const *argv[]) {
ios::sync_with_stdio(0), cin.tie(0);
int T;
cin >> T;
while (T--) {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
reverse(a, a + n);
for (int i = 0; i < n; i++) {
pre[i] = pre[i - 1] + a[i];
}
int i;
for (i = 0; i < n; i++) {
if (pre[i] / (i + 1) < k) break;
}
cout << i << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmin(T &x, T y) {
return (y < x) ? (x = y, 1) : 0;
}
template <typename T>
inline bool chkmax(T &x, T y) {
return (y > x) ? (x = y, 1) : 0;
}
inline int read() {
int x;
char c;
int f = 1;
while ((c = getchar()) != '-' && (c > '9' || c < '0'))
;
if (c == '-') f = -1, c = getchar();
x = c ^ '0';
while ((c = getchar()) >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ '0');
return x * f;
}
inline long long readll() {
long long x;
char c;
int f = 1;
while ((c = getchar()) != '-' && (c > '9' || c < '0'))
;
if (c == '-') f = -1, c = getchar();
x = c ^ '0';
while ((c = getchar()) >= '0' && c <= '9')
x = (x << 1ll) + (x << 3ll) + (c ^ '0');
return x * f;
}
const int maxn = 2e5 + 10;
long long ans;
int n, fa[maxn << 1], rt[maxn << 1], Le[maxn << 1];
bitset<maxn << 1> bit;
int find(int x) {
if (fa[x] == x) return x;
return fa[x] = find(fa[x]);
}
struct Segment_tree {
int cnt;
struct Tree {
long long sum, Ans;
int l, r, tot;
} T[maxn * 40];
inline void push_up(int x) {
T[x].sum = T[T[x].l].sum + T[T[x].r].sum;
T[x].tot = T[T[x].l].tot + T[T[x].r].tot;
T[x].Ans = T[T[x].l].Ans + T[T[x].r].Ans + T[T[x].l].sum * T[T[x].r].tot;
}
void update(int &x, int L, int R, int q) {
if (!x) x = ++cnt;
if (L == R) {
T[x].sum += L, T[x].tot++;
return;
}
int Mid = (L + R) >> 1;
if (q <= Mid)
update(T[x].l, L, Mid, q);
else
update(T[x].r, Mid + 1, R, q);
push_up(x);
}
int merge(int x, int y, int L, int R) {
if (!x || !y) return x ^ y;
if (L == R) {
T[x].Ans += T[x].sum * T[y].tot + T[y].Ans;
T[x].sum += T[y].sum;
T[x].tot += T[y].tot;
} else {
int Mid = (L + R) >> 1;
T[x].l = merge(T[x].l, T[y].l, L, Mid);
T[x].r = merge(T[x].r, T[y].r, Mid + 1, R);
push_up(x);
}
return x;
}
} Seg;
inline void Merge(int x, int y) {
x = find(x), y = find(y);
ans -= Seg.T[rt[x]].Ans + (long long)Le[x] * Seg.T[rt[x]].sum;
ans -= Seg.T[rt[y]].Ans + (long long)Le[y] * Seg.T[rt[y]].sum;
fa[x] = y;
Le[y] = Le[x];
rt[y] = Seg.merge(rt[x], rt[y], 1, n);
ans += Seg.T[rt[y]].Ans + (long long)Le[y] * Seg.T[rt[y]].sum;
}
int main() {
n = read();
for (register int i = 1, iend = maxn * 2 - 10; i <= iend; ++i)
fa[i] = i, Le[i] = i;
for (register int i = 1, iend = n; i <= iend; ++i) {
int x = read(), y = read();
ans -= (long long)x * y;
if (bit[x]) x = find(x) + 1;
bit[x] = 1;
Seg.update(rt[x], 1, n, y);
ans += Seg.T[rt[x]].Ans + (long long)x * y;
if (bit[x - 1]) Merge(x - 1, x);
if (bit[x + 1]) Merge(x, x + 1);
printf("%lld\n", ans);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int BFS(vector<int> G[], int n) {
queue<int> q;
vector<bool> visited(n + 1, false);
vector<int> distance(n + 1, -1);
visited[1] = true;
distance[1] = 0;
q.push(1);
while (!q.empty()) {
int s = q.front();
q.pop();
for (auto u : G[s]) {
if (visited[u]) continue;
visited[u] = true;
distance[u] = distance[s] + 1;
q.push(u);
}
}
return distance[n];
}
int main(int argc, char const *argv[]) {
int n, m, x, y;
bool g = false;
cin >> n >> m;
vector<int> G1[n + 1];
vector<int> G2[n + 1];
vector<vector<bool> > G(n + 1, vector<bool>(n + 1, false));
while (m--) {
cin >> x >> y;
G[x][y] = true;
G[y][x] = true;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (G[i][j]) {
G1[i].push_back(j);
} else {
G2[i].push_back(j);
}
if (G[1][n])
printf("%d\n", BFS(G2, n));
else
printf("%d\n", BFS(G1, n));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long cal(long long a, long long b, long long c, long long n) {
if (n == 0) return 0;
return (b / c) * n + (a / c) * n * (n - 1) / 2 +
cal(c, (a * n + b) % c, a % c, (a % c * n + b % c) / c);
}
long long a, b, p, q;
long long cnt(long long l, long long r, long long vl, long long vr) {
long long sum = cal(p, l * p + q - vl, q, r - l + 1) -
cal(p, l * p + q - vr - 1, q, r - l + 1);
return sum;
}
long long solve() {
cin >> a >> b >> p >> q;
long long l = 0, r = q / 2;
while (l != r) {
long long mid = (l + r) / 2;
long long bruh = cnt(a, b, q / 2 - mid, (q + 1) / 2 + mid);
if (bruh > 0)
r = mid;
else
l = mid + 1;
}
long long gd = l;
l = a, r = b;
while (l != r) {
long long mid = (l + r) / 2;
long long bruh = cnt(a, mid, q / 2 - gd, (q + 1) / 2 + gd);
if (bruh > 0)
r = mid;
else
l = mid + 1;
}
return l;
}
int main() {
int t;
cin >> t;
while (t--) cout << solve() << '\n';
}
| 9 |
#include <iostream>
#include <cstring>
using namespace std;
const int N = 2e5 + 10;
int a[N], st[N];
int main()
{
int t;
cin >> t;
int n, m, k;
while(t --)
{
int success = 0;
cin >> n >> k >> m;
// cout << n << k << m <<endl;
for (int i = 1; i <= n; i ++) st[i] = 0;
if ((n - m) % (k - 1) != 0)
{
puts("NO");
for (int i = 1; i <= m; i ++)
{
int c;
cin >> c;
}
continue;
}
else
{
for (int i = 1; i <= m; i ++)
{
cin >> a[i];
st[a[i]] = 1;
}
int len = k / 2;
if(m == n)
{
success = 1;
}
int success = 0, cnt = 0, num = n - m;
for (int i = 1; i <= n; i ++)
{
if (st[i])
{
if (cnt >= len && num - cnt >= len)
success = 1;
// cout << cnt << endl;
}
else cnt ++;
}
if (success)
puts("YES");
else
puts("NO");
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
char ch[100010];
int main() {
scanf("%s", ch);
int n = strlen(ch);
for (int i = 0; i <= n - 1; i++) cout << ch[i];
for (int i = n - 2; i >= 0; i--) cout << ch[i];
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c, d, e, f, g, mn, mx, l = -1, r = 1000000000, h[100000],
h2[100000];
bool flag = 0;
cin >> a;
for (int k = 1; k <= a; k++) {
l = -1, r = 1000000000;
mn = 1e23;
mx = 0;
flag = 0;
cin >> b;
for (int i = 1; i <= b; i++) {
cin >> h[i] >> h2[i];
c = h[i];
d = h2[i];
mn = min(d, mn);
mx = max(c, mx);
if (l < c) l = c;
if (r > d) r = d;
}
if (r < l) {
flag = 1;
} else
for (int i = 1; i <= b; i++) {
if (l < h[i]) {
flag = 1;
break;
}
if (r > h2[i]) {
flag = 1;
break;
}
}
if (flag == 0) {
cout << 0 << '\n';
} else
cout << mx - mn << '\n';
}
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.