solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T x, T y) {
if (x < y) swap(x, y);
while (y > 0) {
T f = x % y;
x = y;
y = f;
}
return x;
}
template <typename T>
pair<T, T> exgcd(T x, T y) {
if (x < y) swap(x, y);
pair<T, T> r = make_pair(1, 0);
while (y > 0) {
T f = x % y;
r = make_pair(r.second, r.first - (x / y) * r.second);
x = y;
y = f;
}
return r;
}
int n, q, m;
struct QR {
int t, l, r;
};
QR qr[(int)2e5 + 7];
int a[(int)2e5 + 7];
int main(int argc, char *argv[]) {
std::cin.sync_with_stdio(false);
std::cin.tie(nullptr);
cin >> n >> q >> m;
{
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= q; i++) {
cin >> qr[i].t >> qr[i].l >> qr[i].r;
}
for (int j = 1; j <= m; j++) {
int x;
cin >> x;
for (int i = q; i >= 1; i--) {
if (x >= qr[i].l && x <= qr[i].r) {
if (qr[i].t == 1) {
x--;
if (x < qr[i].l) x = qr[i].r;
} else {
x = qr[i].l + qr[i].r - x;
}
}
}
cout << (j > 1 ? " " : "") << a[x];
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool solve() {
int n;
if (scanf("%d", &n) == EOF) return false;
vector<int> x(n);
int a[2] = {};
for (int i = 0; i < n; ++i) {
scanf("%d", &x[i]);
if (i && !a[0] && x[i - 1] > x[i]) a[0] = i;
if (i && !a[1] && x[i - 1] < x[i]) a[1] = i;
}
for (int j = 0; j < 2; ++j)
if (a[j]) {
vector<int> x2 = x;
swap(x2[a[j]], x2[a[j] - 1]);
bool v1 = true, v2 = true;
for (int i = 1; i < n; ++i) {
v1 = v1 && x2[i] >= x2[i - 1];
v2 = v2 && x2[i] <= x2[i - 1];
}
if (!v1 && !v2) {
printf("%d %d\n", a[j], a[j] + 1);
return true;
}
}
printf("-1\n");
return true;
}
int main() {
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
const int maxn = 2 * 1e5 + 10;
int f[maxn];
int a[maxn];
void init(int n) {
for (int i = 1; i <= n; i++) {
f[i] = i;
a[i] = i + 1;
}
}
int getf(int u) {
if (u != f[u])
return f[u] = getf(f[u]);
else
return u;
}
void merge(int u, int v) {
int t1 = getf(u);
int t2 = getf(v);
if (t1 != t2) f[t2] = t1;
}
int main() {
while (cin >> n >> m) {
init(n);
int x, y, z;
while (m--) {
scanf("%d%d%d", &x, &y, &z);
if (x == 1)
merge(y, z);
else if (x == 2) {
int cnn;
for (int i = y + 1; i <= z; i = cnn) {
merge(i - 1, i);
cnn = a[i];
a[i] = z + 1;
}
} else {
if (getf(y) != getf(z))
printf("NO\n");
else
printf("YES\n");
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int mod = 998244353;
const int maxn = 1e6 + 5;
const int inf = 1e7;
const long long onf = 1e18;
using namespace std;
int n, m;
int q[maxn], root[maxn], sum[maxn];
long long ans[maxn];
struct node {
int u, v, val;
bool friend operator<(node a, node b) { return a.val < b.val; }
} a[maxn];
int Find(int x) {
if (x == root[x]) return x;
return root[x] = Find(root[x]);
}
void init() {
for (int i = 1; i <= n; i++) {
sum[i] = 1, root[i] = i;
}
}
int main() {
scanf("%d%d", &n, &m);
init();
for (int i = 1; i < n; i++) scanf("%d%d%d", &a[i].u, &a[i].v, &a[i].val);
sort(a + 1, a + n);
int End = 0;
for (int i = 1; i <= m; i++) {
scanf("%d", &q[i]);
End = max(End, q[i]);
}
for (int i = 1; i < n; i++) {
int x1 = Find(a[i].u);
int y1 = Find(a[i].v);
if (x1 != y1) {
long long temp = (long long)sum[x1] * sum[y1];
sum[y1] += sum[x1], sum[x1] = 0;
root[x1] = y1;
ans[a[i].val] += temp;
}
}
for (int i = 1; i <= End; i++) ans[i] += ans[i - 1];
for (int i = 1; i <= m; i++) printf("%lld ", ans[q[i]]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
map<char, int> mp;
for (auto i : s) {
mp[i]++;
}
vector<char> odd;
for (auto [x, y] : mp) {
if (y % 2) odd.push_back(x);
}
int len = odd.size();
for (int i = 0; i < len / 2; i++) {
mp[odd[i]]++;
mp[len - 1 - i]--;
}
string str, ss;
for (auto [x, y] : mp) {
str += string(y / 2, x);
}
cout << str;
if (s.length() % 2) {
for (auto i : odd) {
if (mp[i] % 2 == 1) {
cout << i;
break;
}
}
}
reverse(str.begin(), str.end());
cout << str;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
char grid[53][53];
bool vis[53][53];
int n, m;
pair<int, int> last;
char curChar;
bool valid(int i, int j) {
return i >= 0 && i < n && j >= 0 && j < m && grid[i][j] == curChar;
}
bool dfs(pair<int, int> curr, pair<int, int> prev) {
if (prev != make_pair(-1, -1)) vis[curr.first][curr.second] = 1;
if (curr == last && prev != make_pair(-1, -1)) return true;
for (int i = 0; i < 4; i++) {
int toX = curr.first + dx[i];
int toY = curr.second + dy[i];
if (valid(toX, toY) && !vis[toX][toY] && make_pair(toX, toY) != prev) {
if (dfs(make_pair(toX, toY), curr)) return true;
}
}
return false;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> grid[i][j];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
memset(vis, 0, sizeof(vis));
last = make_pair(i, j);
curChar = grid[i][j];
if (dfs({i, j}, {-1, -1})) return cout << "Yes\n", 0;
}
}
cout << "No\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int vis[55][500005];
int sum[500005];
int one[55];
void solve() {
int n, d;
while (cin >> n >> d) {
vector<int> C;
int i, x, j;
memset(vis, 0, sizeof vis);
memset(sum, 0, sizeof sum);
memset(one, 0, sizeof one);
for (i = 1; i <= n; i++) {
scanf("%d", &x);
C.push_back(x);
}
sort(C.begin(), C.end());
one[0] = C[0];
for (i = 1; i < C.size(); i++) one[i] = one[i - 1] + C[i];
vis[0][0] = 1;
for (i = 0; i < n; i++)
for (j = 0; j <= i * 10000; j++)
if (vis[i][j]) vis[i + 1][j + C[i]] = 1, vis[i + 1][j] = 1;
vector<int> L;
vector<int>::iterator iter;
for (i = 0; i <= n * 10000; i++)
if (vis[n][i]) L.push_back(i);
int now = 0, tot = 0;
while (1) {
int l = 0, r = L.size() - 1;
int h;
while (r >= l) {
if (r - l <= 1) {
if (L[r] - now <= d)
h = r;
else if (L[l] - now <= d)
h = l;
else
h = -1;
break;
}
int mid = (l + r) >> 1;
if (L[mid] - now > d)
r = mid;
else
l = mid;
}
if (h == -1) break;
if (L[h] > now)
now = L[h];
else
break;
tot++;
}
cout << now << " " << tot << endl;
}
}
int main() {
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
int cnt1[26] = {0}, cnt2[26] = {0}, cur, cnt, n, k;
const char C = 'A';
cin >> n >> k >> str;
for (int i = 0; i < n; i++) cnt2[str[i] - C]++;
for (int i = 0; i < n; i++) {
cnt = 1;
cur = str[i] - C;
for (int j = 0; j < 26; j++) {
if (j != cur)
if (cnt1[j] && cnt2[j]) cnt++;
}
if (cnt > k) {
cout << "YES";
return 0;
}
cnt2[cur]--;
cnt1[cur]++;
}
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
long long mi[200010];
int powmod(long long a, int b) {
long long ans = 1;
while (b) {
if (b & 1) ans *= a, ans %= mod;
b >>= 1;
a *= a, a %= mod;
}
return ans;
}
int C(int i, int j) {
return mi[i] * powmod(mi[j], mod - 2) % mod * powmod(mi[i - j], mod - 2) %
mod;
}
long long dfs(int n, int m, int k) {
if (m == 0) {
if (k == 0 && n > 1) return 1;
if (k == 1 && n == 1) return 1;
return 0;
}
if (k == 0) return (C(n + m, n) - dfs(n, m, 1) + mod) % mod;
return dfs(n, m - 1, 0) % mod;
}
int main() {
int n, m, k;
mi[0] = 1;
for (int i = 1; i <= 200000; i++) mi[i] = mi[i - 1] * i % mod;
scanf("%d%d%d", &m, &n, &k);
n = dfs(n, m, k);
printf("%d\n", n);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string a[100][2];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i][0] >> a[i][1];
for (int i = 0; i < n - 1; i++)
if (a[i][1] == "captain") {
string s = a[i][1];
a[i][1] = a[i + 1][1];
a[i + 1][1] = s;
s = a[i][0];
a[i][0] = a[i + 1][0];
a[i + 1][0] = s;
}
for (int i = 1; i < n; i++)
if (a[i][1] == "rat")
for (int j = i; j > 0; j--)
if (a[j - 1][1] != "rat") {
string s = a[j][1];
a[j][1] = a[j - 1][1];
a[j - 1][1] = s;
s = a[j][0];
a[j][0] = a[j - 1][0];
a[j - 1][0] = s;
}
for (int i = 1; i < n; i++)
if (a[i][1] == "woman" || a[i][1] == "child")
for (int j = i; j > 0; j--)
if (a[j - 1][1] != "woman" && a[j - 1][1] != "child" &&
a[j - 1][1] != "rat") {
string s = a[j][1];
a[j][1] = a[j - 1][1];
a[j - 1][1] = s;
s = a[j][0];
a[j][0] = a[j - 1][0];
a[j - 1][0] = s;
}
for (int i = 0; i < n; i++) cout << a[i][0] << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
char c;
int f = 1;
while (!isdigit(c = getchar()))
if (c == '-') f = -1;
x = (c & 15);
while (isdigit(c = getchar())) x = (x << 1) + (x << 3) + (c & 15);
x *= f;
}
int n, m, i, j, typ[100005];
int a[100005], f[100005], fl[100005], fr[100005];
struct seg1 {
struct nd1 {
int mx, s;
} tr[400005];
nd1 merge(nd1 x, nd1 y) {
if (x.mx > y.mx) return x;
if (x.mx < y.mx) return y;
return (nd1){x.mx, x.s + y.s};
}
void pushup(int x) { tr[x] = merge(tr[x + x], tr[x + x + 1]); }
void update(int x, int l, int r, int y) {
if (l == r) {
tr[x].mx ^= 1;
tr[x].s = 1;
return;
}
int mid = (l + r) / 2;
if (y <= mid)
update(x + x, l, mid, y);
else
update(x + x + 1, mid + 1, r, y);
pushup(x);
}
nd1 query(int x, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return tr[x];
int mid = (l + r) / 2;
if (qr <= mid) return query(x + x, l, mid, ql, qr);
if (ql > mid) return query(x + x + 1, mid + 1, r, ql, qr);
return merge(query(x + x, l, mid, ql, qr),
query(x + x + 1, mid + 1, r, ql, qr));
}
} tr1;
struct seg2 {
int mx[400005];
void pushup(int x) { mx[x] = min(mx[x + x], mx[x + x + 1]); }
void update(int x, int l, int r, int y, int c) {
if (l == r) {
mx[x] += c;
return;
}
int mid = (l + r) / 2;
if (y <= mid)
update(x + x, l, mid, y, c);
else
update(x + x + 1, mid + 1, r, y, c);
pushup(x);
}
int query(int x, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return mx[x];
int mid = (l + r) / 2;
if (qr <= mid) return query(x + x, l, mid, ql, qr);
if (ql > mid) return query(x + x + 1, mid + 1, r, ql, qr);
return max(query(x + x, l, mid, ql, qr),
query(x + x + 1, mid + 1, r, ql, qr));
}
} tr2;
bool check() {
int t = min(i - 1, n - j + 1);
if (!fl[t]) return 0;
t = max(m - j + 1, i - (n - m) - 1);
if (!fr[m - max(-1, t - 1)]) return 0;
if (tr2.mx[1] < 0) return 0;
if (tr1.tr[1].mx == 1 && tr1.tr[1].s > ((n & 1) && (i <= m && m <= j)))
return 0;
return 1;
}
void add(int x) {
typ[x]++;
if (x * 2 - 1 != n) {
if (!typ[n - x + 1]) {
tr1.update(1, 1, n, a[x]);
tr1.update(1, 1, n, a[n - x + 1]);
tr2.update(1, 1, n, a[x], 1);
tr2.update(1, 1, n, a[n - x + 1], -1);
} else {
tr2.update(1, 1, n, a[x], 2);
}
} else {
tr1.update(1, 1, n, a[x]);
tr2.update(1, 1, n, a[x], 1);
}
}
void del(int x) {
typ[x]--;
if (x * 2 - 1 != n) {
if (!typ[n - x + 1]) {
tr1.update(1, 1, n, a[x]);
tr1.update(1, 1, n, a[n - x + 1]);
tr2.update(1, 1, n, a[x], -1);
tr2.update(1, 1, n, a[n - x + 1], 1);
} else {
tr2.update(1, 1, n, a[x], -2);
}
} else {
tr1.update(1, 1, n, a[x]);
tr2.update(1, 1, n, a[x], -1);
}
}
int main() {
read(n);
m = (n + 1) / 2;
for ((i) = 1; (i) <= (n); (i)++) read(a[i]);
for ((i) = 1; (i) <= (m); (i)++) f[i] = (a[i] == a[n - i + 1]);
fl[0] = fr[m + 1] = 1;
for ((i) = 1; (i) <= (m); (i)++) {
fl[i] = (fl[i - 1] && f[i]);
}
for ((i) = (m); (i) >= 1; (i)--) {
fr[i] = (fr[i + 1] && f[i]);
}
j = 1;
long long ans = 0;
for ((i) = 1; (i) <= (n); (i)++) {
while (j <= i) add(j++);
while (j <= n && !check()) {
add(j++);
}
if (check()) ans += (n - j + 2);
while (j <= i) add(j++);
del(i);
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int Mod = 998244353;
int n, m, a[55], w[55], f[55][105][55], g[55][105][55], x, sa, sb;
int power(int b, int e) {
if (!e) return 1;
int tmp = power(b, e >> 1);
tmp = 1ll * tmp * tmp % Mod;
if (e & 1) tmp = 1ll * tmp * b % Mod;
return tmp;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> w[i];
for (int i = 1; i <= n; i++)
if (!a[i])
sa += w[i];
else
sb += w[i];
for (int j = 0; j <= 100; j++)
for (int k = 0; k <= m; k++) f[0][j][k] = j;
for (int i = 1; i <= m; i++)
for (int j = 1; j <= 100; j++)
for (int k = 0; k <= m; k++)
if (sb + k >= j && sa >= m - i - k) {
f[i][j][k] = (1ll * j * f[i - 1][j + 1][k + 1] +
1ll * (sb + k - j) * f[i - 1][j][k + 1] +
1ll * (sa - m + i + k) * f[i - 1][j][k]) %
Mod;
f[i][j][k] =
1ll * f[i][j][k] * power(sa + sb + k - m + i + k, Mod - 2) % Mod;
}
for (int j = 0; j <= 100; j++)
for (int k = 0; k <= m; k++) g[0][j][k] = j;
for (int i = 1; i <= m; i++)
for (int j = 1; j <= 100; j++)
for (int k = 0; k <= m; k++) {
g[i][j][k] = (1ll * j * g[i - 1][j - 1][k] +
1ll * (sb + k) * g[i - 1][j][k + 1] +
1ll * (sa - j - m + i + k) * g[i - 1][j][k]) %
Mod;
g[i][j][k] =
1ll * g[i][j][k] * power(sa + sb + k - m + i + k, Mod - 2) % Mod;
}
for (int i = 1; i <= n; i++)
if (a[i])
cout << f[m][w[i]][0] << '\n';
else
cout << g[m][w[i]][0] << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long mi[4];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
long long w, h;
cin >> w >> h;
int k[4] = {0};
for (int i = 0; i < 4; i++) {
cin >> k[i];
long long pos1 = 0, pos2 = 0;
for (int j = 0; j < k[i]; j++) {
long long tt;
cin >> tt;
if (j == 0) pos1 = tt;
if (j == k[i] - 1) pos2 = tt;
}
mi[i] = pos2 - pos1;
}
for (int i = 0; i < 4; i++) {
if (i < 2)
mi[i] *= h;
else
mi[i] *= w;
}
long long mx = -1e9;
for (int i = 0; i < 4; i++) mx = max(mi[i], mx);
cout << mx << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
int x1, y1, x2, y2;
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
int x = abs(x1 - x2);
x++;
int y = abs(y1 - y2);
y++;
if (x == 1) x++;
if (y == 1) y++;
int ans = (x + y) << 1;
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char T[10][10];
bool noup(int i, int j) {
for (int k = i - 1; k >= 0; k--) {
if (T[k][j] == 'B') return false;
}
return true;
}
bool nodown(int i, int j) {
for (int k = i + 1; k < 8; k++) {
if (T[k][j] == 'W') return false;
}
return true;
}
void read() {
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
cin >> T[i][j];
}
}
}
void solve() {
char a;
int pie = 90, dru = 90;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
a = T[i][j];
if (a == 'W' && noup(i, j)) {
pie = min(pie, i);
} else if (a == 'B' && nodown(i, j)) {
dru = min(dru, 8 - i - 1);
} else
continue;
}
}
if (pie <= dru)
cout << "A" << endl;
else
cout << "B" << endl;
}
int main() {
read();
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:108777216")
using namespace std;
int const MAX_N = 256;
int s[MAX_N][MAX_N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) scanf("%d", &s[i][j]);
int t = 1;
for (int i = 0; i < n && t; i++)
for (int j = 0; j < n && t; j++)
if (s[i][j] != 1) {
int Ok = 0;
for (int a = 0; a < n && !Ok; a++)
for (int b = 0; b < n && !Ok; b++)
if (s[a][j] + s[i][b] == s[i][j]) Ok = 1;
if (!Ok) {
t = 0;
break;
}
}
if (t)
cout << "Yes";
else
cout << "No";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int n, p, a[100005];
int main() {
ios::sync_with_stdio(false);
cin >> n >> p;
for (int i = 0; i < n; ++i) cin >> a[i];
sort(a, a + n);
int xlow = 1, xhigh = 1e9 + 8;
for (int i = n - 1; i >= 0; --i) {
int minx = max(1, a[i] - i);
int maxx = max(1, a[i] - i + p - 1);
xlow = max(minx, xlow);
if (i >= p - 1) xhigh = min(maxx, xhigh);
}
cout << max(xhigh - xlow, 0) << endl;
for (int i = xlow; i < xhigh; ++i) cout << i << " ";
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
void solve() {
map<int, vector<int> > pos;
int arr[500005];
int q, cnt1 = 0;
cin >> q;
while (q--) {
int a, x, y;
cin >> a;
if (a == 1) {
cin >> x;
pos[x].push_back(cnt1);
cnt1++;
} else {
cin >> x >> y;
if (x != y) {
if (pos[x].size() > pos[y].size()) {
swap(pos[x], pos[y]);
}
for (int i = 0; i < pos[x].size(); i++) {
pos[y].push_back(pos[x][i]);
}
pos[x].clear();
}
}
}
for (int i = 0; i < 500005; i++) {
for (int j = 0; j < pos[i].size(); j++) {
arr[pos[i][j]] = i;
}
}
for (int i = 0; i < cnt1; i++) {
cout << arr[i] << " ";
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int t, tc;
t = 1, tc = 0;
while (t--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> tree[2 * 100000 + 4];
long long dp[2 * 100000 + 3][2];
int value[2 * 100000 + 4];
void dfs(int x) {
dp[x][0] = 0;
dp[x][1] = -200000000005;
for (int i = 0, sz = tree[x].size(); i < sz; i++) {
int v = tree[x][i];
dfs(v);
long long tmp1 = dp[x][1], tmp0 = dp[x][0];
dp[x][0] = max(tmp0 + dp[v][0], tmp1 + dp[v][1]);
dp[x][1] = max(tmp1 + dp[v][0], tmp0 + dp[v][1]);
}
dp[x][1] = max(dp[x][0] + value[x], dp[x][1]);
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x >> value[i];
if (i == 1) continue;
tree[x].push_back(i);
}
dfs(1);
cout << dp[1][1] << endl;
}
| 6 |
// Author: wlzhouzhuan
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define pii pair<int, int>
#define pb push_back
#define fir first
#define sec second
#define rep(i, l, r) for (int i = l; i <= r; i++)
#define per(i, l, r) for (int i = l; i >= r; i--)
#define mset(s, t) memset(s, t, sizeof(s))
#define mcpy(s, t) memcpy(s, t, sizeof(t))
template<typename T1, typename T2> void ckmin(T1 &a, T2 b) { if (a > b) a = b; }
template<typename T1, typename T2> void ckmax(T1 &a, T2 b) { if (a < b) a = b; }
int read() {
int x = 0, f = 0; char ch = getchar();
while (!isdigit(ch)) f |= ch == '-', ch = getchar();
while (isdigit(ch)) x = 10 * x + ch - '0', ch = getchar();
return f ? -x : x;
}
template<typename T> void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
template<typename T> void print(T x, char let) {
print(x), putchar(let);
}
const int N = 100005;
const int M = 200 * N;
const int inf = 1e9;
int L[N], R[N];
int n, m;
struct node { int x, y, id; };
vector<node> vec[N];
int rt[N << 2], ls[M], rs[M], minn[M], seg_tot;
void ins(int &u, int l, int r, int y, int z) {
if (!u) u = ++seg_tot, minn[u] = inf;
ckmin(minn[u], z);
if (l == r) return ;
int mid = l + r >> 1;
if (y <= mid) ins(ls[u], l, mid, y, z);
else ins(rs[u], mid + 1, r, y, z);
}
void ins(int u, int l, int r, int x, int y, int z) {
ins(rt[u], 1, n, y, z);
if (l == r) return ;
int mid = l + r >> 1;
if (x <= mid) ins(2 * u, l, mid, x, y, z);
else ins(2 * u + 1, mid + 1, r, x, y, z);
}
int qry(int u, int l, int r, int ql, int qr) {
if (!u || qr < l || ql > r || ql > qr) return inf;
if (ql <= l && r <= qr) return minn[u];
int mid = l + r >> 1;
return min(qry(ls[u], l, mid, ql, qr), qry(rs[u], mid + 1, r, ql, qr));
}
int query(int u, int l, int r, int ql, int qr) {
if (qr < l || ql > r || ql > qr) return inf;
if (ql <= l && r <= qr) return qry(rt[u], 1, n, ql, qr);
int mid = l + r >> 1;
return min(query(2 * u, l, mid, ql, qr), query(2 * u + 1, mid + 1, r, ql, qr));
}
int ans[N];
queue<node> q;
void add(int l, int r) {
if (l <= r) {
int t = query(1, 1, n, l, r);
if (t != inf) q.push({l, r, t});
}
}
int solve() {
// printf("solve!\n");
add(1, n);
int len = 0;
while (!q.empty()) {
node u = q.front(); q.pop();
// printf("%d %d %d\n", u.x, u.y, u.id);
len += R[u.id] - L[u.id] + 1;
add(u.x, L[u.id] - 1);
add(R[u.id] + 1, u.y);
}
return len;
}
int main() {
n = read(), m = read();
rep(i, 1, m) {
int l = read(), r = read();
L[i] = l, R[i] = r;
vec[r - l + 1].pb({l, r, i});
}
per(i, n, 1) {
for (auto v: vec[i]) ins(1, 1, n, v.x, v.y, v.id);
ans[i] = solve();
}
rep(i, 1, n) print(ans[i], '\n');
return 0;
} | 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tst;
cin >> tst;
while (tst--) {
int rows, cols;
cin >> rows >> cols;
vector<bool> rc(rows);
vector<bool> cc(cols);
for (int i = 0; i < rows; i++) rc[i] = true;
for (int i = 0; i < cols; i++) cc[i] = true;
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
int temp;
cin >> temp;
if (temp == 1) {
rc[i] = false;
cc[j] = false;
}
}
}
int rocc = rows, cocc = cols;
for (int i = 0; i < rows; i++) {
if (!rc[i]) rocc--;
}
for (int i = 0; i < cols; i++) {
if (!cc[i]) cocc--;
}
rocc = min(rocc, cocc);
if (rocc % 2 == 0)
cout << "Vivek";
else
cout << "Ashish";
cout << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
int input[1000010], check[1000100];
int main() {
int i, cnt = 0, tmp, a, b;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &input[i]);
check[input[i]] = i;
}
for (i = 1; i <= n; i++) {
if (input[i] != i) {
check[input[i]] = check[i];
swap(input[check[i]], input[i]);
check[i] = i;
cnt++;
}
}
if (cnt % 2 == (n * 3) % 2)
printf("Petr");
else
printf("Um_nik");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, t0, t1, s0[N], s1[N];
long long a[N], f[N], g[N], dp[70][N];
inline void srt(long long x) {
int cc = 0;
for (int i = 1; i <= n; ++i)
if (!(a[f[i]] >> x & 1)) g[++cc] = f[i];
for (int i = 1; i <= n; ++i)
if (a[f[i]] >> x & 1) g[++cc] = f[i];
for (int i = 1; i <= n; ++i) f[i] = g[i];
}
inline void init(long long x) {
for (int i = 1; i <= n; ++i) {
s0[i] = s0[i - 1];
s1[i] = s1[i - 1];
if (a[f[i]] >> x & 1)
s1[i]++;
else
s0[i]++;
}
t1 = s1[n];
t0 = s0[n];
}
int main() {
long long mx = 0;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%lld", &a[i]), mx = max(mx, a[i]);
for (int i = 1; i <= n; ++i) a[i] = mx - a[i], f[i] = i;
memset(dp, 0x3f, sizeof(dp));
dp[0][0] = 0;
for (long long i = 0; i < 62; ++i) {
if (i) srt(i - 1);
init(i);
for (int j = 0; j <= n; ++j) {
int w, stt;
w = s1[n - j] + t0 - s0[n - j];
stt = t1 - s1[n - j];
dp[i + 1][stt] = min(dp[i + 1][stt], dp[i][j] + w);
w = s0[n - j] + t1 - s1[n - j];
stt = n - s0[n - j];
dp[i + 1][stt] = min(dp[i + 1][stt], dp[i][j] + w);
}
}
printf("%lld\n", dp[62][0]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
string tobin(int x, int len) {
string c;
while (x > 0) {
c.push_back(x % 2 + '0');
x >>= 1;
}
while (int((c).size()) < len) c.push_back('0');
reverse((c).begin(), (c).end());
return c;
}
char s[1000005];
int n;
vector<int> st;
void solve() {
for (int i = 0; i < n; ++i) {
if (s[i] == 'l')
st.push_back(i);
else
printf("%d\n", i + 1);
}
for (int i = int((st).size()) - 1; i >= 0; --i) printf("%d\n", st[i] + 1);
}
int main() {
scanf("%s", &s);
n = strlen(s);
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char s[1123456];
long long a[1123456] = {}, b[1123456] = {};
int main() {
scanf("%s", s);
int n = strlen(s);
for (int i = (1); i < (n); i++)
if (s[i - 1] == 'v' && s[i] == 'v') a[i] = 1;
for (int i = (0); i < ((n)); i++) b[i + 1] = b[i] + a[i];
long long ans = 0;
for (int i = (0); i < ((n)); i++) {
if (s[i] != 'o') continue;
ans += (b[n] - b[i + 1]) * (b[i] - a[0]);
}
printf("%lld\n", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, v[50], idx[50], ans[50];
bool cmp(int a, int b) { return v[a] < v[b]; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> v[i], idx[i] = i;
sort(idx + 1, idx + n + 1, cmp);
ans[idx[1]] = v[idx[n]];
for (int i = 1; i < n; i++) ans[idx[i + 1]] = v[idx[i]];
for (int i = 1; i <= n; i++) cout << ans[i] << " \n"[i == n];
}
| 6 |
#include <bits/stdc++.h>
int main() {
std::ios_base::sync_with_stdio(0);
int n, k;
std::cin >> n >> k;
std::multiset<long long> vbudke;
for (int i(0); i < k; i++) {
vbudke.insert(0);
}
long long s, m, lCurrentServer;
for (int i(0); i < n; i++) {
lCurrentServer = *vbudke.begin();
vbudke.erase(vbudke.begin());
std::cin >> s >> m;
if (s > lCurrentServer) {
lCurrentServer = s + m;
} else {
lCurrentServer += m;
}
std::cout << lCurrentServer << std::endl;
vbudke.insert(lCurrentServer);
}
std::cin.get();
std::cin.get();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MX = (1 << 20);
int n, m;
pair<int, int> arr[MX];
set<int> S;
set<int>::iterator it;
vector<int> sol;
map<pair<int, int>, int> idx;
int main() {
scanf("%d %d", &n, &m);
for (int j = 1; j <= n; j++) S.insert(j);
for (int j = 1; j <= m; j++) {
int a, b;
scanf("%d %d", &a, &b);
arr[j] = make_pair(a, n - b + 1);
idx[make_pair(n - b + 1, a)] = j;
}
sort(arr + 1, arr + 1 + m);
for (int j = 1; j <= m; j++) swap(arr[j].first, arr[j].second);
for (int j = 1; j <= m; j++) {
it = S.lower_bound(arr[j].first);
if (it == S.end()) continue;
if (*it > arr[j].second) continue;
S.erase(it);
sol.push_back(idx[arr[j]]);
}
sort(sol.begin(), sol.end());
cout << sol.size() << endl;
for (int j = 0; j < sol.size(); j++) cout << sol[j] << ' ';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
while (0) {
};
std::cin.tie(0);
std::cout.sync_with_stdio(false);
int n, m, a, b;
cin >> n >> m;
vector<list<int> > e(n + 1);
vector<list<int> > k(n + 1);
vector<set<int> > st(n + 1);
vector<bool> vis(n + 1, false);
for (int i = 0; i < m; i++) {
cin >> a >> b;
e[a].push_back(b);
e[b].push_back(a);
}
for (int i = 0; i < n; i++) {
cin >> a;
k[a].push_back(i + 1);
}
bool cond = true;
list<int> ans;
for (int i = 1; i < n + 1; i++) {
for (auto j : k[i]) {
ans.push_back(j);
if (st[j].size() != i - 1)
cond = false;
else if (i > 1)
if (*st[j].rbegin() == i) cond = false;
if (!cond) break;
vis[j] = true;
for (auto m : e[j]) {
if (!vis[m]) st[m].insert(i);
}
}
if (!cond) break;
}
if (!cond)
cout << -1 << endl;
else
for (auto i : ans) cout << i << " ";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s;
void sdvig() {
char x = s[0];
s.erase(0, 1);
s = s + (char)x;
}
vector<string> v;
string fin;
vector<int> dp[4];
int k, base = 1000000007;
int mod(int x) {
if (x < 0) x += base;
return x;
}
int main() {
cin >> s >> fin;
cin >> k;
v.push_back(s);
int l = s.length();
for (int i = 1; i < l; i++) {
sdvig();
v.push_back(s);
}
sdvig();
sort(v.begin(), v.end());
vector<int> gvv(1100);
dp[1] = gvv;
dp[2] = dp[1];
int sum1 = 0, sum2 = 0;
int g;
for (int i = 0; i < v.size(); i++)
if (v[i] == s) {
dp[1][i] = 1;
sum1++;
}
for (int i = 1; i <= k; i++) {
sum2 = 0;
for (int j = 0; j < v.size(); j++) {
dp[2][j] = (mod(sum1 - dp[1][j])) % base;
sum2 = (sum2 + dp[2][j]) % base;
}
sum1 = sum2;
swap(dp[1], dp[2]);
}
int ans = 0;
for (int i = 0; i < v.size(); i++) {
if (v[i] == fin) {
ans = (ans + dp[1][i]) % base;
break;
}
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int q, k;
long double dp[10000][1001], p;
int main() {
ios_base::sync_with_stdio(false);
cin >> k >> q;
dp[0][0] = 1;
for (int i = 1; i < 10000; i++)
for (int j = 1; j <= k; j++)
dp[i][j] = ((long double)j / (long double)k) * dp[i - 1][j] +
((long double)(k - j + 1) / (long double)k) * dp[i - 1][j - 1];
while (q--) {
cin >> p;
for (int i = 1; i; i++) {
if (dp[i][k] >= p / (long double)2000) {
cout << i << endl;
break;
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[100010];
int pre[10009];
int main() {
int n;
int i, j;
int w;
scanf("%d%d", &n, &w);
pre[0] = 0;
int maxa = -0x3f3f3f3f;
int mina = 0x3f3f3f3f;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
pre[i] = pre[i - 1] + a[i];
maxa = max(maxa, pre[i]);
mina = min(mina, pre[i]);
}
mina = min(0, mina);
maxa = max(maxa, 0);
if (maxa > w || mina < -1 * w || -mina > w - maxa) {
printf("0\n");
return 0;
}
mina *= -1;
maxa = w - maxa;
printf("%d\n", maxa - mina + 1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char f, s;
cin >> s >> f;
int n;
cin >> n;
n %= 4;
int ff, ss;
switch (f) {
case 'v':
ff = 0;
break;
case '<':
ff = 1;
break;
case '^':
ff = 2;
break;
case '>':
ff = 3;
break;
default:
break;
}
switch (s) {
case 'v':
ss = 0;
break;
case '<':
ss = 1;
break;
case '^':
ss = 2;
break;
case '>':
ss = 3;
break;
default:
break;
}
int tt = ss;
ss += n;
ss %= 4;
bool con = false;
if (ss == ff) con = true;
while (n--) {
tt--;
if (tt == -1) tt = 3;
}
if (tt == ff) {
if (con)
cout << "undefined";
else
cout << "ccw";
} else {
if (con)
cout << "cw";
else
cout << "undefined";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout.precision(18);
int t;
t = 1;
while (t--) {
string s;
cin >> s;
int flag = 0;
for (int i = 0; i < (s.size()); i++) {
if (i > 0 && i < s.size() - 1) {
if (s[i] != '.' && s[i - 1] != '.' && s[i + 1] != '.' &&
s[i] != s[i - 1] && s[i] != s[i + 1] && s[i - 1] != s[i + 1])
flag = 1;
}
}
if (flag)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
long long int ceil(long long int a, long long int b) {
if ((a >= 0 && b >= 0) || (a < 0 && b < 0)) return (a / b) + ((a % b) != 0);
return a / b;
}
long long int floor(long long int a, long long int b) {
if ((a >= 0 && b >= 0) || (a < 0 && b < 0)) return a / b;
return a / b - ((a % b) != 0);
}
void IO() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
void solve(vector<string>& grid, int n) {
char a = grid[1][0];
char b = grid[0][1];
char x = grid[n - 1][n - 2];
char y = grid[n - 2][n - 1];
int num0 = 0;
if (a == '0') num0++;
if (b == '0') num0++;
if (x == '0') num0++;
if (y == '0') num0++;
if (num0 == 0 || num0 == 4) {
cout << 2 << "\n";
cout << "2 1\n1 2\n";
} else if (num0 == 1 || num0 == 3) {
cout << 1 << "\n";
if (a == b) {
if (x == a) cout << n << " " << n - 1 << "\n";
if (y == a) cout << n - 1 << " " << n << "\n";
}
if (x == y) {
if (a == x) cout << "2 1\n";
if (b == x) cout << "1 2\n";
}
} else {
if (a == b) {
cout << "0\n";
return;
}
cout << 2 << "\n";
if (a == '1') cout << "2 1\n";
if (b == '1') cout << "1 2\n";
if (x == '0') cout << n << " " << n - 1 << "\n";
if (y == '0') cout << n - 1 << " " << n << "\n";
}
}
int main() {
IO();
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<string> grid(n);
for (int i = 0; i < n; i++) cin >> grid[i];
solve(grid, n);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int t, n, i, j, chk;
char str[110][3];
scanf("%d", &t);
for (i = 0; i < t; i++) {
scanf("%d", &n);
for (j = 0; j < n - 2; j++) {
scanf("%s", str[j]);
}
printf("%c", str[0][0]);
chk = 0;
for (j = 0; j < n - 3; j++) {
if (str[j][1] == str[j + 1][0]) {
printf("%c", str[j][1]);
continue;
} else {
printf("%c%c", str[j][1], str[j + 1][0]);
chk = 1;
}
}
printf("%c", str[n - 3][1]);
if (chk == 0) printf("a");
printf("\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using std::memset;
using std::pow;
using std::printf;
using std::scanf;
const double eps = 1e-9;
int n;
long long peo[500005];
int k;
long long all;
bool judgedown(long long mid) {
long long tmp = 0;
for (int i = 0; i < n; ++i) {
tmp += std::max(mid - peo[i], 0LL);
}
return tmp <= k;
}
bool judgeup(long long mid) {
long long tmp = 0;
for (int i = 0; i < n; ++i) {
tmp += std::max(peo[i] - mid, 0LL);
}
return tmp <= k;
}
long long binaryup() {
long long left = all % n ? all / n : all / n - 1;
long long right = peo[n - 1];
while (left + 1 < right) {
long long mid = (left + right) / 2;
if (judgeup(mid)) {
right = mid;
} else {
left = mid;
}
}
return right;
}
long long binarydown() {
long long left = peo[0];
long long right = all / n + 1;
while (left + 1 < right) {
long long mid = (left + right) / 2;
if (judgedown(mid)) {
left = mid;
} else {
right = mid;
}
}
return left;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) {
scanf("%lld", peo + i);
all += peo[i];
}
std::sort(peo, peo + n);
printf("%lld\n", binaryup() - binarydown());
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 17;
const int MAXS = (1 << MAXN);
int fa_mask[MAXN];
int seq[MAXN];
bool used[MAXN];
long long f[MAXS];
int n, m;
long long k;
void init() {
cin >> n >> k >> m;
k -= 2000;
memset(fa_mask, 0, sizeof(fa_mask));
for (int x, y, i = 0; i < m; ++i) {
cin >> x >> y;
--x;
--y;
fa_mask[x] |= (1 << y);
}
}
long long cal(int bound) {
f[0] = 1;
for (int lab, limit = (1 << n), sta = 1; sta < limit; ++sta) {
f[sta] = 0;
lab = -1;
for (int i = 0; i < n; ++i) lab += (sta & (1 << i)) > 0;
for (int i = 0; i < n; ++i) {
if ((sta & (1 << i)) && !(sta & fa_mask[i]) &&
(bound < i || seq[i] == lab))
f[sta] += f[sta ^ (1 << i)];
}
}
return f[(1 << n) - 1];
}
void solve() {
memset(seq, 255, sizeof(seq));
if (k > cal(-1)) {
cout << "The times have changed" << endl;
return;
}
memset(used, 0, sizeof(used));
long long tmp;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (used[j]) continue;
used[j] = 1;
seq[i] = j;
tmp = cal(i);
if (tmp < k) {
used[j] = 0;
k -= tmp;
} else
break;
}
}
for (int i = 0; i < n; ++i) cout << seq[i] + 1 << (i == n - 1 ? '\n' : ' ');
}
int main() {
init();
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
static const double EPS = 1e-9;
int ROUND(double x) { return (int)(x + 0.5); }
bool ISINT(double x) { return fabs(ROUND(x) - x) <= EPS; }
bool ISEQUAL(double x, double y) {
return fabs(x - y) <= EPS * max(1.0, max(fabs(x), fabs(y)));
}
double SQSUM(double x, double y) { return x * x + y * y; }
template <class T>
bool INRANGE(T x, T a, T b) {
return a <= x && x <= b;
}
long long get(long long tmp) {
long long a = 0;
long long b = 0;
long long base = 1;
while (tmp) {
a += base * (tmp % 10);
b += base * (9 - (tmp % 10));
tmp /= 10;
base *= 10;
}
long long c = a * b;
return c;
}
int main() {
int tmp1, tmp2;
scanf("%d %d ", &tmp1, &tmp2);
long long l = tmp1, r = tmp2;
vector<long long> res;
res.push_back(get(l));
res.push_back(get(r));
for (long long i = 5; i <= r; i *= 10) {
if (INRANGE(i, l, r)) {
res.push_back(get(i));
}
}
sort(res.rbegin(), res.rend());
cout << res[0] << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
typedef pair<int, int> pi;
typedef long long ll;
void Solve() {
int n;
cin >> n;
int answer = 0;
int lastValue = -1;
for (int i = 1; i <= n; ++i) {
int a;
cin >> a;
if (lastValue != -1) {
int mn = min(a, lastValue);
int mx = max(a, lastValue);
while (mn * 2 < mx) {
mn *= 2;
++answer;
}
}
lastValue = a;
}
cout << answer << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
Solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long lpss[52];
long long lpst[52];
long long nxts[52][26];
long long nxtt[52][26];
void init(string s, long long lps[], long long nxt[52][26], long long n) {
for (long long i = (1), _b = (n - 1); i <= _b; i++) {
long long curr = lps[i - 1];
while (curr != 0 && s[curr] != s[i]) curr = lps[curr - 1];
if (s[curr] == s[i]) curr++;
lps[i] = curr;
}
for (long long i = (0), _b = (n); i <= _b; i++) {
for (long long j = (0), _b = (25); j <= _b; j++) {
char c = (char)('a' + j);
long long curr = i;
while (curr != 0 && s[curr] != c) curr = lps[curr - 1];
if (s[curr] == c) curr++;
nxt[i][j] = curr;
}
}
}
long long dp[1001][52][52];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string c;
cin >> c;
string s, t;
cin >> s >> t;
long long n = s.length();
long long m = t.length();
long long x = c.length();
init(s, lpss, nxts, n);
init(t, lpst, nxtt, m);
for (long long i = (0), _b = (1000); i <= _b; i++) {
for (long long j = (0), _b = (51); j <= _b; j++) {
for (long long k = (0), _b = (51); k <= _b; k++) {
dp[i][j][k] = -1000000000000000000;
}
}
}
dp[0][0][0] = 0;
for (long long i = (0), _b = (x - 1); i <= _b; i++) {
for (long long j = (0), _b = (n); j <= _b; j++) {
for (long long k = (0), _b = (m); k <= _b; k++) {
if (dp[i][j][k] == -1000000000000000000) continue;
for (long long z = (0), _b = (25); z <= _b; z++) {
if (c[i] == '*' || c[i] == (char)('a' + z)) {
char xx = (char)('a' + z);
long long nj = nxts[j][z];
long long nk = nxtt[k][z];
long long diff = (nj == n) - (nk == m);
long long tmp = dp[i][j][k] + diff;
dp[i + 1][nj][nk] = max(dp[i + 1][nj][nk], tmp);
}
}
}
}
}
long long ans = -1000000000000000000;
for (long long i = (0), _b = (n); i <= _b; i++) {
for (long long j = (0), _b = (m); j <= _b; j++) {
ans = max(ans, dp[x][i][j]);
}
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
struct edge {
int to;
long long c;
edge(int to_, long long c_) {
to = to_;
c = c_;
}
};
int n;
std::vector<long long> a;
std::vector<std::vector<edge> > g;
int count = 0;
void dfs(int v, long long sum, int prev = -1) {
if (sum > a[v]) {
return;
}
++count;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i].to;
int cost = g[v][i].c;
if (to == prev) continue;
dfs(to, std::max(sum + cost, 0ll), v);
}
}
int main() {
std::cin >> n;
a.resize(n);
g.resize(n);
for (int i = 0; i < n; i++) {
std::cin >> a[i];
}
for (int i = 0; i < n - 1; i++) {
int t;
long long cc;
std::cin >> t >> cc;
--t;
g[i + 1].push_back(edge(t, cc));
g[t].push_back(edge(i + 1, cc));
}
dfs(0, 0);
int res = n - count;
std::cout << res << std::endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int Rd() {
int s = 0;
char fl = 0, c = getchar();
while (c < '0' || c > '9') fl |= (c == '-'), c = getchar();
while (c >= '0' && c <= '9')
s = (s << 3) + (s << 1) + (c ^ 48), c = getchar();
return fl ? -s : s;
}
const int N = 1e5 + 5;
void Exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) return x = 1, y = 0, void();
Exgcd(b, a % b, x, y);
long long t = x;
x = y, y = t - (a / b) * y;
}
int n, m, cnt;
long long ans;
long long Inv(int a) {
long long x, y;
Exgcd(a, m, x, y);
x = (x % m + m) % m;
return x;
}
int to[N << 1], nxt[N << 1], vedge[N << 1], h[N];
int dep[N], son[N], siz[N], prt[N], pw[N];
int disup[N], disdown[N];
inline void AddEdge(int x, int y, int z) {
to[++cnt] = y, nxt[cnt] = h[x], h[x] = cnt, vedge[cnt] = z;
}
void DFS_pre(int x, int fa) {
siz[x] = 1;
for (int i = h[x]; i; i = nxt[i]) {
int y = to[i];
if (y == fa) continue;
dep[y] = dep[x] + 1;
disup[y] = (disup[x] + 1ll * pw[dep[x]] * vedge[i]) % m;
disdown[y] = (disdown[x] * 10ll + vedge[i]) % m;
DFS_pre(y, x), siz[x] += siz[y];
if (siz[y] > siz[son[x]]) son[x] = y;
}
}
map<int, int> U, D;
inline void Calc(int x, int lca) {
int up = (1ll * disdown[lca] * pw[dep[lca]] % m -
1ll * disdown[x] * pw[dep[lca]] % m * pw[dep[lca]] % m *
Inv(pw[dep[x]]) % m +
disup[lca]) %
m;
int down = (1ll * disdown[lca] * Inv(pw[dep[lca]]) % m +
1ll * (disup[lca] - disup[x]) *
Inv(1ll * pw[dep[lca]] * pw[dep[lca]] % m) % m) %
m;
up = (up + m) % m, down = (down + m) % m;
if (U.count(up)) ans += U[up];
if (D.count(down)) ans += D[down];
}
inline void Add(int x) {
++U[disup[x]];
int tmp = 1ll * disdown[x] * Inv(pw[dep[x]]) % m;
++D[tmp];
}
void DFS(int x, int fa, int lca, char bj) {
if (bj)
Calc(x, lca);
else
Add(x);
for (int i = h[x]; i; i = nxt[i]) {
int y = to[i];
if (y == fa) continue;
DFS(y, x, lca, bj);
}
}
void Dsu_on_Tree(int x, int fa, char bj) {
for (int i = h[x]; i; i = nxt[i]) {
int y = to[i];
if (y == fa || y == son[x]) continue;
Dsu_on_Tree(y, x, 0);
}
if (son[x]) Dsu_on_Tree(son[x], x, 1);
for (int i = h[x]; i; i = nxt[i]) {
int y = to[i];
if (y == fa || y == son[x]) continue;
DFS(y, x, x, 1), DFS(y, x, x, 0);
}
Calc(x, x), Add(x);
if (!bj) U.clear(), D.clear();
}
int main() {
n = Rd(), m = Rd(), pw[0] = 1;
for (int i = 1; i <= n; ++i) pw[i] = 10ll * pw[i - 1] % m;
for (int i = 1; i < n; ++i) {
int x = Rd() + 1, y = Rd() + 1, z = Rd();
AddEdge(x, y, z), AddEdge(y, x, z);
}
DFS_pre(1, 0);
Dsu_on_Tree(1, 0, 1);
printf("%lld\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int II() {
int q;
scanf("%d", &q);
return q;
}
long long LII() {
long long q;
scanf("%lld", &q);
return q;
}
const long long Mx = 200005;
vector<long long> v[Mx], pa[Mx];
vector<pair<long long, long long>> vv[Mx];
long long tree[Mx];
long long ar[Mx], br[Mx];
void update(long long in) {
while (in < Mx) {
tree[in] += 1, in += (in & (-in));
}
}
long long query(long long in) {
long long sum = 0;
while (in > 0) {
sum += tree[in], in -= (in & (-in));
}
return sum;
}
void solve() {
for (long long i = 1; i < Mx; i++) {
for (long long j = i; j < Mx; j += i) {
v[j].push_back(i);
}
}
long long N, M;
cin >> N >> M;
for (long long i = 1; i <= N; i++) {
scanf("%lld", &ar[i]);
br[ar[i]] = i;
}
for (long long i = 1; i <= M; i++) {
long long l, r;
cin >> l >> r;
vv[r].push_back({l, i});
}
vector<pair<long long, long long>> ans;
for (long long i = 1; i <= N; i++) {
for (auto it : v[ar[i]]) {
long long j = br[it];
long long k = i;
if (j > k) swap(j, k);
pa[k].push_back(j);
}
}
for (long long i = 1; i <= N; i++) {
for (auto it : pa[i]) {
update(it);
}
for (auto it : vv[i]) {
ans.push_back({it.second, query(i) - query(it.first - 1)});
}
}
sort(ans.begin(), ans.end());
for (auto it : ans) printf("%lld\n", it.second);
}
int32_t main() {
long long tt;
tt = 1;
long long cas = 1;
while (tt--) {
solve();
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> Size, parent;
void makeSet(int p) {
parent[p] = p;
Size[p] = 1;
}
int Find_set(int v) {
if (v == parent[v]) return v;
return parent[v] = Find_set(parent[v]);
}
void Union_set(int a, int b) {
a = Find_set(a);
b = Find_set(b);
if (a != b) {
if (Size[a] < Size[b]) {
swap(a, b);
}
parent[b] = a;
Size[a] += Size[b];
}
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
parent.resize(n + 1);
Size.resize(n + 1);
for (int i = 1; i <= n; i++) {
makeSet(i);
}
long long a[n + 1];
for (int i = 1; i <= n; i++) {
cin >> a[i];
Union_set(i, a[i]);
}
for (int i = 1; i <= n; i++) {
Union_set(i, a[i]);
}
for (int i = 1; i <= n; i++) {
cout << Size[parent[i]] << " ";
}
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long double n, sum = 0, count = 0, m, flag = 0, ans = 0, k;
long double h, area, reqarea;
cin >> n >> h;
long double l = 0, r = 1.0, b, H;
while (r - l > 0.00000001) {
b = (l + r) / 2.0;
if (h - b * b * h * n > 0.00000001)
l = b + 0.00000001;
else
r = b - 0.00000001;
count++;
}
H = b * h;
long double a = b;
cout << setprecision(15) << fixed << H << " ";
for (int i = 0; i < n - 2; i++) {
long double l = a, r = 1.0, b;
while (r - l > 0.00000001) {
b = (l + r) / 2.0;
if (h - ((a + b) * (b * h - H) * n) > 0.00000001)
l = b + 0.00000001;
else
r = b - 0.00000001;
}
H = b * h;
a = b;
cout << setprecision(15) << fixed << H << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
lint pw(lint n, lint k) {
if (k == 0) return 1;
if (k & 1) return n * pw(n, k - 1);
lint res = pw(n, k / 2);
return res * res;
}
lint get_block_size_up_to_nth_block(lint n) {
lint lg = log10(n);
lint add = 0;
lint res = 0;
for (lint len = 0; len <= lg; len++) {
lint cnt = (len == lg) ? n - lint(pw(10ll, len)) + 1
: lint(pw(10ll, len + 1)) - lint(pw(10ll, len));
res += add * cnt + ((cnt * (cnt + 1)) / 2) * (len + 1);
add += cnt * (len + 1);
}
return res;
}
lint get_in_block(lint n) {
lint lg = log10(n);
lint add = 0;
lint res = 0;
for (lint len = 0; len <= lg; len++) {
lint cnt = (len == lg) ? n - lint(pw(10ll, len)) + 1
: lint(pw(10ll, len + 1)) - lint(pw(10ll, len));
res += cnt * (len + 1);
}
return res;
}
char solve(lint k) {
lint le = 1, ri = 1e9;
lint block = 0;
while (le <= ri) {
lint mid = (le + ri) / 2;
if (get_block_size_up_to_nth_block(mid) >= k) {
block = mid;
ri = mid - 1;
} else {
le = mid + 1;
}
}
k -= get_block_size_up_to_nth_block(block - 1);
le = 1, ri = 1e9;
lint ans = -1;
while (le <= ri) {
lint mid = (le + ri) / 2;
if (get_in_block(mid) >= k) {
ans = mid;
ri = mid - 1;
} else {
le = mid + 1;
}
}
return to_string(ans)[k - get_in_block(ans - 1) - 1];
}
int main() {
lint q;
cin >> q;
for (int i = 0; i < q; i++) {
lint k;
cin >> k;
cout << solve(k) << "\n";
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
multiset<int> gub[100003];
int good;
int a[100003];
int tem[100003];
int siz;
void mergesort(int *a, int *b, int n) {
int i, i0, i1, iRight, iEnd, width, j;
for (width = 1; width < n; width *= 2)
for (i = 0; i + width < n; i += width * 2) {
i0 = i;
i1 = iRight = i + width;
iEnd = min(i + width * 2, n);
for (j = i; i0 < iRight; j++)
if (i1 == iEnd || a[i0] < a[i1])
b[j] = a[i0++];
else
b[j] = a[i1++];
for (j = i; j < i1; j++) a[j] = b[j];
}
}
int f(int x) {
int res = 0;
int chel = good;
set<int>::iterator it;
siz = 0;
for (int i = 1; i <= 100000; i++) {
int coun = gub[i].size();
for (it = gub[i].begin(); coun >= x; it++) {
res += *it;
chel++;
coun--;
}
while (it != gub[i].end()) {
a[siz++] = *it;
it++;
}
}
mergesort(a, tem, siz);
for (int i = 0; i < x - chel; i++) res += a[i];
return res;
}
int main() {
scanf("%d", &n);
int i;
int x, y;
for (i = 0; i < n; i++) {
scanf("%d %d", &x, &y);
if (x == 0)
good++;
else
gub[x].insert(y);
}
int l, r, re, m1, m2;
l = 1;
r = n;
while (r - l > 3) {
m1 = l + (r - l) / 3;
m2 = r - (r - l) / 3;
if (f(m1) < f(m2))
r = m2;
else
l = m1;
}
int mini = 2000000000;
for (i = l; i <= r; i++) mini = min(mini, f(i));
printf("%d\n", mini);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
string s;
cin >> n >> k >> s;
int a = 0, b = 0, del = 0, ans = 0;
for (int i = 0; i < s.length(); i++) {
s[i] == 'a' ? a++ : b++;
if (min(a, b) <= k) {
ans = max(ans, a + b);
} else {
s[del++] == 'a' ? a-- : b--;
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1000000000000000000ll;
int n, c, d, a[100101], p[100010];
long long f[2], g[2], nw;
char s[5];
int main() {
scanf("%d%d%d", &n, &c, &d);
for (int i = 1; i <= n; i++) scanf("%d%s", &a[i], s), p[i] = (s[0] == 'P');
scanf("%d", &a[n + 1]), f[0] = 0, f[1] = inf;
for (int i = 1; i <= n; i++) {
int l = i;
while (i < n && p[i + 1] == p[i]) i++;
g[0] = f[0] + 1ll * d * (i - l + 1);
nw = g[1] = f[1] + 1ll * c * (a[i + 1] - a[l]) + 1ll * d * (i - l);
for (int j = 1; j <= i - l; j++)
nw += 1ll * c * (a[i + 1] - a[i - j + 1]) - d, g[1] = min(g[1], nw);
nw = f[0] + 1ll * d * (i - l + 1);
for (int j = 1; j <= i - l + 1; j++)
nw += 1ll * c * (a[i + 1] - a[i - j + 1]) - d, g[1] = min(g[1], nw);
f[0] = g[0], f[1] = g[1];
}
printf("%I64d\n", min(f[0], f[1]));
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
const long long P = 127;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
long long g = 0;
map<long long, vector<pair<long long, long long> > > m;
for (int i = 0; i < n; i++) {
long long a, b, c;
cin >> a >> b >> c;
if (m.find(a) == m.end()) m[a] = vector<pair<long long, long long> >();
m[a].emplace_back(b, c);
g = gcd(g, c);
}
long long x = 0, y = 0;
for (auto p : m) {
long long tx = 0;
long long ty = 0;
sort(p.second.begin(), p.second.end());
long long d = 0;
for (int i = 0; i < p.second.size(); i++) d = gcd(d, p.second[i].second);
for (int i = 0; i < p.second.size(); i++)
tx = tx * P + p.second[i].first, ty = ty * P + p.second[i].second / d;
if (x == 0) x = tx, y = ty;
if (x != tx || y != ty) {
cout << 0;
return 0;
}
}
long long res = 1;
long long t = 2;
while (t * t <= g) {
if (g % t == 0) {
int c = 0;
while (g % t == 0) c++, g /= t;
res *= c + 1;
}
t++;
}
if (g > 1) res *= 2;
cout << res;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int counts = 0;
while (n--) {
string a;
cin >> a;
int num[10] = {};
bool good = true;
for (int i = 0; i < a.size(); i++) {
num[a[i] - '0']++;
}
for (int i = 0; i <= k; i++) {
if (num[i] == 0) {
good = false;
break;
}
}
if (good) counts++;
}
cout << counts << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
long long a, b, c;
cin >> t;
while (t--) {
cin >> a >> b >> c;
if (a >= c)
cout << "-1 " << b << '\n';
else if (a * b <= c)
cout << "1 -1\n";
else
cout << "1 " << b << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool check(int a, int b, int x, int y, int r) {
if (pow((x - a), 2) + pow((y - b), 2) > r * r) {
return 0;
} else {
return 1;
}
}
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
set<pair<int, int>> st;
int xmin = 0, xmax = 0, ymin = 0, ymax = 0;
xmin = min(a, c);
xmax = max(a, c);
ymin = min(b, d);
ymax = max(b, d);
for (int i = ymin; i <= ymax; i++) st.insert(make_pair(xmin, i));
for (int i = ymin; i <= ymax; i++) st.insert(make_pair(xmax, i));
for (int i = xmin; i <= xmax; i++) st.insert(make_pair(i, ymin));
for (int i = xmin; i <= xmax; i++) st.insert(make_pair(i, ymax));
int n;
cin >> n;
vector<pair<int, int>> arr;
vector<int> rad;
for (int i = 0; i < n; i++) {
int a, b, c;
cin >> a >> b >> c;
arr.push_back(make_pair(a, b));
rad.push_back(c);
}
for (auto j = 0; j < n; j++) {
auto i = st.begin();
while (i != st.end()) {
if (check(i->first, i->second, arr[j].first, arr[j].second, rad[j])) {
st.erase(i);
i = st.begin();
} else {
i++;
}
}
}
cout << st.size();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = (long long)1 << 62;
long long QPow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
long long inf = (long long)1 << 30;
int x1[4], y11[4], x2[4], y2[4];
int arr[4];
signed main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t;
int m;
int n;
map<pair<long long, long long>, int> pp;
int cnth = 0, cntv = 0;
map<pair<long long, long long>, int> pos;
for (int i = 0; i < 4; i++) {
cin >> x1[i] >> y11[i] >> x2[i] >> y2[i];
pos[make_pair(x1[i], y11[i])]++;
pos[make_pair(x2[i], y2[i])]++;
if (x1[i] == x2[i]) cntv++, arr[i] = 1;
if (y11[i] == y2[i]) cnth++;
}
int cnt2 = 0;
for (int i = 0; i < 4; i++) {
for (int j = i + 1; j < 4; j++) {
long long xx1 = x1[i] - x2[i];
long long yy1 = y11[i] - y2[i];
long long xx2 = x1[j] - x2[j];
long long yy2 = y11[j] - y2[j];
if (xx1 * xx2 + yy1 * yy2 == 0) cnt2++;
}
}
bool flag = 1;
pair<long long, long long> v1, v2;
for (int i = 0; i < 4; i++) {
long long xx1 = x1[i] - x2[i];
long long yy1 = y11[i] - y2[i];
if (xx1 == 0) v1 = make_pair(abs(xx1), abs(yy1));
if (yy1 == 0) v2 = make_pair(abs(xx1), abs(yy1));
if (!((xx1 == 0) ^ (yy1 == 0))) flag = 0;
pp[make_pair(abs(xx1), abs(yy1))]++;
}
if (pp.size() != 2) flag = 0;
for (auto it : pp) {
if (it.second != 2) flag = 0;
}
if ((long long)v1.first * v2.first + (long long)v1.second * v2.second != 0)
flag = 0;
if (pos.size() != 4) flag = 0;
for (auto it : pos) {
if (it.second != 2) flag = 0;
}
if (cntv == 2 && cnth == 2 && cnt2 == 4 && flag) {
map<int, int> mm;
for (int i = 0; i < 4; i++) mm[x1[i]] = 1;
if (mm.size() != 2) {
cout << "NO\n";
return 0;
}
mm.clear();
for (int i = 0; i < 4; i++) mm[y11[i]] = 1;
if (mm.size() != 2) {
cout << "NO\n";
return 0;
}
mm.clear();
for (int i = 0; i < 4; i++) mm[x2[i]] = 1;
if (mm.size() != 2) {
cout << "NO\n";
return 0;
}
mm.clear();
for (int i = 0; i < 4; i++) mm[y2[i]] = 1;
if (mm.size() != 2) {
cout << "NO\n";
return 0;
}
mm.clear();
cout << "YES\n";
} else
cout << "NO\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int A[200004], B[200004];
pair<int, int> V[200004];
int N;
int main() {
scanf("%d\n", &N);
for (int i = 1; i <= N; ++i) {
scanf("%d", &A[i]);
}
for (int i = 1; i <= N; ++i) {
scanf("%d", &B[i]);
V[i] = {B[i], i};
}
sort(V + 1, V + 1 + N);
sort(A + 1, A + 1 + N);
for (int i = 1; i <= N; ++i) {
B[V[i].second] = A[N - i + 1];
}
for (int i = 1; i <= N; ++i) {
cout << B[i] << ' ';
}
cout << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, h;
cin >> n >> h;
vector<pair<int, int>> A(n);
for (int i = 0; i < n; i++) {
cin >> A[i].first;
A[i].second = i;
}
if (n == 2) {
cout << 0 << "\n";
cout << "1 1\n";
return 0;
}
sort(A.begin(), A.end());
int a = A[n - 1].first + A[n - 2].first - (A[0].first + A[1].first);
int b = abs(
max(A[n - 1].first + A[n - 2].first, A[0].first + A[n - 1].first + h) -
min(A[1].first + A[2].first, (A[0].first + A[1].first + h)));
cout << min(a, b) << "\n";
if (a < b) {
for (int i = 0; i < n; i++) cout << 2 << " ";
} else {
for (int i = 0; i < n; i++) {
if (A[0].second == i)
cout << "1 ";
else
cout << "2 ";
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool uin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
bool uax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const int MAXN = 210000;
int fenw[MAXN];
int a[MAXN];
int ans[MAXN];
int fenw_sum(int x) {
int sum = 0;
for (; x >= 0; x &= x + 1, --x) sum += fenw[x];
return sum;
}
void fenw_add(int x, int z) {
for (; x < MAXN; x |= x + 1) fenw[x] += z;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed;
int N;
cin >> N;
for (int i = 0; i < (int)(N); ++i) cin >> a[i];
vector<pair<int, int> > w;
for (int i = 0; i < (int)(N); ++i) w.push_back(make_pair(a[i], i));
sort((w).begin(), (w).end());
for (pair<int, int> p : w) {
int i = p.second;
for (int k = 1; k * i + 1 < N && k < N; ++k) {
ans[k] += fenw_sum(min(k * i + k, N)) - fenw_sum(k * i);
}
fenw_add(i, 1);
}
for (int k = 1; k <= (int)(N - 1); ++k) cout << ans[k] << " \n"[k + 1 == N];
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int wt[1010], b[1010], visit[1010] = {0}, num_set;
long long int dp[1010][1010];
vector<long long int> g[1010], st[1010];
void dfs(long long int n) {
visit[n] = 1;
st[num_set].push_back(n);
for (long long int i = 0; i < g[n].size(); i++) {
if (visit[g[n][i]] == 0) dfs(g[n][i]);
}
return;
}
int main() {
long long int n, m, w;
long long int x, y;
num_set = 1;
cin >> n >> m >> w;
for (long long int i = 1; i <= n; i++) cin >> wt[i];
for (long long int i = 1; i <= n; i++) cin >> b[i];
while (m--) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
for (long long int i = 1; i <= n; i++) {
if (visit[i] == 0) {
dfs(i);
num_set++;
}
}
for (long long int i = 1; i < num_set; i++) {
for (long long int j = 0; j < st[i].size(); j++) {
for (long long int k = 1; k <= w; k++) {
dp[i][k] = max(dp[i][k], dp[i - 1][k]);
if (wt[st[i][j]] <= k) dp[i][k] = max(dp[i][k], b[st[i][j]]);
}
}
}
for (long long int i = 1; i < num_set; i++) {
for (long long int j = 0; j < st[i].size(); j++) {
for (long long int k = 1; k <= w; k++) {
dp[i][k] = max(dp[i][k], dp[i - 1][k]);
if (wt[st[i][j]] <= k)
dp[i][k] = max(dp[i][k], dp[i - 1][k - wt[st[i][j]]] + b[st[i][j]]);
}
}
}
for (long long int i = 1; i < num_set; i++) {
long long int tot = 0;
long long int tw = 0;
for (long long int j = 0; j < st[i].size(); j++) {
tot += b[st[i][j]];
tw += wt[st[i][j]];
}
for (long long int k = 1; k <= w; k++) {
dp[i][k] = max(dp[i - 1][k], dp[i][k]);
if (tw <= k) dp[i][k] = max(dp[i][k], dp[i - 1][k - tw] + tot);
}
}
cout << dp[num_set - 1][w] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long M = 1e9 + 7;
const int N = 20 + 7;
long long f[N], pw[N][N], chs[N][N], rd;
void dst(vector<long long> v, long long d) {
if (d == 0) {
rd++;
if (rd % 1000000 == 0) cout << rd << endl;
return;
}
for (long long i = 0; i < 16; i++)
if (v[i]) {
v[i]--;
dst(v, d - 1);
v[i]++;
}
}
long long dp[(1 << 16) + 7][N];
long long get(vector<long long> v, long long d) {
memset(dp, 0, sizeof dp);
dp[0][0] = 1;
for (long long msk = 1; msk < (1 << 16); msk++)
for (long long i = 0; i <= d; i++) {
long long x;
for (long long j = 0; j < 16; j++)
if ((msk >> j) & 1) x = j;
for (long long put = 0; put <= min(v[x], i); put++)
dp[msk][i] += dp[msk ^ (1 << x)][i - put] * chs[put][i];
}
return dp[(1 << 16) - 1][d];
}
int32_t main() {
chs[0][0] = 1;
for (long long i = 1; i < N; i++)
for (long long j = 0; j <= i; j++)
if (i == j || j == 0)
chs[j][i] = 1;
else
chs[j][i] = chs[j][i - 1] + chs[j - 1][i - 1];
for (long long i = 1; i < N; i++) {
pw[i][0] = 1;
for (long long j = 1; j < N; j++) {
if (sqrt(pw[i][j - 1]) * sqrt(i) <= 1e8) pw[i][j] = pw[i][j - 1] * i;
}
}
long long lim, k, len;
cin >> k >> lim;
vector<long long> v;
for (long long j = 0; j < 16; j++) v.push_back(lim);
for (long long i = 1;; i++) {
v[1]--;
long long sm = get(v, i - 1) * 15;
v[1]++;
if (sm >= k) {
len = i;
break;
} else
k -= sm;
}
vector<long long> res;
for (long long i = 1; i <= len; i++) {
long long x = 0;
if (i == 1) x = 1;
while (1) {
if (v[x] == 0) {
x++;
continue;
}
v[x]--;
long long way = get(v, len - i);
if (way >= k) {
res.push_back(x);
break;
} else {
k -= way;
v[x]++;
x++;
}
}
}
for (auto x : res)
if (x <= 9)
cout << x;
else
cout << (char)('a' + x - 10);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
int dis(pair<int, int> x, pair<int, int> y) {
return abs(x.first - y.first) + abs(x.second - y.second);
}
int main() {
int n;
scanf("%d", &n);
vector<pair<int, int> > v, g;
v.push_back(make_pair(1000000007, 0));
v.push_back(make_pair(0, -1000000007));
v.push_back(make_pair(-1000000007, 0));
v.push_back(make_pair(0, 1000000007));
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
g.push_back(make_pair(x, y));
if (v[0].first > x) v[0] = make_pair(x, y);
if (v[1].second < y) v[1] = make_pair(x, y);
if (v[2].first < x) v[2] = make_pair(x, y);
if (v[3].second > y) v[3] = make_pair(x, y);
}
int ans = 0;
for (int i = 0; i < int(v.size()); i++)
for (int j = i + 1; j < int(v.size()); j++)
for (__typeof((g).begin()) it = (g).begin(); it != (g).end(); it++)
umax(ans, dis(v[i], v[j]) + dis(v[j], *it) + dis(*it, v[i]));
printf("%d ", ans);
for (int i = 4; i <= n; i++)
printf("%d ",
2 * (v[2].first - v[0].first) + 2 * (v[1].second - v[3].second));
puts("");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char* argv[]) {
int n, cnt = 0;
cin >> n;
int a[100];
memset(a, 0, sizeof(a));
for (int i = 0; i < n; i++) {
int k, x = 0;
cin >> k;
while (k != 0) {
x = x + k % 10;
k = k / 10;
}
a[x]++;
}
for (int i = 1; i < 100; i++) {
while (a[i] > 0) {
a[i] = a[i] - 1;
for (int j = i; j < 100; j++) {
if (a[j] > 0 && (i + j) % 3 == 0) {
cnt++;
a[j]--;
break;
}
}
}
}
cout << cnt;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct SegTree {
int n, *v;
int t[4 * 1000010];
int neutral = 0;
int join(int a, int b) { return (a + b); }
void build(int node, int i, int j) {
if (i == j) {
t[node] = v[i];
} else {
int mid = i + (j - i) / 2;
build((node << 1), i, mid);
build(((node << 1) + 1), mid + 1, j);
t[node] = join(t[(node << 1)], t[((node << 1) + 1)]);
}
}
void update(int node, int i, int j, int index, int value) {
if (i == j) {
t[node] = v[index] += value;
} else {
int mid = i + (j - i) / 2;
if (index <= mid)
update((node << 1), i, mid, index, value);
else
update(((node << 1) + 1), mid + 1, j, index, value);
t[node] = join(t[(node << 1)], t[((node << 1) + 1)]);
}
}
int query(int node, int i, int j, int l, int r) {
if (l <= i && j <= r) return t[node];
if (i > r || l > j) return neutral;
int mid = i + (j - i) / 2;
return join(query((node << 1), i, mid, l, min(r, mid)),
query(((node << 1) + 1), mid + 1, j, max(l, mid + 1), r));
}
void build(int _v[], int _n) {
n = _n;
v = _v;
build(1, 1, n);
}
void update(int index, int value) { update(1, 1, n, index, value); }
int query(int a, int b) { return query(1, 1, n, a, b); }
};
int n, a[1000010], v[1000010], freq[1000010], freq2[1000010];
unordered_map<int, int> mp;
SegTree st1, st2;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
v[i] = a[i];
}
sort(v + 1, v + 1 + n);
int ind = 0;
for (int i = 1; i <= n; ++i) {
if (!mp[v[i]]) {
freq[ind + 1] = 1;
mp[v[i]] = ++ind;
} else {
freq[mp[v[i]]]++;
}
}
st1.build(freq, n);
st2.build(freq2, n);
long long int ans = 0;
for (int i = 1; i <= n; ++i) {
st1.update(mp[a[i]], -1);
long long int ret1 = st1.query(1, mp[a[i]] - 1);
long long int ret2 = st2.query(mp[a[i]] + 1, n);
ans += ret1 * ret2;
st2.update(mp[a[i]], 1);
}
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
int N;
int UVV[99999][3];
int UV[199998][2];
int UV_tmp[199998][2];
int UV_cnt[100000];
int UV_B[100001];
int C[100000];
int g(int a, int b) {
if (C[b] == 1) return b;
int k = rand() % C[b];
if (UV[UV_B[b] + k][1] == a) k = (k + 1) % C[b];
return g(b, UV[UV_B[b] + k][1]);
}
void gg(int *out, int a, int b) {
int kk[2];
int k = 0;
for (int i = UV_B[b]; k < 2; ++i) {
if (UV[i][1] == a) continue;
kk[k++] = UV[i][1];
}
out[0] = g(b, kk[0]);
out[1] = g(b, kk[1]);
}
void f1(int a, int b, int c) {
int ar[2];
gg(ar, a, b);
printf("%d %d %d\n", (a) + 1, (ar[0]) + 1, c);
;
printf("%d %d %d\n", (a) + 1, (ar[1]) + 1, c);
;
printf("%d %d %d\n", (ar[0]) + 1, (ar[1]) + 1, -c);
;
}
void f(int a, int b, int c) {
if (C[a] == 1) {
if (C[b] == 1) {
printf("%d %d %d\n", (a) + 1, (b) + 1, c * 2);
;
} else {
f1(a, b, c);
}
} else if (C[b] == 1) {
f1(b, a, c);
} else {
int ar[2][2];
gg(ar[0], a, b);
gg(ar[1], b, a);
printf("%d %d %d\n", (ar[0][0]) + 1, (ar[1][0]) + 1, c);
;
printf("%d %d %d\n", (ar[0][0]) + 1, (ar[1][1]) + 1, c);
;
printf("%d %d %d\n", (ar[1][0]) + 1, (ar[1][1]) + 1, -c);
;
printf("%d %d %d\n", (ar[0][0]) + 1, (ar[0][1]) + 1, -c);
;
printf("%d %d %d\n", (ar[0][0]) + 1, (ar[1][1]) + 1, -c);
;
printf("%d %d %d\n", (ar[0][1]) + 1, (ar[1][1]) + 1, c);
;
}
}
int f_cnt(int a, int b, int c) {
if (C[a] == 1) {
if (C[b] == 1) {
return 1;
} else {
return 3;
}
} else if (C[b] == 1) {
return 3;
} else {
return 6;
}
}
int main() {
scanf("%d", &N);
for (int i = 0; i < N; ++i) {
C[i] = 0;
UV_cnt[i] = 0;
}
for (int i = 0; i < N - 1; ++i) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
a -= 1;
b -= 1;
C[a] += 1;
C[b] += 1;
UVV[i][0] = a;
UVV[i][1] = b;
UVV[i][2] = c / 2;
UV_tmp[i * 2][0] = a;
UV_tmp[i * 2][1] = b;
UV_tmp[i * 2 + 1][0] = b;
UV_tmp[i * 2 + 1][1] = a;
UV_cnt[a] += 1;
UV_cnt[b] += 1;
}
for (int i = 0; i < N; ++i) {
if (C[i] == 2) goto NO;
}
for (int i = 1; i < N; ++i) UV_cnt[i] += UV_cnt[i - 1];
UV_B[0] = 0;
for (int i = 0; i < N; ++i) UV_B[i + 1] = UV_cnt[i];
for (int i = 0; i < N * 2 - 2; ++i) {
int d = --UV_cnt[UV_tmp[i][0]];
UV[d][0] = UV_tmp[i][0];
UV[d][1] = UV_tmp[i][1];
}
puts("YES");
int m;
m = 0;
for (int i = 0; i < N - 1; ++i) m += f_cnt(UVV[i][0], UVV[i][1], UVV[i][2]);
printf("%d\n", m);
for (int i = 0; i < N - 1; ++i) f(UVV[i][0], UVV[i][1], UVV[i][2]);
return 0;
NO:
puts("NO");
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("-O3")
using namespace std;
void _main();
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
_main();
}
template <class V, int NV>
struct SegTree {
V comp(V& l, V& r) {
auto v = vector<int>(60);
for (int i = 0; i < 60; i++) v[i] = l[i] + r[(i + l[i]) % 60];
return v;
};
vector<V> val;
SegTree() { val = vector<V>(NV * 2, vector<int>(60)); }
V get(int x, int y, int l = 0, int r = NV, int k = 1) {
if (r <= x || y <= l) return vector<int>(60);
if (x <= l && r <= y) return val[k];
auto A = get(x, y, l, (l + r) / 2, k * 2);
auto B = get(x, y, (l + r) / 2, r, k * 2 + 1);
return comp(A, B);
}
void update(int i, V v) {
i += NV;
val[i] = v;
while (i > 1) i >>= 1, val[i] = comp(val[i * 2], val[i * 2 + 1]);
}
};
int N, A[101010], M;
SegTree<vector<int>, 1 << 17> st;
void update(int i, int a) {
auto v = vector<int>(60);
for (int j = 0; j < 60; j++) {
if ((j % a) == 0)
v[j] = 2;
else
v[j] = 1;
}
st.update(i, v);
}
void _main() {
cin >> N;
for (int i = 0; i < N; i++) cin >> A[i];
for (int i = 0; i < N; i++) update(i, A[i]);
cin >> M;
for (int i = 0; i < M; i++) {
string s;
int x, y;
cin >> s >> x >> y;
if (s == "C") {
x--;
A[x] = y;
update(x, A[x]);
} else {
x--;
y--;
auto v = st.get(x, y);
printf("%d\n", v[0]);
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int mod = 1e9 + 7;
int arr[500];
int main() {
int k, n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
if (a % 2) {
cout << "First" << endl;
return 0;
}
}
cout << "Second" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int N, M, A, B;
long long fact[2000100], ifact[2000100];
long long pw(long long N, long long k) {
if (!k) return 1;
if (k % 2) return (pw(N, k - 1) * N) % 1000000007;
long long ret = pw(N, k / 2);
return (ret * ret) % 1000000007;
}
inline long long inv(long long N) { return pw(N, 1000000007 - 2); }
inline long long comb(int N, int k) {
long long ret = fact[N];
ret = (ret * ifact[k]) % 1000000007;
ret = (ret * ifact[N - k]) % 1000000007;
return ret;
}
inline long long aranj(int N, int k) {
long long ret = fact[N];
ret = (ret * ifact[N - k]) % 1000000007;
return ret;
}
inline long long cntsum(long long M, long long k) {
if (k > M) return 0;
M -= k;
return comb(M + k - 1, M);
}
int main() {
cin >> N >> M >> A >> B;
fact[0] = 1;
for (int i = 1; i <= M + N; ++i) {
fact[i] = (fact[i - 1] * i) % 1000000007;
}
ifact[M + N] = inv(fact[N + M]);
for (int i = M + N; i >= 1; --i) {
ifact[i - 1] = (ifact[i] * i) % 1000000007;
}
long long ret = 0;
for (int k = 0; k <= N - 2; ++k) {
long long rez = 1;
rez = (rez * aranj(N - 2, k)) % 1000000007;
rez = (rez * cntsum(M, k + 1)) % 1000000007;
int R = N - k - 2;
if (R >= 1) {
rez = (rez * pw(M, R)) % 1000000007;
rez = (rez * (k + 2)) % 1000000007;
rez = (rez * pw(N, R - 1)) % 1000000007;
}
ret += rez;
}
cout << ret % 1000000007 << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
template <typename T>
T pow(T a, T b, long long m) {
T ans = 1;
while (b > 0) {
if (b % 2 == 1) ans = ((ans % m) * (a % m)) % m;
b /= 2;
a = ((a % m) * (a % m)) % m;
}
return ans % m;
}
const long double eps = 1e-10L;
vector<char> v;
char a[1005][1005];
long long dist[1005][1005];
long long n, m, k;
bool isvalid(long long x, long long y) {
if (x < 0 || x >= n || y < 0 || y >= m || a[x][y] == '*') return false;
return true;
}
char opp(char dir) {
if (dir == 'U') return 'D';
if (dir == 'D') return 'U';
if (dir == 'L') return 'R';
return 'L';
}
long long dr[] = {1, 0, 0, -1};
long long dc[] = {0, -1, 1, 0};
int32_t main() {
cin >> n >> m >> k;
long long x, y;
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++) {
cin >> a[i][j];
if (a[i][j] == 'X') {
x = i;
y = j;
}
}
if (k & 1) {
cout << "IMPOSSIBLE";
return 0;
}
v.push_back('D');
v.push_back('L');
v.push_back('R');
v.push_back('U');
string ans = "";
for (long long i = 0; i < 1005; i++)
for (long long j = 0; j < 1005; j++) dist[i][j] = (long long)2e18;
queue<pair<long long, long long> > q;
q.push(make_pair(x, y));
dist[x][y] = 0;
while (!q.empty()) {
long long xx = q.front().first;
long long yy = q.front().second;
q.pop();
for (long long i = 0; i < 4; i++) {
long long nx = xx + dr[i];
long long ny = yy + dc[i];
if (isvalid(nx, ny) && dist[nx][ny] == (long long)2e18) {
dist[nx][ny] = dist[xx][yy] + 1;
q.push(make_pair(nx, ny));
}
}
}
for (long long i = 0; i < k; i++) {
for (long long dir = 0; dir < 4; dir++) {
long long nx = x + dr[dir];
long long ny = y + dc[dir];
if (isvalid(nx, ny) && dist[nx][ny] <= (k - i - 1)) {
x = nx;
y = ny;
ans += v[dir];
break;
}
}
}
if (ans.length() != k) {
cout << "IMPOSSIBLE";
} else
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:200000000")
using namespace std;
const int INF = (int)1e9;
const long long INF64 = (long long)1e18;
const long double eps = 1e-9;
const long double pi = 3.14159265358979323846;
int d[300][20000], n, m;
bool solve() {
if (!(cin >> n >> m)) return false;
string s;
s.reserve(m);
bool ok = true;
for (int i = 0; i < int(n); ++i) {
cin >> s;
if (!ok) continue;
if (s.find('1') == string::npos) {
ok = false;
continue;
}
int dist = 0;
int pos = s.find('1');
for (int j = 0; j < int(m); ++j) {
int val = (j + pos) % m;
if (s[val] == '1') {
dist = 0;
} else
dist++;
d[i][(j + pos) % m] = dist;
}
for (int j = int(m + 1) - 1; j >= 0; --j) {
if (s[(j + pos) % m] == '1') {
dist = 0;
} else
dist++;
d[i][(j + pos) % m] = min(d[i][(j + pos) % m], dist);
}
}
if (!ok) {
puts("-1");
return true;
}
int ans = INT_MAX;
for (int i = 0; i < int(m); ++i) {
int sum = 0;
for (int j = 0; j < n; j++) {
sum += d[j][i];
}
ans = min(ans, sum);
}
cout << ans << endl;
return true;
}
int main() {
while (solve())
;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
char c[5100];
int sg[5100], a[5100], ans, n, bo[5100];
int main() {
scanf("%s", c + 1);
n = strlen(c + 1);
for (int i = 3; i <= n; ++i) {
memset(bo, 0, sizeof(bo));
for (int j = 2; j <= i - 1; ++j) bo[sg[j - 1] ^ sg[i - j]] = 1;
for (int j = 0; j <= n; ++j)
if (!bo[j]) {
sg[i] = j;
break;
}
}
for (int i = 1; i + 2 <= n; ++i)
if (c[i] == c[i + 2]) {
int j = i + 3;
while (j <= n && c[j] == c[j - 2]) j++;
ans ^= sg[j - i];
for (int k = i + 1; k <= j - 2; ++k)
a[k] = sg[j - i] ^ sg[k - i] ^ sg[j - k - 1];
i = j - 2;
}
if (!ans) {
printf("Second\n");
} else {
printf("First\n");
for (int i = 1; i <= n; ++i)
if (a[i] == ans) {
printf("%d\n", i);
break;
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream& operator<<(ostream& stream, const vector<T> v) {
stream << "[ ";
for (int i = 0; i < (int)v.size(); i++) stream << v[i] << " ";
stream << "]";
return stream;
}
long long fpow(long long x, long long p, long long m) {
long long r = 1;
for (; p; p >>= 1) {
if (p & 1) r = r * x % m;
x = x * x % m;
}
return r;
}
int gcd(int a, int b) {
if (!b) return a;
return gcd(b, a % b);
}
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
const int maxn = 200000;
long long inv(long long a, long long b) {
return a < 2 ? a : ((a - inv(b % a, a)) * b + 1) / a % b;
}
long long N, p, l, r, sz;
vector<int> pfact;
struct num {
vector<int> put;
long long val;
num(long long x = 1) {
put.resize(sz);
if (x == 0) {
val = 0;
return;
}
for (int i = 0; i < sz; i++)
while (x % pfact[i] == 0) put[i]++, x /= pfact[i];
val = x;
}
num operator*(const num& o) const {
num r = *this;
r.val = (r.val * o.val) % p;
for (int i = 0; i < sz; i++) r.put[i] += o.put[i];
return r;
}
num operator/(const num& o) const {
num r = *this;
r.val = (r.val * inv(o.val, p)) % p;
for (int i = 0; i < sz; i++) r.put[i] -= o.put[i];
return r;
}
long long toval() const {
long long res = val;
for (int i = 0; i < sz; i++) res = (res * fpow(pfact[i], put[i], p)) % p;
return res;
}
} fact[200010];
void getfactors() {
long long nr = p, i;
for (i = 2; i * i <= nr; i++) {
if (nr % i == 0) {
pfact.push_back(i);
while (nr % i == 0) nr /= i;
}
}
if (nr > 1) pfact.push_back(nr);
sz = pfact.size();
}
num binom(long long n, long long k) {
if (k > n) return num(0);
return fact[n] / fact[n - k] / fact[k];
}
long long paths(long long l) {
long long res = 0, i;
for (i = 0; i <= N; i++) {
if (i % 2 != l % 2) continue;
num cr = binom(N, i) * binom(i, (i + l) / 2);
res = (res + cr.toval()) % p;
}
return res;
}
int main() {
cin >> N >> p >> l >> r;
getfactors();
int i;
fact[0] = num(1);
for (i = 1; i <= maxn; i++) fact[i] = fact[i - 1] * num(i);
long long res = 0;
if (l == r)
res = (paths(l) - paths(l + 2)) % p;
else
res = (paths(l) + paths(l + 1) - paths(r + 1) - paths(r + 2)) % p;
res = (res + p) % p;
cout << res << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int lb(const vector<int> &cor, int n) {
int L = cor.size();
if (cor[0] >= n) {
return 0;
}
int bg = L;
int sm = 0;
while (bg - sm > 1) {
int md = (bg + sm) / 2;
if (cor[md] >= n) {
bg = md;
} else {
sm = md;
}
}
return bg;
}
bool inmax(int &a, int b) {
if (b > a) {
a = b;
return true;
}
return false;
}
vector<vector<int> > prd(const vector<vector<int> > &a,
const vector<vector<int> > &b, int L) {
vector<vector<int> > trt(L, vector<int>(L, 0));
for (int i = 0; i < L; i++) {
for (int j = i; j < L; j++) {
for (int k = i; k <= j; k++) {
inmax(trt[i][j], a[i][k] + b[k][j]);
}
}
}
return trt;
}
int clcA(vector<vector<int> > &A, int N, const int L) {
vector<vector<int> > trt(L, vector<int>(L, 0));
vector<vector<int> > tmp = A;
while (N) {
if (N & 1) {
trt = prd(trt, tmp, L);
}
N /= 2;
tmp = prd(tmp, tmp, L);
}
return trt[0][L - 1];
}
int main() {
int N, T;
if (scanf("%d%d", &N, &T) == EOF) {
return 0;
}
vector<int> cor;
int A[N];
for (int i = 0; i < N; i++) {
if (scanf("%d", A + i) == EOF) {
return 0;
}
cor.push_back(A[i]);
}
sort(cor.begin(), cor.end());
cor.erase(unique(cor.begin(), cor.end()), cor.end());
for (int i = 0; i < N; i++) {
A[i] = lb(cor, A[i]);
}
int L = cor.size();
int dp2[L][N + 1];
for (int i = 0; i < L; i++) {
fill(dp2[i], dp2[i] + N + 1, N + 1);
dp2[i][0] = i;
bool f = false;
for (int j = 0; j < N; j++) {
if (f) {
if (A[j] >= i) {
int bg = N;
int sm = 0;
while (bg - sm > 1) {
int md = (bg + sm) / 2;
if (dp2[i][md] > A[j]) {
bg = md;
} else {
sm = md;
}
}
dp2[i][bg] = A[j];
}
} else {
if (A[j] == i) {
f = true;
dp2[i][1] = i;
}
}
}
}
vector<vector<int> > dp(L);
fill(dp.begin(), dp.end(), vector<int>(L, 0));
for (int i = 0; i < L; i++) {
for (int j = 0; j <= N; j++) {
for (int k = dp2[i][j]; k < L; k++) {
inmax(dp[i][k], j);
}
}
}
printf("%d\n", clcA(dp, T, L));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m, i, j, k, t, cnt = 0;
vector<pair<long long, long long> > answer;
cin >> k;
for (t = 1; t < 10000001; t++) {
m = t;
j = 6ll * k + m * (m * m - 1);
n = j / (3ll * m * (m + 1));
if (n < m) continue;
if (k == (m * (m + 1) * (3 * n - m + 1)) / 6) answer.push_back({m, n});
}
cnt = 2 * answer.size();
for (auto x : answer)
if (x.first == x.second) cnt--;
cout << cnt << endl;
for (auto x : answer) cout << x.first << " " << x.second << endl;
reverse(answer.begin(), answer.end());
for (auto x : answer) {
if (x.first != x.second) cout << x.second << " " << x.first << endl;
}
return (0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 4 * 10001;
int main() {
int n, m, k, t;
cin >> n >> m >> k >> t;
vector<vector<int> > frees(n + 1);
vector<int> sum(n + 1);
int x, y;
for (int i = 0; i < k; ++i) {
cin >> x >> y;
frees[x].push_back(y);
}
for (int i = 1; i <= n; ++i) {
sort(frees[i].begin(), frees[i].end());
sum[i] = frees[i].size() + sum[i - 1];
}
int ans;
for (int i = 0; i < t; ++i) {
cin >> x >> y;
int cnt = 0;
bool flag = false;
for (int j = 0; j < frees[x].size(); ++j) {
if (frees[x][j] == y) {
cout << "Waste" << endl;
flag = true;
}
if (frees[x][j] > y) break;
}
if (flag) continue;
for (int j = 0; j < frees[x].size(); ++j) {
if (frees[x][j] < y)
++cnt;
else
break;
}
ans = ((x - 1) * m + y - sum[x - 1] - cnt) % 3 - 1;
if (ans == 0)
cout << "Carrots" << endl;
else if (ans == 1)
cout << "Kiwis" << endl;
else
cout << "Grapes" << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using pll = pair<long long, long long>;
using vl = vector<long long>;
using vpll = vector<pll>;
using mll = map<long long, long long>;
using mcl = map<char, long long>;
using msl = map<string, long long>;
using sl = set<long long>;
using sc = set<char>;
using dl = deque<long long>;
const int N = 1e6 + 5;
long long mod = 1e9 + 7;
vl adj[N];
vpll adjc[N];
long long vis[N];
long long arr[N];
long long muld(long long a, long long b) {
return (((a % mod) * (b % mod)) % mod);
}
long long sumd(long long a, long long b) {
return (((a % mod) + (b % mod)) % mod);
}
long long subd(long long a, long long b) {
return (((a % mod) - (b % mod) + mod) % mod);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long a, b, c, d, n, m, p, x, y, z, i, j, k,
f = 0, tc, cnt = 0, sum = 0, mul = 1, mi = 1e18, ma = -1e18, cs;
string str;
char ch;
double db;
long long l, r;
cin >> tc;
for (cs = 1; cs <= tc; cs++) {
cin >> n;
for (i = 0; i < n; i++) cout << 1 << " ";
cout << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d, i, kt, j, dem = 0;
string S;
cin >> n >> d;
cin >> S;
i = 0;
kt = 0;
while (i < n - 1 && kt == 0) {
j = min(i + d, n - 1);
while (j > i && S[j] == '0') j--;
if (j > i) {
i = j;
dem++;
} else
kt = 1;
}
if (i == n - 1)
cout << dem;
else
cout << -1;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long md = (long long)1e9 + 7, inf = (long long)1e18;
int n, m, k;
struct edge {
int a, b;
int f, c;
int ind;
edge() = default;
edge(int a, int b, int c, int ind) : a(a), b(b), f(0), c(c), ind(ind){};
};
const int MX = 600 * 5;
int fin = MX - 1;
edge e[MX * 10];
int sz = 0;
vector<int> g[10 * MX];
int used[MX];
int timer = 1;
void add_edge(int a, int b, int c, int ind) {
e[sz] = edge(a, b, c, ind);
g[a].push_back(sz++);
e[sz] = edge(b, a, 0, ind);
g[b].push_back(sz++);
}
void init() {
sz = 0;
timer++;
for (int i = 0; i < 3 * (n + m); i++) g[i].clear();
g[fin].clear();
}
int dfs(int v) {
if (v == fin) return 1;
used[v] = timer;
for (int i : g[v]) {
int to = e[i].b;
if (e[i].f != e[i].c && used[to] != timer && dfs(to)) {
e[i].f++;
e[i ^ 1].f--;
return 1;
}
}
return 0;
}
void solve() {
vector<int> szz(n + 1);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
add_edge(0, i + 1, 1, i);
add_edge(i + 1, m + a, 1, i);
add_edge(i + 1, m + b, 1, i);
szz[a]++, szz[b]++;
}
int val = 0;
for (int i = 1; i <= n; i++) {
add_edge(i + m, fin, max(0, 2 * (szz[i] - k)), -1);
val += max(0, 2 * (szz[i] - k));
}
int res = 0;
while (dfs(0)) {
timer++, res++;
}
vector<int> ans(m);
if (res == val) {
int some = 1000;
for (int i = 0; i < m; i++) ans[i] = i + 1;
vector<vector<int> > to_ans(n);
for (int i = 0; i < m; i++) {
for (int j : g[i + 1]) {
if (e[j].c != 0 && e[j].f == e[j].c) {
to_ans[e[j].b - (m + 1)].push_back(e[j].ind);
}
}
}
for (int i = 0; i < n; i++) {
;
while (!to_ans[i].empty()) {
int v1 = to_ans[i].back();
to_ans[i].pop_back();
int v2 = to_ans[i].back();
to_ans[i].pop_back();
ans[v1] = ans[v2] = some++;
}
}
}
for (int i : ans) cout << i << ' ';
cout << '\n';
return;
}
int main() {
iostream::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int test;
cin >> test;
while (test--) {
cin >> n >> m >> k;
init();
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, i, m;
vector<int> v;
cin >> n;
v.resize(100000, 0);
for (i = 1; i <= n / 2; i++) {
cin >> x;
if (x >= i) {
v[x - i]++;
}
}
if (n % 2) {
cin >> x;
if (x >= i) {
v[x - i]++;
}
}
for (i = n / 2 + 1 + n % 2; i <= n; i++) {
cin >> x;
if (x >= n + 1 - i) {
v[x + i - 1 - n]++;
}
}
m = 0;
for (i = 0; i <= 100000; i++) {
if (v[i] > m) {
m = v[i];
}
}
cout << n - m << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0xcfcfcfcfcfcfcfcf;
long long dp[2][200005];
long long a[310], b[310], t[310];
int que[200005];
int main() {
int n, m, d;
cin >> n >> m >> d;
for (int i = 1; i <= m; i++) cin >> a[i] >> b[i] >> t[i];
memset(dp, inf, sizeof(dp));
memset(que, 0, sizeof(que));
for (int i = 1; i <= n; i++) dp[0][i] = 0;
int k = 1;
for (int i = 1; i <= m; i++) {
int l = 1, r = 0;
int h = 1;
for (int j = 1; j <= n; j++) {
for (; h <= min(1ll * n, j + d * (t[i] - t[i - 1])); h++) {
while (l <= r && dp[k ^ 1][que[r]] <= dp[k ^ 1][h]) r--;
que[++r] = h;
}
while (l <= r && que[l] < min(1ll * n, j - d * (t[i] - t[i - 1]))) l++;
dp[k][j] = dp[k ^ 1][que[l]] - abs(a[i] - j) + b[i];
}
k = k ^ 1;
}
long long ans = inf;
for (int i = 1; i <= n; i++) ans = max(ans, dp[k ^ 1][i]);
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL), cout.tie(NULL);
int n, i;
cin >> n;
vector<int> v(n + 1);
for (i = 1; i <= n; i++) cin >> v[i];
for (i = 1; i <= n / 2; i++) {
if (i % 2 == 1) swap(v[i], v[n + 1 - i]);
}
for (i = 1; i <= n; i++) {
cout << v[i] << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 101000;
template <int N>
struct Primes {
bool used[N];
vector<int> p;
Primes() {
used[0] = used[1] = true;
for (int i = 2; i < N; i++) {
if (!used[i]) {
p.push_back(i);
}
for (int j = 2 * i; j < N; j += i) {
used[j] = true;
}
}
}
};
Primes<MN> p;
vector<pair<int, int> > res;
int main() {
int n;
cin >> n;
set<int> s;
for (int i = 1; i <= n; i++) {
s.insert(i);
}
reverse(p.p.begin(), p.p.end());
for (int d : p.p) {
set<int> u;
for (int i = d; i <= n; i += d) {
if (s.count(i)) {
u.insert(i);
}
}
if (u.size() < 2) continue;
if (u.size() % 2 == 1) {
u.erase(d * 2);
}
vector<int> v(u.begin(), u.end());
for (int i = 0; i < v.size() / 2; i++) {
s.erase(v[i * 2]);
s.erase(v[i * 2 + 1]);
res.push_back(pair<int, int>(v[i * 2], v[i * 2 + 1]));
}
}
cout << res.size() << endl;
for (pair<int, int> p : res) {
printf("%d %d\n", p.first, p.second);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10, SQ = 350, T = MAXN / SQ + 10;
pair<int, int> qw[MAXN];
long long n, a, sum[T][5], cl[T];
map<int, int> mp;
bool usd[MAXN];
vector<long long> A;
string qt;
void addnum(int pos, bool d) {
int S = pos / SQ, num = 0;
if (d) {
usd[pos] = true;
cl[S]++;
} else {
usd[pos] = false;
cl[S]--;
}
for (int i = 0; i < S; i++) num += cl[i];
for (int i = S * SQ; i < pos; i++) num += usd[i];
num++;
if (d)
sum[S][num % 5] += A[pos];
else
sum[S][num % 5] -= A[pos], num++;
for (int i = pos + 1; i < min((int)A.size(), (S + 1) * SQ); i++)
if (usd[i]) {
sum[S][num % 5] -= A[i];
if (d)
sum[S][(num + 1) % 5] += A[i];
else
sum[S][(num - 1 + 5) % 5] += A[i];
num++;
}
for (int i = S + 1; i * SQ < A.size(); i++) {
long long stmp[5];
for (int j = 0; j < 5; j++) stmp[j] = sum[i][j];
for (int j = 0; j < 5; j++) {
if (d)
sum[i][j] = stmp[(j - 1 + 5) % 5];
else
sum[i][j] = stmp[(j + 1) % 5];
}
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> qt;
if (qt == "add") {
cin >> a;
A.push_back(a);
qw[i] = {0, a};
} else if (qt == "del") {
cin >> a;
qw[i] = {1, a};
} else
qw[i] = {2, 0};
}
sort(A.begin(), A.end());
for (int i = 0; i < A.size(); i++) mp[A[i]] = i;
for (int k = 0; k < n; k++) {
if (qw[k].first == 0)
addnum(mp[qw[k].second], 1);
else if (qw[k].first == 1)
addnum(mp[qw[k].second], 0);
else {
long long res = 0;
for (int i = 0; i * SQ < A.size(); i++) res += sum[i][3];
cout << res << endl;
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long y[1000];
int GCD(int u, int v) {
while (v != 0) {
int r = u % v;
u = v;
v = r;
}
return u;
}
long long g;
int main() {
int n;
std::ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) cin >> y[i];
for (int i = 0; i < n; i++) {
long long secondStart = LONG_LONG_MIN;
long long secondSlope = LONG_LONG_MIN;
long long secondSlopeDen = LONG_LONG_MIN;
long long slope = y[i] - y[0];
long long slopeDen = i;
g = GCD(slope, slopeDen);
if (g != 0) {
slope /= g;
slopeDen /= g;
}
for (int k = 1; k < n; k++) {
if (k == i) continue;
long long slope2 = y[k] - y[0];
long long slopeDen2 = k;
g = GCD(slope2, slopeDen2);
slope2 /= g;
slopeDen2 /= g;
if (slope == slope2 && slopeDen == slopeDen2) continue;
}
int slope0 = y[1] - y[0];
int slope0Den = 1;
for (int k = 1; k < n; k++) {
if (k == i) continue;
long long slope2 = y[k] - y[0];
long long slopeDen2 = k;
g = GCD(slope2, slopeDen2);
slope2 /= g;
slopeDen2 /= g;
if (slope == slope2 && slopeDen == slopeDen2) continue;
if (secondStart == LONG_LONG_MIN)
secondStart = k;
else if (secondSlope == LONG_LONG_MIN) {
secondSlope = y[k] - y[secondStart];
secondSlopeDen = k - secondStart;
g = GCD(secondSlope, secondSlopeDen);
secondSlope /= g;
secondSlopeDen /= g;
} else {
slope2 = y[k] - y[secondStart];
slopeDen2 = k - secondStart;
g = GCD(slope2, slopeDen2);
slope2 /= g;
slopeDen2 /= g;
if (slope2 != secondSlope || slopeDen2 != secondSlopeDen) goto nexti;
}
}
if ((secondSlopeDen != LONG_LONG_MIN && slope == secondSlope &&
slopeDen == secondSlopeDen) ||
(secondStart != LONG_LONG_MIN && secondSlopeDen == LONG_LONG_MIN) ||
(secondSlopeDen != LONG_LONG_MIN && slope == 0 && slopeDen == 0 &&
(slope0 != secondSlope || slope0Den != secondSlopeDen))) {
cout << "Yes";
return 0;
}
nexti:;
}
cout << "No";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline bool equal(double _x, double _y) {
return _x > _y - 1e-9 && _x < _y + 1e-9;
}
int l[2000005], r[2000005], now, ans;
bool vis[2000005];
void init(int t, int x, int d) {
if (d == -1) return;
if (1 & (x >> d)) {
if (!r[t]) r[t] = ++now;
init(r[t], x, d - 1);
} else {
if (!l[t]) l[t] = ++now;
init(l[t], x, d - 1);
}
}
void qr(int t, int x, int d) {
if (d == -1) return;
if (1 & (x >> d)) {
if (r[t]) {
ans |= 1 << d;
qr(r[t], x, d - 1);
} else
qr(l[t], x, d - 1);
} else {
if (l[t])
qr(l[t], x, d - 1);
else {
ans |= 1 << d;
qr(r[t], x, d - 1);
}
}
}
int main() {
int n, m, x, t = 0;
scanf("%d%d", &n, &m);
while (n--) {
scanf("%d", &x);
vis[x] = 1;
}
for (int i = 0; i <= 6e5; i++)
if (!vis[i]) init(0, i, 25);
while (m--) {
scanf("%d", &x);
t ^= x;
ans = 0;
qr(0, t, 25);
printf("%d\n", ans ^ t);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int const N = 2 * 1e5 + 10;
long long a[N];
map<long long, int> mp;
vector<int> v;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, sum = 0;
cin >> n;
for (int i = 0; i < (int)(n); ++i) cin >> a[i], mp[a[i]]++, sum += a[i];
for (int i = 0; i < (int)(n); ++i)
if (((mp[(sum - a[i]) / 2] && a[i] != (sum - a[i]) / 2) ||
(a[i] == (sum - a[i]) / 2 && mp[(sum - a[i]) / 2] > 1)) &&
(sum - a[i]) % 2 == 0)
v.push_back(i + 1);
int sz = v.size();
cout << sz << endl;
for (int i = 0; i < (int)(sz); ++i) cout << v[i] << " ";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INFll = 0x3f3f3f3f3f3f3f3f;
int a[100005];
int n, k;
int main() {
scanf("%d%d", &n, &k);
bool f = true;
int mn = 1e9 + 9;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
mn = min(mn, a[i]);
if (i >= 1) {
if (abs(a[i] - a[i - 1]) % k != 0) {
f = false;
}
}
}
if (!f) {
cout << -1 << endl;
return 0;
}
long long ans = 0;
for (int i = 0; i < n; i++) {
ans += 1ll * (a[i] - mn) / k;
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct range {
int l, r, c;
range(int l = 0, int r = 0, int c = 0) : l(l), r(r), c(c) {}
bool operator<(const range &o) const { return l < o.l; }
};
int N, M;
long long t[400010], lz[400010];
set<range> rng;
void unlz(int nod, int l, int r) {
if (lz[nod] == 0) return;
t[nod] += (r - l + 1) * lz[nod];
if (l != r) lz[nod * 2] += lz[nod], lz[nod * 2 + 1] += lz[nod];
lz[nod] = 0;
}
void upd(int nod, int l, int r, int ql, int qr, int val) {
unlz(nod, l, r);
if (ql <= l && r <= qr) {
lz[nod] += val;
return;
}
int mid = (l + r) / 2;
if (ql <= mid) upd(nod * 2, l, mid, ql, qr, val);
if (mid < qr) upd(nod * 2 + 1, mid + 1, r, ql, qr, val);
unlz(nod * 2, l, mid), unlz(nod * 2 + 1, mid + 1, r);
t[nod] = t[nod * 2] + t[nod * 2 + 1];
}
long long query(int nod, int l, int r, int ql, int qr) {
unlz(nod, l, r);
if (ql <= l && r <= qr) return t[nod];
int mid = (l + r) / 2;
long long res = 0;
if (ql <= mid) res += query(nod * 2, l, mid, ql, qr);
if (mid < qr) res += query(nod * 2 + 1, mid + 1, r, ql, qr);
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> N >> M;
int i;
for (i = 1; i <= N; i++) rng.insert(range(i, i, i));
while (M--) {
int tp, l, r, x;
cin >> tp;
if (tp == 1) {
cin >> l >> r >> x;
auto it = --rng.upper_bound(range(l));
if ((*it).l < l) {
range rg = *it;
rng.erase(it);
rng.insert(range(rg.l, l - 1, rg.c));
it = rng.insert(range(l, rg.r, rg.c)).first;
}
range rg;
int lr = -1;
while (it != rng.end() && (*it).r <= r) {
rg = *it;
it = rng.erase(it);
upd(1, 1, N, rg.l, rg.r, abs(rg.c - x));
lr = rg.r;
}
if (it != rng.end() && (*it).l <= r) {
rg = (*it);
rng.erase(it);
rng.insert(range(rg.l, r, x));
rng.insert(range(r + 1, rg.r, rg.c));
upd(1, 1, N, rg.l, r, abs(rg.c - x));
}
if (lr != -1) rng.insert(range(l, lr, x));
} else {
cin >> l >> r;
cout << query(1, 1, N, l, r) << "\n";
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int p1, p2, p3, p4, q = 0, a, b;
cin >> p1 >> p2 >> p3 >> p4 >> a >> b;
for (int i = a; i <= b; i++) {
if (i % p1 == i && i % p2 == i && i % p3 == i && i % p4 == i) {
q++;
}
}
cout << q << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int used[200] = {0};
int main() {
int i, j, k;
string s;
cin >> s;
int len = s.size();
bool at = 0;
for (i = 1; i < len; i++)
if (s[i] == 'd') {
if (i + 2 < len - 1 && s[i + 1] == 'o' && s[i + 2] == 't') used[i] = 1;
} else if (s[i] == 'a') {
if (!at && s[i + 1] == 't') {
used[i] = 2;
at = 1;
}
}
for (i = 0; i < len; i++)
if (!used[i])
cout << s[i];
else if (used[i] == 1) {
cout << ".";
i += 2;
} else if (used[i] == 2) {
cout << "@";
i++;
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
int a[n];
for (size_t i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
a[0] += k;
if (abs(a[n - 1] - a[0]) <= k)
cout << a[0] << "\n";
else
cout << "-1\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
long long int t, n, i, a, b;
cin >> t;
while (t--) {
cin >> n;
if (n <= 3)
cout << "-1";
else {
a = n - n % 2;
for (; a >= 6; a -= 2) cout << a << " ";
cout << "2 4 1 3 ";
b = (n % 2 == 1 ? n : n - 1);
for (i = 5; i <= b; i += 2) {
cout << i << " ";
}
}
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
int main() {
int t, R, r, k;
scanf("%d", &t);
while (t--) {
scanf("%d%d%d", &R, &r, &k);
double d = (R - r) / 4. / R / r, x = (R + r) / 4. / R / r, y = d * k * 2,
z = sqrt(x * x + y * y);
double x1 = x - d * x / z, y1 = y - d * y / z, z1 = x1 * x1 + y1 * y1;
double x2 = x + d * x / z, y2 = y + d * y / z, z2 = x2 * x2 + y2 * y2;
x1 /= z1, y1 /= z1, x2 /= z2, y2 /= z2, x1 -= x2, y1 -= y2;
printf("%.9lf\n", sqrt(x1 * x1 + y1 * y1) / 2);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, sieve[1000000 + 5], cur, xin;
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
if (sieve[i] > 0) continue;
for (int j = i; j <= n; j += i) {
sieve[j] = i;
}
}
xin = 1000000;
cur = sieve[n];
for (int i = n - cur + 1; i < n; i++) {
if (i == sieve[i])
xin = min(xin, i);
else
xin = min(xin, i - sieve[i] + 1);
}
printf("%d\n", xin);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1005;
const int mod = 1e9 + 7;
int n, dp[2][MAXN], ans;
inline void add(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
int main() {
scanf("%d", &n);
int now = 0;
dp[now][1] = ans = 1;
for (int i = 2; i <= 2 * n; ++i) {
now ^= 1;
memset(dp[now], 0, sizeof dp[now]);
for (int j = max(1, i - 1 - n); j < i && j <= n; ++j) {
if (j < n) add(dp[now][j + 1], dp[now ^ 1][j]);
if (i - 1 - j < j) add(dp[now][j], dp[now ^ 1][j]);
}
if (i & 1)
for (int j = max(1, i - n); j <= i && j <= n; ++j) add(ans, dp[now][j]);
}
printf("%d\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, i, j;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
;
long long sum = 0, maxi = 0;
for (i = 0; i < n; i++) {
maxi = max(maxi, a[i]);
sum += a[i];
}
for (i = maxi; i <= 1000; i++) {
long long c = 0;
for (j = 0; j < n; j++) c += i - a[j];
if (c > sum) {
cout << i;
return 0;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 7;
int n;
int x;
map<int, long long> mp;
long long dp[N][2];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &x);
mp[x]++;
}
long long z = 1e5;
for (long long i = 1; i <= 1e5; i++) {
dp[i][0] = max(dp[i - 1][0], dp[i - 1][1]);
dp[i][1] = dp[i - 1][0] + mp[i] * i;
}
printf("%lld\n", max(dp[z][0], dp[z][1]));
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int Array[100005], SPF[1500005], B[100005];
bool Primes[1500005];
void Sieve() {
int i, j;
for (i = 2; i <= 1500000; ++i) {
if (SPF[i] != 0) continue;
j = 2;
SPF[i] = i;
while (i * j <= 1500000) {
if (SPF[i * j] == 0) SPF[i * j] = i;
++j;
}
}
}
int main() {
int N, i, y;
bool Check, flag;
scanf("%d", &N);
Sieve();
int x, index = N + 1;
fill(Primes, Primes + 1300001, false);
for (i = 1; i <= N; ++i) {
scanf("%d", Array + i);
x = Array[i];
Check = flag = false;
while (index > N && x > 1) {
Check = true;
y = SPF[x];
if (Primes[y] == true) {
index = i - 1;
flag = true;
}
x /= y;
}
if (Check == true && flag == false) {
x = Array[i];
while (x > 1) {
y = SPF[x];
Primes[y] = true;
x /= y;
}
}
}
if (index == N + 1) index = N;
for (i = 1; i <= index; ++i) B[i] = Array[i];
if (index == N) {
for (i = 1; i <= N; ++i) printf("%d ", B[i]);
puts("");
return 0;
}
i = Array[index + 1] + 1;
while (true) {
x = i;
while (x > 1) {
y = SPF[x];
if (Primes[y] == true) break;
x /= y;
}
if (x == 1) {
B[index + 1] = i;
x = i;
while (x > 1) {
y = SPF[x];
Primes[y] = true;
x /= y;
}
break;
}
++i;
}
i = index + 2;
int j = 2;
while (i <= N) {
x = j;
while (x > 1) {
y = SPF[x];
if (Primes[y] == true) break;
x /= y;
}
if (x == 1) {
B[i++] = j;
x = j;
while (x > 1) {
y = SPF[x];
Primes[y] = true;
x /= y;
}
}
if (j == 2)
++j;
else
j += 2;
}
for (i = 1; i <= N; ++i) printf("%d ", B[i]);
puts("");
return 0;
}
| 5 |
#include <bits/stdc++.h>
const double eps = (1e-10);
using namespace std;
int dcmp(long double a, long double b) {
return fabsl(a - b) <= eps ? 0 : (a > b) ? 1 : -1;
}
long long getBit(int num, int idx) { return ((num >> idx) & 1) == 1; }
long long setBit1(int num, int idx) { return num | (1 << idx); }
long long setBit0(long long num, int idx) { return num & ~(1ll << idx); }
long long flipBit(long long num, int idx) { return num ^ (1ll << idx); }
void M() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int countNumBit1(int mask) {
int ret = 0;
while (mask) {
mask &= (mask - 1);
++ret;
}
return ret;
}
long long inf = (1ll << 62);
const int MAX = 1000009;
priority_queue<long long> pqR, pqC;
int C[MAX], R[MAX];
long long rows[MAX], cls[MAX];
int main() {
int n, m, k;
long long p;
cin >> n >> m >> k >> p;
for (int i = 1; i <= n; i++) {
long long no;
for (int j = 1; j <= m; j++) cin >> no, C[j] += no, R[i] += no;
}
for (int i = 1; i <= n; i++) {
pqR.push(R[i]);
}
for (int i = 1; i <= m; i++) pqC.push(C[i]);
long long re;
for (int i = 1; i <= k; i++) {
rows[i] = pqR.top() + rows[i - 1];
re = pqR.top() - (m * p);
pqR.push(re);
pqR.pop();
cls[i] = pqC.top() + cls[i - 1];
re = pqC.top() - (n * p);
pqC.push(re);
pqC.pop();
}
long long mx = -inf;
for (int i = 0; i <= k; i++) {
mx = max(mx, rows[i] + cls[k - i] - (k - i) * p * i);
}
cout << mx << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int dirs[4][2]{{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
void solve() {
int N, M, K;
cin >> N >> M >> K;
bool lake[N][M];
for (int n = (0); n < (N); ++n)
for (int m = (0); m < (M); ++m) {
char c;
cin >> c;
lake[n][m] = c == '.';
}
int id[N][M];
for (int n = (0); n < (N); ++n)
for (int m = (0); m < (M); ++m) id[n][m] = -1;
int cid = -1;
vector<pair<int, int> > sizes;
for (int n = (0); n < (N); ++n)
for (int m = (0); m < (M); ++m) {
if (id[n][m] == -1 && lake[n][m]) {
vector<pair<int, int> > active(1, {n, m});
id[n][m] = ++cid;
sizes.push_back({1, cid});
bool ocean = false;
while (!active.empty()) {
int y = active.back().first;
int x = active.back().second;
active.pop_back();
ocean = ocean || y == 0 || x == 0 || y == N - 1 || x == M - 1;
for (int dir = 0; dir < 4; ++dir) {
int nx = x + dirs[dir][0];
int ny = y + dirs[dir][1];
if (nx >= 0 && nx < M && ny >= 0 && ny < N && lake[ny][nx] &&
id[ny][nx] == -1) {
id[ny][nx] = cid;
active.push_back({ny, nx});
sizes.back().first++;
}
}
}
if (ocean) {
sizes.pop_back();
}
}
}
sort(sizes.begin(), sizes.end());
int res = 0;
bool dry[cid + 1];
fill_n(dry, cid + 1, false);
for (int i = 0; i < sizes.size() - K; ++i) {
res += sizes[i].first;
dry[sizes[i].second] = true;
}
cout << res << endl;
for (int n = (0); n < (N); ++n) {
for (int m = (0); m < (M); ++m)
cout << (id[n][m] == -1 || dry[id[n][m]] ? '*' : '.');
cout << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cout << setprecision(12) << fixed;
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool mini(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool maxi(T &a, T b) {
return a < b ? (a = b, true) : false;
}
signed main() {
int n;
cin >> n;
vector<pair<int, int> > ans;
int flag;
for (int i = 0; i < (int)(n); i++) {
if (ans.size() == 2) break;
if (i < n - 1) {
cout << "? " << i + 1 << ' ' << 1 << ' ' << i + 1 << ' ' << n << "\n";
cin >> flag;
}
if (flag & 1 || ((int)ans.size() && i == n - 1)) {
int l = 0, r = n - 1;
while (l < r) {
int mid = (l + r) >> 1;
cout << "? " << i + 1 << ' ' << 1 << ' ' << i + 1 << ' ' << mid + 1
<< "\n";
int t;
cin >> t;
if (~t & 1)
l = mid + 1;
else
r = mid;
}
ans.push_back(make_pair(i, l));
}
}
for (int j = 0; j < (int)(n); j++) {
if (ans.size() == 2) break;
if (j < n - 1) {
cout << "? " << 1 << ' ' << j + 1 << ' ' << n << ' ' << j + 1 << "\n";
cin >> flag;
}
if (flag & 1 || (j == n - 1)) {
int l = 0, r = n - 1;
while (l < r) {
int mid = (l + r) >> 1;
cout << "? " << 1 << ' ' << j + 1 << ' ' << mid + 1 << ' ' << j + 1
<< "\n";
int t;
cin >> t;
if (~t & 1)
l = mid + 1;
else
r = mid;
}
ans.push_back(make_pair(l, j));
}
}
cout << "!";
for (auto e : ans) cout << ' ' << e.first + 1 << ' ' << e.second + 1;
cout << "\n";
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.